Camera: Add input side to camera3 HAL device (3b53bc9b) · Commits · e / os / android_frameworks_av

camera/CameraMetadata.cpp

+105 −12

Original line number	Diff line number	Diff line
		@@ -23,19 +23,22 @@
		namespace android {

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

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

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

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

		@@ -44,6 +47,11 @@ CameraMetadata &CameraMetadata::operator=(const CameraMetadata &other) {
		}

		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();
		@@ -53,16 +61,44 @@ CameraMetadata &CameraMetadata::operator=(const camera_metadata_t *buffer) {
		}

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

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

		status_t CameraMetadata::unlock(const camera_metadata_t *buffer) {
		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;
		@@ -70,15 +106,27 @@ void CameraMetadata::clear() {
		}

		void CameraMetadata::acquire(camera_metadata_t *buffer) {
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return;
		}
		clear();
		mBuffer = 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) {
		if (mLocked) {
		ALOGE("%s: CameraMetadata is locked", __FUNCTION__);
		return INVALID_OPERATION;
		}
		return append_camera_metadata(mBuffer, other.mBuffer);
		}

		@@ -92,6 +140,10 @@ bool CameraMetadata::isEmpty() const {
		}

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

		@@ -115,69 +167,101 @@ status_t CameraMetadata::checkType(uint32_t tag, uint8_t expectedType) {
		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 update(tag, (const void*)data, data_count);
		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 update(tag, (const void*)data, data_count);
		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 update(tag, (const void*)data, data_count);
		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 update(tag, (const void*)data, data_count);
		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 update(tag, (const void*)data, data_count);
		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 update(tag, (const void*)data, data_count);
		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;
		}
		return update(tag, (const void*)string.string(), string.size());
		return updateImpl(tag, (const void*)string.string(), string.size());
		}

		status_t CameraMetadata::update(uint32_t tag, const void *data,
		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);
		@@ -216,6 +300,11 @@ bool CameraMetadata::exists(uint32_t tag) const {
		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;
		@@ -238,6 +327,10 @@ camera_metadata_ro_entry_t CameraMetadata::find(uint32_t tag) const {
		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;

include/camera/CameraMetadata.h

+19 −1

Original line number	Diff line number	Diff line
		@@ -48,6 +48,23 @@ class CameraMetadata {
		CameraMetadata &operator=(const CameraMetadata &other);
		CameraMetadata &operator=(const camera_metadata_t *buffer);

		/**
		* Get reference to the underlying metadata buffer. Ownership remains with
		* the CameraMetadata object, but non-const CameraMetadata methods will not
		* work until unlock() is called. Note that the lock has nothing to do with
		* thread-safety, it simply prevents the camera_metadata_t pointer returned
		* here from being accidentally invalidated by CameraMetadata operations.
		*/
		const camera_metadata_t* getAndLock();

		/**
		* Unlock the CameraMetadata for use again. After this unlock, the pointer
		* given from getAndLock() may no longer be used. The pointer passed out
		* from getAndLock must be provided to guarantee that the right object is
		* being unlocked.
		*/
		status_t unlock(const camera_metadata_t *buffer);

		/**
		* Release a raw metadata buffer to the caller. After this call,
		* CameraMetadata no longer references the buffer, and the caller takes
		@@ -154,6 +171,7 @@ class CameraMetadata {

		private:
		camera_metadata_t *mBuffer;
		bool mLocked;

		/**
		* Check if tag has a given type
		@@ -163,7 +181,7 @@ class CameraMetadata {
		/**
		* Base update entry method
		*/
		status_t update(uint32_t tag, const void *data, size_t data_count);
		status_t updateImpl(uint32_t tag, const void *data, size_t data_count);

		/**
		* Resize metadata buffer if needed by reallocating it and copying it over.

services/camera/libcameraservice/Camera3Device.cpp

+782 −38

File changed.

Preview size limit exceeded, changes collapsed.

services/camera/libcameraservice/Camera3Device.h

+152 −11

Original line number	Diff line number	Diff line
		@@ -14,8 +14,8 @@
		* limitations under the License.
		*/

		#ifndef ANDROID_SERVERS_CAMERA_CAMERA3DEVICE_H
		#define ANDROID_SERVERS_CAMERA_CAMERA3DEVICE_H
		#ifndef ANDROID_SERVERS_CAMERA3DEVICE_H
		#define ANDROID_SERVERS_CAMERA3DEVICE_H

		#include <utils/Condition.h>
		#include <utils/Errors.h>
		@@ -24,6 +24,8 @@
		#include <utils/Thread.h>

		#include "CameraDeviceBase.h"
		#include "camera3/Camera3Stream.h"
		#include "camera3/Camera3OutputStream.h"

		#include "hardware/camera3.h"

		@@ -55,44 +57,121 @@ class Camera3Device :
		virtual ~Camera3Device();

		/**
		* CameraDevice interface
		* CameraDeviceBase interface
		*/

		virtual int getId() const;

		// Transitions to idle state on success.
		virtual status_t initialize(camera_module_t *module);
		virtual status_t disconnect();
		virtual status_t dump(int fd, const Vector<String16> &args);
		virtual const CameraMetadata& info() const;

		// Capture and setStreamingRequest will configure streams if currently in
		// idle state
		virtual status_t capture(CameraMetadata &request);
		virtual status_t setStreamingRequest(const CameraMetadata &request);
		virtual status_t clearStreamingRequest();

		virtual status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout);

		// Actual stream creation/deletion is delayed until first request is submitted
		// If adding streams while actively capturing, will pause device before adding
		// stream, reconfiguring device, and unpausing.
		virtual status_t createStream(sp<ANativeWindow> consumer,
		uint32_t width, uint32_t height, int format, size_t size,
		int *id);
		virtual status_t createReprocessStreamFromStream(int outputId, int *id);

		virtual status_t getStreamInfo(int id,
		uint32_t width, uint32_t height, uint32_t *format);
		virtual status_t setStreamTransform(int id, int transform);

		virtual status_t deleteStream(int id);
		virtual status_t deleteReprocessStream(int id);

		virtual status_t createDefaultRequest(int templateId, CameraMetadata *request);

		// Transitions to the idle state on success
		virtual status_t waitUntilDrained();

		virtual status_t setNotifyCallback(NotificationListener *listener);
		virtual status_t waitForNextFrame(nsecs_t timeout);
		virtual status_t getNextFrame(CameraMetadata *frame);

		virtual status_t triggerAutofocus(uint32_t id);
		virtual status_t triggerCancelAutofocus(uint32_t id);
		virtual status_t triggerPrecaptureMetering(uint32_t id);

		virtual status_t pushReprocessBuffer(int reprocessStreamId,
		buffer_handle_t *buffer, wp<BufferReleasedListener> listener);

		private:
		static const nsecs_t kShutdownTimeout = 5000000000; // 5 sec


		Mutex mLock;

		/** Scope for mLock **/

		const int mId;
		camera3_device_t *mHal3Device;

		CameraMetadata mDeviceInfo;
		vendor_tag_query_ops_t mVendorTagOps;

		enum {
		STATUS_ERROR,
		STATUS_UNINITIALIZED,
		STATUS_IDLE,
		STATUS_ACTIVE
		} mStatus;

		// Mapping of stream IDs to stream instances
		typedef KeyedVector<int, sp<camera3::Camera3OutputStream> > StreamSet;

		StreamSet mOutputStreams;
		sp<camera3::Camera3Stream> mInputStream;
		int mNextStreamId;

		// Need to hold on to stream references until configure completes.
		Vector<sp<camera3::Camera3Stream> > mDeletedStreams;

		/** End scope for mLock **/

		class CaptureRequest : public LightRefBase<CaptureRequest> {
		public:
		CameraMetadata mSettings;
		sp<camera3::Camera3Stream> mInputStream;
		Vector<sp<camera3::Camera3Stream> > mOutputStreams;
		};
		typedef List<sp<CaptureRequest> > RequestList;

		/**
		* Lock-held version of waitUntilDrained. Will transition to IDLE on
		* success.
		*/
		status_t waitUntilDrainedLocked();

		/**
		* Do common work for setting up a streaming or single capture request.
		* On success, will transition to ACTIVE if in IDLE.
		*/
		sp<CaptureRequest> setUpRequestLocked(const CameraMetadata &request);

		/**
		* Build a CaptureRequest request from the CameraDeviceBase request
		* settings.
		*/
		sp<CaptureRequest> createCaptureRequest(const CameraMetadata &request);

		/**
		* Take the currently-defined set of streams and configure the HAL to use
		* them. This is a long-running operation (may be several hundered ms).
		*/
		status_t configureStreamsLocked();

		/**
		* Thread for managing capture request submission to HAL device.
		*/
		@@ -100,18 +179,80 @@ class Camera3Device :

		public:

		RequestThread(wp<Camera3Device> parent);
		RequestThread(wp<Camera3Device> parent,
		camera3_device_t *hal3Device);

		/**
		* Call after stream (re)-configuration is completed.
		*/
		void configurationComplete();

		/**
		* Set or clear the list of repeating requests. Does not block
		* on either. Use waitUntilPaused to wait until request queue
		* has emptied out.
		*/
		status_t setRepeatingRequests(const RequestList& requests);
		status_t clearRepeatingRequests();

		status_t queueRequest(sp<CaptureRequest> request);

		/**
		* Pause/unpause the capture thread. Doesn't block, so use
		* waitUntilPaused to wait until the thread is paused.
		*/
		void setPaused(bool paused);

		/**
		* Wait until thread is paused, either due to setPaused(true)
		* or due to lack of input requests. Returns TIMED_OUT in case
		* the thread does not pause within the timeout.
		*/
		status_t waitUntilPaused(nsecs_t timeout);

		protected:

		virtual bool threadLoop();

		private:
		static const nsecs_t kRequestTimeout = 50e6; // 50 ms

		// Waits for a request, or returns NULL if times out.
		sp<CaptureRequest> waitForNextRequest();

		// Return buffers, etc, for a request that couldn't be fully
		// constructed. The buffers will be returned in the ERROR state
		// to mark them as not having valid data.
		// All arguments will be modified.
		void cleanUpFailedRequest(camera3_capture_request_t &request,
		sp<CaptureRequest> &nextRequest,
		Vector<camera3_stream_buffer_t> &outputBuffers);

		// Pause handling
		bool waitIfPaused();

		wp<Camera3Device> mParent;
		camera3_device_t *mHal3Device;

		Mutex mRequestLock;
		Condition mRequestSignal;
		RequestList mRequestQueue;
		RequestList mRepeatingRequests;

		bool mReconfigured;

		// Used by waitIfPaused, waitForNextRequest, and waitUntilPaused
		Mutex mPauseLock;
		bool mDoPause;
		Condition mDoPauseSignal;
		bool mPaused;
		Condition mPausedSignal;

		sp<CaptureRequest> mPrevRequest;

		int32_t mFrameNumber;
		};
		sp<RequestThread> requestThread;
		sp<RequestThread> mRequestThread;

		/**
		* Callback functions from HAL device