Merge "Camera: HAL1 recording batching support" into oc-dev (32a81b60) · Commits · e / os / android_frameworks_av

camera/Camera.cpp

+45 −0

Original line number	Diff line number	Diff line
		@@ -240,6 +240,14 @@ void Camera::releaseRecordingFrameHandle(native_handle_t* handle)
		c->releaseRecordingFrameHandle(handle);
		}

		void Camera::releaseRecordingFrameHandleBatch(
		const std::vector<native_handle_t*> handles) {
		ALOGV("releaseRecordingFrameHandleBatch");
		sp <::android::hardware::ICamera> c = mCamera;
		if (c == 0) return;
		c->releaseRecordingFrameHandleBatch(handles);
		}

		// get preview state
		bool Camera::previewEnabled()
		{
		@@ -418,6 +426,37 @@ void Camera::recordingFrameHandleCallbackTimestamp(nsecs_t timestamp, native_han
		}
		}

		void Camera::recordingFrameHandleCallbackTimestampBatch(
		const std::vector<nsecs_t>& timestamps,
		const std::vector<native_handle_t*>& handles)
		{
		// If recording proxy listener is registered, forward the frame and return.
		// The other listener (mListener) is ignored because the receiver needs to
		// call releaseRecordingFrameHandle.
		sp<ICameraRecordingProxyListener> proxylistener;
		{
		Mutex::Autolock _l(mLock);
		proxylistener = mRecordingProxyListener;
		}
		if (proxylistener != NULL) {
		proxylistener->recordingFrameHandleCallbackTimestampBatch(timestamps, handles);
		return;
		}

		sp<CameraListener> listener;
		{
		Mutex::Autolock _l(mLock);
		listener = mListener;
		}

		if (listener != NULL) {
		listener->postRecordingFrameHandleTimestampBatch(timestamps, handles);
		} else {
		ALOGW("No listener was set. Drop a batch of recording frames.");
		releaseRecordingFrameHandleBatch(handles);
		}
		}

		sp<ICameraRecordingProxy> Camera::getRecordingProxy() {
		ALOGV("getProxy");
		return new RecordingProxy(this);
		@@ -448,6 +487,12 @@ void Camera::RecordingProxy::releaseRecordingFrameHandle(native_handle_t* handle
		mCamera->releaseRecordingFrameHandle(handle);
		}

		void Camera::RecordingProxy::releaseRecordingFrameHandleBatch(
		const std::vector<native_handle_t*>& handles) {
		ALOGV("RecordingProxy::releaseRecordingFrameHandleBatch");
		mCamera->releaseRecordingFrameHandleBatch(handles);
		}

		Camera::RecordingProxy::RecordingProxy(const sp<Camera>& camera)
		{
		mCamera = camera;

camera/ICamera.cpp

+32 −0

Original line number	Diff line number	Diff line
		@@ -55,6 +55,7 @@ enum {
		SET_VIDEO_BUFFER_MODE,
		SET_VIDEO_BUFFER_TARGET,
		RELEASE_RECORDING_FRAME_HANDLE,
		RELEASE_RECORDING_FRAME_HANDLE_BATCH,
		};

		class BpCamera: public BpInterface<ICamera>
		@@ -172,6 +173,24 @@ public:
		native_handle_delete(handle);
		}

		void releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles) {
		ALOGV("releaseRecordingFrameHandleBatch");
		Parcel data, reply;
		data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
		uint32_t n = handles.size();
		data.writeUint32(n);
		for (auto& handle : handles) {
		data.writeNativeHandle(handle);
		}
		remote()->transact(RELEASE_RECORDING_FRAME_HANDLE_BATCH, data, &reply);

		// Close the native handle because camera received a dup copy.
		for (auto& handle : handles) {
		native_handle_close(handle);
		native_handle_delete(handle);
		}
		}

		status_t setVideoBufferMode(int32_t videoBufferMode)
		{
		ALOGV("setVideoBufferMode: %d", videoBufferMode);
		@@ -378,6 +397,19 @@ status_t BnCamera::onTransact(
		releaseRecordingFrameHandle(data.readNativeHandle());
		return NO_ERROR;
		} break;
		case RELEASE_RECORDING_FRAME_HANDLE_BATCH: {
		ALOGV("RELEASE_RECORDING_FRAME_HANDLE_BATCH");
		CHECK_INTERFACE(ICamera, data, reply);
		// releaseRecordingFrameHandle will be responsble to close the native handle.
		uint32_t n = data.readUint32();
		std::vector<native_handle_t*> handles;
		handles.reserve(n);
		for (uint32_t i = 0; i < n; i++) {
		handles.push_back(data.readNativeHandle());
		}
		releaseRecordingFrameHandleBatch(handles);
		return NO_ERROR;
		} break;
		case SET_VIDEO_BUFFER_MODE: {
		ALOGV("SET_VIDEO_BUFFER_MODE");
		CHECK_INTERFACE(ICamera, data, reply);

camera/ICameraClient.cpp

+59 −0

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@ enum {
		DATA_CALLBACK,
		DATA_CALLBACK_TIMESTAMP,
		RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP,
		RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH,
		};

		class BpCameraClient: public BpInterface<ICameraClient>
		@@ -91,6 +92,29 @@ public:
		remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP, data, &reply,
		IBinder::FLAG_ONEWAY);
		}

		void recordingFrameHandleCallbackTimestampBatch(
		const std::vector<nsecs_t>& timestamps,
		const std::vector<native_handle_t*>& handles) {
		ALOGV("recordingFrameHandleCallbackTimestampBatch");
		Parcel data, reply;
		data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());
		uint32_t n = timestamps.size();
		if (n != handles.size()) {
		ALOGE("%s: size of timestamps(%zu) and handles(%zu) mismatch!",
		__FUNCTION__, timestamps.size(), handles.size());
		return;
		}
		data.writeUint32(n);
		for (auto ts : timestamps) {
		data.writeInt64(ts);
		}
		for (auto& handle : handles) {
		data.writeNativeHandle(handle);
		}
		remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH, data, &reply,
		IBinder::FLAG_ONEWAY);
		}
		};

		IMPLEMENT_META_INTERFACE(CameraClient, "android.hardware.ICameraClient");
		@@ -154,6 +178,41 @@ status_t BnCameraClient::onTransact(
		recordingFrameHandleCallbackTimestamp(timestamp, handle);
		return NO_ERROR;
		} break;
		case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH: {
		ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH");
		CHECK_INTERFACE(ICameraClient, data, reply);
		uint32_t n = 0;
		status_t res = data.readUint32(&n);
		if (res != OK) {
		ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);
		return BAD_VALUE;
		}
		std::vector<nsecs_t> timestamps;
		std::vector<native_handle_t*> handles;
		timestamps.reserve(n);
		handles.reserve(n);
		for (uint32_t i = 0; i < n; i++) {
		res = data.readInt64(&timestamps[i]);
		if (res != OK) {
		ALOGE("%s: Failed to read timestamp[%d]: %s (%d)",
		__FUNCTION__, i, strerror(-res), res);
		return BAD_VALUE;
		}
		}
		for (uint32_t i = 0; i < n; i++) {
		native_handle_t* handle = data.readNativeHandle();
		if (handle == nullptr) {
		ALOGE("%s: Received a null native handle at handles[%d]",
		__FUNCTION__, i);
		return BAD_VALUE;
		}
		handles.push_back(handle);
		}

		// The native handle will be freed in BpCamera::releaseRecordingFrameHandleBatch.
		recordingFrameHandleCallbackTimestampBatch(timestamps, handles);
		return NO_ERROR;
		} break;
		default:
		return BBinder::onTransact(code, data, reply, flags);
		}

