• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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*>(&sectionIndex))) != 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*>(&sectionCount))) != 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