Resolve conflict (e1a2df55) · Commits · e / os / android_frameworks_av

CleanSpec.mk

+13 −0

Original line number	Diff line number	Diff line
		@@ -47,6 +47,19 @@ $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libmedia_nativ
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/lib/libmedia_native.so)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/symbols/system/lib/libmedia_native.so)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/libmedia_native.so)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libaudioflinger_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/libaudioflinger.so)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libaudiopolicy_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/libaudiopolicy.so)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libaudiopolicy_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/libaudiopolicy.so)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libaudiopolicyservice_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libaudiopolicymanager_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/libaudiopolicyservice.so)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/libaudiopolicymanager.so)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libaudiopolicyservice_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libaudiopolicymanager_intermediates)

		# ************************************************
		# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST
		# ************************************************

camera/Android.mk

+18 −0

Original line number	Diff line number	Diff line
		# Copyright 2010 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.

		CAMERA_CLIENT_LOCAL_PATH:= $(call my-dir)
		include $(call all-subdir-makefiles)
		include $(CLEAR_VARS)
		@@ -8,6 +22,7 @@ LOCAL_SRC_FILES:= \
		Camera.cpp \
		CameraMetadata.cpp \
		CameraParameters.cpp \
		CaptureResult.cpp \
		CameraParameters2.cpp \
		ICamera.cpp \
		ICameraClient.cpp \
		@@ -22,6 +37,8 @@ LOCAL_SRC_FILES:= \
		camera2/CaptureRequest.cpp \
		ProCamera.cpp \
		CameraBase.cpp \
		CameraUtils.cpp \
		VendorTagDescriptor.cpp

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		@@ -35,6 +52,7 @@ LOCAL_SHARED_LIBRARIES := \

		LOCAL_C_INCLUDES += \
		system/media/camera/include \
		system/media/private/camera/include \

		LOCAL_MODULE:= libcamera_client

camera/Camera.cpp

+26 −0