camera/ICameraRecordingProxy.cpp

+44 −0

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@ enum {
		STOP_RECORDING,
		RELEASE_RECORDING_FRAME,
		RELEASE_RECORDING_FRAME_HANDLE,
		RELEASE_RECORDING_FRAME_HANDLE_BATCH,
		};


		@@ -82,6 +83,24 @@ public:
		native_handle_close(handle);
		native_handle_delete(handle);
		}

		void releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles) {
		ALOGV("releaseRecordingFrameHandleBatch");
		Parcel data, reply;
		data.writeInterfaceToken(ICameraRecordingProxy::getInterfaceDescriptor());
		uint32_t n = handles.size();
		data.writeUint32(n);
		for (auto& handle : handles) {
		data.writeNativeHandle(handle);
		}
		remote()->transact(RELEASE_RECORDING_FRAME_HANDLE_BATCH, data, &reply);

		// Close the native handle because camera received a dup copy.
		for (auto& handle : handles) {
		native_handle_close(handle);
		native_handle_delete(handle);
		}
		}
		};

		IMPLEMENT_META_INTERFACE(CameraRecordingProxy, "android.hardware.ICameraRecordingProxy");
		@@ -121,6 +140,31 @@ status_t BnCameraRecordingProxy::onTransact(
		releaseRecordingFrameHandle(data.readNativeHandle());
		return NO_ERROR;
		} break;
		case RELEASE_RECORDING_FRAME_HANDLE_BATCH: {
		ALOGV("RELEASE_RECORDING_FRAME_HANDLE_BATCH");
		CHECK_INTERFACE(ICameraRecordingProxy, data, reply);
		uint32_t n = 0;
		status_t res = data.readUint32(&n);
		if (res != OK) {
		ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);
		return BAD_VALUE;
		}
		std::vector<native_handle_t*> handles;
		handles.reserve(n);
		for (uint32_t i = 0; i < n; i++) {
		native_handle_t* handle = data.readNativeHandle();
		if (handle == nullptr) {
		ALOGE("%s: Received a null native handle at handles[%d]",
		__FUNCTION__, i);
		return BAD_VALUE;
		}
		handles.push_back(handle);
		}

		// releaseRecordingFrameHandleBatch will be responsble to close the native handle.
		releaseRecordingFrameHandleBatch(handles);
		return NO_ERROR;
		} break;
		default:
		return BBinder::onTransact(code, data, reply, flags);
		}

