camera/VendorTagDescriptor.cpp

   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
  33 namespace android {
  34
  35 extern "C" {
  36
  37 static int vendor_tag_descriptor_get_tag_count(const vendor_tag_ops_t* v);
  38 static void vendor_tag_descriptor_get_all_tags(const vendor_tag_ops_t* v, uint32_t* tagArray);
  39 static const char* vendor_tag_descriptor_get_section_name(const vendor_tag_ops_t* v, uint32_t tag);
  40 static const char* vendor_tag_descriptor_get_tag_name(const vendor_tag_ops_t* v, uint32_t tag);
  41 static int vendor_tag_descriptor_get_tag_type(const vendor_tag_ops_t* v, uint32_t tag);
  42
  43 } /* extern "C" */
  44
  45
  46 static Mutex sLock;
  47 static sp<VendorTagDescriptor> sGlobalVendorTagDescriptor;
  48
  49 VendorTagDescriptor::VendorTagDescriptor() {}
  50
  51 VendorTagDescriptor::~VendorTagDescriptor() {
  52     size_t len = mReverseMapping.size();
  53     for (size_t i = 0; i < len; ++i)  {
  54         delete mReverseMapping[i];
  55     }
  56 }
  57
  58 status_t VendorTagDescriptor::createDescriptorFromOps(const vendor_tag_ops_t* vOps,
  59             /*out*/
  60             sp<VendorTagDescriptor>& descriptor) {
  61     if (vOps == NULL) {
  62         ALOGE("%s: vendor_tag_ops argument was NULL.", __FUNCTION__);
  63         return BAD_VALUE;
  64     }
  65
  66     int tagCount = vOps->get_tag_count(vOps);
  67     if (tagCount < 0 || tagCount > INT32_MAX) {
  68         ALOGE("%s: tag count %d from vendor ops is invalid.", __FUNCTION__, tagCount);
  69         return BAD_VALUE;
  70     }
  71
  72     Vector<uint32_t> tagArray;
  73     LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
  74             "%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
  75
  76     vOps->get_all_tags(vOps, /*out*/tagArray.editArray());
  77
  78     sp<VendorTagDescriptor> desc = new VendorTagDescriptor();
  79     desc->mTagCount = tagCount;
  80
  81     SortedVector<String8> sections;
  82     KeyedVector<uint32_t, String8> tagToSectionMap;
  83
  84     for (size_t i = 0; i < static_cast<size_t>(tagCount); ++i) {
  85         uint32_t tag = tagArray[i];
  86         if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
  87             ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
  88             return BAD_VALUE;
  89         }
  90         const char *tagName = vOps->get_tag_name(vOps, tag);
  91         if (tagName == NULL) {
  92             ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
  93             return BAD_VALUE;
  94         }
  95         desc->mTagToNameMap.add(tag, String8(tagName));
  96         const char *sectionName = vOps->get_section_name(vOps, tag);
  97         if (sectionName == NULL) {
  98             ALOGE("%s: no section name defined for vendor tag %d.", __FUNCTION__, tag);
  99             return BAD_VALUE;
 100         }
 101
 102         String8 sectionString(sectionName);
 103
 104         sections.add(sectionString);
 105         tagToSectionMap.add(tag, sectionString);
 106
 107         int tagType = vOps->get_tag_type(vOps, tag);
 108         if (tagType < 0 || tagType >= NUM_TYPES) {
 109             ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
 110             return BAD_VALUE;
 111         }
 112         desc->mTagToTypeMap.add(tag, tagType);
 113     }
 114
 115     desc->mSections = sections;
 116
 117     for (size_t i = 0; i < static_cast<size_t>(tagCount); ++i) {
 118         uint32_t tag = tagArray[i];
 119         String8 sectionString = tagToSectionMap.valueFor(tag);
 120
 121         // Set up tag to section index map
 122         ssize_t index = sections.indexOf(sectionString);
 123         LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
 124         desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
 125
 126         // Set up reverse mapping
 127         ssize_t reverseIndex = -1;
 128         if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
 129             KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
 130             reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
 131         }
 132         desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
 133     }
 134
 135     descriptor = desc;
 136     return OK;
 137 }
 138
 139 status_t VendorTagDescriptor::createFromParcel(const Parcel* parcel,
 140             /*out*/
 141             sp<VendorTagDescriptor>& descriptor) {
 142     status_t res = OK;
 143     if (parcel == NULL) {
 144         ALOGE("%s: parcel argument was NULL.", __FUNCTION__);
 145         return BAD_VALUE;
 146     }
 147
 148     int32_t tagCount = 0;
 149     if ((res = parcel->readInt32(&tagCount)) != OK) {
 150         ALOGE("%s: could not read tag count from parcel", __FUNCTION__);
 151         return res;
 152     }
 153
 154     if (tagCount < 0 || tagCount > INT32_MAX) {
 155         ALOGE("%s: tag count %d from vendor ops is invalid.", __FUNCTION__, tagCount);
 156         return BAD_VALUE;
 157     }
 158
 159     sp<VendorTagDescriptor> desc = new VendorTagDescriptor();
 160     desc->mTagCount = tagCount;
 161
 162     uint32_t tag, sectionIndex;
 163     uint32_t maxSectionIndex = 0;
 164     int32_t tagType;
 165     Vector<uint32_t> allTags;
 166     for (int32_t i = 0; i < tagCount; ++i) {
 167         if ((res = parcel->readInt32(reinterpret_cast<int32_t*>(&tag))) != OK) {
 168             ALOGE("%s: could not read tag id from parcel for index %d", __FUNCTION__, i);
 169             break;
 170         }
 171         if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
 172             ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
 173             res = BAD_VALUE;
 174             break;
 175         }
 176         if ((res = parcel->readInt32(&tagType)) != OK) {
 177             ALOGE("%s: could not read tag type from parcel for tag %d", __FUNCTION__, tag);
 178             break;
 179         }
 180         if (tagType < 0 || tagType >= NUM_TYPES) {
 181             ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
 182             res = BAD_VALUE;
 183             break;
 184         }
 185         String8 tagName = parcel->readString8();
 186         if (tagName.isEmpty()) {
 187             ALOGE("%s: parcel tag name was NULL for tag %d.", __FUNCTION__, tag);
 188             res = NOT_ENOUGH_DATA;
 189             break;
 190         }
 191
 192         if ((res = parcel->readInt32(reinterpret_cast<int32_t*>(&sectionIndex))) != OK) {
 193             ALOGE("%s: could not read section index for tag %d.", __FUNCTION__, tag);
 194             break;
 195         }
 196
 197         maxSectionIndex = (maxSectionIndex >= sectionIndex) ? maxSectionIndex : sectionIndex;
 198
 199         allTags.add(tag);
 200         desc->mTagToNameMap.add(tag, tagName);
 201         desc->mTagToSectionMap.add(tag, sectionIndex);
 202         desc->mTagToTypeMap.add(tag, tagType);
 203     }
 204
 205     if (res != OK) {
 206         return res;
 207     }
 208
 209     size_t sectionCount = 0;
 210     if (tagCount > 0) {
 211         if ((res = parcel->readInt32(reinterpret_cast<int32_t*>(&sectionCount))) != OK) {
 212             ALOGE("%s: could not read section count for.", __FUNCTION__);
 213             return res;
 214         }
 215         if (sectionCount < (maxSectionIndex + 1)) {
 216             ALOGE("%s: Incorrect number of sections defined, received %zu, needs %d.",
 217                     __FUNCTION__, sectionCount, (maxSectionIndex + 1));
 218             return BAD_VALUE;
 219         }
 220         LOG_ALWAYS_FATAL_IF(desc->mSections.setCapacity(sectionCount) <= 0,
 221                 "Vector capacity must be positive");
 222         for (size_t i = 0; i < sectionCount; ++i) {
 223             String8 sectionName = parcel->readString8();
 224             if (sectionName.isEmpty()) {
 225                 ALOGE("%s: parcel section name was NULL for section %zu.",
 226                       __FUNCTION__, i);
 227                 return NOT_ENOUGH_DATA;
 228             }
 229             desc->mSections.add(sectionName);
 230         }
 231     }
 232
 233     LOG_ALWAYS_FATAL_IF(static_cast<size_t>(tagCount) != allTags.size(),
 234                         "tagCount must be the same as allTags size");
 235     // Set up reverse mapping
 236     for (size_t i = 0; i < static_cast<size_t>(tagCount); ++i) {
 237         uint32_t tag = allTags[i];
 238         String8 sectionString = desc->mSections[desc->mTagToSectionMap.valueFor(tag)];
 239
 240         ssize_t reverseIndex = -1;
 241         if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
 242             KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
 243             reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
 244         }
 245         desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
 246     }
 247
 248     descriptor = desc;
 249     return res;
 250 }
 251
 252 int VendorTagDescriptor::getTagCount() const {
 253     size_t size = mTagToNameMap.size();
 254     if (size == 0) {
 255         return VENDOR_TAG_COUNT_ERR;
 256     }
 257     return size;
 258 }
 259
 260 void VendorTagDescriptor::getTagArray(uint32_t* tagArray) const {
 261     size_t size = mTagToNameMap.size();
 262     for (size_t i = 0; i < size; ++i) {
 263         tagArray[i] = mTagToNameMap.keyAt(i);
 264     }
 265 }
 266
 267 const char* VendorTagDescriptor::getSectionName(uint32_t tag) const {
 268     ssize_t index = mTagToSectionMap.indexOfKey(tag);
 269     if (index < 0) {
 270         return VENDOR_SECTION_NAME_ERR;
 271     }
 272     return mSections[mTagToSectionMap.valueAt(index)].string();
 273 }
 274
 275 const char* VendorTagDescriptor::getTagName(uint32_t tag) const {
 276     ssize_t index = mTagToNameMap.indexOfKey(tag);
 277     if (index < 0) {
 278         return VENDOR_TAG_NAME_ERR;
 279     }
 280     return mTagToNameMap.valueAt(index).string();
 281 }
 282
 283 int VendorTagDescriptor::getTagType(uint32_t tag) const {
 284     ssize_t index = mTagToNameMap.indexOfKey(tag);
 285     if (index < 0) {
 286         return VENDOR_TAG_TYPE_ERR;
 287     }
 288     return mTagToTypeMap.valueFor(tag);
 289 }
 290
 291 status_t VendorTagDescriptor::writeToParcel(Parcel* parcel) const {
 292     status_t res = OK;
 293     if (parcel == NULL) {
 294         ALOGE("%s: parcel argument was NULL.", __FUNCTION__);
 295         return BAD_VALUE;
 296     }
 297
 298     if ((res = parcel->writeInt32(mTagCount)) != OK) {
 299         return res;
 300     }
 301
 302     size_t size = mTagToNameMap.size();
 303     uint32_t tag, sectionIndex;
 304     int32_t tagType;
 305     for (size_t i = 0; i < size; ++i) {
 306         tag = mTagToNameMap.keyAt(i);
 307         String8 tagName = mTagToNameMap[i];
 308         sectionIndex = mTagToSectionMap.valueFor(tag);
 309         tagType = mTagToTypeMap.valueFor(tag);
 310         if ((res = parcel->writeInt32(tag)) != OK) break;
 311         if ((res = parcel->writeInt32(tagType)) != OK) break;
 312         if ((res = parcel->writeString8(tagName)) != OK) break;
 313         if ((res = parcel->writeInt32(sectionIndex)) != OK) break;
 314     }
 315
 316     size_t numSections = mSections.size();
 317     if (numSections > 0) {
 318         if ((res = parcel->writeInt32(numSections)) != OK) return res;
 319         for (size_t i = 0; i < numSections; ++i) {
 320             if ((res = parcel->writeString8(mSections[i])) != OK) return res;
 321         }
 322     }
 323
 324     return res;
 325 }
 326
 327 SortedVector<String8> VendorTagDescriptor::getAllSectionNames() const {
 328     return mSections;
 329 }
 330
 331 status_t VendorTagDescriptor::lookupTag(String8 name, String8 section, /*out*/uint32_t* tag) const {
 332     ssize_t index = mReverseMapping.indexOfKey(section);
 333     if (index < 0) {
 334         ALOGE("%s: Section '%s' does not exist.", __FUNCTION__, section.string());
 335         return BAD_VALUE;
 336     }
 337
 338     ssize_t nameIndex = mReverseMapping[index]->indexOfKey(name);
 339     if (nameIndex < 0) {
 340         ALOGE("%s: Tag name '%s' does not exist.", __FUNCTION__, name.string());
 341         return BAD_VALUE;
 342     }
 343
 344     if (tag != NULL) {
 345         *tag = mReverseMapping[index]->valueAt(nameIndex);
 346     }
 347     return OK;
 348 }
 349
 350 void VendorTagDescriptor::dump(int fd, int verbosity, int indentation) const {
 351
 352     size_t size = mTagToNameMap.size();
 353     if (size == 0) {
 354         dprintf(fd, "%*sDumping configured vendor tag descriptors: None set\n",
 355                 indentation, "");
 356         return;
 357     }
 358
 359     dprintf(fd, "%*sDumping configured vendor tag descriptors: %zu entries\n",
 360             indentation, "", size);
 361     for (size_t i = 0; i < size; ++i) {
 362         uint32_t tag =  mTagToNameMap.keyAt(i);
 363
 364         if (verbosity < 1) {
 365             dprintf(fd, "%*s0x%x\n", indentation + 2, "", tag);
 366             continue;
 367         }
 368         String8 name = mTagToNameMap.valueAt(i);
 369         uint32_t sectionId = mTagToSectionMap.valueFor(tag);
 370         String8 sectionName = mSections[sectionId];
 371         int type = mTagToTypeMap.valueFor(tag);
 372         const char* typeName = (type >= 0 && type < NUM_TYPES) ?
 373                 camera_metadata_type_names[type] : "UNKNOWN";
 374         dprintf(fd, "%*s0x%x (%s) with type %d (%s) defined in section %s\n", indentation + 2,
 375             "", tag, name.string(), type, typeName, sectionName.string());
 376     }
 377
 378 }
 379
 380 status_t VendorTagDescriptor::setAsGlobalVendorTagDescriptor(const sp<VendorTagDescriptor>& desc) {
 381     status_t res = OK;
 382     Mutex::Autolock al(sLock);
 383     sGlobalVendorTagDescriptor = desc;
 384
 385     vendor_tag_ops_t* opsPtr = NULL;
 386     if (desc != NULL) {
 387         opsPtr = &(desc->mVendorOps);
 388         opsPtr->get_tag_count = vendor_tag_descriptor_get_tag_count;
 389         opsPtr->get_all_tags = vendor_tag_descriptor_get_all_tags;
 390         opsPtr->get_section_name = vendor_tag_descriptor_get_section_name;
 391         opsPtr->get_tag_name = vendor_tag_descriptor_get_tag_name;
 392         opsPtr->get_tag_type = vendor_tag_descriptor_get_tag_type;
 393     }
 394     if((res = set_camera_metadata_vendor_ops(opsPtr)) != OK) {
 395         ALOGE("%s: Could not set vendor tag descriptor, received error %s (%d)."
 396                 , __FUNCTION__, strerror(-res), res);
 397     }
 398     return res;
 399 }
 400
 401 void VendorTagDescriptor::clearGlobalVendorTagDescriptor() {
 402     Mutex::Autolock al(sLock);
 403     set_camera_metadata_vendor_ops(NULL);
 404     sGlobalVendorTagDescriptor.clear();
 405 }
 406
 407 sp<VendorTagDescriptor> VendorTagDescriptor::getGlobalVendorTagDescriptor() {
 408     Mutex::Autolock al(sLock);
 409     return sGlobalVendorTagDescriptor;
 410 }
 411
 412 extern "C" {
 413
 414 int vendor_tag_descriptor_get_tag_count(const vendor_tag_ops_t* /*v*/) {
 415     Mutex::Autolock al(sLock);
 416     if (sGlobalVendorTagDescriptor == NULL) {
 417         ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__);
 418         return VENDOR_TAG_COUNT_ERR;
 419     }
 420     return sGlobalVendorTagDescriptor->getTagCount();
 421 }
 422
 423 void vendor_tag_descriptor_get_all_tags(const vendor_tag_ops_t* /*v*/, uint32_t* tagArray) {
 424     Mutex::Autolock al(sLock);
 425     if (sGlobalVendorTagDescriptor == NULL) {
 426         ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__);
 427         return;
 428     }
 429     sGlobalVendorTagDescriptor->getTagArray(tagArray);
 430 }
 431
 432 const char* vendor_tag_descriptor_get_section_name(const vendor_tag_ops_t* /*v*/, uint32_t tag) {
 433     Mutex::Autolock al(sLock);
 434     if (sGlobalVendorTagDescriptor == NULL) {
 435         ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__);
 436         return VENDOR_SECTION_NAME_ERR;
 437     }
 438     return sGlobalVendorTagDescriptor->getSectionName(tag);
 439 }
 440
 441 const char* vendor_tag_descriptor_get_tag_name(const vendor_tag_ops_t* /*v*/, uint32_t tag) {
 442     Mutex::Autolock al(sLock);
 443     if (sGlobalVendorTagDescriptor == NULL) {
 444         ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__);
 445         return VENDOR_TAG_NAME_ERR;
 446     }
 447     return sGlobalVendorTagDescriptor->getTagName(tag);
 448 }
 449
 450 int vendor_tag_descriptor_get_tag_type(const vendor_tag_ops_t* /*v*/, uint32_t tag) {
 451     Mutex::Autolock al(sLock);
 452     if (sGlobalVendorTagDescriptor == NULL) {
 453         ALOGE("%s: Vendor tag descriptor not initialized.", __FUNCTION__);
 454         return VENDOR_TAG_TYPE_ERR;
 455     }
 456     return sGlobalVendorTagDescriptor->getTagType(tag);
 457 }
 458
 459 } /* extern "C" */
 460 } /* namespace android */