Original line number	Diff line number	Diff line
		@@ -77,6 +77,32 @@ sp<Camera> Camera::connect(int cameraId, const String16& clientPackageName,
		return CameraBaseT::connect(cameraId, clientPackageName, clientUid);
		}

		status_t Camera::connectLegacy(int cameraId, int halVersion,
		const String16& clientPackageName,
		int clientUid,
		sp<Camera>& camera)
		{
		ALOGV("%s: connect legacy camera device", __FUNCTION__);
		sp<Camera> c = new Camera(cameraId);
		sp<ICameraClient> cl = c;
		status_t status = NO_ERROR;
		const sp<ICameraService>& cs = CameraBaseT::getCameraService();

		if (cs != 0) {
		status = cs.get()->connectLegacy(cl, cameraId, halVersion, clientPackageName,
		clientUid, /out/c->mCamera);
		}
		if (status == OK && c->mCamera != 0) {
		c->mCamera->asBinder()->linkToDeath(c);
		c->mStatus = NO_ERROR;
		camera = c;
		} else {
		ALOGW("An error occurred while connecting to camera: %d", cameraId);
		c.clear();
		}
		return status;
		}

		status_t Camera::reconnect()
		{
		ALOGV("reconnect");

camera/CameraMetadata.cpp

+110 −31

Original line number	Diff line number	Diff line
		@@ -25,6 +25,9 @@

		namespace android {

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

		typedef Parcel::WritableBlob WritableBlob;
		typedef Parcel::ReadableBlob ReadableBlob;

		@@ -270,7 +273,8 @@ status_t CameraMetadata::update(uint32_t tag,
		if ( (res = checkType(tag, TYPE_BYTE)) != OK) {
		return res;
		}
		return updateImpl(tag, (const void*)string.string(), string.size());
		// string.size() doesn't count the null termination character.
		return updateImpl(tag, (const void*)string.string(), string.size() + 1);
		}

		status_t CameraMetadata::updateImpl(uint32_t tag, const void *data,
		@@ -431,40 +435,70 @@ status_t CameraMetadata::readFromParcel(const Parcel& data,
		*out = NULL;
		}

		// arg0 = metadataSize (int32)
		int32_t metadataSizeTmp = -1;
		if ((err = data.readInt32(&metadataSizeTmp)) != OK) {
		// See CameraMetadata::writeToParcel for parcel data layout diagram and explanation.
		// arg0 = blobSize (int32)
		int32_t blobSizeTmp = -1;
		if ((err = data.readInt32(&blobSizeTmp)) != OK) {
		ALOGE("%s: Failed to read metadata size (error %d %s)",
		__FUNCTION__, err, strerror(-err));
		return err;
		}
		const size_t metadataSize = static_cast<size_t>(metadataSizeTmp);
		const size_t blobSize = static_cast<size_t>(blobSizeTmp);
		const size_t alignment = get_camera_metadata_alignment();

		if (metadataSize == 0) {
		// Special case: zero blob size means zero sized (NULL) metadata.
		if (blobSize == 0) {
		ALOGV("%s: Read 0-sized metadata", __FUNCTION__);
		return OK;
		}

		// NOTE: this doesn't make sense to me. shouldnt the blob
		if (blobSize <= alignment) {
		ALOGE("%s: metadata blob is malformed, blobSize(%zu) should be larger than alignment(%zu)",
		__FUNCTION__, blobSize, alignment);
		return BAD_VALUE;
		}

		const size_t metadataSize = blobSize - alignment;

		// NOTE: this doesn't make sense to me. shouldn't the blob
		// know how big it is? why do we have to specify the size
		// to Parcel::readBlob ?

		ReadableBlob blob;
		// arg1 = metadata (blob)
		do {
		if ((err = data.readBlob(metadataSize, &blob)) != OK) {
		ALOGE("%s: Failed to read metadata blob (sized %d). Possible "
		if ((err = data.readBlob(blobSize, &blob)) != OK) {
		ALOGE("%s: Failed to read metadata blob (sized %zu). Possible "
		" serialization bug. Error %d %s",
		__FUNCTION__, metadataSize, err, strerror(-err));
		__FUNCTION__, blobSize, err, strerror(-err));
		break;
		}
		const camera_metadata_t* tmp =
		reinterpret_cast<const camera_metadata_t*>(blob.data());

		// arg2 = offset (blob)
		// Must be after blob since we don't know offset until after writeBlob.
		int32_t offsetTmp;
		if ((err = data.readInt32(&offsetTmp)) != OK) {
		ALOGE("%s: Failed to read metadata offsetTmp (error %d %s)",
		__FUNCTION__, err, strerror(-err));
		break;
		}
		const size_t offset = static_cast<size_t>(offsetTmp);
		if (offset >= alignment) {
		ALOGE("%s: metadata offset(%zu) should be less than alignment(%zu)",
		__FUNCTION__, blobSize, alignment);
		err = BAD_VALUE;
		break;
		}

		const uintptr_t metadataStart = reinterpret_cast<uintptr_t>(blob.data()) + offset;
		const camera_metadata_t* tmp =
		reinterpret_cast<const camera_metadata_t*>(metadataStart);
		ALOGV("%s: alignment is: %zu, metadata start: %p, offset: %zu",
		__FUNCTION__, alignment, tmp, offset);
		metadata = allocate_copy_camera_metadata_checked(tmp, metadataSize);
		if (metadata == NULL) {
		// We consider that allocation only fails if the validation
		// also failed, therefore the readFromParcel was a failure.
		ALOGE("%s: metadata allocation and copy failed", __FUNCTION__);
		err = BAD_VALUE;
		}
		} while(0);
		@@ -485,38 +519,80 @@ status_t CameraMetadata::writeToParcel(Parcel& data,
		const camera_metadata_t* metadata) {
		status_t res = OK;

		// arg0 = metadataSize (int32)
		/**
		* Below is the camera metadata parcel layout:
		*
		* \|--------------------------------------------\|
		* \| arg0: blobSize \|
		* \| (length = 4) \|
		* \|--------------------------------------------\|<--Skip the rest if blobSize == 0.
		* \| \|
		* \| \|
		* \| arg1: blob \|
		* \| (length = variable, see arg1 layout below) \|
		* \| \|
		* \| \|
		* \|--------------------------------------------\|
		* \| arg2: offset \|
		* \| (length = 4) \|
		* \|--------------------------------------------\|
		*/

		// arg0 = blobSize (int32)
		if (metadata == NULL) {
		// Write zero blobSize for null metadata.
		return data.writeInt32(0);
		}

		/**
		* Always make the blob size sufficiently larger, as we need put alignment
		* padding and metadata into the blob. Since we don't know the alignment
		* offset before writeBlob. Then write the metadata to aligned offset.
		*/
		const size_t metadataSize = get_camera_metadata_compact_size(metadata);
		res = data.writeInt32(static_cast<int32_t>(metadataSize));
		const size_t alignment = get_camera_metadata_alignment();
		const size_t blobSize = metadataSize + alignment;
		res = data.writeInt32(static_cast<int32_t>(blobSize));
		if (res != OK) {
		return res;
		}

		// arg1 = metadata (blob)
		size_t offset = 0;
		/**
		* arg1 = metadata (blob).
		*
		* The blob size is the sum of front padding size, metadata size and back padding
		* size, which is equal to metadataSize + alignment.
		*
		* The blob layout is:
		* \|------------------------------------\|<----Start address of the blob (unaligned).
		* \| front padding \|
		* \| (size = offset) \|
		* \|------------------------------------\|<----Aligned start address of metadata.
		* \| \|
		* \| \|
		* \| metadata \|
		* \| (size = metadataSize) \|
		* \| \|
		* \| \|
		* \|------------------------------------\|
		* \| back padding \|
		* \| (size = alignment - offset) \|
		* \|------------------------------------\|<----End address of blob.
		* (Blob start address + blob size).
		*/
		WritableBlob blob;
		do {
		res = data.writeBlob(metadataSize, &blob);
		res = data.writeBlob(blobSize, &blob);
		if (res != OK) {
		break;
		}
		copy_camera_metadata(blob.data(), metadataSize, metadata);

		IF_ALOGV() {
		if (validate_camera_metadata_structure(
		(const camera_metadata_t*)blob.data(),
		&metadataSize) != OK) {
		ALOGV("%s: Failed to validate metadata %p after writing blob",
		__FUNCTION__, blob.data());
		} else {
		ALOGV("%s: Metadata written to blob. Validation success",
		__FUNCTION__);
		}
		}
		const uintptr_t metadataStart = ALIGN_TO(blob.data(), alignment);
		offset = metadataStart - reinterpret_cast<uintptr_t>(blob.data());
		ALOGV("%s: alignment is: %zu, metadata start: %p, offset: %zu",
		__FUNCTION__, alignment,
		reinterpret_cast<const void *>(metadataStart), offset);
		copy_camera_metadata(reinterpret_cast<void*>(metadataStart), metadataSize, metadata);

		// Not too big of a problem since receiving side does hard validation
		// Don't check the size since the compact size could be larger
		@@ -528,6 +604,9 @@ status_t CameraMetadata::writeToParcel(Parcel& data,
		} while(false);
		blob.release();

		// arg2 = offset (int32)
		res = data.writeInt32(static_cast<int32_t>(offset));

		return res;
		}

camera/CameraParameters.cpp

+42 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include <string.h>
		#include <stdlib.h>
		#include <camera/CameraParameters.h>
		#include <system/graphics.h>

		namespace android {
		// Parameter keys to communicate between camera application and driver.
		@@ -483,4 +484,45 @@ status_t CameraParameters::dump(int fd, const Vector<String16>& /args/) const
		return NO_ERROR;
		}

		void CameraParameters::getSupportedPreviewFormats(Vector<int>& formats) const {
		const char* supportedPreviewFormats =
		get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);

		String8 fmtStr(supportedPreviewFormats);
		char* prevFmts = fmtStr.lockBuffer(fmtStr.size());

		char* savePtr;
		char* fmt = strtok_r(prevFmts, ",", &savePtr);
		while (fmt) {
		int actual = previewFormatToEnum(fmt);
		if (actual != -1) {
		formats.add(actual);
		}
		fmt = strtok_r(NULL, ",", &savePtr);
		}
		fmtStr.unlockBuffer(fmtStr.size());
		}


		int CameraParameters::previewFormatToEnum(const char* format) {
		return
		!format ?
		HAL_PIXEL_FORMAT_YCrCb_420_SP :
		!strcmp(format, PIXEL_FORMAT_YUV422SP) ?
		HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
		!strcmp(format, PIXEL_FORMAT_YUV420SP) ?
		HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
		!strcmp(format, PIXEL_FORMAT_YUV422I) ?
		HAL_PIXEL_FORMAT_YCbCr_422_I : // YUY2
		!strcmp(format, PIXEL_FORMAT_YUV420P) ?
		HAL_PIXEL_FORMAT_YV12 : // YV12
		!strcmp(format, PIXEL_FORMAT_RGB565) ?
		HAL_PIXEL_FORMAT_RGB_565 : // RGB565
		!strcmp(format, PIXEL_FORMAT_RGBA8888) ?
		HAL_PIXEL_FORMAT_RGBA_8888 : // RGB8888
		!strcmp(format, PIXEL_FORMAT_BAYER_RGGB) ?
		HAL_PIXEL_FORMAT_RAW_SENSOR : // Raw sensor data
		-1;
		}

		}; // namespace android