camera/src/camera_metadata.c

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #define _GNU_SOURCE // for fdprintf
  17 #include <system/camera_metadata.h>
  18 #include <cutils/log.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <errno.h>
  22
  23 #define OK         0
  24 #define ERROR      1
  25 #define NOT_FOUND -ENOENT
  26 /**
  27  * A single metadata entry, storing an array of values of a given type. If the
  28  * array is no larger than 4 bytes in size, it is stored in the data.value[]
  29  * array; otherwise, it can found in the parent's data array at index
  30  * data.offset.
  31  */
  32 typedef struct camera_metadata_buffer_entry {
  33     uint32_t tag;
  34     size_t   count;
  35     union {
  36         size_t  offset;
  37         uint8_t value[4];
  38     } data;
  39     uint8_t  type;
  40     uint8_t  reserved[3];
  41 } __attribute__((packed)) camera_metadata_buffer_entry_t;
  42
  43 /**
  44  * A packet of metadata. This is a list of entries, each of which may point to
  45  * its values stored at an offset in data.
  46  *
  47  * It is assumed by the utility functions that the memory layout of the packet
  48  * is as follows:
  49  *
  50  *   |-----------------------------------------------|
  51  *   | camera_metadata_t                             |
  52  *   |                                               |
  53  *   |-----------------------------------------------|
  54  *   | reserved for future expansion                 |
  55  *   |-----------------------------------------------|
  56  *   | camera_metadata_buffer_entry_t #0             |
  57  *   |-----------------------------------------------|
  58  *   | ....                                          |
  59  *   |-----------------------------------------------|
  60  *   | camera_metadata_buffer_entry_t #entry_count-1 |
  61  *   |-----------------------------------------------|
  62  *   | free space for                                |
  63  *   | (entry_capacity-entry_count) entries          |
  64  *   |-----------------------------------------------|
  65  *   | start of camera_metadata.data                 |
  66  *   |                                               |
  67  *   |-----------------------------------------------|
  68  *   | free space for                                |
  69  *   | (data_capacity-data_count) bytes              |
  70  *   |-----------------------------------------------|
  71  *
  72  * With the total length of the whole packet being camera_metadata.size bytes.
  73  *
  74  * In short, the entries and data are contiguous in memory after the metadata
  75  * header.
  76  */
  77 struct camera_metadata {
  78     size_t                   size;
  79     uint32_t                 version;
  80     uint32_t                 flags;
  81     size_t                   entry_count;
  82     size_t                   entry_capacity;
  83     camera_metadata_buffer_entry_t *entries;
  84     size_t                   data_count;
  85     size_t                   data_capacity;
  86     uint8_t                 *data;
  87     void                    *user; // User set pointer, not copied with buffer
  88     uint8_t                  reserved[0];
  89 };
  90
  91 /** Versioning information */
  92 #define CURRENT_METADATA_VERSION 1
  93
  94 /** Flag definitions */
  95 #define FLAG_SORTED 0x00000001
  96
  97 /** Tag information */
  98
  99 typedef struct tag_info {
 100     const char *tag_name;
 101     uint8_t     tag_type;
 102 } tag_info_t;
 103
 104 #include "camera_metadata_tag_info.c"
 105
 106 const size_t camera_metadata_type_size[NUM_TYPES] = {
 107     [TYPE_BYTE]     = sizeof(uint8_t),
 108     [TYPE_INT32]    = sizeof(int32_t),
 109     [TYPE_FLOAT]    = sizeof(float),
 110     [TYPE_INT64]    = sizeof(int64_t),
 111     [TYPE_DOUBLE]   = sizeof(double),
 112     [TYPE_RATIONAL] = sizeof(camera_metadata_rational_t)
 113 };
 114
 115 const char *camera_metadata_type_names[NUM_TYPES] = {
 116     [TYPE_BYTE]     = "byte",
 117     [TYPE_INT32]    = "int32",
 118     [TYPE_FLOAT]    = "float",
 119     [TYPE_INT64]    = "int64",
 120     [TYPE_DOUBLE]   = "double",
 121     [TYPE_RATIONAL] = "rational"
 122 };
 123
 124 camera_metadata_t *allocate_camera_metadata(size_t entry_capacity,
 125                                             size_t data_capacity) {
 126     if (entry_capacity == 0) return NULL;
 127
 128     size_t memory_needed = calculate_camera_metadata_size(entry_capacity,
 129                                                           data_capacity);
 130     void *buffer = malloc(memory_needed);
 131     return place_camera_metadata(buffer, memory_needed,
 132                                  entry_capacity,
 133                                  data_capacity);
 134 }
 135
 136 camera_metadata_t *place_camera_metadata(void *dst,
 137                                          size_t dst_size,
 138                                          size_t entry_capacity,
 139                                          size_t data_capacity) {
 140     if (dst == NULL) return NULL;
 141     if (entry_capacity == 0) return NULL;
 142
 143     size_t memory_needed = calculate_camera_metadata_size(entry_capacity,
 144                                                           data_capacity);
 145     if (memory_needed > dst_size) return NULL;
 146
 147     camera_metadata_t *metadata = (camera_metadata_t*)dst;
 148     metadata->version = CURRENT_METADATA_VERSION;
 149     metadata->flags = 0;
 150     metadata->entry_count = 0;
 151     metadata->entry_capacity = entry_capacity;
 152     metadata->entries = (camera_metadata_buffer_entry_t*)(metadata + 1);
 153     metadata->data_count = 0;
 154     metadata->data_capacity = data_capacity;
 155     metadata->size = memory_needed;
 156     if (metadata->data_capacity != 0) {
 157         metadata->data =
 158                 (uint8_t*)(metadata->entries + metadata->entry_capacity);
 159     } else {
 160         metadata->data = NULL;
 161     }
 162     metadata->user = NULL;
 163
 164     return metadata;
 165 }
 166 void free_camera_metadata(camera_metadata_t *metadata) {
 167     free(metadata);
 168 }
 169
 170 size_t calculate_camera_metadata_size(size_t entry_count,
 171                                       size_t data_count) {
 172     size_t memory_needed = sizeof(camera_metadata_t);
 173     memory_needed += sizeof(camera_metadata_buffer_entry_t[entry_count]);
 174     memory_needed += sizeof(uint8_t[data_count]);
 175     return memory_needed;
 176 }
 177
 178 size_t get_camera_metadata_size(const camera_metadata_t *metadata) {
 179     if (metadata == NULL) return ERROR;
 180
 181     return metadata->size;
 182 }
 183
 184 size_t get_camera_metadata_compact_size(const camera_metadata_t *metadata) {
 185     if (metadata == NULL) return ERROR;
 186
 187     ptrdiff_t reserved_size = metadata->size -
 188             calculate_camera_metadata_size(metadata->entry_capacity,
 189                                            metadata->data_capacity);
 190
 191     return calculate_camera_metadata_size(metadata->entry_count,
 192                                           metadata->data_count) + reserved_size;
 193 }
 194
 195 size_t get_camera_metadata_entry_count(const camera_metadata_t *metadata) {
 196     return metadata->entry_count;
 197 }
 198
 199 size_t get_camera_metadata_entry_capacity(const camera_metadata_t *metadata) {
 200     return metadata->entry_capacity;
 201 }
 202
 203 size_t get_camera_metadata_data_count(const camera_metadata_t *metadata) {
 204     return metadata->data_count;
 205 }
 206
 207 size_t get_camera_metadata_data_capacity(const camera_metadata_t *metadata) {
 208     return metadata->data_capacity;
 209 }
 210
 211 camera_metadata_t* copy_camera_metadata(void *dst, size_t dst_size,
 212         const camera_metadata_t *src) {
 213     size_t memory_needed = get_camera_metadata_compact_size(src);
 214
 215     if (dst == NULL) return NULL;
 216     if (dst_size < memory_needed) return NULL;
 217
 218     // If copying a newer version of the structure, there may be additional
 219     // header fields we don't know about but need to copy
 220     ptrdiff_t reserved_size = src->size -
 221             calculate_camera_metadata_size(src->entry_capacity,
 222                                            src->data_capacity);
 223
 224     camera_metadata_t *metadata = (camera_metadata_t*)dst;
 225     metadata->version = CURRENT_METADATA_VERSION;
 226     metadata->flags = src->flags;
 227     metadata->entry_count = src->entry_count;
 228     metadata->entry_capacity = src->entry_count;
 229     metadata->entries = (camera_metadata_buffer_entry_t*)
 230              ((uint8_t *)(metadata + 1) + reserved_size);
 231     metadata->data_count = src->data_count;
 232     metadata->data_capacity = src->data_count;
 233     metadata->data = (uint8_t *)(metadata->entries + metadata->entry_capacity);
 234     metadata->size = memory_needed;
 235
 236     if (reserved_size > 0) {
 237         memcpy(metadata->reserved, src->reserved, reserved_size);
 238     }
 239     memcpy(metadata->entries, src->entries,
 240             sizeof(camera_metadata_buffer_entry_t[metadata->entry_count]));
 241     memcpy(metadata->data, src->data,
 242             sizeof(uint8_t[metadata->data_count]));
 243     metadata->user = NULL;
 244
 245     return metadata;
 246 }
 247
 248 int append_camera_metadata(camera_metadata_t *dst,
 249         const camera_metadata_t *src) {
 250     if (dst == NULL || src == NULL ) return ERROR;
 251
 252     if (dst->entry_capacity < src->entry_count + dst->entry_count) return ERROR;
 253     if (dst->data_capacity < src->data_count + dst->data_count) return ERROR;
 254
 255     memcpy(dst->entries + dst->entry_count, src->entries,
 256             sizeof(camera_metadata_buffer_entry_t[src->entry_count]));
 257     memcpy(dst->data + dst->data_count, src->data,
 258             sizeof(uint8_t[src->data_count]));
 259     if (dst->data_count != 0) {
 260         unsigned int i;
 261         for (i = dst->entry_count;
 262              i < dst->entry_count + src->entry_count;
 263              i++) {
 264             camera_metadata_buffer_entry_t *entry = dst->entries + i;
 265             if ( camera_metadata_type_size[entry->type] * entry->count > 4 ) {
 266                 entry->data.offset += dst->data_count;
 267             }
 268         }
 269     }
 270     if (dst->entry_count == 0) {
 271         // Appending onto empty buffer, keep sorted state
 272         dst->flags |= src->flags & FLAG_SORTED;
 273     } else if (src->entry_count != 0) {
 274         // Both src, dst are nonempty, cannot assume sort remains
 275         dst->flags &= ~FLAG_SORTED;
 276     } else {
 277         // Src is empty, keep dst sorted state
 278     }
 279     dst->entry_count += src->entry_count;
 280     dst->data_count += src->data_count;
 281
 282     return OK;
 283 }
 284
 285 camera_metadata_t *clone_camera_metadata(const camera_metadata_t *src) {
 286     int res;
 287     if (src == NULL) return NULL;
 288     camera_metadata_t *clone = allocate_camera_metadata(
 289         get_camera_metadata_entry_count(src),
 290         get_camera_metadata_data_count(src));
 291     if (clone != NULL) {
 292         res = append_camera_metadata(clone, src);
 293         if (res != OK) {
 294             free_camera_metadata(clone);
 295             clone = NULL;
 296         }
 297     }
 298     return clone;
 299 }
 300
 301 size_t calculate_camera_metadata_entry_data_size(uint8_t type,
 302         size_t data_count) {
 303     if (type >= NUM_TYPES) return 0;
 304     size_t data_bytes = data_count *
 305             camera_metadata_type_size[type];
 306     return data_bytes <= 4 ? 0 : data_bytes;
 307 }
 308
 309 static int add_camera_metadata_entry_raw(camera_metadata_t *dst,
 310         uint32_t tag,
 311         uint8_t  type,
 312         const void *data,
 313         size_t data_count) {
 314
 315     if (dst == NULL) return ERROR;
 316     if (dst->entry_count == dst->entry_capacity) return ERROR;
 317     if (data == NULL) return ERROR;
 318
 319     size_t data_bytes =
 320             calculate_camera_metadata_entry_data_size(type, data_count);
 321
 322     camera_metadata_buffer_entry_t *entry = dst->entries + dst->entry_count;
 323     entry->tag = tag;
 324     entry->type = type;
 325     entry->count = data_count;
 326
 327     if (data_bytes == 0) {
 328         memcpy(entry->data.value, data,
 329                 data_count * camera_metadata_type_size[type] );
 330     } else {
 331         entry->data.offset = dst->data_count;
 332         memcpy(dst->data + entry->data.offset, data, data_bytes);
 333         dst->data_count += data_bytes;
 334     }
 335     dst->entry_count++;
 336     dst->flags &= ~FLAG_SORTED;
 337     return OK;
 338 }
 339
 340 int add_camera_metadata_entry(camera_metadata_t *dst,
 341         uint32_t tag,
 342         const void *data,
 343         size_t data_count) {
 344
 345     int type = get_camera_metadata_tag_type(tag);
 346     if (type == -1) {
 347         ALOGE("%s: Unknown tag %04x.", __FUNCTION__, tag);
 348         return ERROR;
 349     }
 350
 351     return add_camera_metadata_entry_raw(dst,
 352             tag,
 353             type,
 354             data,
 355             data_count);
 356 }
 357
 358 static int compare_entry_tags(const void *p1, const void *p2) {
 359     uint32_t tag1 = ((camera_metadata_buffer_entry_t*)p1)->tag;
 360     uint32_t tag2 = ((camera_metadata_buffer_entry_t*)p2)->tag;
 361     return  tag1 < tag2 ? -1 :
 362             tag1 == tag2 ? 0 :
 363             1;
 364 }
 365
 366 int sort_camera_metadata(camera_metadata_t *dst) {
 367     if (dst == NULL) return ERROR;
 368     if (dst->flags & FLAG_SORTED) return OK;
 369
 370     qsort(dst->entries, dst->entry_count,
 371             sizeof(camera_metadata_buffer_entry_t),
 372             compare_entry_tags);
 373     dst->flags |= FLAG_SORTED;
 374
 375     return OK;
 376 }
 377
 378 int get_camera_metadata_entry(camera_metadata_t *src,
 379         size_t index,
 380         camera_metadata_entry_t *entry) {
 381     if (src == NULL || entry == NULL) return ERROR;
 382     if (index >= src->entry_count) return ERROR;
 383
 384     camera_metadata_buffer_entry_t *buffer_entry = src->entries + index;
 385
 386     entry->index = index;
 387     entry->tag = buffer_entry->tag;
 388     entry->type = buffer_entry->type;
 389     entry->count = buffer_entry->count;
 390     if (buffer_entry->count *
 391             camera_metadata_type_size[buffer_entry->type] > 4) {
 392         entry->data.u8 = src->data + buffer_entry->data.offset;
 393     } else {
 394         entry->data.u8 = buffer_entry->data.value;
 395     }
 396     return OK;
 397 }
 398
 399 int find_camera_metadata_entry(camera_metadata_t *src,
 400         uint32_t tag,
 401         camera_metadata_entry_t *entry) {
 402     if (src == NULL) return ERROR;
 403
 404     uint32_t index;
 405     if (src->flags & FLAG_SORTED) {
 406         // Sorted entries, do a binary search
 407         camera_metadata_buffer_entry_t *search_entry = NULL;
 408         camera_metadata_buffer_entry_t key;
 409         key.tag = tag;
 410         search_entry = bsearch(&key,
 411                 src->entries,
 412                 src->entry_count,
 413                 sizeof(camera_metadata_buffer_entry_t),
 414                 compare_entry_tags);
 415         if (search_entry == NULL) return NOT_FOUND;
 416         index = search_entry - src->entries;
 417     } else {
 418         // Not sorted, linear search
 419         for (index = 0; index < src->entry_count; index++) {
 420             if (src->entries[index].tag == tag) {
 421                 break;
 422             }
 423         }
 424         if (index == src->entry_count) return NOT_FOUND;
 425     }
 426
 427     return get_camera_metadata_entry(src, index,
 428             entry);
 429 }
 430
 431 int find_camera_metadata_ro_entry(const camera_metadata_t *src,
 432         uint32_t tag,
 433         camera_metadata_ro_entry_t *entry) {
 434     return find_camera_metadata_entry((camera_metadata_t*)src, tag,
 435             (camera_metadata_entry_t*)entry);
 436 }
 437
 438
 439 int delete_camera_metadata_entry(camera_metadata_t *dst,
 440         size_t index) {
 441     if (dst == NULL) return ERROR;
 442     if (index >= dst->entry_count) return ERROR;
 443
 444     camera_metadata_buffer_entry_t *entry = dst->entries + index;
 445     size_t data_bytes = calculate_camera_metadata_entry_data_size(entry->type,
 446             entry->count);
 447
 448     if (data_bytes > 0) {
 449         // Shift data buffer to overwrite deleted data
 450         uint8_t *start = dst->data + entry->data.offset;
 451         uint8_t *end = start + data_bytes;
 452         size_t length = dst->data_count - entry->data.offset - data_bytes;
 453         memmove(start, end, length);
 454
 455         // Update all entry indices to account for shift
 456         camera_metadata_buffer_entry_t *e = dst->entries;
 457         size_t i;
 458         for (i = 0; i < dst->entry_count; i++) {
 459             if (calculate_camera_metadata_entry_data_size(
 460                     e->type, e->count) > 0 &&
 461                     e->data.offset > entry->data.offset) {
 462                 e->data.offset -= data_bytes;
 463             }
 464             ++e;
 465         }
 466         dst->data_count -= data_bytes;
 467     }
 468     // Shift entry array
 469     memmove(entry, entry + 1,
 470             sizeof(camera_metadata_buffer_entry_t) *
 471             (dst->entry_count - index - 1) );
 472     dst->entry_count -= 1;
 473
 474     return OK;
 475 }
 476
 477 int update_camera_metadata_entry(camera_metadata_t *dst,
 478         size_t index,
 479         const void *data,
 480         size_t data_count,
 481         camera_metadata_entry_t *updated_entry) {
 482     if (dst == NULL) return ERROR;
 483     if (index >= dst->entry_count) return ERROR;
 484
 485     camera_metadata_buffer_entry_t *entry = dst->entries + index;
 486
 487     size_t data_bytes =
 488             calculate_camera_metadata_entry_data_size(entry->type,
 489                     data_count);
 490     size_t entry_bytes =
 491             calculate_camera_metadata_entry_data_size(entry->type,
 492                     entry->count);
 493     if (data_bytes != entry_bytes) {
 494         // May need to shift/add to data array
 495         if (dst->data_capacity < dst->data_count + data_bytes - entry_bytes) {
 496             // No room
 497             return ERROR;
 498         }
 499         if (entry_bytes != 0) {
 500             // Remove old data
 501             uint8_t *start = dst->data + entry->data.offset;
 502             uint8_t *end = start + entry_bytes;
 503             size_t length = dst->data_count - entry->data.offset - entry_bytes;
 504             memmove(start, end, length);
 505             dst->data_count -= entry_bytes;
 506
 507             // Update all entry indices to account for shift
 508             camera_metadata_buffer_entry_t *e = dst->entries;
 509             size_t i;
 510             for (i = 0; i < dst->entry_count; i++) {
 511                 if (calculate_camera_metadata_entry_data_size(
 512                         e->type, e->count) > 0 &&
 513                         e->data.offset > entry->data.offset) {
 514                     e->data.offset -= entry_bytes;
 515                 }
 516                 ++e;
 517             }
 518         }
 519
 520         if (data_bytes != 0) {
 521             // Append new data
 522             entry->data.offset = dst->data_count;
 523
 524             memcpy(dst->data + entry->data.offset, data, data_bytes);
 525             dst->data_count += data_bytes;
 526         }
 527     } else if (data_bytes != 0) {
 528         // data size unchanged, reuse same data location
 529         memcpy(dst->data + entry->data.offset, data, data_bytes);
 530     }
 531
 532     if (data_bytes == 0) {
 533         // Data fits into entry
 534         memcpy(entry->data.value, data,
 535                 data_count * camera_metadata_type_size[entry->type]);
 536     }
 537
 538     entry->count = data_count;
 539
 540     if (updated_entry != NULL) {
 541         get_camera_metadata_entry(dst,
 542                 index,
 543                 updated_entry);
 544     }
 545
 546     return OK;
 547 }
 548
 549 int set_camera_metadata_user_pointer(camera_metadata_t *dst, void* user) {
 550     if (dst == NULL) return ERROR;
 551     dst->user = user;
 552     return OK;
 553 }
 554
 555 int get_camera_metadata_user_pointer(camera_metadata_t *dst, void** user) {
 556     if (dst == NULL) return ERROR;
 557     *user = dst->user;
 558     return OK;
 559 }
 560
 561 static const vendor_tag_query_ops_t *vendor_tag_ops = NULL;
 562
 563 const char *get_camera_metadata_section_name(uint32_t tag) {
 564     uint32_t tag_section = tag >> 16;
 565     if (tag_section >= VENDOR_SECTION && vendor_tag_ops != NULL) {
 566         return vendor_tag_ops->get_camera_vendor_section_name(
 567             vendor_tag_ops,
 568             tag);
 569     }
 570     if (tag_section >= ANDROID_SECTION_COUNT) {
 571         return NULL;
 572     }
 573     return camera_metadata_section_names[tag_section];
 574 }
 575
 576 const char *get_camera_metadata_tag_name(uint32_t tag) {
 577     uint32_t tag_section = tag >> 16;
 578     if (tag_section >= VENDOR_SECTION && vendor_tag_ops != NULL) {
 579         return vendor_tag_ops->get_camera_vendor_tag_name(
 580             vendor_tag_ops,
 581             tag);
 582     }
 583     if (tag_section >= ANDROID_SECTION_COUNT ||
 584         tag >= camera_metadata_section_bounds[tag_section][1] ) {
 585         return NULL;
 586     }
 587     uint32_t tag_index = tag & 0xFFFF;
 588     return tag_info[tag_section][tag_index].tag_name;
 589 }
 590
 591 int get_camera_metadata_tag_type(uint32_t tag) {
 592     uint32_t tag_section = tag >> 16;
 593     if (tag_section >= VENDOR_SECTION && vendor_tag_ops != NULL) {
 594         return vendor_tag_ops->get_camera_vendor_tag_type(
 595             vendor_tag_ops,
 596             tag);
 597     }
 598     if (tag_section >= ANDROID_SECTION_COUNT ||
 599             tag >= camera_metadata_section_bounds[tag_section][1] ) {
 600         return -1;
 601     }
 602     uint32_t tag_index = tag & 0xFFFF;
 603     return tag_info[tag_section][tag_index].tag_type;
 604 }
 605
 606 int set_camera_metadata_vendor_tag_ops(const vendor_tag_query_ops_t *query_ops) {
 607     vendor_tag_ops = query_ops;
 608     return OK;
 609 }
 610
 611 static void print_data(int fd, const uint8_t *data_ptr, int type, int count,
 612         int indentation);
 613
 614 void dump_camera_metadata(const camera_metadata_t *metadata,
 615         int fd,
 616         int verbosity) {
 617     dump_indented_camera_metadata(metadata, fd, verbosity, 0);
 618 }
 619
 620 void dump_indented_camera_metadata(const camera_metadata_t *metadata,
 621         int fd,
 622         int verbosity,
 623         int indentation) {
 624     if (metadata == NULL) {
 625         fdprintf(fd, "%*sDumping camera metadata array: Not allocated",
 626                 indentation, "");
 627         return;
 628     }
 629     unsigned int i;
 630     fdprintf(fd,
 631             "%*sDumping camera metadata array: %d / %d entries, "
 632             "%d / %d bytes of extra data.\n", indentation, "",
 633             metadata->entry_count, metadata->entry_capacity,
 634             metadata->data_count, metadata->data_capacity);
 635     fdprintf(fd, "%*sVersion: %d, Flags: %08x\n",
 636             indentation + 2, "",
 637             metadata->version, metadata->flags);
 638     for (i=0; i < metadata->entry_count; i++) {
 639         camera_metadata_buffer_entry_t *entry = metadata->entries + i;
 640
 641         const char *tag_name, *tag_section;
 642         tag_section = get_camera_metadata_section_name(entry->tag);
 643         if (tag_section == NULL) {
 644             tag_section = "unknownSection";
 645         }
 646         tag_name = get_camera_metadata_tag_name(entry->tag);
 647         if (tag_name == NULL) {
 648             tag_name = "unknownTag";
 649         }
 650         const char *type_name;
 651         if (entry->type >= NUM_TYPES) {
 652             type_name = "unknown";
 653         } else {
 654             type_name = camera_metadata_type_names[entry->type];
 655         }
 656         fdprintf(fd, "%*s%s.%s (%05x): %s[%d]\n",
 657              indentation + 2, "",
 658              tag_section,
 659              tag_name,
 660              entry->tag,
 661              type_name,
 662              entry->count);
 663
 664         if (verbosity < 1) continue;
 665
 666         if (entry->type >= NUM_TYPES) continue;
 667
 668         size_t type_size = camera_metadata_type_size[entry->type];
 669         uint8_t *data_ptr;
 670         if ( type_size * entry->count > 4 ) {
 671             if (entry->data.offset >= metadata->data_count) {
 672                 ALOGE("%s: Malformed entry data offset: %d (max %d)",
 673                         __FUNCTION__,
 674                         entry->data.offset,
 675                         metadata->data_count);
 676                 continue;
 677             }
 678             data_ptr = metadata->data + entry->data.offset;
 679         } else {
 680             data_ptr = entry->data.value;
 681         }
 682         int count = entry->count;
 683         if (verbosity < 2 && count > 16) count = 16;
 684
 685         print_data(fd, data_ptr, entry->type, count, indentation);
 686     }
 687 }
 688
 689 static void print_data(int fd, const uint8_t *data_ptr,
 690         int type, int count, int indentation) {
 691     static int values_per_line[NUM_TYPES] = {
 692         [TYPE_BYTE]     = 16,
 693         [TYPE_INT32]    = 4,
 694         [TYPE_FLOAT]    = 8,
 695         [TYPE_INT64]    = 2,
 696         [TYPE_DOUBLE]   = 4,
 697         [TYPE_RATIONAL] = 2,
 698     };
 699     size_t type_size = camera_metadata_type_size[type];
 700
 701     int lines = count / values_per_line[type];
 702     if (count % values_per_line[type] != 0) lines++;
 703
 704     int index = 0;
 705     int j, k;
 706     for (j = 0; j < lines; j++) {
 707         fdprintf(fd, "%*s[", indentation + 4, "");
 708         for (k = 0;
 709              k < values_per_line[type] && count > 0;
 710              k++, count--, index += type_size) {
 711
 712             switch (type) {
 713                 case TYPE_BYTE:
 714                     fdprintf(fd, "%hhu ",
 715                             *(data_ptr + index));
 716                     break;
 717                 case TYPE_INT32:
 718                     fdprintf(fd, "%d ",
 719                             *(int32_t*)(data_ptr + index));
 720                     break;
 721                 case TYPE_FLOAT:
 722                     fdprintf(fd, "%0.2f ",
 723                             *(float*)(data_ptr + index));
 724                     break;
 725                 case TYPE_INT64:
 726                     fdprintf(fd, "%lld ",
 727                             *(int64_t*)(data_ptr + index));
 728                     break;
 729                 case TYPE_DOUBLE:
 730                     fdprintf(fd, "%0.2f ",
 731                             *(float*)(data_ptr + index));
 732                     break;
 733                 case TYPE_RATIONAL: {
 734                     int32_t numerator = *(int32_t*)(data_ptr + index);
 735                     int32_t denominator = *(int32_t*)(data_ptr + index + 4);
 736                     fdprintf(fd, "(%d / %d) ",
 737                             numerator, denominator);
 738                     break;
 739                 }
 740                 default:
 741                     fdprintf(fd, "??? ");
 742             }
 743         }
 744         fdprintf(fd, "]\n");
 745     }
 746 }