Merge changes from topic 'camera-hidl-hal' (e1ee8c24) · Commits · e / os / android_hardware_interfaces

camera/Android.bp

+4 −0

Original line number	Diff line number	Diff line
		// This is an autogenerated file, do not edit.
		subdirs = [
		"common/1.0",
		"common/1.0/default",
		"device/1.0",
		"device/3.2",
		"device/3.2/default",
		"metadata/3.2",
		"provider/2.4",
		"provider/2.4/default",
		"provider/2.4/vts/functional",
		]

camera/common/1.0/default/Android.bp

0 → 100644

+15 −0

Original line number	Diff line number	Diff line
		cc_library_static {
		name: "android.hardware.camera.common@1.0-helper",
		srcs: ["CameraModule.cpp", "CameraMetadata.cpp", "VendorTagDescriptor.cpp"],
		cflags: [
		"-Werror",
		"-Wextra",
		"-Wall",
		],
		shared_libs: [
		"liblog",
		"libhardware",
		"libcamera_metadata"],
		include_dirs: ["system/media/private/camera/include"],
		export_include_dirs : ["include"]
		}

camera/common/1.0/default/CameraMetadata.cpp

0 → 100644

+568 −0

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

		// #define LOG_NDEBUG 0

		#define LOG_TAG "CamComm1.0-MD"
		#include <utils/Log.h>
		#include <utils/Errors.h>

		#include "CameraMetadata.h"
		#include "VendorTagDescriptor.h"

		namespace android {
		namespace hardware {
		namespace camera {
		namespace common {
		namespace V1_0 {
		namespace helper {

		#define ALIGN_TO(val, alignment) \
		(((uintptr_t)(val) + ((alignment) - 1)) & ~((alignment) - 1))

		CameraMetadata::CameraMetadata() :
		mBuffer(NULL), mLocked(false) {
		}

		CameraMetadata::CameraMetadata(size_t entryCapacity, size_t dataCapacity) :
		mLocked(false)
		{
		mBuffer = allocate_camera_metadata(entryCapacity, dataCapacity);
		}

		CameraMetadata::CameraMetadata(const CameraMetadata &other) :
		mLocked(false) {
		mBuffer = clone_camera_metadata(other.mBuffer);
		}

		CameraMetadata::CameraMetadata(camera_metadata_t *buffer) :
		mBuffer(NULL), mLocked(false) {
		acquire(buffer);
		}

		CameraMetadata &CameraMetadata::operator=(const CameraMetadata &other) {
		return operator=(other.mBuffer);
		}

		CameraMetadata &CameraMetadata::operator=(const camera_metadata_t *buffer) {
		if (mLocked) {
		ALOGE("%s: Assignment to a locked CameraMetadata!", __FUNCTION__);
		return *this;
		}

		if (CC_LIKELY(buffer != mBuffer)) {
		camera_metadata_t *newBuffer = clone_camera_metadata(buffer);
		clear();
		mBuffer = newBuffer;
		}
		return *this;
		}

		CameraMetadata::~CameraMetadata() {
		mLocked = false;
		clear();
		}

		const camera_metadata_t* CameraMetadata::getAndLock() const {
		mLocked = true;
		return mBuffer;
		}

		status_t CameraMetadata::unlock(const camera_metadata_t *buffer) const {
		if (!mLocked) {
		ALOGE("%s: Can't unlock a non-locked CameraMetadata!", __FUNCTION__);
		return INVALID_OPERATION;
		}
		if (buffer != mBuffer) {
		ALOGE("%s: Can't unlock CameraMetadata with wrong pointer!",
		__FUNCTION__);
		return BAD_VALUE;
		}
		mLocked = false;
		return OK;
		}

		camera_metadata_t* CameraMetadata::release() {
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return NULL;
		}
		camera_metadata_t *released = mBuffer;
		mBuffer = NULL;
		return released;
		}

		void CameraMetadata::clear() {
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return;
		}
		if (mBuffer) {
		free_camera_metadata(mBuffer);
		mBuffer = NULL;
		}
		}

		void CameraMetadata::acquire(camera_metadata_t *buffer) {
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return;
		}
		clear();
		mBuffer = buffer;

		ALOGE_IF(validate_camera_metadata_structure(mBuffer, /size/NULL) != OK,
		"%s: Failed to validate metadata structure %p",
		__FUNCTION__, buffer);
		}

		void CameraMetadata::acquire(CameraMetadata &other) {
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return;
		}
		acquire(other.release());
		}

		status_t CameraMetadata::append(const CameraMetadata &other) {
		return append(other.mBuffer);
		}

		status_t CameraMetadata::append(const camera_metadata_t* other) {
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		size_t extraEntries = get_camera_metadata_entry_count(other);
		size_t extraData = get_camera_metadata_data_count(other);
		resizeIfNeeded(extraEntries, extraData);

		return append_camera_metadata(mBuffer, other);
		}

		size_t CameraMetadata::entryCount() const {
		return (mBuffer == NULL) ? 0 :
		get_camera_metadata_entry_count(mBuffer);
		}

		bool CameraMetadata::isEmpty() const {
		return entryCount() == 0;
		}

		status_t CameraMetadata::sort() {
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		return sort_camera_metadata(mBuffer);
		}

		status_t CameraMetadata::checkType(uint32_t tag, uint8_t expectedType) {
		int tagType = get_camera_metadata_tag_type(tag);
		if ( CC_UNLIKELY(tagType == -1)) {
		ALOGE("Update metadata entry: Unknown tag %d", tag);
		return INVALID_OPERATION;
		}
		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,
		camera_metadata_type_names[tagType],
		camera_metadata_type_names[expectedType]);
		return INVALID_OPERATION;
		}
		return OK;
		}

		status_t CameraMetadata::update(uint32_t tag,
		const int32_t *data, size_t data_count) {
		status_t res;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		if ( (res = checkType(tag, TYPE_INT32)) != OK) {
		return res;
		}
		return updateImpl(tag, (const void*)data, data_count);
		}

		status_t CameraMetadata::update(uint32_t tag,
		const uint8_t *data, size_t data_count) {
		status_t res;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		if ( (res = checkType(tag, TYPE_BYTE)) != OK) {
		return res;
		}
		return updateImpl(tag, (const void*)data, data_count);
		}

		status_t CameraMetadata::update(uint32_t tag,
		const float *data, size_t data_count) {
		status_t res;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		if ( (res = checkType(tag, TYPE_FLOAT)) != OK) {
		return res;
		}
		return updateImpl(tag, (const void*)data, data_count);
		}

		status_t CameraMetadata::update(uint32_t tag,
		const int64_t *data, size_t data_count) {
		status_t res;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		if ( (res = checkType(tag, TYPE_INT64)) != OK) {
		return res;
		}
		return updateImpl(tag, (const void*)data, data_count);
		}

		status_t CameraMetadata::update(uint32_t tag,
		const double *data, size_t data_count) {
		status_t res;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		if ( (res = checkType(tag, TYPE_DOUBLE)) != OK) {
		return res;
		}
		return updateImpl(tag, (const void*)data, data_count);
		}

		status_t CameraMetadata::update(uint32_t tag,
		const camera_metadata_rational_t *data, size_t data_count) {
		status_t res;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		if ( (res = checkType(tag, TYPE_RATIONAL)) != OK) {
		return res;
		}
		return updateImpl(tag, (const void*)data, data_count);
		}

		status_t CameraMetadata::update(uint32_t tag,
		const String8 &string) {
		status_t res;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		if ( (res = checkType(tag, TYPE_BYTE)) != OK) {
		return res;
		}
		// string.size() doesn't count the null termination character.
		return updateImpl(tag, (const void*)string.string(), string.size() + 1);
		}

		status_t CameraMetadata::update(const camera_metadata_ro_entry &entry) {
		status_t res;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		if ( (res = checkType(entry.tag, entry.type)) != OK) {
		return res;
		}
		return updateImpl(entry.tag, (const void*)entry.data.u8, entry.count);
		}

		status_t CameraMetadata::updateImpl(uint32_t tag, const void *data,
		size_t data_count) {
		status_t res;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		int type = get_camera_metadata_tag_type(tag);
		if (type == -1) {
		ALOGE("%s: Tag %d not found", __FUNCTION__, tag);
		return BAD_VALUE;
		}
		// Safety check - ensure that data isn't pointing to this metadata, since
		// that would get invalidated if a resize is needed
		size_t bufferSize = get_camera_metadata_size(mBuffer);
		uintptr_t bufAddr = reinterpret_cast<uintptr_t>(mBuffer);
		uintptr_t dataAddr = reinterpret_cast<uintptr_t>(data);
		if (dataAddr > bufAddr && dataAddr < (bufAddr + bufferSize)) {
		ALOGE("%s: Update attempted with data from the same metadata buffer!",
		__FUNCTION__);
		return INVALID_OPERATION;
		}

		size_t data_size = calculate_camera_metadata_entry_data_size(type,
		data_count);

		res = resizeIfNeeded(1, data_size);

		if (res == OK) {
		camera_metadata_entry_t entry;
		res = find_camera_metadata_entry(mBuffer, tag, &entry);
		if (res == NAME_NOT_FOUND) {
		res = add_camera_metadata_entry(mBuffer,
		tag, data, data_count);
		} else if (res == OK) {
		res = update_camera_metadata_entry(mBuffer,
		entry.index, data, data_count, NULL);
		}
		}

		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);
		}

		IF_ALOGV() {
		ALOGE_IF(validate_camera_metadata_structure(mBuffer, /size/NULL) !=
		OK,

		"%s: Failed to validate metadata structure after update %p",
		__FUNCTION__, mBuffer);
		}

		return res;
		}

		bool CameraMetadata::exists(uint32_t tag) const {
		camera_metadata_ro_entry entry;
		return find_camera_metadata_ro_entry(mBuffer, tag, &entry) == 0;
		}

		camera_metadata_entry_t CameraMetadata::find(uint32_t tag) {
		status_t res;
		camera_metadata_entry entry;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		entry.count = 0;
		return entry;
		}
		res = find_camera_metadata_entry(mBuffer, tag, &entry);
		if (CC_UNLIKELY( res != OK )) {
		entry.count = 0;
		entry.data.u8 = NULL;
		}
		return entry;
		}

		camera_metadata_ro_entry_t CameraMetadata::find(uint32_t tag) const {
		status_t res;
		camera_metadata_ro_entry entry;
		res = find_camera_metadata_ro_entry(mBuffer, tag, &entry);
		if (CC_UNLIKELY( res != OK )) {
		entry.count = 0;
		entry.data.u8 = NULL;
		}
		return entry;
		}

		status_t CameraMetadata::erase(uint32_t tag) {
		camera_metadata_entry_t entry;
		status_t res;
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		res = find_camera_metadata_entry(mBuffer, tag, &entry);
		if (res == NAME_NOT_FOUND) {
		return OK;
		} 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);
		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);
		}
		return res;
		}

		void CameraMetadata::dump(int fd, int verbosity, int indentation) const {
		dump_indented_camera_metadata(mBuffer, fd, verbosity, indentation);
		}

		status_t CameraMetadata::resizeIfNeeded(size_t extraEntries, size_t extraData) {
		if (mBuffer == NULL) {
		mBuffer = allocate_camera_metadata(extraEntries * 2, extraData * 2);
		if (mBuffer == NULL) {
		ALOGE("%s: Can't allocate larger metadata buffer", __FUNCTION__);
		return NO_MEMORY;
		}
		} else {
		size_t currentEntryCount = get_camera_metadata_entry_count(mBuffer);
		size_t currentEntryCap = get_camera_metadata_entry_capacity(mBuffer);
		size_t newEntryCount = currentEntryCount +
		extraEntries;
		newEntryCount = (newEntryCount > currentEntryCap) ?
		newEntryCount * 2 : currentEntryCap;

		size_t currentDataCount = get_camera_metadata_data_count(mBuffer);
		size_t currentDataCap = get_camera_metadata_data_capacity(mBuffer);
		size_t newDataCount = currentDataCount +
		extraData;
		newDataCount = (newDataCount > currentDataCap) ?
		newDataCount * 2 : currentDataCap;

		if (newEntryCount > currentEntryCap \|\|
		newDataCount > currentDataCap) {
		camera_metadata_t *oldBuffer = mBuffer;
		mBuffer = allocate_camera_metadata(newEntryCount,
		newDataCount);
		if (mBuffer == NULL) {
		ALOGE("%s: Can't allocate larger metadata buffer", __FUNCTION__);
		return NO_MEMORY;
		}
		append_camera_metadata(mBuffer, oldBuffer);
		free_camera_metadata(oldBuffer);
		}
		}
		return OK;
		}

		void CameraMetadata::swap(CameraMetadata& other) {
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return;
		} else if (other.mLocked) {
		ALOGE("%s: Other CameraMetadata is locked", __FUNCTION__);
		return;
		}

		camera_metadata* thisBuf = mBuffer;
		camera_metadata* otherBuf = other.mBuffer;

		other.mBuffer = thisBuf;
		mBuffer = otherBuf;
		}

		status_t CameraMetadata::getTagFromName(const char *name,
		const VendorTagDescriptor* vTags, uint32_t *tag) {

		if (name == nullptr \|\| tag == nullptr) return BAD_VALUE;

		size_t nameLength = strlen(name);

		const SortedVector<String8> *vendorSections;
		size_t vendorSectionCount = 0;

		if (vTags != NULL) {
		vendorSections = vTags->getAllSectionNames();
		vendorSectionCount = vendorSections->size();
		}

		// First, find the section by the longest string match
		const char *section = NULL;
		size_t sectionIndex = 0;
		size_t sectionLength = 0;
		size_t totalSectionCount = ANDROID_SECTION_COUNT + vendorSectionCount;
		for (size_t i = 0; i < totalSectionCount; ++i) {

		const char *str = (i < ANDROID_SECTION_COUNT) ? camera_metadata_section_names[i] :
		(*vendorSections)[i - ANDROID_SECTION_COUNT].string();

		ALOGV("%s: Trying to match against section '%s'", __FUNCTION__, str);

		if (strstr(name, str) == name) { // name begins with the section name
		size_t strLength = strlen(str);

		ALOGV("%s: Name begins with section name", __FUNCTION__);

		// section name is the longest we've found so far
		if (section == NULL \|\| sectionLength < strLength) {
		section = str;
		sectionIndex = i;
		sectionLength = strLength;

		ALOGV("%s: Found new best section (%s)", __FUNCTION__, section);
		}
		}
		}

		// TODO: Make above get_camera_metadata_section_from_name ?

		if (section == NULL) {
		return NAME_NOT_FOUND;
		} else {
		ALOGV("%s: Found matched section '%s' (%zu)",
		__FUNCTION__, section, sectionIndex);
		}

		// Get the tag name component of the name
		const char *nameTagName = name + sectionLength + 1; // x.y.z -> z
		if (sectionLength + 1 >= nameLength) {
		return BAD_VALUE;
		}

		// Match rest of name against the tag names in that section only
		uint32_t candidateTag = 0;
		if (sectionIndex < ANDROID_SECTION_COUNT) {
		// Match built-in tags (typically android.*)
		uint32_t tagBegin, tagEnd; // [tagBegin, tagEnd)
		tagBegin = camera_metadata_section_bounds[sectionIndex][0];
		tagEnd = camera_metadata_section_bounds[sectionIndex][1];

		for (candidateTag = tagBegin; candidateTag < tagEnd; ++candidateTag) {
		const char *tagName = get_camera_metadata_tag_name(candidateTag);

		if (strcmp(nameTagName, tagName) == 0) {
		ALOGV("%s: Found matched tag '%s' (%d)",
		__FUNCTION__, tagName, candidateTag);
		break;
		}
		}

		if (candidateTag == tagEnd) {
		return NAME_NOT_FOUND;
		}
		} else if (vTags != NULL) {
		// Match vendor tags (typically com.*)
		const String8 sectionName(section);
		const String8 tagName(nameTagName);

		status_t res = OK;
		if ((res = vTags->lookupTag(tagName, sectionName, &candidateTag)) != OK) {
		return NAME_NOT_FOUND;
		}
		}

		*tag = candidateTag;
		return OK;
		}


		} // namespace helper
		} // namespace V1_0
		} // namespace common
		} // namespace camera
		} // namespace hardware
		} // namespace android

camera/common/1.0/default/CameraModule.cpp

0 → 100644

+451 −0

File added.

Preview size limit exceeded, changes collapsed.

camera/common/1.0/default/VendorTagDescriptor.cpp

0 → 100644

+367 −0

File added.

Preview size limit exceeded, changes collapsed.