Merge "Camera service: Initialization for camera2 clients and devices" (9d1e267c) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/Android.mk

+2 −1

Original line number	Diff line number	Diff line
		@@ -21,7 +21,8 @@ LOCAL_SHARED_LIBRARIES:= \
		libmedia_native \
		libcamera_client \
		libgui \
		libhardware
		libhardware \
		libcamera_metadata

		LOCAL_C_INCLUDES += \
		system/media/camera/include

services/camera/libcameraservice/Camera2Client.cpp

+698 −8

File changed.

Preview size limit exceeded, changes collapsed.

services/camera/libcameraservice/Camera2Client.h

+10 −1

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

		#include "Camera2Device.h"
		#include "CameraService.h"
		#include "camera/CameraParameters.h"

		namespace android {

		@@ -55,17 +56,25 @@ public:
		// Interface used by CameraService
		Camera2Client(const sp<CameraService>& cameraService,
		const sp<ICameraClient>& cameraClient,
		const sp<Camera2Device>& device,
		int cameraId,
		int cameraFacing,
		int clientPid);
		~Camera2Client();

		status_t initialize(camera_module_t *module);

		virtual status_t dump(int fd, const Vector<String16>& args);

		private:
		CameraParameters *mParams;
		sp<Camera2Device> mDevice;

		// Convert static camera info from a camera2 device to the
		// old API parameter map.
		status_t buildDefaultParameters();

		// Free parameters for mapping from new to old HAL
		static const unsigned int kNumZoomSteps = 10;
		};

		}; // namespace android

services/camera/libcameraservice/Camera2Device.cpp

+285 −10

