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_NDEBUG 0 18 19 #define LOG_TAG "Camera2-Metadata" 20 #include <utils/Log.h> 21 #include <utils/Errors.h> 22 23 #include <binder/Parcel.h> 24 #include <camera/CameraMetadata.h> 25 #include <camera/VendorTagDescriptor.h> 26 27 namespace android { 28 29 #define ALIGN_TO(val, alignment) \ 30 (((uintptr_t)(val) + ((alignment) - 1)) & ~((alignment) - 1)) 31 32 typedef Parcel::WritableBlob WritableBlob; 33 typedef Parcel::ReadableBlob ReadableBlob; 34 35 CameraMetadata::CameraMetadata() : 36 mBuffer(NULL), mLocked(false) { 37 } 38 39 CameraMetadata::CameraMetadata(size_t entryCapacity, size_t dataCapacity) : 40 mLocked(false) 41 { 42 mBuffer = allocate_camera_metadata(entryCapacity, dataCapacity); 43 } 44 45 CameraMetadata::CameraMetadata(const CameraMetadata &other) : 46 mLocked(false) { 47 mBuffer = clone_camera_metadata(other.mBuffer); 48 } 49 50 CameraMetadata::CameraMetadata(camera_metadata_t *buffer) : 51 mBuffer(NULL), mLocked(false) { 52 acquire(buffer); 53 } 54 55 CameraMetadata &CameraMetadata::operator=(const CameraMetadata &other) { 56 return operator=(other.mBuffer); 57 } 58 59 CameraMetadata &CameraMetadata::operator=(const camera_metadata_t *buffer) { 60 if (mLocked) { 61 ALOGE("%s: Assignment to a locked CameraMetadata!", __FUNCTION__); 62 return *this; 63 } 64 65 if (CC_LIKELY(buffer != mBuffer)) { 66 camera_metadata_t *newBuffer = clone_camera_metadata(buffer); 67 clear(); 68 mBuffer = newBuffer; 69 } 70 return *this; 71 } 72 73 CameraMetadata::~CameraMetadata() { 74 mLocked = false; 75 clear(); 76 } 77 78 const camera_metadata_t* CameraMetadata::getAndLock() const { 79 mLocked = true; 80 return mBuffer; 81 } 82 83 status_t CameraMetadata::unlock(const camera_metadata_t *buffer) const { 84 if (!mLocked) { 85 ALOGE("%s: Can't unlock a non-locked CameraMetadata!", __FUNCTION__); 86 return INVALID_OPERATION; 87 } 88 if (buffer != mBuffer) { 89 ALOGE("%s: Can't unlock CameraMetadata with wrong pointer!", 90 __FUNCTION__); 91 return BAD_VALUE; 92 } 93 mLocked = false; 94 return OK; 95 } 96 97 camera_metadata_t* CameraMetadata::release() { 98 if (mLocked) { 99 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 100 return NULL; 101 } 102 camera_metadata_t *released = mBuffer; 103 mBuffer = NULL; 104 return released; 105 } 106 107 void CameraMetadata::clear() { 108 if (mLocked) { 109 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 110 return; 111 } 112 if (mBuffer) { 113 free_camera_metadata(mBuffer); 114 mBuffer = NULL; 115 } 116 } 117 118 void CameraMetadata::acquire(camera_metadata_t *buffer) { 119 if (mLocked) { 120 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 121 return; 122 } 123 clear(); 124 mBuffer = buffer; 125 126 ALOGE_IF(validate_camera_metadata_structure(mBuffer, /*size*/NULL) != OK, 127 "%s: Failed to validate metadata structure %p", 128 __FUNCTION__, buffer); 129 } 130 131 void CameraMetadata::acquire(CameraMetadata &other) { 132 if (mLocked) { 133 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 134 return; 135 } 136 acquire(other.release()); 137 } 138 139 status_t CameraMetadata::append(const CameraMetadata &other) { 140 return append(other.mBuffer); 141 } 142 143 status_t CameraMetadata::append(const camera_metadata_t* other) { 144 if (mLocked) { 145 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 146 return INVALID_OPERATION; 147 } 148 size_t extraEntries = get_camera_metadata_entry_count(other); 149 size_t extraData = get_camera_metadata_data_count(other); 150 resizeIfNeeded(extraEntries, extraData); 151 152 return append_camera_metadata(mBuffer, other); 153 } 154 155 size_t CameraMetadata::entryCount() const { 156 return (mBuffer == NULL) ? 0 : 157 get_camera_metadata_entry_count(mBuffer); 158 } 159 160 bool CameraMetadata::isEmpty() const { 161 return entryCount() == 0; 162 } 163 164 status_t CameraMetadata::sort() { 165 if (mLocked) { 166 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 167 return INVALID_OPERATION; 168 } 169 return sort_camera_metadata(mBuffer); 170 } 171 172 status_t CameraMetadata::checkType(uint32_t tag, uint8_t expectedType) { 173 int tagType = get_local_camera_metadata_tag_type(tag, mBuffer); 174 if ( CC_UNLIKELY(tagType == -1)) { 175 ALOGE("Update metadata entry: Unknown tag %d", tag); 176 return INVALID_OPERATION; 177 } 178 if ( CC_UNLIKELY(tagType != expectedType) ) { 179 ALOGE("Mismatched tag type when updating entry %s (%d) of type %s; " 180 "got type %s data instead ", 181 get_local_camera_metadata_tag_name(tag, mBuffer), tag, 182 camera_metadata_type_names[tagType], 183 camera_metadata_type_names[expectedType]); 184 return INVALID_OPERATION; 185 } 186 return OK; 187 } 188 189 status_t CameraMetadata::update(uint32_t tag, 190 const int32_t *data, size_t data_count) { 191 status_t res; 192 if (mLocked) { 193 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 194 return INVALID_OPERATION; 195 } 196 if ( (res = checkType(tag, TYPE_INT32)) != OK) { 197 return res; 198 } 199 return updateImpl(tag, (const void*)data, data_count); 200 } 201 202 status_t CameraMetadata::update(uint32_t tag, 203 const uint8_t *data, size_t data_count) { 204 status_t res; 205 if (mLocked) { 206 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 207 return INVALID_OPERATION; 208 } 209 if ( (res = checkType(tag, TYPE_BYTE)) != OK) { 210 return res; 211 } 212 return updateImpl(tag, (const void*)data, data_count); 213 } 214 215 status_t CameraMetadata::update(uint32_t tag, 216 const float *data, size_t data_count) { 217 status_t res; 218 if (mLocked) { 219 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 220 return INVALID_OPERATION; 221 } 222 if ( (res = checkType(tag, TYPE_FLOAT)) != OK) { 223 return res; 224 } 225 return updateImpl(tag, (const void*)data, data_count); 226 } 227 228 status_t CameraMetadata::update(uint32_t tag, 229 const int64_t *data, size_t data_count) { 230 status_t res; 231 if (mLocked) { 232 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 233 return INVALID_OPERATION; 234 } 235 if ( (res = checkType(tag, TYPE_INT64)) != OK) { 236 return res; 237 } 238 return updateImpl(tag, (const void*)data, data_count); 239 } 240 241 status_t CameraMetadata::update(uint32_t tag, 242 const double *data, size_t data_count) { 243 status_t res; 244 if (mLocked) { 245 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 246 return INVALID_OPERATION; 247 } 248 if ( (res = checkType(tag, TYPE_DOUBLE)) != OK) { 249 return res; 250 } 251 return updateImpl(tag, (const void*)data, data_count); 252 } 253 254 status_t CameraMetadata::update(uint32_t tag, 255 const camera_metadata_rational_t *data, size_t data_count) { 256 status_t res; 257 if (mLocked) { 258 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 259 return INVALID_OPERATION; 260 } 261 if ( (res = checkType(tag, TYPE_RATIONAL)) != OK) { 262 return res; 263 } 264 return updateImpl(tag, (const void*)data, data_count); 265 } 266 267 status_t CameraMetadata::update(uint32_t tag, 268 const String8 &string) { 269 status_t res; 270 if (mLocked) { 271 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 272 return INVALID_OPERATION; 273 } 274 if ( (res = checkType(tag, TYPE_BYTE)) != OK) { 275 return res; 276 } 277 // string.size() doesn't count the null termination character. 278 return updateImpl(tag, (const void*)string.string(), string.size() + 1); 279 } 280 281 status_t CameraMetadata::update(const camera_metadata_ro_entry &entry) { 282 status_t res; 283 if (mLocked) { 284 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 285 return INVALID_OPERATION; 286 } 287 if ( (res = checkType(entry.tag, entry.type)) != OK) { 288 return res; 289 } 290 return updateImpl(entry.tag, (const void*)entry.data.u8, entry.count); 291 } 292 293 status_t CameraMetadata::updateImpl(uint32_t tag, const void *data, 294 size_t data_count) { 295 status_t res; 296 if (mLocked) { 297 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 298 return INVALID_OPERATION; 299 } 300 int type = get_local_camera_metadata_tag_type(tag, mBuffer); 301 if (type == -1) { 302 ALOGE("%s: Tag %d not found", __FUNCTION__, tag); 303 return BAD_VALUE; 304 } 305 // Safety check - ensure that data isn't pointing to this metadata, since 306 // that would get invalidated if a resize is needed 307 size_t bufferSize = get_camera_metadata_size(mBuffer); 308 uintptr_t bufAddr = reinterpret_cast<uintptr_t>(mBuffer); 309 uintptr_t dataAddr = reinterpret_cast<uintptr_t>(data); 310 if (dataAddr > bufAddr && dataAddr < (bufAddr + bufferSize)) { 311 ALOGE("%s: Update attempted with data from the same metadata buffer!", 312 __FUNCTION__); 313 return INVALID_OPERATION; 314 } 315 316 size_t data_size = calculate_camera_metadata_entry_data_size(type, 317 data_count); 318 319 res = resizeIfNeeded(1, data_size); 320 321 if (res == OK) { 322 camera_metadata_entry_t entry; 323 res = find_camera_metadata_entry(mBuffer, tag, &entry); 324 if (res == NAME_NOT_FOUND) { 325 res = add_camera_metadata_entry(mBuffer, 326 tag, data, data_count); 327 } else if (res == OK) { 328 res = update_camera_metadata_entry(mBuffer, 329 entry.index, data, data_count, NULL); 330 } 331 } 332 333 if (res != OK) { 334 ALOGE("%s: Unable to update metadata entry %s.%s (%x): %s (%d)", 335 __FUNCTION__, get_local_camera_metadata_section_name(tag, mBuffer), 336 get_local_camera_metadata_tag_name(tag, mBuffer), tag, 337 strerror(-res), res); 338 } 339 340 IF_ALOGV() { 341 ALOGE_IF(validate_camera_metadata_structure(mBuffer, /*size*/NULL) != 342 OK, 343 344 "%s: Failed to validate metadata structure after update %p", 345 __FUNCTION__, mBuffer); 346 } 347 348 return res; 349 } 350 351 bool CameraMetadata::exists(uint32_t tag) const { 352 camera_metadata_ro_entry entry; 353 return find_camera_metadata_ro_entry(mBuffer, tag, &entry) == 0; 354 } 355 356 camera_metadata_entry_t CameraMetadata::find(uint32_t tag) { 357 status_t res; 358 camera_metadata_entry entry; 359 if (mLocked) { 360 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 361 entry.count = 0; 362 return entry; 363 } 364 res = find_camera_metadata_entry(mBuffer, tag, &entry); 365 if (CC_UNLIKELY( res != OK )) { 366 entry.count = 0; 367 entry.data.u8 = NULL; 368 } 369 return entry; 370 } 371 372 camera_metadata_ro_entry_t CameraMetadata::find(uint32_t tag) const { 373 status_t res; 374 camera_metadata_ro_entry entry; 375 res = find_camera_metadata_ro_entry(mBuffer, tag, &entry); 376 if (CC_UNLIKELY( res != OK )) { 377 entry.count = 0; 378 entry.data.u8 = NULL; 379 } 380 return entry; 381 } 382 383 status_t CameraMetadata::erase(uint32_t tag) { 384 camera_metadata_entry_t entry; 385 status_t res; 386 if (mLocked) { 387 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 388 return INVALID_OPERATION; 389 } 390 res = find_camera_metadata_entry(mBuffer, tag, &entry); 391 if (res == NAME_NOT_FOUND) { 392 return OK; 393 } else if (res != OK) { 394 ALOGE("%s: Error looking for entry %s.%s (%x): %s %d", 395 __FUNCTION__, 396 get_local_camera_metadata_section_name(tag, mBuffer), 397 get_local_camera_metadata_tag_name(tag, mBuffer), 398 tag, strerror(-res), res); 399 return res; 400 } 401 res = delete_camera_metadata_entry(mBuffer, entry.index); 402 if (res != OK) { 403 ALOGE("%s: Error deleting entry %s.%s (%x): %s %d", 404 __FUNCTION__, 405 get_local_camera_metadata_section_name(tag, mBuffer), 406 get_local_camera_metadata_tag_name(tag, mBuffer), 407 tag, strerror(-res), res); 408 } 409 return res; 410 } 411 412 void CameraMetadata::dump(int fd, int verbosity, int indentation) const { 413 dump_indented_camera_metadata(mBuffer, fd, verbosity, indentation); 414 } 415 416 status_t CameraMetadata::resizeIfNeeded(size_t extraEntries, size_t extraData) { 417 if (mBuffer == NULL) { 418 mBuffer = allocate_camera_metadata(extraEntries * 2, extraData * 2); 419 if (mBuffer == NULL) { 420 ALOGE("%s: Can't allocate larger metadata buffer", __FUNCTION__); 421 return NO_MEMORY; 422 } 423 } else { 424 size_t currentEntryCount = get_camera_metadata_entry_count(mBuffer); 425 size_t currentEntryCap = get_camera_metadata_entry_capacity(mBuffer); 426 size_t newEntryCount = currentEntryCount + 427 extraEntries; 428 newEntryCount = (newEntryCount > currentEntryCap) ? 429 newEntryCount * 2 : currentEntryCap; 430 431 size_t currentDataCount = get_camera_metadata_data_count(mBuffer); 432 size_t currentDataCap = get_camera_metadata_data_capacity(mBuffer); 433 size_t newDataCount = currentDataCount + 434 extraData; 435 newDataCount = (newDataCount > currentDataCap) ? 436 newDataCount * 2 : currentDataCap; 437 438 if (newEntryCount > currentEntryCap || 439 newDataCount > currentDataCap) { 440 camera_metadata_t *oldBuffer = mBuffer; 441 mBuffer = allocate_camera_metadata(newEntryCount, 442 newDataCount); 443 if (mBuffer == NULL) { 444 ALOGE("%s: Can't allocate larger metadata buffer", __FUNCTION__); 445 return NO_MEMORY; 446 } 447 append_camera_metadata(mBuffer, oldBuffer); 448 free_camera_metadata(oldBuffer); 449 } 450 } 451 return OK; 452 } 453 454 status_t CameraMetadata::readFromParcel(const Parcel& data, 455 camera_metadata_t** out) { 456 457 status_t err = OK; 458 459 camera_metadata_t* metadata = NULL; 460 461 if (out) { 462 *out = NULL; 463 } 464 465 // See CameraMetadata::writeToParcel for parcel data layout diagram and explanation. 466 // arg0 = blobSize (int32) 467 int32_t blobSizeTmp = -1; 468 if ((err = data.readInt32(&blobSizeTmp)) != OK) { 469 ALOGE("%s: Failed to read metadata size (error %d %s)", 470 __FUNCTION__, err, strerror(-err)); 471 return err; 472 } 473 const size_t blobSize = static_cast<size_t>(blobSizeTmp); 474 const size_t alignment = get_camera_metadata_alignment(); 475 476 // Special case: zero blob size means zero sized (NULL) metadata. 477 if (blobSize == 0) { 478 ALOGV("%s: Read 0-sized metadata", __FUNCTION__); 479 return OK; 480 } 481 482 if (blobSize <= alignment) { 483 ALOGE("%s: metadata blob is malformed, blobSize(%zu) should be larger than alignment(%zu)", 484 __FUNCTION__, blobSize, alignment); 485 return BAD_VALUE; 486 } 487 488 const size_t metadataSize = blobSize - alignment; 489 490 // NOTE: this doesn't make sense to me. shouldn't the blob 491 // know how big it is? why do we have to specify the size 492 // to Parcel::readBlob ? 493 ReadableBlob blob; 494 // arg1 = metadata (blob) 495 do { 496 if ((err = data.readBlob(blobSize, &blob)) != OK) { 497 ALOGE("%s: Failed to read metadata blob (sized %zu). Possible " 498 " serialization bug. Error %d %s", 499 __FUNCTION__, blobSize, err, strerror(-err)); 500 break; 501 } 502 503 // arg2 = offset (blob) 504 // Must be after blob since we don't know offset until after writeBlob. 505 int32_t offsetTmp; 506 if ((err = data.readInt32(&offsetTmp)) != OK) { 507 ALOGE("%s: Failed to read metadata offsetTmp (error %d %s)", 508 __FUNCTION__, err, strerror(-err)); 509 break; 510 } 511 const size_t offset = static_cast<size_t>(offsetTmp); 512 if (offset >= alignment) { 513 ALOGE("%s: metadata offset(%zu) should be less than alignment(%zu)", 514 __FUNCTION__, blobSize, alignment); 515 err = BAD_VALUE; 516 break; 517 } 518 519 const uintptr_t metadataStart = reinterpret_cast<uintptr_t>(blob.data()) + offset; 520 const camera_metadata_t* tmp = 521 reinterpret_cast<const camera_metadata_t*>(metadataStart); 522 ALOGV("%s: alignment is: %zu, metadata start: %p, offset: %zu", 523 __FUNCTION__, alignment, tmp, offset); 524 metadata = allocate_copy_camera_metadata_checked(tmp, metadataSize); 525 if (metadata == NULL) { 526 // We consider that allocation only fails if the validation 527 // also failed, therefore the readFromParcel was a failure. 528 ALOGE("%s: metadata allocation and copy failed", __FUNCTION__); 529 err = BAD_VALUE; 530 } 531 } while(0); 532 blob.release(); 533 534 if (out) { 535 ALOGV("%s: Set out metadata to %p", __FUNCTION__, metadata); 536 *out = metadata; 537 } else if (metadata != NULL) { 538 ALOGV("%s: Freed camera metadata at %p", __FUNCTION__, metadata); 539 free_camera_metadata(metadata); 540 } 541 542 return err; 543 } 544 545 status_t CameraMetadata::writeToParcel(Parcel& data, 546 const camera_metadata_t* metadata) { 547 status_t res = OK; 548 549 /** 550 * Below is the camera metadata parcel layout: 551 * 552 * |--------------------------------------------| 553 * | arg0: blobSize | 554 * | (length = 4) | 555 * |--------------------------------------------|<--Skip the rest if blobSize == 0. 556 * | | 557 * | | 558 * | arg1: blob | 559 * | (length = variable, see arg1 layout below) | 560 * | | 561 * | | 562 * |--------------------------------------------| 563 * | arg2: offset | 564 * | (length = 4) | 565 * |--------------------------------------------| 566 */ 567 568 // arg0 = blobSize (int32) 569 if (metadata == NULL) { 570 // Write zero blobSize for null metadata. 571 return data.writeInt32(0); 572 } 573 574 /** 575 * Always make the blob size sufficiently larger, as we need put alignment 576 * padding and metadata into the blob. Since we don't know the alignment 577 * offset before writeBlob. Then write the metadata to aligned offset. 578 */ 579 const size_t metadataSize = get_camera_metadata_compact_size(metadata); 580 const size_t alignment = get_camera_metadata_alignment(); 581 const size_t blobSize = metadataSize + alignment; 582 res = data.writeInt32(static_cast<int32_t>(blobSize)); 583 if (res != OK) { 584 return res; 585 } 586 587 size_t offset = 0; 588 /** 589 * arg1 = metadata (blob). 590 * 591 * The blob size is the sum of front padding size, metadata size and back padding 592 * size, which is equal to metadataSize + alignment. 593 * 594 * The blob layout is: 595 * |------------------------------------|<----Start address of the blob (unaligned). 596 * | front padding | 597 * | (size = offset) | 598 * |------------------------------------|<----Aligned start address of metadata. 599 * | | 600 * | | 601 * | metadata | 602 * | (size = metadataSize) | 603 * | | 604 * | | 605 * |------------------------------------| 606 * | back padding | 607 * | (size = alignment - offset) | 608 * |------------------------------------|<----End address of blob. 609 * (Blob start address + blob size). 610 */ 611 WritableBlob blob; 612 do { 613 res = data.writeBlob(blobSize, false, &blob); 614 if (res != OK) { 615 break; 616 } 617 const uintptr_t metadataStart = ALIGN_TO(blob.data(), alignment); 618 offset = metadataStart - reinterpret_cast<uintptr_t>(blob.data()); 619 ALOGV("%s: alignment is: %zu, metadata start: %p, offset: %zu", 620 __FUNCTION__, alignment, 621 reinterpret_cast<const void *>(metadataStart), offset); 622 copy_camera_metadata(reinterpret_cast<void*>(metadataStart), metadataSize, metadata); 623 624 // Not too big of a problem since receiving side does hard validation 625 // Don't check the size since the compact size could be larger 626 if (validate_camera_metadata_structure(metadata, /*size*/NULL) != OK) { 627 ALOGW("%s: Failed to validate metadata %p before writing blob", 628 __FUNCTION__, metadata); 629 } 630 631 } while(false); 632 blob.release(); 633 634 // arg2 = offset (int32) 635 res = data.writeInt32(static_cast<int32_t>(offset)); 636 637 return res; 638 } 639 640 status_t CameraMetadata::readFromParcel(const Parcel *parcel) { 641 642 ALOGV("%s: parcel = %p", __FUNCTION__, parcel); 643 644 status_t res = OK; 645 646 if (parcel == NULL) { 647 ALOGE("%s: parcel is null", __FUNCTION__); 648 return BAD_VALUE; 649 } 650 651 if (mLocked) { 652 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 653 return INVALID_OPERATION; 654 } 655 656 camera_metadata *buffer = NULL; 657 // TODO: reading should return a status code, in case validation fails 658 res = CameraMetadata::readFromParcel(*parcel, &buffer); 659 660 if (res != NO_ERROR) { 661 ALOGE("%s: Failed to read from parcel. Metadata is unchanged.", 662 __FUNCTION__); 663 return res; 664 } 665 666 clear(); 667 mBuffer = buffer; 668 669 return OK; 670 } 671 672 status_t CameraMetadata::writeToParcel(Parcel *parcel) const { 673 674 ALOGV("%s: parcel = %p", __FUNCTION__, parcel); 675 676 if (parcel == NULL) { 677 ALOGE("%s: parcel is null", __FUNCTION__); 678 return BAD_VALUE; 679 } 680 681 return CameraMetadata::writeToParcel(*parcel, mBuffer); 682 } 683 684 void CameraMetadata::swap(CameraMetadata& other) { 685 if (mLocked) { 686 ALOGE("%s: CameraMetadata is locked", __FUNCTION__); 687 return; 688 } else if (other.mLocked) { 689 ALOGE("%s: Other CameraMetadata is locked", __FUNCTION__); 690 return; 691 } 692 693 camera_metadata* thisBuf = mBuffer; 694 camera_metadata* otherBuf = other.mBuffer; 695 696 other.mBuffer = thisBuf; 697 mBuffer = otherBuf; 698 } 699 700 status_t CameraMetadata::getTagFromName(const char *name, 701 const VendorTagDescriptor* vTags, uint32_t *tag) { 702 703 if (name == nullptr || tag == nullptr) return BAD_VALUE; 704 705 size_t nameLength = strlen(name); 706 707 const SortedVector<String8> *vendorSections; 708 size_t vendorSectionCount = 0; 709 710 if (vTags != NULL) { 711 vendorSections = vTags->getAllSectionNames(); 712 vendorSectionCount = vendorSections->size(); 713 } 714 715 // First, find the section by the longest string match 716 const char *section = NULL; 717 size_t sectionIndex = 0; 718 size_t sectionLength = 0; 719 size_t totalSectionCount = ANDROID_SECTION_COUNT + vendorSectionCount; 720 for (size_t i = 0; i < totalSectionCount; ++i) { 721 722 const char *str = (i < ANDROID_SECTION_COUNT) ? camera_metadata_section_names[i] : 723 (*vendorSections)[i - ANDROID_SECTION_COUNT].string(); 724 725 ALOGV("%s: Trying to match against section '%s'", __FUNCTION__, str); 726 727 if (strstr(name, str) == name) { // name begins with the section name 728 size_t strLength = strlen(str); 729 730 ALOGV("%s: Name begins with section name", __FUNCTION__); 731 732 // section name is the longest we've found so far 733 if (section == NULL || sectionLength < strLength) { 734 section = str; 735 sectionIndex = i; 736 sectionLength = strLength; 737 738 ALOGV("%s: Found new best section (%s)", __FUNCTION__, section); 739 } 740 } 741 } 742 743 // TODO: Make above get_camera_metadata_section_from_name ? 744 745 if (section == NULL) { 746 return NAME_NOT_FOUND; 747 } else { 748 ALOGV("%s: Found matched section '%s' (%zu)", 749 __FUNCTION__, section, sectionIndex); 750 } 751 752 // Get the tag name component of the name 753 const char *nameTagName = name + sectionLength + 1; // x.y.z -> z 754 if (sectionLength + 1 >= nameLength) { 755 return BAD_VALUE; 756 } 757 758 // Match rest of name against the tag names in that section only 759 uint32_t candidateTag = 0; 760 if (sectionIndex < ANDROID_SECTION_COUNT) { 761 // Match built-in tags (typically android.*) 762 uint32_t tagBegin, tagEnd; // [tagBegin, tagEnd) 763 tagBegin = camera_metadata_section_bounds[sectionIndex][0]; 764 tagEnd = camera_metadata_section_bounds[sectionIndex][1]; 765 766 for (candidateTag = tagBegin; candidateTag < tagEnd; ++candidateTag) { 767 const char *tagName = get_camera_metadata_tag_name(candidateTag); 768 769 if (strcmp(nameTagName, tagName) == 0) { 770 ALOGV("%s: Found matched tag '%s' (%d)", 771 __FUNCTION__, tagName, candidateTag); 772 break; 773 } 774 } 775 776 if (candidateTag == tagEnd) { 777 return NAME_NOT_FOUND; 778 } 779 } else if (vTags != NULL) { 780 // Match vendor tags (typically com.*) 781 const String8 sectionName(section); 782 const String8 tagName(nameTagName); 783 784 status_t res = OK; 785 if ((res = vTags->lookupTag(tagName, sectionName, &candidateTag)) != OK) { 786 return NAME_NOT_FOUND; 787 } 788 } 789 790 *tag = candidateTag; 791 return OK; 792 } 793 794 795 }; // namespace android 796