camera/ICameraRecordingProxyListener.cpp

+66 −0

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@ namespace android {
		enum {
		DATA_CALLBACK_TIMESTAMP = IBinder::FIRST_CALL_TRANSACTION,
		RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP,
		RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH
		};

		class BpCameraRecordingProxyListener: public BpInterface<ICameraRecordingProxyListener>
		@@ -62,6 +63,36 @@ public:
		native_handle_close(handle);
		native_handle_delete(handle);
		}

		void recordingFrameHandleCallbackTimestampBatch(
		const std::vector<nsecs_t>& timestamps,
		const std::vector<native_handle_t*>& handles) {
		ALOGV("recordingFrameHandleCallbackTimestampBatch");
		Parcel data, reply;
		data.writeInterfaceToken(ICameraRecordingProxyListener::getInterfaceDescriptor());

		uint32_t n = timestamps.size();
		if (n != handles.size()) {
		ALOGE("%s: size of timestamps(%zu) and handles(%zu) mismatch!",
		__FUNCTION__, timestamps.size(), handles.size());
		return;
		}
		data.writeUint32(n);
		for (auto ts : timestamps) {
		data.writeInt64(ts);
		}
		for (auto& handle : handles) {
		data.writeNativeHandle(handle);
		}
		remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH, data, &reply,
		IBinder::FLAG_ONEWAY);

		// The native handle is dupped in ICameraClient so we need to free it here.
		for (auto& handle : handles) {
		native_handle_close(handle);
		native_handle_delete(handle);
		}
		}
		};

		IMPLEMENT_META_INTERFACE(CameraRecordingProxyListener, "android.hardware.ICameraRecordingProxyListener");
		@@ -101,6 +132,41 @@ status_t BnCameraRecordingProxyListener::onTransact(
		recordingFrameHandleCallbackTimestamp(timestamp, handle);
		return NO_ERROR;
		} break;
		case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH: {
		ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH");
		CHECK_INTERFACE(ICameraRecordingProxyListener, data, reply);
		uint32_t n = 0;
		status_t res = data.readUint32(&n);
		if (res != OK) {
		ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);
		return BAD_VALUE;
		}
		std::vector<nsecs_t> timestamps;
		std::vector<native_handle_t*> handles;
		timestamps.reserve(n);
		handles.reserve(n);
		for (uint32_t i = 0; i < n; i++) {
		res = data.readInt64(&timestamps[i]);
		if (res != OK) {
		ALOGE("%s: Failed to read timestamp[%d]: %s (%d)",
		__FUNCTION__, i, strerror(-res), res);
		return BAD_VALUE;
		}
		}
		for (uint32_t i = 0; i < n; i++) {
		native_handle_t* handle = data.readNativeHandle();
		if (handle == nullptr) {
		ALOGE("%s: Received a null native handle at handles[%d]",
		__FUNCTION__, i);
		return BAD_VALUE;
		}
		handles.push_back(handle);
		}
		// The native handle will be freed in
		// BpCameraRecordingProxy::releaseRecordingFrameHandleBatch.
		recordingFrameHandleCallbackTimestampBatch(timestamps, handles);
		return NO_ERROR;
		} break;
		default:
		return BBinder::onTransact(code, data, reply, flags);
		}