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_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_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_entry_t #0             |
  57  *   |----------------------------------------|
  58  *   | ....                                   |
  59  *   |----------------------------------------|
  60  *   | camera_metadata_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_entry_t *entries;
  84     size_t                   data_count;
  85     size_t                   data_capacity;
  86     uint8_t                 *data;
  87     uint8_t                  reserved[0];
  88 };
  89
  90 /** Versioning information */
  91 #define CURRENT_METADATA_VERSION 1
  92
  93 /** Flag definitions */
  94 #define FLAG_SORTED 0x00000001
  95
  96 /** Tag information */
  97
  98 typedef struct tag_info {
  99     const char *tag_name;
 100     uint8_t     tag_type;
 101 } tag_info_t;
 102
 103 #include "camera_metadata_tag_info.c"
 104
 105 size_t camera_metadata_type_size[NUM_TYPES] = {
 106     [TYPE_BYTE]     = sizeof(uint8_t),
 107     [TYPE_INT32]    = sizeof(int32_t),
 108     [TYPE_FLOAT]    = sizeof(float),
 109     [TYPE_INT64]    = sizeof(int64_t),
 110     [TYPE_DOUBLE]   = sizeof(double),
 111     [TYPE_RATIONAL] = sizeof(camera_metadata_rational_t)
 112 };
 113
 114 char *camera_metadata_type_names[NUM_TYPES] = {
 115     [TYPE_BYTE]     = "byte",
 116     [TYPE_INT32]    = "int32",
 117     [TYPE_FLOAT]    = "float",
 118     [TYPE_INT64]    = "int64",
 119     [TYPE_RATIONAL] = "rational"
 120 };
 121
 122 camera_metadata_t *allocate_camera_metadata(size_t entry_capacity,
 123                                             size_t data_capacity) {
 124     size_t memory_needed = calculate_camera_metadata_size(entry_capacity,
 125                                                           data_capacity);
 126     void *buffer = malloc(memory_needed);
 127     return place_camera_metadata(buffer, memory_needed,
 128                                  entry_capacity,
 129                                  data_capacity);
 130 }
 131
 132 camera_metadata_t *place_camera_metadata(void *dst,
 133                                          size_t dst_size,
 134                                          size_t entry_capacity,
 135                                          size_t data_capacity) {
 136     if (dst == NULL) return NULL;
 137     if (entry_capacity == 0) return NULL;
 138
 139     size_t memory_needed = calculate_camera_metadata_size(entry_capacity,
 140                                                           data_capacity);
 141     if (memory_needed > dst_size) return NULL;
 142
 143     camera_metadata_t *metadata = (camera_metadata_t*)dst;
 144     metadata->version = CURRENT_METADATA_VERSION;
 145     metadata->flags = 0;
 146     metadata->entry_count = 0;
 147     metadata->entry_capacity = entry_capacity;
 148     metadata->entries = (camera_metadata_entry_t*)(metadata + 1);
 149     metadata->data_count = 0;
 150     metadata->data_capacity = data_capacity;
 151     metadata->size = memory_needed;
 152     if (metadata->data_capacity != 0) {
 153         metadata->data =
 154                 (uint8_t*)(metadata->entries + metadata->entry_capacity);
 155     } else {
 156         metadata->data = NULL;
 157     }
 158
 159     return metadata;
 160 }
 161 void free_camera_metadata(camera_metadata_t *metadata) {
 162     free(metadata);
 163 }
 164
 165 size_t calculate_camera_metadata_size(size_t entry_count,
 166                                       size_t data_count) {
 167     size_t memory_needed = sizeof(camera_metadata_t);
 168     memory_needed += sizeof(camera_metadata_entry_t[entry_count]);
 169     memory_needed += sizeof(uint8_t[data_count]);
 170     return memory_needed;
 171 }
 172
 173 size_t get_camera_metadata_size(const camera_metadata_t *metadata) {
 174     if (metadata == NULL) return ERROR;
 175
 176     return metadata->size;
 177 }
 178
 179 size_t get_camera_metadata_compact_size(const camera_metadata_t *metadata) {
 180     if (metadata == NULL) return ERROR;
 181
 182     ptrdiff_t reserved_size = metadata->size -
 183             calculate_camera_metadata_size(metadata->entry_capacity,
 184                                            metadata->data_capacity);
 185
 186     return calculate_camera_metadata_size(metadata->entry_count,
 187                                           metadata->data_count) + reserved_size;
 188 }
 189
 190 size_t get_camera_metadata_entry_count(const camera_metadata_t *metadata) {
 191     return metadata->entry_count;
 192 }
 193
 194 size_t get_camera_metadata_entry_capacity(const camera_metadata_t *metadata) {
 195     return metadata->entry_capacity;
 196 }
 197
 198 size_t get_camera_metadata_data_count(const camera_metadata_t *metadata) {
 199     return metadata->data_count;
 200 }
 201
 202 size_t get_camera_metadata_data_capacity(const camera_metadata_t *metadata) {
 203     return metadata->data_capacity;
 204 }
 205
 206 camera_metadata_t* copy_camera_metadata(void *dst, size_t dst_size,
 207         const camera_metadata_t *src) {
 208     size_t memory_needed = get_camera_metadata_compact_size(src);
 209
 210     if (dst == NULL) return NULL;
 211     if (dst_size < memory_needed) return NULL;
 212
 213     // If copying a newer version of the structure, there may be additional
 214     // header fields we don't know about but need to copy
 215     ptrdiff_t reserved_size = src->size -
 216             calculate_camera_metadata_size(src->entry_capacity,
 217                                            src->data_capacity);
 218
 219     camera_metadata_t *metadata = (camera_metadata_t*)dst;
 220     metadata->version = CURRENT_METADATA_VERSION;
 221     metadata->flags = src->flags;
 222     metadata->entry_count = src->entry_count;
 223     metadata->entry_capacity = src->entry_count;
 224     metadata->entries = (camera_metadata_entry_t*)
 225              ((uint8_t *)(metadata + 1) + reserved_size);
 226     metadata->data_count = src->data_count;
 227     metadata->data_capacity = src->data_count;
 228     metadata->data = (uint8_t *)(metadata->entries + metadata->entry_capacity);
 229     metadata->size = memory_needed;
 230
 231     if (reserved_size > 0) {
 232         memcpy(metadata->reserved, src->reserved, reserved_size);
 233     }
 234     memcpy(metadata->entries, src->entries,
 235             sizeof(camera_metadata_entry_t[metadata->entry_count]));
 236     memcpy(metadata->data, src->data,
 237             sizeof(uint8_t[metadata->data_count]));
 238
 239     return metadata;
 240 }
 241
 242 int append_camera_metadata(camera_metadata_t *dst,
 243         const camera_metadata_t *src) {
 244     if (dst == NULL || src == NULL ) return ERROR;
 245
 246     if (dst->entry_capacity < src->entry_count + dst->entry_count) return ERROR;
 247     if (dst->data_capacity < src->data_count + dst->data_count) return ERROR;
 248
 249     memcpy(dst->entries + dst->entry_count, src->entries,
 250             sizeof(camera_metadata_entry_t[src->entry_count]));
 251     memcpy(dst->data + dst->data_count, src->data,
 252             sizeof(uint8_t[src->data_count]));
 253     if (dst->data_count != 0) {
 254         unsigned int i;
 255         for (i = dst->entry_count;
 256              i < dst->entry_count + src->entry_count;
 257              i++) {
 258             camera_metadata_entry_t *entry = dst->entries + i;
 259             if ( camera_metadata_type_size[entry->type] * entry->count > 4 ) {
 260                 entry->data.offset += dst->data_count;
 261             }
 262         }
 263     }
 264     dst->entry_count += src->entry_count;
 265     dst->data_count += src->data_count;
 266     dst->flags &= ~FLAG_SORTED;
 267
 268     return OK;
 269 }
 270
 271 size_t calculate_camera_metadata_entry_data_size(uint8_t type,
 272         size_t data_count) {
 273     if (type >= NUM_TYPES) return 0;
 274     size_t data_bytes = data_count *
 275             camera_metadata_type_size[type];
 276     return data_bytes <= 4 ? 0 : data_bytes;
 277 }
 278
 279 static int add_camera_metadata_entry_raw(camera_metadata_t *dst,
 280         uint32_t tag,
 281         uint8_t  type,
 282         const void *data,
 283         size_t data_count) {
 284
 285     if (dst == NULL) return ERROR;
 286     if (dst->entry_count == dst->entry_capacity) return ERROR;
 287     if (data == NULL) return ERROR;
 288
 289     size_t data_bytes =
 290             calculate_camera_metadata_entry_data_size(type, data_count);
 291
 292     camera_metadata_entry_t *entry = dst->entries + dst->entry_count;
 293     entry->tag = tag;
 294     entry->type = type;
 295     entry->count = data_count;
 296
 297     if (data_bytes == 0) {
 298         memcpy(entry->data.value, data,
 299                 data_count * camera_metadata_type_size[type] );
 300     } else {
 301         entry->data.offset = dst->data_count;
 302         memcpy(dst->data + entry->data.offset, data, data_bytes);
 303         dst->data_count += data_bytes;
 304     }
 305     dst->entry_count++;
 306     dst->flags &= ~FLAG_SORTED;
 307     return OK;
 308 }
 309
 310 int add_camera_metadata_entry(camera_metadata_t *dst,
 311         uint32_t tag,
 312         const void *data,
 313         size_t data_count) {
 314
 315     int type = get_camera_metadata_tag_type(tag);
 316     if (type == -1) {
 317         ALOGE("%s: Unknown tag %04x.", __FUNCTION__, tag);
 318         return ERROR;
 319     }
 320
 321     return add_camera_metadata_entry_raw(dst,
 322             tag,
 323             type,
 324             data,
 325             data_count);
 326 }
 327
 328 static int compare_entry_tags(const void *p1, const void *p2) {
 329     uint32_t tag1 = ((camera_metadata_entry_t*)p1)->tag;
 330     uint32_t tag2 = ((camera_metadata_entry_t*)p2)->tag;
 331     return  tag1 < tag2 ? -1 :
 332             tag1 == tag2 ? 0 :
 333             1;
 334 }
 335
 336 int sort_camera_metadata(camera_metadata_t *dst) {
 337     if (dst == NULL) return ERROR;
 338     if (dst->flags & FLAG_SORTED) return OK;
 339
 340     qsort(dst->entries, dst->entry_count,
 341             sizeof(camera_metadata_entry_t),
 342             compare_entry_tags);
 343     dst->flags |= FLAG_SORTED;
 344
 345     return OK;
 346 }
 347
 348 int get_camera_metadata_entry(camera_metadata_t *src,
 349         uint32_t index,
 350         uint32_t *tag,
 351         uint8_t *type,
 352         void **data,
 353         size_t *data_count) {
 354     if (src == NULL ) return ERROR;
 355     if (index >= src->entry_count) return ERROR;
 356
 357     camera_metadata_entry_t *entry = src->entries + index;
 358
 359     if (tag != NULL) *tag = entry->tag;
 360     if (type != NULL) *type = entry->type;
 361     if (data_count != NULL) *data_count = entry->count;
 362     if (data != NULL) {
 363         if (entry->count * camera_metadata_type_size[entry->type] > 4) {
 364             *data = src->data + entry->data.offset;
 365         } else {
 366             *data = entry->data.value;
 367         }
 368     }
 369     return OK;
 370 }
 371
 372 int find_camera_metadata_entry(camera_metadata_t *src,
 373         uint32_t tag,
 374         uint8_t *type,
 375         void **data,
 376         size_t *data_count) {
 377     if (src == NULL) return ERROR;
 378
 379     camera_metadata_entry_t *entry = NULL;
 380     if (src->flags & FLAG_SORTED) {
 381         // Sorted entries, do a binary search
 382         camera_metadata_entry_t key;
 383         key.tag = tag;
 384         entry = bsearch(&key,
 385                 src->entries,
 386                 src->entry_count,
 387                 sizeof(camera_metadata_entry_t),
 388                 compare_entry_tags);
 389     } else {
 390         // Not sorted, linear search
 391         unsigned int i;
 392         for (i = 0; i < src->entry_count; i++) {
 393             if (src->entries[i].tag == tag) {
 394                 entry = src->entries + i;
 395                 break;
 396             }
 397         }
 398     }
 399     if (entry == NULL) return NOT_FOUND;
 400
 401     if (type != NULL) *type = entry->type;
 402     if (data_count != NULL) *data_count = entry->count;
 403     if (data != NULL) {
 404         if (entry->count * camera_metadata_type_size[entry->type] > 4) {
 405             *data = src->data + entry->data.offset;
 406         } else {
 407             *data = entry->data.value;
 408         }
 409     }
 410     return OK;
 411 }
 412
 413 static const vendor_tag_query_ops_t *vendor_tag_ops = NULL;
 414
 415 const char *get_camera_metadata_section_name(uint32_t tag) {
 416     uint32_t tag_section = tag >> 16;
 417     if (tag_section >= VENDOR_SECTION && vendor_tag_ops != NULL) {
 418         return vendor_tag_ops->get_camera_vendor_section_name(
 419             vendor_tag_ops,
 420             tag);
 421     }
 422     if (tag_section >= ANDROID_SECTION_COUNT) {
 423         return NULL;
 424     }
 425     return camera_metadata_section_names[tag_section];
 426 }
 427
 428 const char *get_camera_metadata_tag_name(uint32_t tag) {
 429     uint32_t tag_section = tag >> 16;
 430     if (tag_section >= VENDOR_SECTION && vendor_tag_ops != NULL) {
 431         return vendor_tag_ops->get_camera_vendor_tag_name(
 432             vendor_tag_ops,
 433             tag);
 434     }
 435     if (tag_section >= ANDROID_SECTION_COUNT ||
 436         tag >= camera_metadata_section_bounds[tag_section][1] ) {
 437         return NULL;
 438     }
 439     uint32_t tag_index = tag & 0xFFFF;
 440     return tag_info[tag_section][tag_index].tag_name;
 441 }
 442
 443 int get_camera_metadata_tag_type(uint32_t tag) {
 444     uint32_t tag_section = tag >> 16;
 445     if (tag_section >= VENDOR_SECTION && vendor_tag_ops != NULL) {
 446         return vendor_tag_ops->get_camera_vendor_tag_type(
 447             vendor_tag_ops,
 448             tag);
 449     }
 450     if (tag_section >= ANDROID_SECTION_COUNT ||
 451             tag >= camera_metadata_section_bounds[tag_section][1] ) {
 452         return -1;
 453     }
 454     uint32_t tag_index = tag & 0xFFFF;
 455     return tag_info[tag_section][tag_index].tag_type;
 456 }
 457
 458 int set_camera_metadata_vendor_tag_ops(const vendor_tag_query_ops_t *query_ops) {
 459     vendor_tag_ops = query_ops;
 460     return OK;
 461 }
 462
 463 static void print_data(int fd, const uint8_t *data_ptr, int type, int count);
 464
 465 void dump_camera_metadata(const camera_metadata_t *metadata,
 466         int fd,
 467         int verbosity) {
 468     if (metadata == NULL) {
 469         ALOGE("%s: Metadata is null.", __FUNCTION__);
 470         return;
 471     }
 472     unsigned int i;
 473     fdprintf(fd,
 474             "Dumping camera metadata array. %d entries, "
 475             "%d bytes of extra data.\n",
 476             metadata->entry_count, metadata->data_count);
 477     fdprintf(fd, "  (%d entries and %d bytes data reserved)\n",
 478             metadata->entry_capacity, metadata->data_capacity);
 479     fdprintf(fd, "  Version: %d, Flags: %08x\n",
 480             metadata->version, metadata->flags);
 481     for (i=0; i < metadata->entry_count; i++) {
 482         camera_metadata_entry_t *entry = metadata->entries + i;
 483
 484         const char *tag_name, *tag_section;
 485         tag_section = get_camera_metadata_section_name(entry->tag);
 486         if (tag_section == NULL) {
 487             tag_section = "unknownSection";
 488         }
 489         tag_name = get_camera_metadata_tag_name(entry->tag);
 490         if (tag_name == NULL) {
 491             tag_name = "unknownTag";
 492         }
 493         const char *type_name;
 494         if (entry->type >= NUM_TYPES) {
 495             type_name = "unknown";
 496         } else {
 497             type_name = camera_metadata_type_names[entry->type];
 498         }
 499         fdprintf(fd, "Tag: %s.%s (%05x): %s[%d]\n",
 500              tag_section,
 501              tag_name,
 502              entry->tag,
 503              type_name,
 504              entry->count);
 505
 506         if (verbosity < 1) continue;
 507
 508         if (entry->type >= NUM_TYPES) continue;
 509
 510         size_t type_size = camera_metadata_type_size[entry->type];
 511         uint8_t *data_ptr;
 512         if ( type_size * entry->count > 4 ) {
 513             if (entry->data.offset >= metadata->data_count) {
 514                 ALOGE("%s: Malformed entry data offset: %d (max %d)",
 515                         __FUNCTION__,
 516                         entry->data.offset,
 517                         metadata->data_count);
 518                 continue;
 519             }
 520             data_ptr = metadata->data + entry->data.offset;
 521         } else {
 522             data_ptr = entry->data.value;
 523         }
 524         int count = entry->count;
 525         if (verbosity < 2 && count > 16) count = 16;
 526
 527         print_data(fd, data_ptr, entry->type, count);
 528     }
 529 }
 530
 531 static void print_data(int fd, const uint8_t *data_ptr, int type, int count) {
 532     static int values_per_line[NUM_TYPES] = {
 533         [TYPE_BYTE]     = 16,
 534         [TYPE_INT32]    = 4,
 535         [TYPE_FLOAT]    = 8,
 536         [TYPE_INT64]    = 2,
 537         [TYPE_DOUBLE]   = 4,
 538         [TYPE_RATIONAL] = 2,
 539     };
 540     size_t type_size = camera_metadata_type_size[type];
 541
 542     int lines = count / values_per_line[type];
 543     if (count % values_per_line[type] != 0) lines++;
 544
 545     int index = 0;
 546     int j, k;
 547     for (j = 0; j < lines; j++) {
 548         fdprintf(fd, " [");
 549         for (k = 0;
 550              k < values_per_line[type] && count > 0;
 551              k++, count--, index += type_size) {
 552
 553             switch (type) {
 554                 case TYPE_BYTE:
 555                     fdprintf(fd, "%hhu ",
 556                             *(data_ptr + index));
 557                     break;
 558                 case TYPE_INT32:
 559                     fdprintf(fd, "%d ",
 560                             *(int32_t*)(data_ptr + index));
 561                     break;
 562                 case TYPE_FLOAT:
 563                     fdprintf(fd, "%0.2f ",
 564                             *(float*)(data_ptr + index));
 565                     break;
 566                 case TYPE_INT64:
 567                     fdprintf(fd, "%lld ",
 568                             *(int64_t*)(data_ptr + index));
 569                     break;
 570                 case TYPE_DOUBLE:
 571                     fdprintf(fd, "%0.2f ",
 572                             *(float*)(data_ptr + index));
 573                     break;
 574                 case TYPE_RATIONAL: {
 575                     int32_t numerator = *(int32_t*)(data_ptr + index);
 576                     int32_t denominator = *(int32_t*)(data_ptr + index + 4);
 577                     fdprintf(fd, "(%d / %d) ",
 578                             numerator, denominator);
 579                     break;
 580                 }
 581                 default:
 582                     fdprintf(fd, "??? ");
 583             }
 584         }
 585         fdprintf(fd, "]\n");
 586     }
 587 }