Original line number	Diff line number	Diff line
		@@ -22,8 +22,8 @@

		namespace android {

		Camera2Device::Camera2Device(const char *name):
		mName(name),
		Camera2Device::Camera2Device(int id):
		mId(id),
		mDevice(NULL)
		{

		@@ -35,32 +35,307 @@ Camera2Device::~Camera2Device()
		status_t res;
		res = mDevice->common.close(&mDevice->common);
		if (res != OK) {
		ALOGE("Could not close camera2 %s: %s (%d)",
		mName, strerror(-res), res);
		ALOGE("%s: Could not close camera %d: %s (%d)",
		__FUNCTION__,
		mId, strerror(-res), res);
		}
		mDevice = NULL;
		}
		}

		status_t Camera2Device::initialize(hw_module_t *module)
		status_t Camera2Device::initialize(camera_module_t *module)
		{
		status_t res;
		res = module->methods->open(module, mName,
		char name[10];
		snprintf(name, sizeof(name), "%d", mId);

		res = module->common.methods->open(&module->common, name,
		reinterpret_cast<hw_device_t**>(&mDevice));

		if (res != OK) {
		ALOGE("Could not open camera %s: %s (%d)", mName, strerror(-res), res);
		ALOGE("%s: Could not open camera %d: %s (%d)", __FUNCTION__,
		mId, strerror(-res), res);
		return res;
		}

		if (mDevice->common.version != CAMERA_DEVICE_API_VERSION_2_0) {
		ALOGE("Could not open camera %s: "
		"Camera device is not version 2.0, reports %x instead",
		mName, mDevice->common.version);
		ALOGE("%s: Could not open camera %d: "
		"Camera device is not version %x, reports %x instead",
		__FUNCTION__, mId, CAMERA_DEVICE_API_VERSION_2_0,
		mDevice->common.version);
		return BAD_VALUE;
		}

		camera_info info;
		res = module->get_camera_info(mId, &info);
		if (res != OK ) return res;

		if (info.device_version != mDevice->common.version) {
		ALOGE("%s: HAL reporting mismatched camera_info version (%x)"
		" and device version (%x).", __FUNCTION__,
		mDevice->common.version, info.device_version);
		return BAD_VALUE;
		}

		mDeviceInfo = info.static_camera_characteristics;

		res = mDevice->ops->set_request_queue_src_ops(mDevice,
		mRequestQueue.getToConsumerInterface());
		if (res != OK) return res;

		res = mDevice->ops->set_frame_queue_dst_ops(mDevice,
		mFrameQueue.getToProducerInterface());
		if (res != OK) return res;

		res = mDevice->ops->get_metadata_vendor_tag_ops(mDevice, &mVendorTagOps);
		if (res != OK ) return res;

		return OK;
		}

		status_t Camera2Device::setStreamingRequest(camera_metadata_t* request)
		{
		mRequestQueue.setStreamSlot(request);
		return OK;
		}

		/**
		* Camera2Device::MetadataQueue
		*/

		Camera2Device::MetadataQueue::MetadataQueue():
		mDevice(NULL),
		mFrameCount(0),
		mCount(0),
		mStreamSlotCount(0),
		mSignalConsumer(true)
		{
		camera2_request_queue_src_ops::dequeue_request = consumer_dequeue;
		camera2_request_queue_src_ops::request_count = consumer_buffer_count;
		camera2_request_queue_src_ops::free_request = consumer_free;

		camera2_frame_queue_dst_ops::dequeue_frame = producer_dequeue;
		camera2_frame_queue_dst_ops::cancel_frame = producer_cancel;
		camera2_frame_queue_dst_ops::enqueue_frame = producer_enqueue;
		}

		Camera2Device::MetadataQueue::~MetadataQueue() {
		Mutex::Autolock l(mMutex);
		freeBuffers(mEntries.begin(), mEntries.end());
		freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
		}

		// Interface to camera2 HAL as consumer (input requests/reprocessing)
		const camera2_request_queue_src_ops_t*
		Camera2Device::MetadataQueue::getToConsumerInterface() {
		return static_cast<camera2_request_queue_src_ops_t*>(this);
		}

		void Camera2Device::MetadataQueue::setFromConsumerInterface(camera2_device_t *d) {
		Mutex::Autolock l(mMutex);
		mDevice = d;
		}

		const camera2_frame_queue_dst_ops_t*
		Camera2Device::MetadataQueue::getToProducerInterface() {
		return static_cast<camera2_frame_queue_dst_ops_t*>(this);
		}

		// Real interfaces
		status_t Camera2Device::MetadataQueue::enqueue(camera_metadata_t *buf) {
		Mutex::Autolock l(mMutex);

		mCount++;
		mEntries.push_back(buf);
		notEmpty.signal();

		if (mSignalConsumer && mDevice != NULL) {
		mSignalConsumer = false;

		mMutex.unlock();
		ALOGV("%s: Signaling consumer", __FUNCTION__);
		mDevice->ops->notify_request_queue_not_empty(mDevice);
		mMutex.lock();
		}
		return OK;
		}

		int Camera2Device::MetadataQueue::getBufferCount() {
		Mutex::Autolock l(mMutex);
		if (mStreamSlotCount > 0) {
		return CAMERA2_REQUEST_QUEUE_IS_BOTTOMLESS;
		}
		return mCount;
		}

		status_t Camera2Device::MetadataQueue::dequeue(camera_metadata_t **buf,
		bool incrementCount)
		{
		Mutex::Autolock l(mMutex);

		if (mCount == 0) {
		if (mStreamSlotCount == 0) {
		ALOGV("%s: Empty", __FUNCTION__);
		*buf = NULL;
		mSignalConsumer = true;
		return OK;
		}
		ALOGV("%s: Streaming %d frames to queue", __FUNCTION__,
		mStreamSlotCount);

		for (List<camera_metadata_t*>::iterator slotEntry = mStreamSlot.begin();
		slotEntry != mStreamSlot.end();
		slotEntry++ ) {
		size_t entries = get_camera_metadata_entry_count(*slotEntry);
		size_t dataBytes = get_camera_metadata_data_count(*slotEntry);

		camera_metadata_t *copy =
		allocate_camera_metadata(entries, dataBytes);
		append_camera_metadata(copy, *slotEntry);
		mEntries.push_back(copy);
		}
		mCount = mStreamSlotCount;
		}
		ALOGV("MetadataQueue: deque (%d buffers)", mCount);
		camera_metadata_t b = (mEntries.begin());
		mEntries.erase(mEntries.begin());

		if (incrementCount) {
		add_camera_metadata_entry(b,
		ANDROID_REQUEST_FRAME_COUNT,
		(void**)&mFrameCount, 1);
		mFrameCount++;
		}

		*buf = b;
		mCount--;

		return OK;
		}

		status_t Camera2Device::MetadataQueue::waitForBuffer(nsecs_t timeout)
		{
		Mutex::Autolock l(mMutex);
		status_t res;
		while (mCount == 0) {
		res = notEmpty.waitRelative(mMutex,timeout);
		if (res != OK) return res;
		}
		return OK;
		}

		status_t Camera2Device::MetadataQueue::setStreamSlot(camera_metadata_t *buf)
		{
		Mutex::Autolock l(mMutex);
		if (buf == NULL) {
		freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
		mStreamSlotCount = 0;
		return OK;
		}
		if (mStreamSlotCount > 1) {
		List<camera_metadata_t*>::iterator deleter = ++mStreamSlot.begin();
		freeBuffers(++mStreamSlot.begin(), mStreamSlot.end());
		mStreamSlotCount = 1;
		}
		if (mStreamSlotCount == 1) {
		free_camera_metadata( *(mStreamSlot.begin()) );
		*(mStreamSlot.begin()) = buf;
		} else {
		mStreamSlot.push_front(buf);
		mStreamSlotCount = 1;
		}
		return OK;
		}

		status_t Camera2Device::MetadataQueue::setStreamSlot(
		const List<camera_metadata_t*> &bufs)
		{
		Mutex::Autolock l(mMutex);
		if (mStreamSlotCount > 0) {
		freeBuffers(mStreamSlot.begin(), mStreamSlot.end());
		}
		mStreamSlot = bufs;
		mStreamSlotCount = mStreamSlot.size();

		return OK;
		}

		status_t Camera2Device::MetadataQueue::freeBuffers(
		List<camera_metadata_t*>::iterator start,
		List<camera_metadata_t*>::iterator end)
		{
		while (start != end) {
		free_camera_metadata(*start);
		start = mStreamSlot.erase(start);
		}
		return OK;
		}

		Camera2Device::MetadataQueue* Camera2Device::MetadataQueue::getInstance(
		const camera2_request_queue_src_ops_t *q)
		{
		const MetadataQueue* cmq = static_cast<const MetadataQueue*>(q);
		return const_cast<MetadataQueue*>(cmq);
		}

		Camera2Device::MetadataQueue* Camera2Device::MetadataQueue::getInstance(
		const camera2_frame_queue_dst_ops_t *q)
		{
		const MetadataQueue* cmq = static_cast<const MetadataQueue*>(q);
		return const_cast<MetadataQueue*>(cmq);
		}

		int Camera2Device::MetadataQueue::consumer_buffer_count(
		const camera2_request_queue_src_ops_t *q)
		{
		MetadataQueue *queue = getInstance(q);
		return queue->getBufferCount();
		}

		int Camera2Device::MetadataQueue::consumer_dequeue(
		const camera2_request_queue_src_ops_t *q,
		camera_metadata_t **buffer)
		{
		MetadataQueue *queue = getInstance(q);
		return queue->dequeue(buffer, true);
		}

		int Camera2Device::MetadataQueue::consumer_free(
		const camera2_request_queue_src_ops_t *q,
		camera_metadata_t *old_buffer)
		{
		MetadataQueue *queue = getInstance(q);
		free_camera_metadata(old_buffer);
		return OK;
		}

		int Camera2Device::MetadataQueue::producer_dequeue(
		const camera2_frame_queue_dst_ops_t *q,
		size_t entries, size_t bytes,
		camera_metadata_t **buffer)
		{
		camera_metadata_t *new_buffer =
		allocate_camera_metadata(entries, bytes);
		if (new_buffer == NULL) return NO_MEMORY;
		*buffer = new_buffer;
		return OK;
		}

		int Camera2Device::MetadataQueue::producer_cancel(
		const camera2_frame_queue_dst_ops_t *q,
		camera_metadata_t *old_buffer)
		{
		free_camera_metadata(old_buffer);
		return OK;
		}

		int Camera2Device::MetadataQueue::producer_enqueue(
		const camera2_frame_queue_dst_ops_t *q,
		camera_metadata_t *filled_buffer)
		{
		MetadataQueue *queue = getInstance(q);
		return queue->enqueue(filled_buffer);
		}


		}; // namespace android

