113 lines
4.0 KiB
C++
113 lines
4.0 KiB
C++
/*
|
|
* Copyright (C) 2022 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
#ifndef ANDROID_SERVERS_CAMERA_CAMERAPROVIDERINFO_TEMPLATEDH
|
|
#define ANDROID_SERVERS_CAMERA_CAMERAPROVIDERINFO_TEMPLATEDH
|
|
|
|
#include "common/CameraProviderManager.h"
|
|
|
|
namespace android {
|
|
|
|
template <class VendorTagSectionVectorType, class VendorTagSectionType>
|
|
status_t IdlVendorTagDescriptor::createDescriptorFromIdl(
|
|
const VendorTagSectionVectorType& vts,
|
|
sp<VendorTagDescriptor>& descriptor) {
|
|
|
|
int tagCount = 0;
|
|
|
|
for (size_t s = 0; s < vts.size(); s++) {
|
|
tagCount += vts[s].tags.size();
|
|
}
|
|
|
|
if (tagCount < 0 || tagCount > INT32_MAX) {
|
|
ALOGE("%s: tag count %d from vendor tag sections is invalid.", __FUNCTION__, tagCount);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
Vector<uint32_t> tagArray;
|
|
LOG_ALWAYS_FATAL_IF(tagArray.resize(tagCount) != tagCount,
|
|
"%s: too many (%u) vendor tags defined.", __FUNCTION__, tagCount);
|
|
sp<IdlVendorTagDescriptor> desc = new IdlVendorTagDescriptor();
|
|
desc->mTagCount = tagCount;
|
|
|
|
SortedVector<String8> sections;
|
|
KeyedVector<uint32_t, String8> tagToSectionMap;
|
|
|
|
int idx = 0;
|
|
for (size_t s = 0; s < vts.size(); s++) {
|
|
const VendorTagSectionType& section = vts[s];
|
|
const char *sectionName = section.sectionName.c_str();
|
|
if (sectionName == NULL) {
|
|
ALOGE("%s: no section name defined for vendor tag section %zu.", __FUNCTION__, s);
|
|
return BAD_VALUE;
|
|
}
|
|
String8 sectionString(sectionName);
|
|
sections.add(sectionString);
|
|
|
|
for (size_t j = 0; j < section.tags.size(); j++) {
|
|
uint32_t tag = section.tags[j].tagId;
|
|
if (tag < CAMERA_METADATA_VENDOR_TAG_BOUNDARY) {
|
|
ALOGE("%s: vendor tag %d not in vendor tag section.", __FUNCTION__, tag);
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
tagArray.editItemAt(idx++) = section.tags[j].tagId;
|
|
|
|
const char *tagName = section.tags[j].tagName.c_str();
|
|
if (tagName == NULL) {
|
|
ALOGE("%s: no tag name defined for vendor tag %d.", __FUNCTION__, tag);
|
|
return BAD_VALUE;
|
|
}
|
|
desc->mTagToNameMap.add(tag, String8(tagName));
|
|
tagToSectionMap.add(tag, sectionString);
|
|
|
|
int tagType = (int) section.tags[j].tagType;
|
|
if (tagType < 0 || tagType >= NUM_TYPES) {
|
|
ALOGE("%s: tag type %d from vendor ops does not exist.", __FUNCTION__, tagType);
|
|
return BAD_VALUE;
|
|
}
|
|
desc->mTagToTypeMap.add(tag, tagType);
|
|
}
|
|
}
|
|
|
|
desc->mSections = sections;
|
|
|
|
for (size_t i = 0; i < tagArray.size(); ++i) {
|
|
uint32_t tag = tagArray[i];
|
|
String8 sectionString = tagToSectionMap.valueFor(tag);
|
|
|
|
// Set up tag to section index map
|
|
ssize_t index = sections.indexOf(sectionString);
|
|
LOG_ALWAYS_FATAL_IF(index < 0, "index %zd must be non-negative", index);
|
|
desc->mTagToSectionMap.add(tag, static_cast<uint32_t>(index));
|
|
|
|
// Set up reverse mapping
|
|
ssize_t reverseIndex = -1;
|
|
if ((reverseIndex = desc->mReverseMapping.indexOfKey(sectionString)) < 0) {
|
|
KeyedVector<String8, uint32_t>* nameMapper = new KeyedVector<String8, uint32_t>();
|
|
reverseIndex = desc->mReverseMapping.add(sectionString, nameMapper);
|
|
}
|
|
desc->mReverseMapping[reverseIndex]->add(desc->mTagToNameMap.valueFor(tag), tag);
|
|
}
|
|
|
|
descriptor = std::move(desc);
|
|
return OK;
|
|
}
|
|
|
|
|
|
} // namespace android
|
|
|
|
#endif
|