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 17 #define LOG_TAG "camera_metadata" 18 19 #include <system/camera_metadata.h> 20 #include <camera_metadata_hidden.h> 21 22 #include <assert.h> 23 #include <errno.h> 24 #include <inttypes.h> 25 #include <stdio.h> 26 #include <stdlib.h> 27 28 #include <log/log.h> 29 30 #define OK 0 31 #define ERROR 1 32 #define NOT_FOUND (-ENOENT) 33 #define SN_EVENT_LOG_ID 0x534e4554 34 35 #define ALIGN_TO(val, alignment) \ 36 (((uintptr_t)(val) + ((alignment) - 1)) & ~((alignment) - 1)) 37 38 /** 39 * A single metadata entry, storing an array of values of a given type. If the 40 * array is no larger than 4 bytes in size, it is stored in the data.value[] 41 * array; otherwise, it can found in the parent's data array at index 42 * data.offset. 43 */ 44 #define ENTRY_ALIGNMENT ((size_t) 4) 45 typedef struct camera_metadata_buffer_entry { 46 uint32_t tag; 47 uint32_t count; 48 union { 49 uint32_t offset; 50 uint8_t value[4]; 51 } data; 52 uint8_t type; 53 uint8_t reserved[3]; 54 } camera_metadata_buffer_entry_t; 55 56 typedef uint32_t metadata_uptrdiff_t; 57 typedef uint32_t metadata_size_t; 58 59 /** 60 * A packet of metadata. This is a list of entries, each of which may point to 61 * its values stored at an offset in data. 62 * 63 * It is assumed by the utility functions that the memory layout of the packet 64 * is as follows: 65 * 66 * |-----------------------------------------------| 67 * | camera_metadata_t | 68 * | | 69 * |-----------------------------------------------| 70 * | reserved for future expansion | 71 * |-----------------------------------------------| 72 * | camera_metadata_buffer_entry_t #0 | 73 * |-----------------------------------------------| 74 * | .... | 75 * |-----------------------------------------------| 76 * | camera_metadata_buffer_entry_t #entry_count-1 | 77 * |-----------------------------------------------| 78 * | free space for | 79 * | (entry_capacity-entry_count) entries | 80 * |-----------------------------------------------| 81 * | start of camera_metadata.data | 82 * | | 83 * |-----------------------------------------------| 84 * | free space for | 85 * | (data_capacity-data_count) bytes | 86 * |-----------------------------------------------| 87 * 88 * With the total length of the whole packet being camera_metadata.size bytes. 89 * 90 * In short, the entries and data are contiguous in memory after the metadata 91 * header. 92 */ 93 #define METADATA_ALIGNMENT ((size_t) 4) 94 struct camera_metadata { 95 metadata_size_t size; 96 uint32_t version; 97 uint32_t flags; 98 metadata_size_t entry_count; 99 metadata_size_t entry_capacity; 100 metadata_uptrdiff_t entries_start; // Offset from camera_metadata 101 metadata_size_t data_count; 102 metadata_size_t data_capacity; 103 metadata_uptrdiff_t data_start; // Offset from camera_metadata 104 uint32_t padding; // padding to 8 bytes boundary 105 metadata_vendor_id_t vendor_id; 106 }; 107 108 /** 109 * A datum of metadata. This corresponds to camera_metadata_entry_t::data 110 * with the difference that each element is not a pointer. We need to have a 111 * non-pointer type description in order to figure out the largest alignment 112 * requirement for data (DATA_ALIGNMENT). 113 */ 114 #define DATA_ALIGNMENT ((size_t) 8) 115 typedef union camera_metadata_data { 116 uint8_t u8; 117 int32_t i32; 118 float f; 119 int64_t i64; 120 double d; 121 camera_metadata_rational_t r; 122 } camera_metadata_data_t; 123 124 _Static_assert(sizeof(metadata_size_t) == 4, 125 "Size of metadata_size_t must be 4"); 126 _Static_assert(sizeof(metadata_uptrdiff_t) == 4, 127 "Size of metadata_uptrdiff_t must be 4"); 128 _Static_assert(sizeof(metadata_vendor_id_t) == 8, 129 "Size of metadata_vendor_id_t must be 8"); 130 _Static_assert(sizeof(camera_metadata_data_t) == 8, 131 "Size of camera_metadata_data_t must be 8"); 132 133 _Static_assert(offsetof(camera_metadata_buffer_entry_t, tag) == 0, 134 "Offset of tag must be 0"); 135 _Static_assert(offsetof(camera_metadata_buffer_entry_t, count) == 4, 136 "Offset of count must be 4"); 137 _Static_assert(offsetof(camera_metadata_buffer_entry_t, data) == 8, 138 "Offset of data must be 8"); 139 _Static_assert(offsetof(camera_metadata_buffer_entry_t, type) == 12, 140 "Offset of type must be 12"); 141 _Static_assert(sizeof(camera_metadata_buffer_entry_t) == 16, 142 "Size of camera_metadata_buffer_entry_t must be 16"); 143 144 _Static_assert(offsetof(camera_metadata_t, size) == 0, 145 "Offset of size must be 0"); 146 _Static_assert(offsetof(camera_metadata_t, version) == 4, 147 "Offset of version must be 4"); 148 _Static_assert(offsetof(camera_metadata_t, flags) == 8, 149 "Offset of flags must be 8"); 150 _Static_assert(offsetof(camera_metadata_t, entry_count) == 12, 151 "Offset of entry_count must be 12"); 152 _Static_assert(offsetof(camera_metadata_t, entry_capacity) == 16, 153 "Offset of entry_capacity must be 16"); 154 _Static_assert(offsetof(camera_metadata_t, entries_start) == 20, 155 "Offset of entries_start must be 20"); 156 _Static_assert(offsetof(camera_metadata_t, data_count) == 24, 157 "Offset of data_count must be 24"); 158 _Static_assert(offsetof(camera_metadata_t, data_capacity) == 28, 159 "Offset of data_capacity must be 28"); 160 _Static_assert(offsetof(camera_metadata_t, data_start) == 32, 161 "Offset of data_start must be 32"); 162 _Static_assert(offsetof(camera_metadata_t, vendor_id) == 40, 163 "Offset of vendor_id must be 40"); 164 _Static_assert(sizeof(camera_metadata_t) == 48, 165 "Size of camera_metadata_t must be 48"); 166 167 /** 168 * The preferred alignment of a packet of camera metadata. In general, 169 * this is the lowest common multiple of the constituents of a metadata 170 * package, i.e, of DATA_ALIGNMENT and ENTRY_ALIGNMENT. 171 */ 172 #define MAX_ALIGNMENT(A, B) (((A) > (B)) ? (A) : (B)) 173 #define METADATA_PACKET_ALIGNMENT \ 174 MAX_ALIGNMENT(MAX_ALIGNMENT(DATA_ALIGNMENT, METADATA_ALIGNMENT), ENTRY_ALIGNMENT) 175 176 /** Versioning information */ 177 #define CURRENT_METADATA_VERSION 1 178 179 /** Flag definitions */ 180 #define FLAG_SORTED 0x00000001 181 182 /** Tag information */ 183 184 typedef struct tag_info { 185 const char *tag_name; 186 uint8_t tag_type; 187 } tag_info_t; 188 189 #include "camera_metadata_tag_info.c" 190 191 const size_t camera_metadata_type_size[NUM_TYPES] = { 192 [TYPE_BYTE] = sizeof(uint8_t), 193 [TYPE_INT32] = sizeof(int32_t), 194 [TYPE_FLOAT] = sizeof(float), 195 [TYPE_INT64] = sizeof(int64_t), 196 [TYPE_DOUBLE] = sizeof(double), 197 [TYPE_RATIONAL] = sizeof(camera_metadata_rational_t) 198 }; 199 200 const char *camera_metadata_type_names[NUM_TYPES] = { 201 [TYPE_BYTE] = "byte", 202 [TYPE_INT32] = "int32", 203 [TYPE_FLOAT] = "float", 204 [TYPE_INT64] = "int64", 205 [TYPE_DOUBLE] = "double", 206 [TYPE_RATIONAL] = "rational" 207 }; 208 209 static camera_metadata_buffer_entry_t *get_entries( 210 const camera_metadata_t *metadata) { 211 return (camera_metadata_buffer_entry_t*) 212 ((uint8_t*)metadata + metadata->entries_start); 213 } 214 215 static uint8_t *get_data(const camera_metadata_t *metadata) { 216 return (uint8_t*)metadata + metadata->data_start; 217 } 218 219 size_t get_camera_metadata_alignment() { 220 return METADATA_PACKET_ALIGNMENT; 221 } 222 223 camera_metadata_t *allocate_copy_camera_metadata_checked( 224 const camera_metadata_t *src, 225 size_t src_size) { 226 227 if (src == NULL) { 228 return NULL; 229 } 230 231 void *buffer = malloc(src_size); 232 memcpy(buffer, src, src_size); 233 234 camera_metadata_t *metadata = (camera_metadata_t*) buffer; 235 if (validate_camera_metadata_structure(metadata, &src_size) != OK) { 236 free(buffer); 237 return NULL; 238 } 239 240 return metadata; 241 } 242 243 camera_metadata_t *allocate_camera_metadata(size_t entry_capacity, 244 size_t data_capacity) { 245 246 size_t memory_needed = calculate_camera_metadata_size(entry_capacity, 247 data_capacity); 248 void *buffer = malloc(memory_needed); 249 camera_metadata_t *metadata = place_camera_metadata( 250 buffer, memory_needed, entry_capacity, data_capacity); 251 if (!metadata) { 252 /* This should not happen when memory_needed is the same 253 * calculated in this function and in place_camera_metadata. 254 */ 255 free(buffer); 256 } 257 return metadata; 258 } 259 260 camera_metadata_t *place_camera_metadata(void *dst, 261 size_t dst_size, 262 size_t entry_capacity, 263 size_t data_capacity) { 264 if (dst == NULL) return NULL; 265 266 size_t memory_needed = calculate_camera_metadata_size(entry_capacity, 267 data_capacity); 268 if (memory_needed > dst_size) return NULL; 269 270 camera_metadata_t *metadata = (camera_metadata_t*)dst; 271 metadata->version = CURRENT_METADATA_VERSION; 272 metadata->flags = 0; 273 metadata->entry_count = 0; 274 metadata->entry_capacity = entry_capacity; 275 metadata->entries_start = 276 ALIGN_TO(sizeof(camera_metadata_t), ENTRY_ALIGNMENT); 277 metadata->data_count = 0; 278 metadata->data_capacity = data_capacity; 279 metadata->size = memory_needed; 280 size_t data_unaligned = (uint8_t*)(get_entries(metadata) + 281 metadata->entry_capacity) - (uint8_t*)metadata; 282 metadata->data_start = ALIGN_TO(data_unaligned, DATA_ALIGNMENT); 283 metadata->vendor_id = CAMERA_METADATA_INVALID_VENDOR_ID; 284 285 assert(validate_camera_metadata_structure(metadata, NULL) == OK); 286 return metadata; 287 } 288 void free_camera_metadata(camera_metadata_t *metadata) { 289 free(metadata); 290 } 291 292 size_t calculate_camera_metadata_size(size_t entry_count, 293 size_t data_count) { 294 size_t memory_needed = sizeof(camera_metadata_t); 295 // Start entry list at aligned boundary 296 memory_needed = ALIGN_TO(memory_needed, ENTRY_ALIGNMENT); 297 memory_needed += sizeof(camera_metadata_buffer_entry_t[entry_count]); 298 // Start buffer list at aligned boundary 299 memory_needed = ALIGN_TO(memory_needed, DATA_ALIGNMENT); 300 memory_needed += sizeof(uint8_t[data_count]); 301 // Make sure camera metadata can be stacked in continuous memory 302 memory_needed = ALIGN_TO(memory_needed, METADATA_PACKET_ALIGNMENT); 303 return memory_needed; 304 } 305 306 size_t get_camera_metadata_size(const camera_metadata_t *metadata) { 307 if (metadata == NULL) return ERROR; 308 309 return metadata->size; 310 } 311 312 size_t get_camera_metadata_compact_size(const camera_metadata_t *metadata) { 313 if (metadata == NULL) return ERROR; 314 315 return calculate_camera_metadata_size(metadata->entry_count, 316 metadata->data_count); 317 } 318 319 size_t get_camera_metadata_entry_count(const camera_metadata_t *metadata) { 320 return metadata->entry_count; 321 } 322 323 size_t get_camera_metadata_entry_capacity(const camera_metadata_t *metadata) { 324 return metadata->entry_capacity; 325 } 326 327 size_t get_camera_metadata_data_count(const camera_metadata_t *metadata) { 328 return metadata->data_count; 329 } 330 331 size_t get_camera_metadata_data_capacity(const camera_metadata_t *metadata) { 332 return metadata->data_capacity; 333 } 334 335 camera_metadata_t* copy_camera_metadata(void *dst, size_t dst_size, 336 const camera_metadata_t *src) { 337 size_t memory_needed = get_camera_metadata_compact_size(src); 338 339 if (dst == NULL) return NULL; 340 if (dst_size < memory_needed) return NULL; 341 342 camera_metadata_t *metadata = 343 place_camera_metadata(dst, dst_size, src->entry_count, src->data_count); 344 345 metadata->flags = src->flags; 346 metadata->entry_count = src->entry_count; 347 metadata->data_count = src->data_count; 348 metadata->vendor_id = src->vendor_id; 349 350 memcpy(get_entries(metadata), get_entries(src), 351 sizeof(camera_metadata_buffer_entry_t[metadata->entry_count])); 352 memcpy(get_data(metadata), get_data(src), 353 sizeof(uint8_t[metadata->data_count])); 354 355 assert(validate_camera_metadata_structure(metadata, NULL) == OK); 356 return metadata; 357 } 358 359 // This method should be used when the camera metadata cannot be trusted. For example, when it's 360 // read from Parcel. 361 static int validate_and_calculate_camera_metadata_entry_data_size(size_t *data_size, uint8_t type, 362 size_t data_count) { 363 if (type >= NUM_TYPES) return ERROR; 364 365 // Check for overflow 366 if (data_count != 0 && 367 camera_metadata_type_size[type] > (SIZE_MAX - DATA_ALIGNMENT + 1) / data_count) { 368 android_errorWriteLog(SN_EVENT_LOG_ID, "30741779"); 369 return ERROR; 370 } 371 372 size_t data_bytes = data_count * camera_metadata_type_size[type]; 373 374 if (data_size) { 375 *data_size = data_bytes <= 4 ? 0 : ALIGN_TO(data_bytes, DATA_ALIGNMENT); 376 } 377 378 return OK; 379 } 380 381 size_t calculate_camera_metadata_entry_data_size(uint8_t type, 382 size_t data_count) { 383 if (type >= NUM_TYPES) return 0; 384 385 size_t data_bytes = data_count * 386 camera_metadata_type_size[type]; 387 388 return data_bytes <= 4 ? 0 : ALIGN_TO(data_bytes, DATA_ALIGNMENT); 389 } 390 391 int validate_camera_metadata_structure(const camera_metadata_t *metadata, 392 const size_t *expected_size) { 393 394 if (metadata == NULL) { 395 ALOGE("%s: metadata is null!", __FUNCTION__); 396 return CAMERA_METADATA_VALIDATION_ERROR; 397 } 398 399 uintptr_t aligned_ptr = ALIGN_TO(metadata, METADATA_PACKET_ALIGNMENT); 400 const uintptr_t alignmentOffset = aligned_ptr - (uintptr_t) metadata; 401 402 // Check that the metadata pointer is well-aligned first. 403 { 404 static const struct { 405 const char *name; 406 size_t alignment; 407 } alignments[] = { 408 { 409 .name = "camera_metadata", 410 .alignment = METADATA_ALIGNMENT 411 }, 412 { 413 .name = "camera_metadata_buffer_entry", 414 .alignment = ENTRY_ALIGNMENT 415 }, 416 { 417 .name = "camera_metadata_data", 418 .alignment = DATA_ALIGNMENT 419 }, 420 }; 421 422 for (size_t i = 0; i < sizeof(alignments)/sizeof(alignments[0]); ++i) { 423 uintptr_t aligned_ptr = ALIGN_TO((uintptr_t) metadata + alignmentOffset, 424 alignments[i].alignment); 425 426 if ((uintptr_t)metadata + alignmentOffset != aligned_ptr) { 427 ALOGE("%s: Metadata pointer is not aligned (actual %p, " 428 "expected %p, offset %" PRIuPTR ") to type %s", 429 __FUNCTION__, metadata, 430 (void*)aligned_ptr, alignmentOffset, alignments[i].name); 431 return CAMERA_METADATA_VALIDATION_ERROR; 432 } 433 } 434 } 435 436 /** 437 * Check that the metadata contents are correct 438 */ 439 440 if (expected_size != NULL && metadata->size > *expected_size) { 441 ALOGE("%s: Metadata size (%" PRIu32 ") should be <= expected size (%zu)", 442 __FUNCTION__, metadata->size, *expected_size); 443 return CAMERA_METADATA_VALIDATION_ERROR; 444 } 445 446 if (metadata->entry_count > metadata->entry_capacity) { 447 ALOGE("%s: Entry count (%" PRIu32 ") should be <= entry capacity " 448 "(%" PRIu32 ")", 449 __FUNCTION__, metadata->entry_count, metadata->entry_capacity); 450 return CAMERA_METADATA_VALIDATION_ERROR; 451 } 452 453 if (metadata->data_count > metadata->data_capacity) { 454 ALOGE("%s: Data count (%" PRIu32 ") should be <= data capacity " 455 "(%" PRIu32 ")", 456 __FUNCTION__, metadata->data_count, metadata->data_capacity); 457 android_errorWriteLog(SN_EVENT_LOG_ID, "30591838"); 458 return CAMERA_METADATA_VALIDATION_ERROR; 459 } 460 461 const metadata_uptrdiff_t entries_end = 462 metadata->entries_start + metadata->entry_capacity; 463 if (entries_end < metadata->entries_start || // overflow check 464 entries_end > metadata->data_start) { 465 466 ALOGE("%s: Entry start + capacity (%" PRIu32 ") should be <= data start " 467 "(%" PRIu32 ")", 468 __FUNCTION__, 469 (metadata->entries_start + metadata->entry_capacity), 470 metadata->data_start); 471 return CAMERA_METADATA_VALIDATION_ERROR; 472 } 473 474 const metadata_uptrdiff_t data_end = 475 metadata->data_start + metadata->data_capacity; 476 if (data_end < metadata->data_start || // overflow check 477 data_end > metadata->size) { 478 479 ALOGE("%s: Data start + capacity (%" PRIu32 ") should be <= total size " 480 "(%" PRIu32 ")", 481 __FUNCTION__, 482 (metadata->data_start + metadata->data_capacity), 483 metadata->size); 484 return CAMERA_METADATA_VALIDATION_ERROR; 485 } 486 487 // Validate each entry 488 const metadata_size_t entry_count = metadata->entry_count; 489 camera_metadata_buffer_entry_t *entries = get_entries(metadata); 490 491 for (size_t i = 0; i < entry_count; ++i) { 492 493 if ((uintptr_t)&entries[i] + alignmentOffset != 494 ALIGN_TO((uintptr_t)&entries[i] + alignmentOffset, ENTRY_ALIGNMENT)) { 495 ALOGE("%s: Entry index %zu had bad alignment (address %p)," 496 " expected alignment %zu", 497 __FUNCTION__, i, &entries[i], ENTRY_ALIGNMENT); 498 return CAMERA_METADATA_VALIDATION_ERROR; 499 } 500 501 camera_metadata_buffer_entry_t entry = entries[i]; 502 503 if (entry.type >= NUM_TYPES) { 504 ALOGE("%s: Entry index %zu had a bad type %d", 505 __FUNCTION__, i, entry.type); 506 return CAMERA_METADATA_VALIDATION_ERROR; 507 } 508 509 // TODO: fix vendor_tag_ops across processes so we don't need to special 510 // case vendor-specific tags 511 uint32_t tag_section = entry.tag >> 16; 512 int tag_type = get_local_camera_metadata_tag_type(entry.tag, metadata); 513 if (tag_type != (int)entry.type && tag_section < VENDOR_SECTION) { 514 ALOGE("%s: Entry index %zu had tag type %d, but the type was %d", 515 __FUNCTION__, i, tag_type, entry.type); 516 return CAMERA_METADATA_VALIDATION_ERROR; 517 } 518 519 size_t data_size; 520 if (validate_and_calculate_camera_metadata_entry_data_size(&data_size, entry.type, 521 entry.count) != OK) { 522 ALOGE("%s: Entry data size is invalid. type: %u count: %u", __FUNCTION__, entry.type, 523 entry.count); 524 return CAMERA_METADATA_VALIDATION_ERROR; 525 } 526 527 if (data_size != 0) { 528 camera_metadata_data_t *data = 529 (camera_metadata_data_t*) (get_data(metadata) + 530 entry.data.offset); 531 532 if ((uintptr_t)data + alignmentOffset != 533 ALIGN_TO((uintptr_t)data + alignmentOffset, DATA_ALIGNMENT)) { 534 ALOGE("%s: Entry index %zu had bad data alignment (address %p)," 535 " expected align %zu, (tag name %s, data size %zu)", 536 __FUNCTION__, i, data, DATA_ALIGNMENT, 537 get_local_camera_metadata_tag_name(entry.tag, metadata) ? 538 : "unknown", data_size); 539 return CAMERA_METADATA_VALIDATION_ERROR; 540 } 541 542 size_t data_entry_end = entry.data.offset + data_size; 543 if (data_entry_end < entry.data.offset || // overflow check 544 data_entry_end > metadata->data_capacity) { 545 546 ALOGE("%s: Entry index %zu data ends (%zu) beyond the capacity " 547 "%" PRIu32, __FUNCTION__, i, data_entry_end, 548 metadata->data_capacity); 549 return CAMERA_METADATA_VALIDATION_ERROR; 550 } 551 552 } else if (entry.count == 0) { 553 if (entry.data.offset != 0) { 554 ALOGE("%s: Entry index %zu had 0 items, but offset was non-0 " 555 "(%" PRIu32 "), tag name: %s", __FUNCTION__, i, entry.data.offset, 556 get_local_camera_metadata_tag_name(entry.tag, metadata) ? : "unknown"); 557 return CAMERA_METADATA_VALIDATION_ERROR; 558 } 559 } // else data stored inline, so we look at value which can be anything. 560 } 561 562 if (alignmentOffset == 0) { 563 return OK; 564 } 565 return CAMERA_METADATA_VALIDATION_SHIFTED; 566 } 567 568 int append_camera_metadata(camera_metadata_t *dst, 569 const camera_metadata_t *src) { 570 if (dst == NULL || src == NULL ) return ERROR; 571 572 // Check for overflow 573 if (src->entry_count + dst->entry_count < src->entry_count) return ERROR; 574 if (src->data_count + dst->data_count < src->data_count) return ERROR; 575 // Check for space 576 if (dst->entry_capacity < src->entry_count + dst->entry_count) return ERROR; 577 if (dst->data_capacity < src->data_count + dst->data_count) return ERROR; 578 579 if ((dst->vendor_id != CAMERA_METADATA_INVALID_VENDOR_ID) && 580 (src->vendor_id != CAMERA_METADATA_INVALID_VENDOR_ID)) { 581 if (dst->vendor_id != src->vendor_id) { 582 ALOGE("%s: Append for metadata from different vendors is" 583 "not supported!", __func__); 584 return ERROR; 585 } 586 } 587 588 memcpy(get_entries(dst) + dst->entry_count, get_entries(src), 589 sizeof(camera_metadata_buffer_entry_t[src->entry_count])); 590 memcpy(get_data(dst) + dst->data_count, get_data(src), 591 sizeof(uint8_t[src->data_count])); 592 if (dst->data_count != 0) { 593 camera_metadata_buffer_entry_t *entry = get_entries(dst) + dst->entry_count; 594 for (size_t i = 0; i < src->entry_count; i++, entry++) { 595 if ( calculate_camera_metadata_entry_data_size(entry->type, 596 entry->count) > 0 ) { 597 entry->data.offset += dst->data_count; 598 } 599 } 600 } 601 if (dst->entry_count == 0) { 602 // Appending onto empty buffer, keep sorted state 603 dst->flags |= src->flags & FLAG_SORTED; 604 } else if (src->entry_count != 0) { 605 // Both src, dst are nonempty, cannot assume sort remains 606 dst->flags &= ~FLAG_SORTED; 607 } else { 608 // Src is empty, keep dst sorted state 609 } 610 dst->entry_count += src->entry_count; 611 dst->data_count += src->data_count; 612 613 if (dst->vendor_id == CAMERA_METADATA_INVALID_VENDOR_ID) { 614 dst->vendor_id = src->vendor_id; 615 } 616 617 assert(validate_camera_metadata_structure(dst, NULL) == OK); 618 return OK; 619 } 620 621 camera_metadata_t *clone_camera_metadata(const camera_metadata_t *src) { 622 int res; 623 if (src == NULL) return NULL; 624 camera_metadata_t *clone = allocate_camera_metadata( 625 get_camera_metadata_entry_count(src), 626 get_camera_metadata_data_count(src)); 627 if (clone != NULL) { 628 res = append_camera_metadata(clone, src); 629 if (res != OK) { 630 free_camera_metadata(clone); 631 clone = NULL; 632 } 633 } 634 assert(validate_camera_metadata_structure(clone, NULL) == OK); 635 return clone; 636 } 637 638 static int add_camera_metadata_entry_raw(camera_metadata_t *dst, 639 uint32_t tag, 640 uint8_t type, 641 const void *data, 642 size_t data_count) { 643 644 if (dst == NULL) return ERROR; 645 if (dst->entry_count == dst->entry_capacity) return ERROR; 646 if (data_count && data == NULL) return ERROR; 647 648 size_t data_bytes = 649 calculate_camera_metadata_entry_data_size(type, data_count); 650 if (data_bytes + dst->data_count > dst->data_capacity) return ERROR; 651 652 size_t data_payload_bytes = 653 data_count * camera_metadata_type_size[type]; 654 camera_metadata_buffer_entry_t *entry = get_entries(dst) + dst->entry_count; 655 memset(entry, 0, sizeof(camera_metadata_buffer_entry_t)); 656 entry->tag = tag; 657 entry->type = type; 658 entry->count = data_count; 659 660 if (data_bytes == 0) { 661 memcpy(entry->data.value, data, 662 data_payload_bytes); 663 } else { 664 entry->data.offset = dst->data_count; 665 memcpy(get_data(dst) + entry->data.offset, data, 666 data_payload_bytes); 667 dst->data_count += data_bytes; 668 } 669 dst->entry_count++; 670 dst->flags &= ~FLAG_SORTED; 671 assert(validate_camera_metadata_structure(dst, NULL) == OK); 672 return OK; 673 } 674 675 int add_camera_metadata_entry(camera_metadata_t *dst, 676 uint32_t tag, 677 const void *data, 678 size_t data_count) { 679 680 int type = get_local_camera_metadata_tag_type(tag, dst); 681 if (type == -1) { 682 ALOGE("%s: Unknown tag %04x.", __FUNCTION__, tag); 683 return ERROR; 684 } 685 686 return add_camera_metadata_entry_raw(dst, 687 tag, 688 type, 689 data, 690 data_count); 691 } 692 693 static int compare_entry_tags(const void *p1, const void *p2) { 694 uint32_t tag1 = ((camera_metadata_buffer_entry_t*)p1)->tag; 695 uint32_t tag2 = ((camera_metadata_buffer_entry_t*)p2)->tag; 696 return tag1 < tag2 ? -1 : 697 tag1 == tag2 ? 0 : 698 1; 699 } 700 701 int sort_camera_metadata(camera_metadata_t *dst) { 702 if (dst == NULL) return ERROR; 703 if (dst->flags & FLAG_SORTED) return OK; 704 705 qsort(get_entries(dst), dst->entry_count, 706 sizeof(camera_metadata_buffer_entry_t), 707 compare_entry_tags); 708 dst->flags |= FLAG_SORTED; 709 710 assert(validate_camera_metadata_structure(dst, NULL) == OK); 711 return OK; 712 } 713 714 int get_camera_metadata_entry(camera_metadata_t *src, 715 size_t index, 716 camera_metadata_entry_t *entry) { 717 if (src == NULL || entry == NULL) return ERROR; 718 if (index >= src->entry_count) return ERROR; 719 720 camera_metadata_buffer_entry_t *buffer_entry = get_entries(src) + index; 721 722 entry->index = index; 723 entry->tag = buffer_entry->tag; 724 entry->type = buffer_entry->type; 725 entry->count = buffer_entry->count; 726 if (buffer_entry->count * 727 camera_metadata_type_size[buffer_entry->type] > 4) { 728 entry->data.u8 = get_data(src) + buffer_entry->data.offset; 729 } else { 730 entry->data.u8 = buffer_entry->data.value; 731 } 732 return OK; 733 } 734 735 int get_camera_metadata_ro_entry(const camera_metadata_t *src, 736 size_t index, 737 camera_metadata_ro_entry_t *entry) { 738 return get_camera_metadata_entry((camera_metadata_t*)src, index, 739 (camera_metadata_entry_t*)entry); 740 } 741 742 int find_camera_metadata_entry(camera_metadata_t *src, 743 uint32_t tag, 744 camera_metadata_entry_t *entry) { 745 if (src == NULL) return ERROR; 746 747 uint32_t index; 748 if (src->flags & FLAG_SORTED) { 749 // Sorted entries, do a binary search 750 camera_metadata_buffer_entry_t *search_entry = NULL; 751 camera_metadata_buffer_entry_t key; 752 key.tag = tag; 753 search_entry = bsearch(&key, 754 get_entries(src), 755 src->entry_count, 756 sizeof(camera_metadata_buffer_entry_t), 757 compare_entry_tags); 758 if (search_entry == NULL) return NOT_FOUND; 759 index = search_entry - get_entries(src); 760 } else { 761 // Not sorted, linear search 762 camera_metadata_buffer_entry_t *search_entry = get_entries(src); 763 for (index = 0; index < src->entry_count; index++, search_entry++) { 764 if (search_entry->tag == tag) { 765 break; 766 } 767 } 768 if (index == src->entry_count) return NOT_FOUND; 769 } 770 771 return get_camera_metadata_entry(src, index, 772 entry); 773 } 774 775 int find_camera_metadata_ro_entry(const camera_metadata_t *src, 776 uint32_t tag, 777 camera_metadata_ro_entry_t *entry) { 778 return find_camera_metadata_entry((camera_metadata_t*)src, tag, 779 (camera_metadata_entry_t*)entry); 780 } 781 782 783 int delete_camera_metadata_entry(camera_metadata_t *dst, 784 size_t index) { 785 if (dst == NULL) return ERROR; 786 if (index >= dst->entry_count) return ERROR; 787 788 camera_metadata_buffer_entry_t *entry = get_entries(dst) + index; 789 size_t data_bytes = calculate_camera_metadata_entry_data_size(entry->type, 790 entry->count); 791 792 if (data_bytes > 0) { 793 // Shift data buffer to overwrite deleted data 794 uint8_t *start = get_data(dst) + entry->data.offset; 795 uint8_t *end = start + data_bytes; 796 size_t length = dst->data_count - entry->data.offset - data_bytes; 797 memmove(start, end, length); 798 799 // Update all entry indices to account for shift 800 camera_metadata_buffer_entry_t *e = get_entries(dst); 801 size_t i; 802 for (i = 0; i < dst->entry_count; i++) { 803 if (calculate_camera_metadata_entry_data_size( 804 e->type, e->count) > 0 && 805 e->data.offset > entry->data.offset) { 806 e->data.offset -= data_bytes; 807 } 808 ++e; 809 } 810 dst->data_count -= data_bytes; 811 } 812 // Shift entry array 813 memmove(entry, entry + 1, 814 sizeof(camera_metadata_buffer_entry_t) * 815 (dst->entry_count - index - 1) ); 816 dst->entry_count -= 1; 817 818 assert(validate_camera_metadata_structure(dst, NULL) == OK); 819 return OK; 820 } 821 822 int update_camera_metadata_entry(camera_metadata_t *dst, 823 size_t index, 824 const void *data, 825 size_t data_count, 826 camera_metadata_entry_t *updated_entry) { 827 if (dst == NULL) return ERROR; 828 if (index >= dst->entry_count) return ERROR; 829 830 camera_metadata_buffer_entry_t *entry = get_entries(dst) + index; 831 832 size_t data_bytes = 833 calculate_camera_metadata_entry_data_size(entry->type, 834 data_count); 835 size_t data_payload_bytes = 836 data_count * camera_metadata_type_size[entry->type]; 837 838 size_t entry_bytes = 839 calculate_camera_metadata_entry_data_size(entry->type, 840 entry->count); 841 if (data_bytes != entry_bytes) { 842 // May need to shift/add to data array 843 if (dst->data_capacity < dst->data_count + data_bytes - entry_bytes) { 844 // No room 845 return ERROR; 846 } 847 if (entry_bytes != 0) { 848 // Remove old data 849 uint8_t *start = get_data(dst) + entry->data.offset; 850 uint8_t *end = start + entry_bytes; 851 size_t length = dst->data_count - entry->data.offset - entry_bytes; 852 memmove(start, end, length); 853 dst->data_count -= entry_bytes; 854 855 // Update all entry indices to account for shift 856 camera_metadata_buffer_entry_t *e = get_entries(dst); 857 size_t i; 858 for (i = 0; i < dst->entry_count; i++) { 859 if (calculate_camera_metadata_entry_data_size( 860 e->type, e->count) > 0 && 861 e->data.offset > entry->data.offset) { 862 e->data.offset -= entry_bytes; 863 } 864 ++e; 865 } 866 } 867 868 if (data_bytes != 0) { 869 // Append new data 870 entry->data.offset = dst->data_count; 871 872 memcpy(get_data(dst) + entry->data.offset, data, data_payload_bytes); 873 dst->data_count += data_bytes; 874 } 875 } else if (data_bytes != 0) { 876 // data size unchanged, reuse same data location 877 memcpy(get_data(dst) + entry->data.offset, data, data_payload_bytes); 878 } 879 880 if (data_bytes == 0) { 881 // Data fits into entry 882 memcpy(entry->data.value, data, 883 data_payload_bytes); 884 } 885 886 entry->count = data_count; 887 888 if (updated_entry != NULL) { 889 get_camera_metadata_entry(dst, 890 index, 891 updated_entry); 892 } 893 894 assert(validate_camera_metadata_structure(dst, NULL) == OK); 895 return OK; 896 } 897 898 static const vendor_tag_ops_t *vendor_tag_ops = NULL; 899 static const struct vendor_tag_cache_ops *vendor_cache_ops = NULL; 900 901 // Declared in system/media/private/camera/include/camera_metadata_hidden.h 902 const char *get_local_camera_metadata_section_name_vendor_id(uint32_t tag, 903 metadata_vendor_id_t id) { 904 uint32_t tag_section = tag >> 16; 905 if (tag_section >= VENDOR_SECTION && vendor_cache_ops != NULL && 906 id != CAMERA_METADATA_INVALID_VENDOR_ID) { 907 return vendor_cache_ops->get_section_name(tag, id); 908 } else if (tag_section >= VENDOR_SECTION && vendor_tag_ops != NULL) { 909 return vendor_tag_ops->get_section_name( 910 vendor_tag_ops, 911 tag); 912 } 913 if (tag_section >= ANDROID_SECTION_COUNT) { 914 return NULL; 915 } 916 return camera_metadata_section_names[tag_section]; 917 } 918 919 // Declared in system/media/private/camera/include/camera_metadata_hidden.h 920 const char *get_local_camera_metadata_tag_name_vendor_id(uint32_t tag, 921 metadata_vendor_id_t id) { 922 uint32_t tag_section = tag >> 16; 923 if (tag_section >= VENDOR_SECTION && vendor_cache_ops != NULL && 924 id != CAMERA_METADATA_INVALID_VENDOR_ID) { 925 return vendor_cache_ops->get_tag_name(tag, id); 926 } else if (tag_section >= VENDOR_SECTION && vendor_tag_ops != NULL) { 927 return vendor_tag_ops->get_tag_name( 928 vendor_tag_ops, 929 tag); 930 } 931 if (tag_section >= ANDROID_SECTION_COUNT || 932 tag >= camera_metadata_section_bounds[tag_section][1] ) { 933 return NULL; 934 } 935 uint32_t tag_index = tag & 0xFFFF; 936 return tag_info[tag_section][tag_index].tag_name; 937 } 938 939 // Declared in system/media/private/camera/include/camera_metadata_hidden.h 940 int get_local_camera_metadata_tag_type_vendor_id(uint32_t tag, 941 metadata_vendor_id_t id) { 942 uint32_t tag_section = tag >> 16; 943 if (tag_section >= VENDOR_SECTION && vendor_cache_ops != NULL && 944 id != CAMERA_METADATA_INVALID_VENDOR_ID) { 945 return vendor_cache_ops->get_tag_type(tag, id); 946 } else if (tag_section >= VENDOR_SECTION && vendor_tag_ops != NULL) { 947 return vendor_tag_ops->get_tag_type( 948 vendor_tag_ops, 949 tag); 950 } 951 if (tag_section >= ANDROID_SECTION_COUNT || 952 tag >= camera_metadata_section_bounds[tag_section][1] ) { 953 return -1; 954 } 955 uint32_t tag_index = tag & 0xFFFF; 956 return tag_info[tag_section][tag_index].tag_type; 957 } 958 959 const char *get_camera_metadata_section_name(uint32_t tag) { 960 return get_local_camera_metadata_section_name(tag, NULL); 961 } 962 963 const char *get_camera_metadata_tag_name(uint32_t tag) { 964 return get_local_camera_metadata_tag_name(tag, NULL); 965 } 966 967 int get_camera_metadata_tag_type(uint32_t tag) { 968 return get_local_camera_metadata_tag_type(tag, NULL); 969 } 970 971 const char *get_local_camera_metadata_section_name(uint32_t tag, 972 const camera_metadata_t *meta) { 973 metadata_vendor_id_t id = (NULL == meta) ? CAMERA_METADATA_INVALID_VENDOR_ID : 974 meta->vendor_id; 975 976 return get_local_camera_metadata_section_name_vendor_id(tag, id); 977 } 978 979 const char *get_local_camera_metadata_tag_name(uint32_t tag, 980 const camera_metadata_t *meta) { 981 metadata_vendor_id_t id = (NULL == meta) ? CAMERA_METADATA_INVALID_VENDOR_ID : 982 meta->vendor_id; 983 984 return get_local_camera_metadata_tag_name_vendor_id(tag, id); 985 } 986 987 int get_local_camera_metadata_tag_type(uint32_t tag, 988 const camera_metadata_t *meta) { 989 metadata_vendor_id_t id = (NULL == meta) ? CAMERA_METADATA_INVALID_VENDOR_ID : 990 meta->vendor_id; 991 992 return get_local_camera_metadata_tag_type_vendor_id(tag, id); 993 } 994 995 int set_camera_metadata_vendor_tag_ops(const vendor_tag_query_ops_t* ops) { 996 // **DEPRECATED** 997 (void) ops; 998 ALOGE("%s: This function has been deprecated", __FUNCTION__); 999 return ERROR; 1000 } 1001 1002 // Declared in system/media/private/camera/include/camera_metadata_hidden.h 1003 int set_camera_metadata_vendor_ops(const vendor_tag_ops_t* ops) { 1004 vendor_tag_ops = ops; 1005 return OK; 1006 } 1007 1008 // Declared in system/media/private/camera/include/camera_metadata_hidden.h 1009 int set_camera_metadata_vendor_cache_ops( 1010 const struct vendor_tag_cache_ops *query_cache_ops) { 1011 vendor_cache_ops = query_cache_ops; 1012 return OK; 1013 } 1014 1015 // Declared in system/media/private/camera/include/camera_metadata_hidden.h 1016 void set_camera_metadata_vendor_id(camera_metadata_t *meta, 1017 metadata_vendor_id_t id) { 1018 if (NULL != meta) { 1019 meta->vendor_id = id; 1020 } 1021 } 1022 1023 // Declared in system/media/private/camera/include/camera_metadata_hidden.h 1024 metadata_vendor_id_t get_camera_metadata_vendor_id( 1025 const camera_metadata_t *meta) { 1026 metadata_vendor_id_t ret = CAMERA_METADATA_INVALID_VENDOR_ID; 1027 1028 if (NULL != meta) { 1029 ret = meta->vendor_id; 1030 } 1031 1032 return ret; 1033 } 1034 1035 static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag, int type, 1036 int count, 1037 int indentation); 1038 1039 void dump_camera_metadata(const camera_metadata_t *metadata, 1040 int fd, 1041 int verbosity) { 1042 dump_indented_camera_metadata(metadata, fd, verbosity, 0); 1043 } 1044 1045 void dump_indented_camera_metadata(const camera_metadata_t *metadata, 1046 int fd, 1047 int verbosity, 1048 int indentation) { 1049 if (metadata == NULL) { 1050 dprintf(fd, "%*sDumping camera metadata array: Not allocated\n", 1051 indentation, ""); 1052 return; 1053 } 1054 unsigned int i; 1055 dprintf(fd, 1056 "%*sDumping camera metadata array: %" PRIu32 " / %" PRIu32 " entries, " 1057 "%" PRIu32 " / %" PRIu32 " bytes of extra data.\n", indentation, "", 1058 metadata->entry_count, metadata->entry_capacity, 1059 metadata->data_count, metadata->data_capacity); 1060 dprintf(fd, "%*sVersion: %d, Flags: %08x\n", 1061 indentation + 2, "", 1062 metadata->version, metadata->flags); 1063 camera_metadata_buffer_entry_t *entry = get_entries(metadata); 1064 for (i=0; i < metadata->entry_count; i++, entry++) { 1065 1066 const char *tag_name, *tag_section; 1067 tag_section = get_local_camera_metadata_section_name(entry->tag, metadata); 1068 if (tag_section == NULL) { 1069 tag_section = "unknownSection"; 1070 } 1071 tag_name = get_local_camera_metadata_tag_name(entry->tag, metadata); 1072 if (tag_name == NULL) { 1073 tag_name = "unknownTag"; 1074 } 1075 const char *type_name; 1076 if (entry->type >= NUM_TYPES) { 1077 type_name = "unknown"; 1078 } else { 1079 type_name = camera_metadata_type_names[entry->type]; 1080 } 1081 dprintf(fd, "%*s%s.%s (%05x): %s[%" PRIu32 "]\n", 1082 indentation + 2, "", 1083 tag_section, 1084 tag_name, 1085 entry->tag, 1086 type_name, 1087 entry->count); 1088 1089 if (verbosity < 1) continue; 1090 1091 if (entry->type >= NUM_TYPES) continue; 1092 1093 size_t type_size = camera_metadata_type_size[entry->type]; 1094 uint8_t *data_ptr; 1095 if ( type_size * entry->count > 4 ) { 1096 if (entry->data.offset >= metadata->data_count) { 1097 ALOGE("%s: Malformed entry data offset: %" PRIu32 " (max %" PRIu32 ")", 1098 __FUNCTION__, 1099 entry->data.offset, 1100 metadata->data_count); 1101 continue; 1102 } 1103 data_ptr = get_data(metadata) + entry->data.offset; 1104 } else { 1105 data_ptr = entry->data.value; 1106 } 1107 int count = entry->count; 1108 if (verbosity < 2 && count > 16) count = 16; 1109 1110 print_data(fd, data_ptr, entry->tag, entry->type, count, indentation); 1111 } 1112 } 1113 1114 static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag, 1115 int type, int count, int indentation) { 1116 static int values_per_line[NUM_TYPES] = { 1117 [TYPE_BYTE] = 16, 1118 [TYPE_INT32] = 4, 1119 [TYPE_FLOAT] = 8, 1120 [TYPE_INT64] = 2, 1121 [TYPE_DOUBLE] = 4, 1122 [TYPE_RATIONAL] = 2, 1123 }; 1124 size_t type_size = camera_metadata_type_size[type]; 1125 char value_string_tmp[CAMERA_METADATA_ENUM_STRING_MAX_SIZE]; 1126 uint32_t value; 1127 1128 int lines = count / values_per_line[type]; 1129 if (count % values_per_line[type] != 0) lines++; 1130 1131 int index = 0; 1132 int j, k; 1133 for (j = 0; j < lines; j++) { 1134 dprintf(fd, "%*s[", indentation + 4, ""); 1135 for (k = 0; 1136 k < values_per_line[type] && count > 0; 1137 k++, count--, index += type_size) { 1138 1139 switch (type) { 1140 case TYPE_BYTE: 1141 value = *(data_ptr + index); 1142 if (camera_metadata_enum_snprint(tag, 1143 value, 1144 value_string_tmp, 1145 sizeof(value_string_tmp)) 1146 == OK) { 1147 dprintf(fd, "%s ", value_string_tmp); 1148 } else { 1149 dprintf(fd, "%hhu ", 1150 *(data_ptr + index)); 1151 } 1152 break; 1153 case TYPE_INT32: 1154 value = 1155 *(int32_t*)(data_ptr + index); 1156 if (camera_metadata_enum_snprint(tag, 1157 value, 1158 value_string_tmp, 1159 sizeof(value_string_tmp)) 1160 == OK) { 1161 dprintf(fd, "%s ", value_string_tmp); 1162 } else { 1163 dprintf(fd, "%" PRId32 " ", 1164 *(int32_t*)(data_ptr + index)); 1165 } 1166 break; 1167 case TYPE_FLOAT: 1168 dprintf(fd, "%0.8f ", 1169 *(float*)(data_ptr + index)); 1170 break; 1171 case TYPE_INT64: 1172 dprintf(fd, "%" PRId64 " ", 1173 *(int64_t*)(data_ptr + index)); 1174 break; 1175 case TYPE_DOUBLE: 1176 dprintf(fd, "%0.8f ", 1177 *(double*)(data_ptr + index)); 1178 break; 1179 case TYPE_RATIONAL: { 1180 int32_t numerator = *(int32_t*)(data_ptr + index); 1181 int32_t denominator = *(int32_t*)(data_ptr + index + 4); 1182 dprintf(fd, "(%d / %d) ", 1183 numerator, denominator); 1184 break; 1185 } 1186 default: 1187 dprintf(fd, "??? "); 1188 } 1189 } 1190 dprintf(fd, "]\n"); 1191 } 1192 } 1193
