Merge "Camera: Support vendor tags from multiple providers" into oc-dev (97e6e199) · Commits · e / os / android_frameworks_av

camera/CameraMetadata.cpp

+12 −9

Original line number	Diff line number	Diff line
		@@ -170,7 +170,7 @@ status_t CameraMetadata::sort() {
		}

		status_t CameraMetadata::checkType(uint32_t tag, uint8_t expectedType) {
		int tagType = get_camera_metadata_tag_type(tag);
		int tagType = get_local_camera_metadata_tag_type(tag, mBuffer);
		if ( CC_UNLIKELY(tagType == -1)) {
		ALOGE("Update metadata entry: Unknown tag %d", tag);
		return INVALID_OPERATION;
		@@ -178,7 +178,7 @@ status_t CameraMetadata::checkType(uint32_t tag, uint8_t expectedType) {
		if ( CC_UNLIKELY(tagType != expectedType) ) {
		ALOGE("Mismatched tag type when updating entry %s (%d) of type %s; "
		"got type %s data instead ",
		get_camera_metadata_tag_name(tag), tag,
		get_local_camera_metadata_tag_name(tag, mBuffer), tag,
		camera_metadata_type_names[tagType],
		camera_metadata_type_names[expectedType]);
		return INVALID_OPERATION;
		@@ -297,7 +297,7 @@ status_t CameraMetadata::updateImpl(uint32_t tag, const void *data,
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		int type = get_camera_metadata_tag_type(tag);
		int type = get_local_camera_metadata_tag_type(tag, mBuffer);
		if (type == -1) {
		ALOGE("%s: Tag %d not found", __FUNCTION__, tag);
		return BAD_VALUE;
		@@ -332,8 +332,9 @@ status_t CameraMetadata::updateImpl(uint32_t tag, const void *data,

		if (res != OK) {
		ALOGE("%s: Unable to update metadata entry %s.%s (%x): %s (%d)",
		__FUNCTION__, get_camera_metadata_section_name(tag),
		get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
		__FUNCTION__, get_local_camera_metadata_section_name(tag, mBuffer),
		get_local_camera_metadata_tag_name(tag, mBuffer), tag,
		strerror(-res), res);
		}

		IF_ALOGV() {
		@@ -392,16 +393,18 @@ status_t CameraMetadata::erase(uint32_t tag) {
		} else if (res != OK) {
		ALOGE("%s: Error looking for entry %s.%s (%x): %s %d",
		__FUNCTION__,
		get_camera_metadata_section_name(tag),
		get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
		get_local_camera_metadata_section_name(tag, mBuffer),
		get_local_camera_metadata_tag_name(tag, mBuffer),
		tag, strerror(-res), res);
		return res;
		}
		res = delete_camera_metadata_entry(mBuffer, entry.index);
		if (res != OK) {
		ALOGE("%s: Error deleting entry %s.%s (%x): %s %d",
		__FUNCTION__,
		get_camera_metadata_section_name(tag),
		get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
		get_local_camera_metadata_section_name(tag, mBuffer),
		get_local_camera_metadata_tag_name(tag, mBuffer),
		tag, strerror(-res), res);
		}
		return res;
		}

camera/VendorTagDescriptor.cpp

+249 −1

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@

		#include <stdio.h>
		#include <string.h>
		#include <inttypes.h>

		namespace android {

		@@ -40,11 +41,22 @@ static const char* vendor_tag_descriptor_get_section_name(const vendor_tag_ops_t
		static const char* vendor_tag_descriptor_get_tag_name(const vendor_tag_ops_t* v, uint32_t tag);
		static int vendor_tag_descriptor_get_tag_type(const vendor_tag_ops_t* v, uint32_t tag);

		static int vendor_tag_descriptor_cache_get_tag_count(metadata_vendor_id_t id);
		static void vendor_tag_descriptor_cache_get_all_tags(uint32_t* tagArray,
		metadata_vendor_id_t id);
		static const char* vendor_tag_descriptor_cache_get_section_name(uint32_t tag,
		metadata_vendor_id_t id);
		static const char* vendor_tag_descriptor_cache_get_tag_name(uint32_t tag,
		metadata_vendor_id_t id);
		static int vendor_tag_descriptor_cache_get_tag_type(uint32_t tag,
		metadata_vendor_id_t id);

		} /* extern "C" */


		static Mutex sLock;
		static sp<VendorTagDescriptor> sGlobalVendorTagDescriptor;
		static sp<VendorTagDescriptorCache> sGlobalVendorTagDescriptorCache;

		namespace hardware {
		namespace camera2 {
		@@ -333,11 +345,166 @@ void VendorTagDescriptor::dump(int fd, int verbosity, int indentation) const {

		}

		status_t VendorTagDescriptorCache::writeToParcel(Parcel* parcel) const {
		status_t res = OK;
		if (parcel == NULL) {
		ALOGE("%s: parcel argument was NULL.", __FUNCTION__);
		return BAD_VALUE;
		}

		if ((res = parcel->writeInt32(mVendorMap.size())) != OK) {
		return res;
		}

		for (const auto &iter : mVendorMap) {
		if ((res = parcel->writeUint64(iter.first)) != OK) break;
		if ((res = parcel->writeParcelable(*iter.second)) != OK) break;
		}

		return res;
		}


		status_t VendorTagDescriptorCache::readFromParcel(const Parcel* parcel) {
		status_t res = OK;
		if (parcel == NULL) {
		ALOGE("%s: parcel argument was NULL.", __FUNCTION__);
		return BAD_VALUE;
		}

		int32_t vendorCount = 0;
		if ((res = parcel->readInt32(&vendorCount)) != OK) {
		ALOGE("%s: could not read vendor count from parcel", __FUNCTION__);
		return res;
		}

		if (vendorCount < 0 \|\| vendorCount > INT32_MAX) {
		ALOGE("%s: vendor count %d from is invalid.", __FUNCTION__, vendorCount);
		return BAD_VALUE;
		}

		metadata_vendor_id_t id;
		for (int32_t i = 0; i < vendorCount; i++) {
		if ((res = parcel->readUint64(&id)) != OK) {
		ALOGE("%s: could not read vendor id from parcel for index %d",
		__FUNCTION__, i);
		break;
		}
		sp<android::VendorTagDescriptor> desc = new android::VendorTagDescriptor();
		if ((res = parcel->readParcelable(desc.get())) != OK) {
		ALOGE("%s: could not read vendor tag descriptor from parcel for index %d rc = %d",
		__FUNCTION__, i, res);
		break;
		}

		if ((res = addVendorDescriptor(id, desc)) != OK) {
		ALOGE("%s: failed to add vendor tag descriptor for index: %d ",
		__FUNCTION__, i);
		break;
		}
		}

		return res;
		}

		int VendorTagDescriptorCache::getTagCount(metadata_vendor_id_t id) const {
		int ret = 0;
		auto desc = mVendorMap.find(id);
		if (desc != mVendorMap.end()) {
		ret = desc->second->getTagCount();
		} else {
		ALOGE("%s: Vendor descriptor id is missing!", __func__);
		}

		return ret;
		}

		void VendorTagDescriptorCache::getTagArray(uint32_t* tagArray,
		metadata_vendor_id_t id) const {
		auto desc = mVendorMap.find(id);
		if (desc != mVendorMap.end()) {
		desc->second->getTagArray(tagArray);
		} else {
		ALOGE("%s: Vendor descriptor id is missing!", __func__);
		}
		}

		const char* VendorTagDescriptorCache::getSectionName(uint32_t tag,
		metadata_vendor_id_t id) const {
		const char *ret = nullptr;
		auto desc = mVendorMap.find(id);
		if (desc != mVendorMap.end()) {
		ret = desc->second->getSectionName(tag);
		} else {
		ALOGE("%s: Vendor descriptor id is missing!", __func__);
		}

		return ret;
		}

		const char* VendorTagDescriptorCache::getTagName(uint32_t tag,
		metadata_vendor_id_t id) const {
		const char *ret = nullptr;
		auto desc = mVendorMap.find(id);
		if (desc != mVendorMap.end()) {
		ret = desc->second->getTagName(tag);
		} else {
		ALOGE("%s: Vendor descriptor id is missing!", __func__);
		}

		return ret;
		}

		int VendorTagDescriptorCache::getTagType(uint32_t tag,
		metadata_vendor_id_t id) const {
		int ret = 0;
		auto desc = mVendorMap.find(id);
		if (desc != mVendorMap.end()) {
		ret = desc->second->getTagType(tag);
		} else {
		ALOGE("%s: Vendor descriptor id is missing!", __func__);
		}

		return ret;
		}

		void VendorTagDescriptorCache::dump(int fd, int verbosity,
		int indentation) const {
		for (const auto &desc : mVendorMap) {
		dprintf(fd, "%*sDumping vendor tag descriptors for vendor with"
		" id %" PRIu64 " \n", indentation, "", desc.first);
		desc.second->dump(fd, verbosity, indentation);
		}
		}

		int32_t VendorTagDescriptorCache::addVendorDescriptor(metadata_vendor_id_t id,
		sp<android::VendorTagDescriptor> desc) {
		auto entry = mVendorMap.find(id);
		if (entry != mVendorMap.end()) {
		ALOGE("%s: Vendor descriptor with same id already present!", __func__);
		return BAD_VALUE;
		}

		mVendorMap.emplace(id, desc);
		return NO_ERROR;
		}

		int32_t VendorTagDescriptorCache::getVendorTagDescriptor(
		metadata_vendor_id_t id, sp<android::VendorTagDescriptor> desc /out*/) {
		auto entry = mVendorMap.find(id);
		if (entry == mVendorMap.end()) {
		return NAME_NOT_FOUND;
		}

		*desc = entry->second;

		return NO_ERROR;
		}

		} // namespace params
		} // namespace camera2
		} // namespace hardware


		status_t VendorTagDescriptor::createDescriptorFromOps(const vendor_tag_ops_t* vOps,
		/out/
		sp<VendorTagDescriptor>& descriptor) {
		@@ -451,6 +618,39 @@ sp<VendorTagDescriptor> VendorTagDescriptor::getGlobalVendorTagDescriptor() {
		return sGlobalVendorTagDescriptor;
		}

		status_t VendorTagDescriptorCache::setAsGlobalVendorTagCache(
		const sp<VendorTagDescriptorCache>& cache) {
		status_t res = OK;
		Mutex::Autolock al(sLock);
		sGlobalVendorTagDescriptorCache = cache;

		struct vendor_tag_cache_ops* opsPtr = NULL;
		if (cache != NULL) {
		opsPtr = &(cache->mVendorCacheOps);
		opsPtr->get_tag_count = vendor_tag_descriptor_cache_get_tag_count;
		opsPtr->get_all_tags = vendor_tag_descriptor_cache_get_all_tags;
		opsPtr->get_section_name = vendor_tag_descriptor_cache_get_section_name;
		opsPtr->get_tag_name = vendor_tag_descriptor_cache_get_tag_name;
		opsPtr->get_tag_type = vendor_tag_descriptor_cache_get_tag_type;
		}
		if((res = set_camera_metadata_vendor_cache_ops(opsPtr)) != OK) {
		ALOGE("%s: Could not set vendor tag cache, received error %s (%d)."
		, __FUNCTION__, strerror(-res), res);
		}
		return res;
		}

		void VendorTagDescriptorCache::clearGlobalVendorTagCache() {
		Mutex::Autolock al(sLock);
		set_camera_metadata_vendor_cache_ops(NULL);
		sGlobalVendorTagDescriptorCache.clear();
		}

		sp<VendorTagDescriptorCache> VendorTagDescriptorCache::getGlobalVendorTagCache() {
		Mutex::Autolock al(sLock);
		return sGlobalVendorTagDescriptorCache;
		}

		extern "C" {

		int vendor_tag_descriptor_get_tag_count(const vendor_tag_ops_t* /v/) {
		@@ -498,5 +698,53 @@ int vendor_tag_descriptor_get_tag_type(const vendor_tag_ops_t* /v/, uint32_t t
		return sGlobalVendorTagDescriptor->getTagType(tag);
		}

		int vendor_tag_descriptor_cache_get_tag_count(metadata_vendor_id_t id) {
		Mutex::Autolock al(sLock);
		if (sGlobalVendorTagDescriptorCache == NULL) {
		ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
		return VENDOR_TAG_COUNT_ERR;
		}
		return sGlobalVendorTagDescriptorCache->getTagCount(id);
		}

		void vendor_tag_descriptor_cache_get_all_tags(uint32_t* tagArray,
		metadata_vendor_id_t id) {
		Mutex::Autolock al(sLock);
		if (sGlobalVendorTagDescriptorCache == NULL) {
		ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
		}
		sGlobalVendorTagDescriptorCache->getTagArray(tagArray, id);
		}

		const char* vendor_tag_descriptor_cache_get_section_name(uint32_t tag,
		metadata_vendor_id_t id) {
		Mutex::Autolock al(sLock);
		if (sGlobalVendorTagDescriptorCache == NULL) {
		ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
		return VENDOR_SECTION_NAME_ERR;
		}
		return sGlobalVendorTagDescriptorCache->getSectionName(tag, id);
		}

		const char* vendor_tag_descriptor_cache_get_tag_name(uint32_t tag,
		metadata_vendor_id_t id) {
		Mutex::Autolock al(sLock);
		if (sGlobalVendorTagDescriptorCache == NULL) {
		ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
		return VENDOR_TAG_NAME_ERR;
		}
		return sGlobalVendorTagDescriptorCache->getTagName(tag, id);
		}

		int vendor_tag_descriptor_cache_get_tag_type(uint32_t tag,
		metadata_vendor_id_t id) {
		Mutex::Autolock al(sLock);
		if (sGlobalVendorTagDescriptorCache == NULL) {
		ALOGE("%s: Vendor tag descriptor cache not initialized.", __FUNCTION__);
		return VENDOR_TAG_NAME_ERR;
		}
		return sGlobalVendorTagDescriptorCache->getTagType(tag, id);
		}

		} /* extern "C" */
		} /* namespace android */

camera/aidl/android/hardware/ICameraService.aidl

+9 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ import android.hardware.ICameraClient;
		import android.hardware.camera2.ICameraDeviceUser;
		import android.hardware.camera2.ICameraDeviceCallbacks;
		import android.hardware.camera2.params.VendorTagDescriptor;
		import android.hardware.camera2.params.VendorTagDescriptorCache;
		import android.hardware.camera2.impl.CameraMetadataNative;
		import android.hardware.ICameraServiceListener;
		import android.hardware.CameraInfo;
		@@ -129,6 +130,14 @@ interface ICameraService
		*/
		VendorTagDescriptor getCameraVendorTagDescriptor();

		/**
		* Retrieve the vendor tag descriptor cache which can have multiple vendor
		* providers.
		* Intended to be used by the native code of CameraMetadataNative to correctly
		* interpret camera metadata with vendor tags.
		*/
		VendorTagDescriptorCache getCameraVendorTagCache();

		/**
		* Read the legacy camera1 parameters into a String
		*/

camera/aidl/android/hardware/camera2/params/VendorTagDescriptorCache.aidl

0 → 100644

+20 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 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.
		*/

		package android.hardware.camera2.params;

		/** @hide */
		parcelable VendorTagDescriptorCache cpp_header "camera/VendorTagDescriptor.h";

camera/include/camera/VendorTagDescriptor.h

+78 −2

Original line number	Diff line number	Diff line
		@@ -22,7 +22,7 @@
		#include <utils/String8.h>
		#include <utils/RefBase.h>
		#include <system/camera_vendor_tags.h>

		#include <unordered_map>
		#include <stdint.h>

		namespace android {
		@@ -166,8 +166,84 @@ class VendorTagDescriptor :

		};

		} /* namespace android */
		namespace hardware {
		namespace camera2 {
		namespace params {

		class VendorTagDescriptorCache : public Parcelable {
		public:

		VendorTagDescriptorCache() {};

		int32_t addVendorDescriptor(metadata_vendor_id_t id,
		sp<android::VendorTagDescriptor> desc);

		int32_t getVendorTagDescriptor(
		metadata_vendor_id_t id,
		sp<android::VendorTagDescriptor> desc /out*/);

		// Parcelable interface
		status_t writeToParcel(Parcel* parcel) const override;
		status_t readFromParcel(const Parcel* parcel) override;

		// Returns the number of vendor tags defined.
		int getTagCount(metadata_vendor_id_t id) const;

		// Returns an array containing the id's of vendor tags defined.
		void getTagArray(uint32_t* tagArray, metadata_vendor_id_t id) const;

		// Returns the section name string for a given vendor tag id.
		const char* getSectionName(uint32_t tag, metadata_vendor_id_t id) const;

		// Returns the tag name string for a given vendor tag id.
		const char* getTagName(uint32_t tag, metadata_vendor_id_t id) const;

		// Returns the tag type for a given vendor tag id.
		int getTagType(uint32_t tag, metadata_vendor_id_t id) const;

		/**
		* Dump the currently configured vendor tags to a file descriptor.
		*/
		void dump(int fd, int verbosity, int indentation) const;

		protected:
		std::unordered_map<metadata_vendor_id_t, sp<android::VendorTagDescriptor>> mVendorMap;
		struct vendor_tag_cache_ops mVendorCacheOps;
		};

		} /* namespace params */
		} /* namespace camera2 */
		} /* namespace hardware */

		class VendorTagDescriptorCache :
		public ::android::hardware::camera2::params::VendorTagDescriptorCache,
		public LightRefBase<VendorTagDescriptorCache> {
		public:

		/**
		* Sets the global vendor tag descriptor cache to use for this process.
		* Camera metadata operations that access vendor tags will use the
		* vendor tag definitions set this way.
		*
		* Returns OK on success, or a negative error code.
		*/
		static status_t setAsGlobalVendorTagCache(
		const sp<VendorTagDescriptorCache>& cache);

		/**
		* Returns the global vendor tag cache used by this process.
		* This will contain NULL if no vendor tags are defined.
		*/
		static sp<VendorTagDescriptorCache> getGlobalVendorTagCache();

		/**
		* Clears the global vendor tag cache used by this process.
		*/
		static void clearGlobalVendorTagCache();

		};

		} /* namespace android */

		#define VENDOR_TAG_DESCRIPTOR_H
		#endif /* VENDOR_TAG_DESCRIPTOR_H */