services/camera/libcameraservice/Camera2Device.h

+94 −4

Original line number	Diff line number	Diff line
		@@ -18,6 +18,9 @@
		#define ANDROID_SERVERS_CAMERA_CAMERA2DEVICE_H

		#include <utils/RefBase.h>
		#include <utils/List.h>
		#include <utils/Mutex.h>
		#include <utils/Condition.h>
		#include <utils/Errors.h>
		#include "hardware/camera2.h"

		@@ -25,17 +28,104 @@ namespace android {

		class Camera2Device : public virtual RefBase {
		public:
		Camera2Device(const char *name);
		Camera2Device(int id);

		~Camera2Device();

		status_t initialize(hw_module_t *module);
		status_t initialize(camera_module_t *module);

		status_t setStreamingRequest(camera_metadata_t* request);

		camera_metadata_t* info() {
		return mDeviceInfo;
		}

		private:

		const int mId;
		camera2_device_t *mDevice;

		camera_metadata_t *mDeviceInfo;
		vendor_tag_query_ops_t *mVendorTagOps;

		/**
		* Queue class for both sending requests to a camera2 device, and for
		* receiving frames from a camera2 device.
		*/
		class MetadataQueue: public camera2_request_queue_src_ops_t,
		public camera2_frame_queue_dst_ops_t {
		public:
		MetadataQueue();
		~MetadataQueue();

		// Interface to camera2 HAL device, either for requests (device is
		// consumer) or for frames (device is producer)
		const camera2_request_queue_src_ops_t* getToConsumerInterface();
		void setFromConsumerInterface(camera2_device_t *d);

		const camera2_frame_queue_dst_ops_t* getToProducerInterface();

		// Real interfaces. On enqueue, queue takes ownership of buffer pointer
		// On dequeue, user takes ownership of buffer pointer.
		status_t enqueue(camera_metadata_t *buf);
		status_t dequeue(camera_metadata_t **buf, bool incrementCount = true);
		int getBufferCount();
		status_t waitForBuffer(nsecs_t timeout);

		// Set repeating buffer(s); if the queue is empty on a dequeue call, the
		// queue copies the contents of the stream slot into the queue, and then
		// dequeues the first new entry.
		status_t setStreamSlot(camera_metadata_t *buf);
		status_t setStreamSlot(const List<camera_metadata_t*> &bufs);

		private:
		status_t freeBuffers(List<camera_metadata_t*>::iterator start,
		List<camera_metadata_t*>::iterator end);

		const char *mName;
		camera2_device_t *mDevice;

		};
		Mutex mMutex;
		Condition notEmpty;

		int mFrameCount;

		int mCount;
		List<camera_metadata_t*> mEntries;
		int mStreamSlotCount;
		List<camera_metadata_t*> mStreamSlot;

		bool mSignalConsumer;

		static MetadataQueue* getInstance(
		const camera2_frame_queue_dst_ops_t *q);
		static MetadataQueue* getInstance(
		const camera2_request_queue_src_ops_t *q);

		static int consumer_buffer_count(
		const camera2_request_queue_src_ops_t *q);

		static int consumer_dequeue(const camera2_request_queue_src_ops_t *q,
		camera_metadata_t **buffer);

		static int consumer_free(const camera2_request_queue_src_ops_t *q,
		camera_metadata_t *old_buffer);

		static int producer_dequeue(const camera2_frame_queue_dst_ops_t *q,
		size_t entries, size_t bytes,
		camera_metadata_t **buffer);

		static int producer_cancel(const camera2_frame_queue_dst_ops_t *q,
		camera_metadata_t *old_buffer);

		static int producer_enqueue(const camera2_frame_queue_dst_ops_t *q,
		camera_metadata_t *filled_buffer);

		}; // class MetadataQueue

		MetadataQueue mRequestQueue;
		MetadataQueue mFrameQueue;

		}; // class Camera2Device

		}; // namespace android