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
663 extern "C" {
664
vendor_tag_descriptor_get_tag_count(const vendor_tag_ops_t *)665 int vendor_tag_descriptor_get_tag_count(const vendor_tag_ops_t* /*v*/) {
666 Mutex::Autolock al(sLock);
667 if (sGlobalVendorTagDescriptor == NULL) {
668 ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__);
669 return VENDOR_TAG_COUNT_ERR;
670 }
671 return sGlobalVendorTagDescriptor->getTagCount();
672 }
673
vendor_tag_descriptor_get_all_tags(const vendor_tag_ops_t *,uint32_t * tagArray)674 void vendor_tag_descriptor_get_all_tags(const vendor_tag_ops_t* /*v*/, uint32_t* tagArray) {
675 Mutex::Autolock al(sLock);
676 if (sGlobalVendorTagDescriptor == NULL) {
677 ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__);
678 return;
679 }
680 sGlobalVendorTagDescriptor->getTagArray(tagArray);
681 }
682
vendor_tag_descriptor_get_section_name(const vendor_tag_ops_t *,uint32_t tag)683 const char* vendor_tag_descriptor_get_section_name(const vendor_tag_ops_t* /*v*/, uint32_t tag) {
684 Mutex::Autolock al(sLock);
685 if (sGlobalVendorTagDescriptor == NULL) {
686 ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__);
687 return VENDOR_SECTION_NAME_ERR;
688 }
689 return sGlobalVendorTagDescriptor->getSectionName(tag);
690 }
691
vendor_tag_descriptor_get_tag_name(const vendor_tag_ops_t *,uint32_t tag)692 const char* vendor_tag_descriptor_get_tag_name(const vendor_tag_ops_t* /*v*/, uint32_t tag) {
693 Mutex::Autolock al(sLock);
694 if (sGlobalVendorTagDescriptor == NULL) {
695 ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__);
696 return VENDOR_TAG_NAME_ERR;
697 }
698 return sGlobalVendorTagDescriptor->getTagName(tag);
699 }
700
vendor_tag_descriptor_get_tag_type(const vendor_tag_ops_t *,uint32_t tag)701 int vendor_tag_descriptor_get_tag_type(const vendor_tag_ops_t* /*v*/, uint32_t tag) {
702 Mutex::Autolock al(sLock);
703 if (sGlobalVendorTagDescriptor == NULL) {
704 ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__);
705 return VENDOR_TAG_TYPE_ERR;
706 }
707 return sGlobalVendorTagDescriptor->getTagType(tag);
708 }
709
vendor_tag_descriptor_cache_get_tag_count(metadata_vendor_id_t id)710 int vendor_tag_descriptor_cache_get_tag_count(metadata_vendor_id_t id) {
711 Mutex::Autolock al(sLock);
712 if (sGlobalVendorTagDescriptorCache == NULL) {
713 ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
714 return VENDOR_TAG_COUNT_ERR;
715 }
716 return sGlobalVendorTagDescriptorCache->getTagCount(id);
717 }
718
vendor_tag_descriptor_cache_get_all_tags(uint32_t * tagArray,metadata_vendor_id_t id)719 void vendor_tag_descriptor_cache_get_all_tags(uint32_t* tagArray,
720 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 }
725 sGlobalVendorTagDescriptorCache->getTagArray(tagArray, id);
726 }
727
vendor_tag_descriptor_cache_get_section_name(uint32_t tag,metadata_vendor_id_t id)728 const char* vendor_tag_descriptor_cache_get_section_name(uint32_t tag,
729 metadata_vendor_id_t id) {
730 Mutex::Autolock al(sLock);
731 if (sGlobalVendorTagDescriptorCache == NULL) {
732 ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
733 return VENDOR_SECTION_NAME_ERR;
734 }
735 return sGlobalVendorTagDescriptorCache->getSectionName(tag, id);
736 }
737
vendor_tag_descriptor_cache_get_tag_name(uint32_t tag,metadata_vendor_id_t id)738 const char* vendor_tag_descriptor_cache_get_tag_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_TAG_NAME_ERR;
744 }
745 return sGlobalVendorTagDescriptorCache->getTagName(tag, id);
746 }
747
vendor_tag_descriptor_cache_get_tag_type(uint32_t tag,metadata_vendor_id_t id)748 int vendor_tag_descriptor_cache_get_tag_type(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->getTagType(tag, id);
756 }
757
758 } /* extern "C" */
759 } /* namespace android */
760