1 /* 2 * Copyright (C) 2014 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 "VendorTagDescriptor" 18 19 #include <binder/Parcel.h> 20 #include <utils/Errors.h> 21 #include <utils/Log.h> 22 #include <utils/Mutex.h> 23 #include <utils/Vector.h> 24 #include <utils/SortedVector.h> 25 #include <system/camera_metadata.h> 26 #include <camera_metadata_hidden.h> 27 28 #include "camera/VendorTagDescriptor.h" 29 30 #include <stdio.h> 31 #include <string.h> 32 #include <inttypes.h> 33 34 namespace android { 35 36 extern "C" { 37 38 static int vendor_tag_descriptor_get_tag_count(const vendor_tag_ops_t* v); 39 static void vendor_tag_descriptor_get_all_tags(const vendor_tag_ops_t* v, uint32_t* tagArray); 40 static const char* vendor_tag_descriptor_get_section_name(const vendor_tag_ops_t* v, uint32_t tag); 41 static const char* vendor_tag_descriptor_get_tag_name(const vendor_tag_ops_t* v, uint32_t tag); 42 static int vendor_tag_descriptor_get_tag_type(const vendor_tag_ops_t* v, uint32_t tag); 43 44 static int vendor_tag_descriptor_cache_get_tag_count(metadata_vendor_id_t id); 45 static void vendor_tag_descriptor_cache_get_all_tags(uint32_t* tagArray, 46 metadata_vendor_id_t id); 47 static const char* vendor_tag_descriptor_cache_get_section_name(uint32_t tag, 48 metadata_vendor_id_t id); 49 static const char* vendor_tag_descriptor_cache_get_tag_name(uint32_t tag, 50 metadata_vendor_id_t id); 51 static int vendor_tag_descriptor_cache_get_tag_type(uint32_t tag, 52 metadata_vendor_id_t id); 53 54 } /* extern "C" */ 55 56 57 static Mutex sLock; 58 static sp<VendorTagDescriptor> sGlobalVendorTagDescriptor; 59 static sp<VendorTagDescriptorCache> sGlobalVendorTagDescriptorCache; 60 61 namespace hardware { 62 namespace camera2 { 63 namespace params { 64 ~VendorTagDescriptor()65 VendorTagDescriptor::~VendorTagDescriptor() { 66 size_t len = mReverseMapping.size(); 67 for (size_t i = 0; i < len; ++i) { 68 delete mReverseMapping[i]; 69 } 70 } 71 VendorTagDescriptor()72 VendorTagDescriptor::VendorTagDescriptor() : 73 mTagCount(0), 74 mVendorOps() { 75 } 76 VendorTagDescriptor(const VendorTagDescriptor & src)77 VendorTagDescriptor::VendorTagDescriptor(const VendorTagDescriptor& src) { 78 copyFrom(src); 79 } 80 operator =(const VendorTagDescriptor & rhs)81 VendorTagDescriptor& VendorTagDescriptor::operator=(const VendorTagDescriptor& rhs) { 82 copyFrom(rhs); 83 return *this; 84 } 85 copyFrom(const VendorTagDescriptor & src)86 void VendorTagDescriptor::copyFrom(const VendorTagDescriptor& src) { 87 if (this == &src) return; 88 89 size_t len = mReverseMapping.size(); 90 for (size_t i = 0; i < len; ++i) { 91 delete mReverseMapping[i]; 92 } 93 mReverseMapping.clear(); 94 95 len = src.mReverseMapping.size(); 96 // Have to copy KeyedVectors inside mReverseMapping 97 for (size_t i = 0; i < len; ++i) { 98 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>(); 99 *nameMapper = *(src.mReverseMapping.valueAt(i)); 100 mReverseMapping.add(src.mReverseMapping.keyAt(i), nameMapper); 101 } 102 // Everything else is simple 103 mTagToNameMap = src.mTagToNameMap; 104 mTagToSectionMap = src.mTagToSectionMap; 105 mTagToTypeMap = src.mTagToTypeMap; 106 mSections = src.mSections; 107 mTagCount = src.mTagCount; 108 mVendorOps = src.mVendorOps; 109 } 110 readFromParcel(const android::Parcel * parcel)111 status_t VendorTagDescriptor::readFromParcel(const android::Parcel* parcel) { 112 status_t res = OK; 113 if (parcel == NULL) { 114 ALOGE("%s: parcel argument was NULL.", __FUNCTION__); 115 return BAD_VALUE; 116 } 117 118 int32_t tagCount = 0; 119 if ((res = parcel->readInt32(&tagCount)) != OK) { 120 ALOGE("%s: could not read tag count from parcel", __FUNCTION__); 121 return res; 122 } 123 124 if (tagCount < 0 || tagCount > INT32_MAX) { 125 ALOGE("%s: tag count %d from vendor ops is invalid.", __FUNCTION__, tagCount); 126 return BAD_VALUE; 127 } 128 129 mTagCount = tagCount; 130 131 uint32_t tag, sectionIndex; 132 uint32_t maxSectionIndex = 0; 133 int32_t tagType; 134 Vector<uint32_t> allTags; 135 for (int32_t i = 0; i < tagCount; ++i) { 136 if ((res = parcel->readInt32(reinterpret_cast<int32_t*>(&tag))) != OK) { 137 ALOGE("%s: could not read tag id from parcel for index %d", __FUNCTION__, i); 138 break; 139 } 140 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) { 141 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag); 142 res = BAD_VALUE; 143 break; 144 } 145 if ((res = parcel->readInt32(&tagType)) != OK) { 146 ALOGE("%s: could not read tag type from parcel for tag %d", __FUNCTION__, tag); 147 break; 148 } 149 if (tagType < 0 || tagType >= NUM_TYPES) { 150 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType); 151 res = BAD_VALUE; 152 break; 153 } 154 String8 tagName = parcel->readString8(); 155 if (tagName.isEmpty()) { 156 ALOGE("%s: parcel tag name was NULL for tag %d.", __FUNCTION__, tag); 157 res = NOT_ENOUGH_DATA; 158 break; 159 } 160 161 if ((res = parcel->readInt32(reinterpret_cast<int32_t*>(§ionIndex))) != OK) { 162 ALOGE("%s: could not read section index for tag %d.", __FUNCTION__, tag); 163 break; 164 } 165 166 maxSectionIndex = (maxSectionIndex >= sectionIndex) ? maxSectionIndex : sectionIndex; 167 168 allTags.add(tag); 169 mTagToNameMap.add(tag, tagName); 170 mTagToSectionMap.add(tag, sectionIndex); 171 mTagToTypeMap.add(tag, tagType); 172 } 173 174 if (res != OK) { 175 return res; 176 } 177 178 size_t sectionCount = 0; 179 if (tagCount > 0) { 180 if ((res = parcel->readInt32(reinterpret_cast<int32_t*>(§ionCount))) != OK) { 181 ALOGE("%s: could not read section count for.", __FUNCTION__); 182 return res; 183 } 184 if (sectionCount < (maxSectionIndex + 1)) { 185 ALOGE("%s: Incorrect number of sections defined, received %zu, needs %d.", 186 __FUNCTION__, sectionCount, (maxSectionIndex + 1)); 187 return BAD_VALUE; 188 } 189 LOG_ALWAYS_FATAL_IF(mSections.setCapacity(sectionCount) <= 0, 190 "Vector capacity must be positive"); 191 for (size_t i = 0; i < sectionCount; ++i) { 192 String8 sectionName = parcel->readString8(); 193 if (sectionName.isEmpty()) { 194 ALOGE("%s: parcel section name was NULL for section %zu.", 195 __FUNCTION__, i); 196 return NOT_ENOUGH_DATA; 197 } 198 mSections.add(sectionName); 199 } 200 } 201 202 LOG_ALWAYS_FATAL_IF(static_cast<size_t>(tagCount) != allTags.size(), 203 "tagCount must be the same as allTags size"); 204 // Set up reverse mapping 205 for (size_t i = 0; i < static_cast<size_t>(tagCount); ++i) { 206 uint32_t tag = allTags[i]; 207 const String8& sectionString = mSections[mTagToSectionMap.valueFor(tag)]; 208 209 ssize_t reverseIndex = -1; 210 if ((reverseIndex = mReverseMapping.indexOfKey(sectionString)) < 0) { 211 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>(); 212 reverseIndex = mReverseMapping.add(sectionString, nameMapper); 213 } 214 mReverseMapping[reverseIndex]->add(mTagToNameMap.valueFor(tag), tag); 215 } 216 217 return res; 218 } 219 getTagCount() const220 int VendorTagDescriptor::getTagCount() const { 221 size_t size = mTagToNameMap.size(); 222 if (size == 0) { 223 return VENDOR_TAG_COUNT_ERR; 224 } 225 return size; 226 } 227 getTagArray(uint32_t * tagArray) const228 void VendorTagDescriptor::getTagArray(uint32_t* tagArray) const { 229 size_t size = mTagToNameMap.size(); 230 for (size_t i = 0; i < size; ++i) { 231 tagArray[i] = mTagToNameMap.keyAt(i); 232 } 233 } 234 getSectionName(uint32_t tag) const235 const char* VendorTagDescriptor::getSectionName(uint32_t tag) const { 236 ssize_t index = mTagToSectionMap.indexOfKey(tag); 237 if (index < 0) { 238 return VENDOR_SECTION_NAME_ERR; 239 } 240 return mSections[mTagToSectionMap.valueAt(index)].string(); 241 } 242 getTagName(uint32_t tag) const243 const char* VendorTagDescriptor::getTagName(uint32_t tag) const { 244 ssize_t index = mTagToNameMap.indexOfKey(tag); 245 if (index < 0) { 246 return VENDOR_TAG_NAME_ERR; 247 } 248 return mTagToNameMap.valueAt(index).string(); 249 } 250 getTagType(uint32_t tag) const251 int VendorTagDescriptor::getTagType(uint32_t tag) const { 252 ssize_t index = mTagToNameMap.indexOfKey(tag); 253 if (index < 0) { 254 return VENDOR_TAG_TYPE_ERR; 255 } 256 return mTagToTypeMap.valueFor(tag); 257 } 258 writeToParcel(android::Parcel * parcel) const259 status_t VendorTagDescriptor::writeToParcel(android::Parcel* parcel) const { 260 status_t res = OK; 261 if (parcel == NULL) { 262 ALOGE("%s: parcel argument was NULL.", __FUNCTION__); 263 return BAD_VALUE; 264 } 265 266 if ((res = parcel->writeInt32(mTagCount)) != OK) { 267 return res; 268 } 269 270 size_t size = mTagToNameMap.size(); 271 uint32_t tag, sectionIndex; 272 int32_t tagType; 273 for (size_t i = 0; i < size; ++i) { 274 tag = mTagToNameMap.keyAt(i); 275 String8 tagName = mTagToNameMap[i]; 276 sectionIndex = mTagToSectionMap.valueFor(tag); 277 tagType = mTagToTypeMap.valueFor(tag); 278 if ((res = parcel->writeInt32(tag)) != OK) break; 279 if ((res = parcel->writeInt32(tagType)) != OK) break; 280 if ((res = parcel->writeString8(tagName)) != OK) break; 281 if ((res = parcel->writeInt32(sectionIndex)) != OK) break; 282 } 283 284 size_t numSections = mSections.size(); 285 if (numSections > 0) { 286 if ((res = parcel->writeInt32(numSections)) != OK) return res; 287 for (size_t i = 0; i < numSections; ++i) { 288 if ((res = parcel->writeString8(mSections[i])) != OK) return res; 289 } 290 } 291 292 return res; 293 } 294 getAllSectionNames() const295 const SortedVector<String8>* VendorTagDescriptor::getAllSectionNames() const { 296 return &mSections; 297 } 298 lookupTag(const String8 & name,const String8 & section,uint32_t * tag) const299 status_t VendorTagDescriptor::lookupTag(const String8& name, const String8& section, /*out*/uint32_t* tag) const { 300 ssize_t index = mReverseMapping.indexOfKey(section); 301 if (index < 0) { 302 ALOGE("%s: Section '%s' does not exist.", __FUNCTION__, section.string()); 303 return BAD_VALUE; 304 } 305 306 ssize_t nameIndex = mReverseMapping[index]->indexOfKey(name); 307 if (nameIndex < 0) { 308 ALOGE("%s: Tag name '%s' does not exist.", __FUNCTION__, name.string()); 309 return BAD_VALUE; 310 } 311 312 if (tag != NULL) { 313 *tag = mReverseMapping[index]->valueAt(nameIndex); 314 } 315 return OK; 316 } 317 getSectionIndex(uint32_t tag) const318 ssize_t VendorTagDescriptor::getSectionIndex(uint32_t tag) const { 319 return mTagToSectionMap.valueFor(tag); 320 } 321 dump(int fd,int verbosity,int indentation) const322 void VendorTagDescriptor::dump(int fd, int verbosity, int indentation) const { 323 324 size_t size = mTagToNameMap.size(); 325 if (size == 0) { 326 dprintf(fd, "%*sDumping configured vendor tag descriptors: None set\n", 327 indentation, ""); 328 return; 329 } 330 331 dprintf(fd, "%*sDumping configured vendor tag descriptors: %zu entries\n", 332 indentation, "", size); 333 for (size_t i = 0; i < size; ++i) { 334 uint32_t tag = mTagToNameMap.keyAt(i); 335 336 if (verbosity < 1) { 337 dprintf(fd, "%*s0x%x\n", indentation + 2, "", tag); 338 continue; 339 } 340 String8 name = mTagToNameMap.valueAt(i); 341 uint32_t sectionId = mTagToSectionMap.valueFor(tag); 342 String8 sectionName = mSections[sectionId]; 343 int type = mTagToTypeMap.valueFor(tag); 344 const char* typeName = (type >= 0 && type < NUM_TYPES) ? 345 camera_metadata_type_names[type] : "UNKNOWN"; 346 dprintf(fd, "%*s0x%x (%s) with type %d (%s) defined in section %s\n", indentation + 2, 347 "", tag, name.string(), type, typeName, sectionName.string()); 348 } 349 350 } 351 writeToParcel(Parcel * parcel) const352 status_t VendorTagDescriptorCache::writeToParcel(Parcel* parcel) const { 353 status_t res = OK; 354 if (parcel == NULL) { 355 ALOGE("%s: parcel argument was NULL.", __FUNCTION__); 356 return BAD_VALUE; 357 } 358 359 if ((res = parcel->writeInt32(mVendorMap.size())) != OK) { 360 return res; 361 } 362 363 for (const auto &iter : mVendorMap) { 364 if ((res = parcel->writeUint64(iter.first)) != OK) break; 365 if ((res = parcel->writeParcelable(*iter.second)) != OK) break; 366 } 367 368 return res; 369 } 370 371 readFromParcel(const Parcel * parcel)372 status_t VendorTagDescriptorCache::readFromParcel(const Parcel* parcel) { 373 status_t res = OK; 374 if (parcel == NULL) { 375 ALOGE("%s: parcel argument was NULL.", __FUNCTION__); 376 return BAD_VALUE; 377 } 378 379 int32_t vendorCount = 0; 380 if ((res = parcel->readInt32(&vendorCount)) != OK) { 381 ALOGE("%s: could not read vendor count from parcel", __FUNCTION__); 382 return res; 383 } 384 385 if (vendorCount < 0 || vendorCount > INT32_MAX) { 386 ALOGE("%s: vendor count %d from is invalid.", __FUNCTION__, vendorCount); 387 return BAD_VALUE; 388 } 389 390 metadata_vendor_id_t id; 391 for (int32_t i = 0; i < vendorCount; i++) { 392 if ((res = parcel->readUint64(&id)) != OK) { 393 ALOGE("%s: could not read vendor id from parcel for index %d", 394 __FUNCTION__, i); 395 break; 396 } 397 sp<android::VendorTagDescriptor> desc = new android::VendorTagDescriptor(); 398 if ((res = parcel->readParcelable(desc.get())) != OK) { 399 ALOGE("%s: could not read vendor tag descriptor from parcel for index %d rc = %d", 400 __FUNCTION__, i, res); 401 break; 402 } 403 404 if ((res = addVendorDescriptor(id, desc)) != OK) { 405 ALOGE("%s: failed to add vendor tag descriptor for index: %d ", 406 __FUNCTION__, i); 407 break; 408 } 409 } 410 411 return res; 412 } 413 414 const std::unordered_map<metadata_vendor_id_t, sp<android::VendorTagDescriptor>> & getVendorIdsAndTagDescriptors()415 VendorTagDescriptorCache::getVendorIdsAndTagDescriptors() { 416 return mVendorMap; 417 } 418 getTagCount(metadata_vendor_id_t id) const419 int VendorTagDescriptorCache::getTagCount(metadata_vendor_id_t id) const { 420 int ret = 0; 421 auto desc = mVendorMap.find(id); 422 if (desc != mVendorMap.end()) { 423 ret = desc->second->getTagCount(); 424 } else { 425 ALOGE("%s: Vendor descriptor id is missing!", __func__); 426 } 427 428 return ret; 429 } 430 getTagArray(uint32_t * tagArray,metadata_vendor_id_t id) const431 void VendorTagDescriptorCache::getTagArray(uint32_t* tagArray, 432 metadata_vendor_id_t id) const { 433 auto desc = mVendorMap.find(id); 434 if (desc != mVendorMap.end()) { 435 desc->second->getTagArray(tagArray); 436 } else { 437 ALOGE("%s: Vendor descriptor id is missing!", __func__); 438 } 439 } 440 getSectionName(uint32_t tag,metadata_vendor_id_t id) const441 const char* VendorTagDescriptorCache::getSectionName(uint32_t tag, 442 metadata_vendor_id_t id) const { 443 const char *ret = nullptr; 444 auto desc = mVendorMap.find(id); 445 if (desc != mVendorMap.end()) { 446 ret = desc->second->getSectionName(tag); 447 } else { 448 ALOGE("%s: Vendor descriptor id is missing!", __func__); 449 } 450 451 return ret; 452 } 453 getTagName(uint32_t tag,metadata_vendor_id_t id) const454 const char* VendorTagDescriptorCache::getTagName(uint32_t tag, 455 metadata_vendor_id_t id) const { 456 const char *ret = nullptr; 457 auto desc = mVendorMap.find(id); 458 if (desc != mVendorMap.end()) { 459 ret = desc->second->getTagName(tag); 460 } else { 461 ALOGE("%s: Vendor descriptor id is missing!", __func__); 462 } 463 464 return ret; 465 } 466 getTagType(uint32_t tag,metadata_vendor_id_t id) const467 int VendorTagDescriptorCache::getTagType(uint32_t tag, 468 metadata_vendor_id_t id) const { 469 int ret = 0; 470 auto desc = mVendorMap.find(id); 471 if (desc != mVendorMap.end()) { 472 ret = desc->second->getTagType(tag); 473 } else { 474 ALOGE("%s: Vendor descriptor id is missing!", __func__); 475 } 476 477 return ret; 478 } 479 dump(int fd,int verbosity,int indentation) const480 void VendorTagDescriptorCache::dump(int fd, int verbosity, 481 int indentation) const { 482 for (const auto &desc : mVendorMap) { 483 dprintf(fd, "%*sDumping vendor tag descriptors for vendor with" 484 " id %" PRIu64 " \n", indentation, "", desc.first); 485 desc.second->dump(fd, verbosity, indentation); 486 } 487 } 488 addVendorDescriptor(metadata_vendor_id_t id,sp<android::VendorTagDescriptor> desc)489 int32_t VendorTagDescriptorCache::addVendorDescriptor(metadata_vendor_id_t id, 490 sp<android::VendorTagDescriptor> desc) { 491 auto entry = mVendorMap.find(id); 492 if (entry != mVendorMap.end()) { 493 ALOGE("%s: Vendor descriptor with same id already present!", __func__); 494 return BAD_VALUE; 495 } 496 497 mVendorMap.emplace(id, desc); 498 return NO_ERROR; 499 } 500 getVendorTagDescriptor(metadata_vendor_id_t id,sp<android::VendorTagDescriptor> * desc)501 int32_t VendorTagDescriptorCache::getVendorTagDescriptor( 502 metadata_vendor_id_t id, sp<android::VendorTagDescriptor> *desc /*out*/) { 503 auto entry = mVendorMap.find(id); 504 if (entry == mVendorMap.end()) { 505 return NAME_NOT_FOUND; 506 } 507 508 *desc = entry->second; 509 510 return NO_ERROR; 511 } 512 513 } // namespace params 514 } // namespace camera2 515 } // namespace hardware 516 createDescriptorFromOps(const vendor_tag_ops_t * vOps,sp<VendorTagDescriptor> & descriptor)517 status_t VendorTagDescriptor::createDescriptorFromOps(const vendor_tag_ops_t* vOps, 518 /*out*/ 519 sp<VendorTagDescriptor>& descriptor) { 520 if (vOps == NULL) { 521 ALOGE("%s: vendor_tag_ops argument was NULL.", __FUNCTION__); 522 return BAD_VALUE; 523 } 524 525 int tagCount = vOps->get_tag_count(vOps); 526 if (tagCount < 0 || tagCount > INT32_MAX) { 527 ALOGE("%s: tag count %d from vendor ops is invalid.", __FUNCTION__, tagCount); 528 return BAD_VALUE; 529 } 530 531 Vector<uint32_t> tagArray; 532 LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount, 533 "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount); 534 535 vOps->get_all_tags(vOps, /*out*/tagArray.editArray()); 536 537 sp<VendorTagDescriptor> desc = new VendorTagDescriptor(); 538 desc->mTagCount = tagCount; 539 540 SortedVector<String8> sections; 541 KeyedVector<uint32_t, String8> tagToSectionMap; 542 543 for (size_t i = 0; i < static_cast<size_t>(tagCount); ++i) { 544 uint32_t tag = tagArray[i]; 545 if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) { 546 ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag); 547 return BAD_VALUE; 548 } 549 const char *tagName = vOps->get_tag_name(vOps, tag); 550 if (tagName == NULL) { 551 ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag); 552 return BAD_VALUE; 553 } 554 desc->mTagToNameMap.add(tag, String8(tagName)); 555 const char *sectionName = vOps->get_section_name(vOps, tag); 556 if (sectionName == NULL) { 557 ALOGE("%s: no section name defined for vendor tag %d.", __FUNCTION__, tag); 558 return BAD_VALUE; 559 } 560 561 String8 sectionString(sectionName); 562 563 sections.add(sectionString); 564 tagToSectionMap.add(tag, sectionString); 565 566 int tagType = vOps->get_tag_type(vOps, tag); 567 if (tagType < 0 || tagType >= NUM_TYPES) { 568 ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType); 569 return BAD_VALUE; 570 } 571 desc->mTagToTypeMap.add(tag, tagType); 572 } 573 574 desc->mSections = sections; 575 576 for (size_t i = 0; i < static_cast<size_t>(tagCount); ++i) { 577 uint32_t tag = tagArray[i]; 578 const String8& sectionString = tagToSectionMap.valueFor(tag); 579 580 // Set up tag to section index map 581 ssize_t index = sections.indexOf(sectionString); 582 LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index); 583 desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index)); 584 585 // Set up reverse mapping 586 ssize_t reverseIndex = -1; 587 if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) { 588 KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>(); 589 reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper); 590 } 591 desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag); 592 } 593 594 descriptor = desc; 595 return OK; 596 } 597 setAsGlobalVendorTagDescriptor(const sp<VendorTagDescriptor> & desc)598 status_t VendorTagDescriptor::setAsGlobalVendorTagDescriptor(const sp<VendorTagDescriptor>& desc) { 599 status_t res = OK; 600 Mutex::Autolock al(sLock); 601 sGlobalVendorTagDescriptor = desc; 602 603 vendor_tag_ops_t* opsPtr = NULL; 604 if (desc != NULL) { 605 opsPtr = &(desc->mVendorOps); 606 opsPtr->get_tag_count = vendor_tag_descriptor_get_tag_count; 607 opsPtr->get_all_tags = vendor_tag_descriptor_get_all_tags; 608 opsPtr->get_section_name = vendor_tag_descriptor_get_section_name; 609 opsPtr->get_tag_name = vendor_tag_descriptor_get_tag_name; 610 opsPtr->get_tag_type = vendor_tag_descriptor_get_tag_type; 611 } 612 if((res = set_camera_metadata_vendor_ops(opsPtr)) != OK) { 613 ALOGE("%s: Could not set vendor tag descriptor, received error %s (%d)." 614 , __FUNCTION__, strerror(-res), res); 615 } 616 return res; 617 } 618 clearGlobalVendorTagDescriptor()619 void VendorTagDescriptor::clearGlobalVendorTagDescriptor() { 620 Mutex::Autolock al(sLock); 621 set_camera_metadata_vendor_ops(NULL); 622 sGlobalVendorTagDescriptor.clear(); 623 } 624 getGlobalVendorTagDescriptor()625 sp<VendorTagDescriptor> VendorTagDescriptor::getGlobalVendorTagDescriptor() { 626 Mutex::Autolock al(sLock); 627 return sGlobalVendorTagDescriptor; 628 } 629 setAsGlobalVendorTagCache(const sp<VendorTagDescriptorCache> & cache)630 status_t VendorTagDescriptorCache::setAsGlobalVendorTagCache( 631 const sp<VendorTagDescriptorCache>& cache) { 632 status_t res = OK; 633 Mutex::Autolock al(sLock); 634 sGlobalVendorTagDescriptorCache = cache; 635 636 struct vendor_tag_cache_ops* opsPtr = NULL; 637 if (cache != NULL) { 638 opsPtr = &(cache->mVendorCacheOps); 639 opsPtr->get_tag_count = vendor_tag_descriptor_cache_get_tag_count; 640 opsPtr->get_all_tags = vendor_tag_descriptor_cache_get_all_tags; 641 opsPtr->get_section_name = vendor_tag_descriptor_cache_get_section_name; 642 opsPtr->get_tag_name = vendor_tag_descriptor_cache_get_tag_name; 643 opsPtr->get_tag_type = vendor_tag_descriptor_cache_get_tag_type; 644 } 645 if((res = set_camera_metadata_vendor_cache_ops(opsPtr)) != OK) { 646 ALOGE("%s: Could not set vendor tag cache, received error %s (%d)." 647 , __FUNCTION__, strerror(-res), res); 648 } 649 return res; 650 } 651 clearGlobalVendorTagCache()652 void VendorTagDescriptorCache::clearGlobalVendorTagCache() { 653 Mutex::Autolock al(sLock); 654 set_camera_metadata_vendor_cache_ops(NULL); 655 sGlobalVendorTagDescriptorCache.clear(); 656 } 657 getGlobalVendorTagCache()658 sp<VendorTagDescriptorCache> VendorTagDescriptorCache::getGlobalVendorTagCache() { 659 Mutex::Autolock al(sLock); 660 return sGlobalVendorTagDescriptorCache; 661 } 662 isVendorCachePresent(metadata_vendor_id_t vendorId)663 bool VendorTagDescriptorCache::isVendorCachePresent(metadata_vendor_id_t vendorId) { 664 Mutex::Autolock al(sLock); 665 if ((sGlobalVendorTagDescriptorCache.get() != nullptr) && 666 (sGlobalVendorTagDescriptorCache->getVendorIdsAndTagDescriptors().find(vendorId) != 667 sGlobalVendorTagDescriptorCache->getVendorIdsAndTagDescriptors().end())) { 668 return true; 669 } 670 return false; 671 } 672 673 extern "C" { 674 vendor_tag_descriptor_get_tag_count(const vendor_tag_ops_t *)675 int vendor_tag_descriptor_get_tag_count(const vendor_tag_ops_t* /*v*/) { 676 Mutex::Autolock al(sLock); 677 if (sGlobalVendorTagDescriptor == NULL) { 678 ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__); 679 return VENDOR_TAG_COUNT_ERR; 680 } 681 return sGlobalVendorTagDescriptor->getTagCount(); 682 } 683 vendor_tag_descriptor_get_all_tags(const vendor_tag_ops_t *,uint32_t * tagArray)684 void vendor_tag_descriptor_get_all_tags(const vendor_tag_ops_t* /*v*/, uint32_t* tagArray) { 685 Mutex::Autolock al(sLock); 686 if (sGlobalVendorTagDescriptor == NULL) { 687 ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__); 688 return; 689 } 690 sGlobalVendorTagDescriptor->getTagArray(tagArray); 691 } 692 vendor_tag_descriptor_get_section_name(const vendor_tag_ops_t *,uint32_t tag)693 const char* vendor_tag_descriptor_get_section_name(const vendor_tag_ops_t* /*v*/, uint32_t tag) { 694 Mutex::Autolock al(sLock); 695 if (sGlobalVendorTagDescriptor == NULL) { 696 ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__); 697 return VENDOR_SECTION_NAME_ERR; 698 } 699 return sGlobalVendorTagDescriptor->getSectionName(tag); 700 } 701 vendor_tag_descriptor_get_tag_name(const vendor_tag_ops_t *,uint32_t tag)702 const char* vendor_tag_descriptor_get_tag_name(const vendor_tag_ops_t* /*v*/, uint32_t tag) { 703 Mutex::Autolock al(sLock); 704 if (sGlobalVendorTagDescriptor == NULL) { 705 ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__); 706 return VENDOR_TAG_NAME_ERR; 707 } 708 return sGlobalVendorTagDescriptor->getTagName(tag); 709 } 710 vendor_tag_descriptor_get_tag_type(const vendor_tag_ops_t *,uint32_t tag)711 int vendor_tag_descriptor_get_tag_type(const vendor_tag_ops_t* /*v*/, uint32_t tag) { 712 Mutex::Autolock al(sLock); 713 if (sGlobalVendorTagDescriptor == NULL) { 714 ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__); 715 return VENDOR_TAG_TYPE_ERR; 716 } 717 return sGlobalVendorTagDescriptor->getTagType(tag); 718 } 719 vendor_tag_descriptor_cache_get_tag_count(metadata_vendor_id_t id)720 int vendor_tag_descriptor_cache_get_tag_count(metadata_vendor_id_t id) { 721 Mutex::Autolock al(sLock); 722 if (sGlobalVendorTagDescriptorCache == NULL) { 723 ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__); 724 return VENDOR_TAG_COUNT_ERR; 725 } 726 return sGlobalVendorTagDescriptorCache->getTagCount(id); 727 } 728 vendor_tag_descriptor_cache_get_all_tags(uint32_t * tagArray,metadata_vendor_id_t id)729 void vendor_tag_descriptor_cache_get_all_tags(uint32_t* tagArray, 730 metadata_vendor_id_t id) { 731 Mutex::Autolock al(sLock); 732 if (sGlobalVendorTagDescriptorCache == NULL) { 733 ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__); 734 } 735 sGlobalVendorTagDescriptorCache->getTagArray(tagArray, id); 736 } 737 vendor_tag_descriptor_cache_get_section_name(uint32_t tag,metadata_vendor_id_t id)738 const char* vendor_tag_descriptor_cache_get_section_name(uint32_t tag, 739 metadata_vendor_id_t id) { 740 Mutex::Autolock al(sLock); 741 if (sGlobalVendorTagDescriptorCache == NULL) { 742 ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__); 743 return VENDOR_SECTION_NAME_ERR; 744 } 745 return sGlobalVendorTagDescriptorCache->getSectionName(tag, id); 746 } 747 vendor_tag_descriptor_cache_get_tag_name(uint32_t tag,metadata_vendor_id_t id)748 const char* vendor_tag_descriptor_cache_get_tag_name(uint32_t tag, 749 metadata_vendor_id_t id) { 750 Mutex::Autolock al(sLock); 751 if (sGlobalVendorTagDescriptorCache == NULL) { 752 ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__); 753 return VENDOR_TAG_NAME_ERR; 754 } 755 return sGlobalVendorTagDescriptorCache->getTagName(tag, id); 756 } 757 vendor_tag_descriptor_cache_get_tag_type(uint32_t tag,metadata_vendor_id_t id)758 int vendor_tag_descriptor_cache_get_tag_type(uint32_t tag, 759 metadata_vendor_id_t id) { 760 Mutex::Autolock al(sLock); 761 if (sGlobalVendorTagDescriptorCache == NULL) { 762 ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__); 763 return VENDOR_TAG_NAME_ERR; 764 } 765 return sGlobalVendorTagDescriptorCache->getTagType(tag, id); 766 } 767 768 } /* extern "C" */ 769 } /* namespace android */ 770