Merge changes from topic 'gralloc_usage_flags' into oc-mr1-dev (5f5dfd4e) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/api2/CameraDeviceClient.cpp

+7 −8

Original line number	Original line	Diff line number	Diff line
	@@ -570,7 +570,7 @@ binder::Status CameraDeviceClient::createDeferredSurfaceStreamLocked(
	/out/		/out/
	int* newStreamId) {		int* newStreamId) {
	int width, height, format, surfaceType;		int width, height, format, surfaceType;
	int32_t consumerUsage;		uint64_t consumerUsage;
	android_dataspace dataSpace;		android_dataspace dataSpace;
	status_t err;		status_t err;
	binder::Status res;		binder::Status res;
	@@ -766,24 +766,23 @@ binder::Status CameraDeviceClient::createSurfaceFromGbp(
	// Query consumer usage bits to set async operation mode for		// Query consumer usage bits to set async operation mode for
	// GLConsumer using controlledByApp parameter.		// GLConsumer using controlledByApp parameter.
	bool useAsync = false;		bool useAsync = false;
	int32_t consumerUsage;		uint64_t consumerUsage = 0;
	status_t err;		status_t err;
	if ((err = gbp->query(NATIVE_WINDOW_CONSUMER_USAGE_BITS,		if ((err = gbp->getConsumerUsage(&consumerUsage)) != OK) {
	&consumerUsage)) != OK) {
	String8 msg = String8::format("Camera %s: Failed to query Surface consumer usage: %s (%d)",		String8 msg = String8::format("Camera %s: Failed to query Surface consumer usage: %s (%d)",
	mCameraIdStr.string(), strerror(-err), err);		mCameraIdStr.string(), strerror(-err), err);
	ALOGE("%s: %s", __FUNCTION__, msg.string());		ALOGE("%s: %s", __FUNCTION__, msg.string());
	return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());		return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string());
	}		}
	if (consumerUsage & GraphicBuffer::USAGE_HW_TEXTURE) {		if (consumerUsage & GraphicBuffer::USAGE_HW_TEXTURE) {
	ALOGW("%s: Camera %s with consumer usage flag: 0x%x: Forcing asynchronous mode for stream",		ALOGW("%s: Camera %s with consumer usage flag: %" PRIu64 ": Forcing asynchronous mode for stream",
	__FUNCTION__, mCameraIdStr.string(), consumerUsage);		__FUNCTION__, mCameraIdStr.string(), consumerUsage);
	useAsync = true;		useAsync = true;
	}		}

	int32_t disallowedFlags = GraphicBuffer::USAGE_HW_VIDEO_ENCODER \|		uint64_t disallowedFlags = GraphicBuffer::USAGE_HW_VIDEO_ENCODER \|
	GRALLOC_USAGE_RENDERSCRIPT;		GRALLOC_USAGE_RENDERSCRIPT;
	int32_t allowedFlags = GraphicBuffer::USAGE_SW_READ_MASK \|		uint64_t allowedFlags = GraphicBuffer::USAGE_SW_READ_MASK \|
	GraphicBuffer::USAGE_HW_TEXTURE \|		GraphicBuffer::USAGE_HW_TEXTURE \|
	GraphicBuffer::USAGE_HW_COMPOSER;		GraphicBuffer::USAGE_HW_COMPOSER;
	bool flexibleConsumer = (consumerUsage & disallowedFlags) == 0 &&		bool flexibleConsumer = (consumerUsage & disallowedFlags) == 0 &&
	@@ -876,7 +875,7 @@ binder::Status CameraDeviceClient::createSurfaceFromGbp(
	//surface class type. Use usage flag to approximate the comparison.		//surface class type. Use usage flag to approximate the comparison.
	if (consumerUsage != streamInfo.consumerUsage) {		if (consumerUsage != streamInfo.consumerUsage) {
	String8 msg = String8::format(		String8 msg = String8::format(
	"Camera %s:Surface usage flag doesn't match 0x%x vs 0x%x",		"Camera %s:Surface usage flag doesn't match %" PRIu64 " vs %" PRIu64 "",
	mCameraIdStr.string(), consumerUsage, streamInfo.consumerUsage);		mCameraIdStr.string(), consumerUsage, streamInfo.consumerUsage);
	ALOGE("%s: %s", __FUNCTION__, msg.string());		ALOGE("%s: %s", __FUNCTION__, msg.string());
	return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());		return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string());

services/camera/libcameraservice/api2/CameraDeviceClient.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -213,13 +213,13 @@ private:
	int height;		int height;
	int format;		int format;
	android_dataspace dataSpace;		android_dataspace dataSpace;
	int32_t consumerUsage;		uint64_t consumerUsage;
	bool finalized = false;		bool finalized = false;
	OutputStreamInfo() :		OutputStreamInfo() :
	width(-1), height(-1), format(-1), dataSpace(HAL_DATASPACE_UNKNOWN),		width(-1), height(-1), format(-1), dataSpace(HAL_DATASPACE_UNKNOWN),
	consumerUsage(0) {}		consumerUsage(0) {}
	OutputStreamInfo(int _width, int _height, int _format, android_dataspace _dataSpace,		OutputStreamInfo(int _width, int _height, int _format, android_dataspace _dataSpace,
	int32_t _consumerUsage) :		uint64_t _consumerUsage) :
	width(_width), height(_height), format(_format),		width(_width), height(_height), format(_format),
	dataSpace(_dataSpace), consumerUsage(_consumerUsage) {}		dataSpace(_dataSpace), consumerUsage(_consumerUsage) {}
	};		};

services/camera/libcameraservice/common/CameraDeviceBase.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -119,7 +119,7 @@ class CameraDeviceBase : public virtual RefBase {
	uint32_t width, uint32_t height, int format,		uint32_t width, uint32_t height, int format,
	android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,		android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,
	int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,		int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
	bool isShared = false, uint32_t consumerUsage = 0) = 0;		bool isShared = false, uint64_t consumerUsage = 0) = 0;

	/**		/**
	* Create an output stream of the requested size, format, rotation and		* Create an output stream of the requested size, format, rotation and
	@@ -132,7 +132,7 @@ class CameraDeviceBase : public virtual RefBase {
	bool hasDeferredConsumer, uint32_t width, uint32_t height, int format,		bool hasDeferredConsumer, uint32_t width, uint32_t height, int format,
	android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,		android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id,
	int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,		int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
	bool isShared = false, uint32_t consumerUsage = 0) = 0;		bool isShared = false, uint64_t consumerUsage = 0) = 0;

	/**		/**
	* Create an input stream of width, height, and format.		* Create an input stream of width, height, and format.

services/camera/libcameraservice/device1/CameraHardwareInterface.cpp

+1 −264

Original line number	Original line	Diff line number	Diff line
	@@ -29,11 +29,6 @@ using hardware::hidl_handle;
	CameraHardwareInterface::~CameraHardwareInterface()		CameraHardwareInterface::~CameraHardwareInterface()
	{		{
	ALOGI("Destroying camera %s", mName.string());		ALOGI("Destroying camera %s", mName.string());
	if (mDevice) {
	int rc = mDevice->common.close(&mDevice->common);
	if (rc != OK)
	ALOGE("Could not close camera %s: %d", mName.string(), rc);
	}
	if (mHidlDevice != nullptr) {		if (mHidlDevice != nullptr) {
	mHidlDevice->close();		mHidlDevice->close();
	mHidlDevice.clear();		mHidlDevice.clear();
	@@ -42,12 +37,6 @@ CameraHardwareInterface::~CameraHardwareInterface()
	}		}

	status_t CameraHardwareInterface::initialize(sp<CameraProviderManager> manager) {		status_t CameraHardwareInterface::initialize(sp<CameraProviderManager> manager) {
	if (mDevice) {
	ALOGE("%s: camera hardware interface has been initialized to libhardware path!",
	__FUNCTION__);
	return INVALID_OPERATION;
	}

	ALOGI("Opening camera %s", mName.string());		ALOGI("Opening camera %s", mName.string());

	status_t ret = manager->openSession(mName.string(), this, &mHidlDevice);		status_t ret = manager->openSession(mName.string(), this, &mHidlDevice);
	@@ -372,7 +361,7 @@ CameraHardwareInterface::setUsage(hardware::graphics::common::V1_0::BufferUsage
	ALOGE("%s: preview window is null", __FUNCTION__);		ALOGE("%s: preview window is null", __FUNCTION__);
	return s;		return s;
	}		}
	mPreviewUsage = (int) usage;		mPreviewUsage = static_cast<uint64_t> (usage);
	int rc = native_window_set_usage(a, mPreviewUsage);		int rc = native_window_set_usage(a, mPreviewUsage);
	if (rc == OK) {		if (rc == OK) {
	cleanupCirculatingBuffers();		cleanupCirculatingBuffers();
	@@ -444,23 +433,6 @@ status_t CameraHardwareInterface::setPreviewWindow(const sp<ANativeWindow>& buf)
	}		}
	return CameraProviderManager::mapToStatusT(		return CameraProviderManager::mapToStatusT(
	mHidlDevice->setPreviewWindow(buf.get() ? this : nullptr));		mHidlDevice->setPreviewWindow(buf.get() ? this : nullptr));
	} else if (mDevice) {
	if (mDevice->ops->set_preview_window) {
	mPreviewWindow = buf;
	if (buf != nullptr) {
	if (mPreviewScalingMode != NOT_SET) {
	setPreviewScalingMode(mPreviewScalingMode);
	}
	if (mPreviewTransform != NOT_SET) {
	setPreviewTransform(mPreviewTransform);
	}
	}
	mHalPreviewWindow.user = this;
	ALOGV("%s &mHalPreviewWindow %p mHalPreviewWindow.user %p",__FUNCTION__,
	&mHalPreviewWindow, mHalPreviewWindow.user);
	return mDevice->ops->set_preview_window(mDevice,
	buf.get() ? &mHalPreviewWindow.nw : 0);
	}
	}		}
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}
	@@ -478,15 +450,6 @@ void CameraHardwareInterface::setCallbacks(notify_callback notify_cb,
	mCbUser = user;		mCbUser = user;

	ALOGV("%s(%s)", __FUNCTION__, mName.string());		ALOGV("%s(%s)", __FUNCTION__, mName.string());

	if (mDevice && mDevice->ops->set_callbacks) {
	mDevice->ops->set_callbacks(mDevice,
	sNotifyCb,
	sDataCb,
	sDataCbTimestamp,
	sGetMemory,
	this);
	}
	}		}

	void CameraHardwareInterface::enableMsgType(int32_t msgType)		void CameraHardwareInterface::enableMsgType(int32_t msgType)
	@@ -494,8 +457,6 @@ void CameraHardwareInterface::enableMsgType(int32_t msgType)
	ALOGV("%s(%s)", __FUNCTION__, mName.string());		ALOGV("%s(%s)", __FUNCTION__, mName.string());
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	mHidlDevice->enableMsgType(msgType);		mHidlDevice->enableMsgType(msgType);
	} else if (mDevice && mDevice->ops->enable_msg_type) {
	mDevice->ops->enable_msg_type(mDevice, msgType);
	}		}
	}		}

	@@ -504,8 +465,6 @@ void CameraHardwareInterface::disableMsgType(int32_t msgType)
	ALOGV("%s(%s)", __FUNCTION__, mName.string());		ALOGV("%s(%s)", __FUNCTION__, mName.string());
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	mHidlDevice->disableMsgType(msgType);		mHidlDevice->disableMsgType(msgType);
	} else if (mDevice && mDevice->ops->disable_msg_type) {
	mDevice->ops->disable_msg_type(mDevice, msgType);
	}		}
	}		}

	@@ -514,8 +473,6 @@ int CameraHardwareInterface::msgTypeEnabled(int32_t msgType)
	ALOGV("%s(%s)", __FUNCTION__, mName.string());		ALOGV("%s(%s)", __FUNCTION__, mName.string());
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return mHidlDevice->msgTypeEnabled(msgType);		return mHidlDevice->msgTypeEnabled(msgType);
	} else if (mDevice && mDevice->ops->msg_type_enabled) {
	return mDevice->ops->msg_type_enabled(mDevice, msgType);
	}		}
	return false;		return false;
	}		}
	@@ -526,8 +483,6 @@ status_t CameraHardwareInterface::startPreview()
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return CameraProviderManager::mapToStatusT(		return CameraProviderManager::mapToStatusT(
	mHidlDevice->startPreview());		mHidlDevice->startPreview());
	} else if (mDevice && mDevice->ops->start_preview) {
	return mDevice->ops->start_preview(mDevice);
	}		}
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}
	@@ -537,8 +492,6 @@ void CameraHardwareInterface::stopPreview()
	ALOGV("%s(%s)", __FUNCTION__, mName.string());		ALOGV("%s(%s)", __FUNCTION__, mName.string());
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	mHidlDevice->stopPreview();		mHidlDevice->stopPreview();
	} else if (mDevice && mDevice->ops->stop_preview) {
	mDevice->ops->stop_preview(mDevice);
	}		}
	}		}

	@@ -547,8 +500,6 @@ int CameraHardwareInterface::previewEnabled()
	ALOGV("%s(%s)", __FUNCTION__, mName.string());		ALOGV("%s(%s)", __FUNCTION__, mName.string());
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return mHidlDevice->previewEnabled();		return mHidlDevice->previewEnabled();
	} else if (mDevice && mDevice->ops->preview_enabled) {
	return mDevice->ops->preview_enabled(mDevice);
	}		}
	return false;		return false;
	}		}
	@@ -559,8 +510,6 @@ status_t CameraHardwareInterface::storeMetaDataInBuffers(int enable)
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return CameraProviderManager::mapToStatusT(		return CameraProviderManager::mapToStatusT(
	mHidlDevice->storeMetaDataInBuffers(enable));		mHidlDevice->storeMetaDataInBuffers(enable));
	} else if (mDevice && mDevice->ops->store_meta_data_in_buffers) {
	return mDevice->ops->store_meta_data_in_buffers(mDevice, enable);
	}		}
	return enable ? INVALID_OPERATION: OK;		return enable ? INVALID_OPERATION: OK;
	}		}
	@@ -571,8 +520,6 @@ status_t CameraHardwareInterface::startRecording()
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return CameraProviderManager::mapToStatusT(		return CameraProviderManager::mapToStatusT(
	mHidlDevice->startRecording());		mHidlDevice->startRecording());
	} else if (mDevice && mDevice->ops->start_recording) {
	return mDevice->ops->start_recording(mDevice);
	}		}
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}
	@@ -585,8 +532,6 @@ void CameraHardwareInterface::stopRecording()
	ALOGV("%s(%s)", __FUNCTION__, mName.string());		ALOGV("%s(%s)", __FUNCTION__, mName.string());
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	mHidlDevice->stopRecording();		mHidlDevice->stopRecording();
	} else if (mDevice && mDevice->ops->stop_recording) {
	mDevice->ops->stop_recording(mDevice);
	}		}
	}		}

	@@ -598,8 +543,6 @@ int CameraHardwareInterface::recordingEnabled()
	ALOGV("%s(%s)", __FUNCTION__, mName.string());		ALOGV("%s(%s)", __FUNCTION__, mName.string());
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return mHidlDevice->recordingEnabled();		return mHidlDevice->recordingEnabled();
	} else if (mDevice && mDevice->ops->recording_enabled) {
	return mDevice->ops->recording_enabled(mDevice);
	}		}
	return false;		return false;
	}		}
	@@ -624,9 +567,6 @@ void CameraHardwareInterface::releaseRecordingFrame(const sp<IMemory>& mem)
	} else {		} else {
	mHidlDevice->releaseRecordingFrame(heapId, bufferIndex);		mHidlDevice->releaseRecordingFrame(heapId, bufferIndex);
	}		}
	} else if (mDevice && mDevice->ops->release_recording_frame) {
	void data = ((uint8_t )heap->base()) + offset;
	return mDevice->ops->release_recording_frame(mDevice, data);
	}		}
	}		}

	@@ -653,9 +593,6 @@ void CameraHardwareInterface::releaseRecordingFrameBatch(const std::vector<sp<IM
	ALOGE("%s only supports VideoNativeHandleMetadata mode", __FUNCTION__);		ALOGE("%s only supports VideoNativeHandleMetadata mode", __FUNCTION__);
	return;		return;
	}		}
	} else {
	ALOGE("Non HIDL mode do not support %s", __FUNCTION__);
	return;
	}		}
	}		}

	@@ -674,8 +611,6 @@ status_t CameraHardwareInterface::autoFocus()
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return CameraProviderManager::mapToStatusT(		return CameraProviderManager::mapToStatusT(
	mHidlDevice->autoFocus());		mHidlDevice->autoFocus());
	} else if (mDevice && mDevice->ops->auto_focus) {
	return mDevice->ops->auto_focus(mDevice);
	}		}
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}
	@@ -686,8 +621,6 @@ status_t CameraHardwareInterface::cancelAutoFocus()
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return CameraProviderManager::mapToStatusT(		return CameraProviderManager::mapToStatusT(
	mHidlDevice->cancelAutoFocus());		mHidlDevice->cancelAutoFocus());
	} else if (mDevice && mDevice->ops->cancel_auto_focus) {
	return mDevice->ops->cancel_auto_focus(mDevice);
	}		}
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}
	@@ -698,8 +631,6 @@ status_t CameraHardwareInterface::takePicture()
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return CameraProviderManager::mapToStatusT(		return CameraProviderManager::mapToStatusT(
	mHidlDevice->takePicture());		mHidlDevice->takePicture());
	} else if (mDevice && mDevice->ops->take_picture) {
	return mDevice->ops->take_picture(mDevice);
	}		}
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}
	@@ -710,8 +641,6 @@ status_t CameraHardwareInterface::cancelPicture()
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return CameraProviderManager::mapToStatusT(		return CameraProviderManager::mapToStatusT(
	mHidlDevice->cancelPicture());		mHidlDevice->cancelPicture());
	} else if (mDevice && mDevice->ops->cancel_picture) {
	return mDevice->ops->cancel_picture(mDevice);
	}		}
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}
	@@ -722,8 +651,6 @@ status_t CameraHardwareInterface::setParameters(const CameraParameters &params)
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return CameraProviderManager::mapToStatusT(		return CameraProviderManager::mapToStatusT(
	mHidlDevice->setParameters(params.flatten().string()));		mHidlDevice->setParameters(params.flatten().string()));
	} else if (mDevice && mDevice->ops->set_parameters) {
	return mDevice->ops->set_parameters(mDevice, params.flatten().string());
	}		}
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}
	@@ -740,14 +667,6 @@ CameraParameters CameraHardwareInterface::getParameters() const
	});		});
	String8 tmp(outParam.c_str());		String8 tmp(outParam.c_str());
	parms.unflatten(tmp);		parms.unflatten(tmp);
	} else if (mDevice && mDevice->ops->get_parameters) {
	char *temp = mDevice->ops->get_parameters(mDevice);
	String8 str_parms(temp);
	if (mDevice->ops->put_parameters)
	mDevice->ops->put_parameters(mDevice, temp);
	else
	free(temp);
	parms.unflatten(str_parms);
	}		}
	return parms;		return parms;
	}		}
	@@ -758,8 +677,6 @@ status_t CameraHardwareInterface::sendCommand(int32_t cmd, int32_t arg1, int32_t
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	return CameraProviderManager::mapToStatusT(		return CameraProviderManager::mapToStatusT(
	mHidlDevice->sendCommand((CommandType) cmd, arg1, arg2));		mHidlDevice->sendCommand((CommandType) cmd, arg1, arg2));
	} else if (mDevice && mDevice->ops->send_command) {
	return mDevice->ops->send_command(mDevice, cmd, arg1, arg2);
	}		}
	return INVALID_OPERATION;		return INVALID_OPERATION;
	}		}
	@@ -773,8 +690,6 @@ void CameraHardwareInterface::release() {
	if (CC_LIKELY(mHidlDevice != nullptr)) {		if (CC_LIKELY(mHidlDevice != nullptr)) {
	mHidlDevice->close();		mHidlDevice->close();
	mHidlDevice.clear();		mHidlDevice.clear();
	} else if (mDevice && mDevice->ops->release) {
	mDevice->ops->release(mDevice);
	}		}
	}		}

	@@ -790,15 +705,10 @@ status_t CameraHardwareInterface::dump(int fd, const Vector<String16>& /args/)
	Status s = mHidlDevice->dumpState(handle);		Status s = mHidlDevice->dumpState(handle);
	native_handle_delete(handle);		native_handle_delete(handle);
	return CameraProviderManager::mapToStatusT(s);		return CameraProviderManager::mapToStatusT(s);
	} else if (mDevice && mDevice->ops->dump) {
	return mDevice->ops->dump(mDevice, fd);
	}		}
	return OK; // It's fine if the HAL doesn't implement dump()		return OK; // It's fine if the HAL doesn't implement dump()
	}		}

	/**
	* Methods for legacy (non-HIDL) path follows
	*/
	void CameraHardwareInterface::sNotifyCb(int32_t msg_type, int32_t ext1,		void CameraHardwareInterface::sNotifyCb(int32_t msg_type, int32_t ext1,
	int32_t ext2, void *user)		int32_t ext2, void *user)
	{		{
	@@ -868,177 +778,4 @@ void CameraHardwareInterface::sPutMemory(camera_memory_t *data)
	mem->decStrong(mem);		mem->decStrong(mem);
	}		}

	ANativeWindow* CameraHardwareInterface::sToAnw(void *user)
	{
	CameraHardwareInterface *object =
	reinterpret_cast<CameraHardwareInterface *>(user);
	return object->mPreviewWindow.get();
	}
	#define anw(n) sToAnw(((struct camera_preview_window *)(n))->user)
	#define hwi(n) reinterpret_cast<CameraHardwareInterface *>(\
	((struct camera_preview_window *)(n))->user)

	int CameraHardwareInterface::sDequeueBuffer(struct preview_stream_ops* w,
	buffer_handle_t** buffer, int *stride)
	{
	int rc;
	ANativeWindow *a = anw(w);
	ANativeWindowBuffer* anb;
	rc = native_window_dequeue_buffer_and_wait(a, &anb);
	if (rc == OK) {
	*buffer = &anb->handle;
	*stride = anb->stride;
	}
	return rc;
	}

	#ifndef container_of
	#define container_of(ptr, type, member) ({ \
	const __typeof__(((type ) 0)->member) __mptr = (ptr); \
	(type ) ((char ) __mptr - (char )(&((type )0)->member)); })
	#endif

	int CameraHardwareInterface::sLockBuffer(struct preview_stream_ops* w,
	buffer_handle_t* /buffer/)
	{
	ANativeWindow *a = anw(w);
	(void)a;
	return 0;
	}

	int CameraHardwareInterface::sEnqueueBuffer(struct preview_stream_ops* w,
	buffer_handle_t* buffer)
	{
	ANativeWindow *a = anw(w);
	return a->queueBuffer(a,
	container_of(buffer, ANativeWindowBuffer, handle), -1);
	}

	int CameraHardwareInterface::sCancelBuffer(struct preview_stream_ops* w,
	buffer_handle_t* buffer)
	{
	ANativeWindow *a = anw(w);
	return a->cancelBuffer(a,
	container_of(buffer, ANativeWindowBuffer, handle), -1);
	}

	int CameraHardwareInterface::sSetBufferCount(struct preview_stream_ops* w, int count)
	{
	ANativeWindow *a = anw(w);

	if (a != nullptr) {
	// Workaround for b/27039775
	// Previously, setting the buffer count would reset the buffer
	// queue's flag that allows for all buffers to be dequeued on the
	// producer side, instead of just the producer's declared max count,
	// if no filled buffers have yet been queued by the producer. This
	// reset no longer happens, but some HALs depend on this behavior,
	// so it needs to be maintained for HAL backwards compatibility.
	// Simulate the prior behavior by disconnecting/reconnecting to the
	// window and setting the values again. This has the drawback of
	// actually causing memory reallocation, which may not have happened
	// in the past.
	CameraHardwareInterface *hw = hwi(w);
	native_window_api_disconnect(a, NATIVE_WINDOW_API_CAMERA);
	native_window_api_connect(a, NATIVE_WINDOW_API_CAMERA);
	if (hw->mPreviewScalingMode != NOT_SET) {
	native_window_set_scaling_mode(a, hw->mPreviewScalingMode);
	}
	if (hw->mPreviewTransform != NOT_SET) {
	native_window_set_buffers_transform(a, hw->mPreviewTransform);
	}
	if (hw->mPreviewWidth != NOT_SET) {
	native_window_set_buffers_dimensions(a,
	hw->mPreviewWidth, hw->mPreviewHeight);
	native_window_set_buffers_format(a, hw->mPreviewFormat);
	}
	if (hw->mPreviewUsage != 0) {
	native_window_set_usage(a, hw->mPreviewUsage);
	}
	if (hw->mPreviewSwapInterval != NOT_SET) {
	a->setSwapInterval(a, hw->mPreviewSwapInterval);
	}
	if (hw->mPreviewCrop.left != NOT_SET) {
	native_window_set_crop(a, &(hw->mPreviewCrop));
	}
	}

	return native_window_set_buffer_count(a, count);
	}

	int CameraHardwareInterface::sSetBuffersGeometry(struct preview_stream_ops* w,
	int width, int height, int format)
	{
	int rc;
	ANativeWindow *a = anw(w);
	CameraHardwareInterface *hw = hwi(w);
	hw->mPreviewWidth = width;
	hw->mPreviewHeight = height;
	hw->mPreviewFormat = format;
	rc = native_window_set_buffers_dimensions(a, width, height);
	if (rc == OK) {
	rc = native_window_set_buffers_format(a, format);
	}
	return rc;
	}

	int CameraHardwareInterface::sSetCrop(struct preview_stream_ops *w,
	int left, int top, int right, int bottom)
	{
	ANativeWindow *a = anw(w);
	CameraHardwareInterface *hw = hwi(w);
	hw->mPreviewCrop.left = left;
	hw->mPreviewCrop.top = top;
	hw->mPreviewCrop.right = right;
	hw->mPreviewCrop.bottom = bottom;
	return native_window_set_crop(a, &(hw->mPreviewCrop));
	}

	int CameraHardwareInterface::sSetTimestamp(struct preview_stream_ops *w,
	int64_t timestamp) {
	ANativeWindow *a = anw(w);
	return native_window_set_buffers_timestamp(a, timestamp);
	}

	int CameraHardwareInterface::sSetUsage(struct preview_stream_ops* w, int usage)
	{
	ANativeWindow *a = anw(w);
	CameraHardwareInterface *hw = hwi(w);
	hw->mPreviewUsage = usage;
	return native_window_set_usage(a, usage);
	}

	int CameraHardwareInterface::sSetSwapInterval(struct preview_stream_ops *w, int interval)
	{
	ANativeWindow *a = anw(w);
	CameraHardwareInterface *hw = hwi(w);
	hw->mPreviewSwapInterval = interval;
	return a->setSwapInterval(a, interval);
	}

	int CameraHardwareInterface::sGetMinUndequeuedBufferCount(
	const struct preview_stream_ops *w,
	int *count)
	{
	ANativeWindow *a = anw(w);
	return a->query(a, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, count);
	}

	void CameraHardwareInterface::initHalPreviewWindow()
	{
	mHalPreviewWindow.nw.cancel_buffer = sCancelBuffer;
	mHalPreviewWindow.nw.lock_buffer = sLockBuffer;
	mHalPreviewWindow.nw.dequeue_buffer = sDequeueBuffer;
	mHalPreviewWindow.nw.enqueue_buffer = sEnqueueBuffer;
	mHalPreviewWindow.nw.set_buffer_count = sSetBufferCount;
	mHalPreviewWindow.nw.set_buffers_geometry = sSetBuffersGeometry;
	mHalPreviewWindow.nw.set_crop = sSetCrop;
	mHalPreviewWindow.nw.set_timestamp = sSetTimestamp;
	mHalPreviewWindow.nw.set_usage = sSetUsage;
	mHalPreviewWindow.nw.set_swap_interval = sSetSwapInterval;

	mHalPreviewWindow.nw.get_min_undequeued_buffer_count =
	sGetMinUndequeuedBufferCount;
	}

	}; // namespace android		}; // namespace android

services/camera/libcameraservice/device1/CameraHardwareInterface.h

+1 −45

Original line number	Original line	Diff line number	Diff line
	@@ -90,7 +90,6 @@ class CameraHardwareInterface :

	public:		public:
	explicit CameraHardwareInterface(const char *name):		explicit CameraHardwareInterface(const char *name):
	mDevice(nullptr),
	mHidlDevice(nullptr),		mHidlDevice(nullptr),
	mName(name),		mName(name),
	mPreviewScalingMode(NOT_SET),		mPreviewScalingMode(NOT_SET),
	@@ -299,7 +298,6 @@ public:
	status_t dump(int fd, const Vector<String16>& /args/) const;		status_t dump(int fd, const Vector<String16>& /args/) const;

	private:		private:
	camera_device_t *mDevice;
	sp<hardware::camera::device::V1_0::ICameraDevice> mHidlDevice;		sp<hardware::camera::device::V1_0::ICameraDevice> mHidlDevice;
	String8 mName;		String8 mName;

	@@ -369,41 +367,6 @@ private:

	static void sPutMemory(camera_memory_t *data);		static void sPutMemory(camera_memory_t *data);

	static ANativeWindow sToAnw(void user);

	static int sDequeueBuffer(struct preview_stream_ops* w,
	buffer_handle_t** buffer, int *stride);

	static int sLockBuffer(struct preview_stream_ops* w,
	buffer_handle_t* /buffer/);

	static int sEnqueueBuffer(struct preview_stream_ops* w,
	buffer_handle_t* buffer);

	static int sCancelBuffer(struct preview_stream_ops* w,
	buffer_handle_t* buffer);

	static int sSetBufferCount(struct preview_stream_ops* w, int count);

	static int sSetBuffersGeometry(struct preview_stream_ops* w,
	int width, int height, int format);

	static int sSetCrop(struct preview_stream_ops *w,
	int left, int top, int right, int bottom);

	static int sSetTimestamp(struct preview_stream_ops *w,
	int64_t timestamp);

	static int sSetUsage(struct preview_stream_ops* w, int usage);

	static int sSetSwapInterval(struct preview_stream_ops *w, int interval);

	static int sGetMinUndequeuedBufferCount(
	const struct preview_stream_ops *w,
	int *count);

	void initHalPreviewWindow();

	std::pair<bool, uint64_t> getBufferId(ANativeWindowBuffer* anb);		std::pair<bool, uint64_t> getBufferId(ANativeWindowBuffer* anb);
	void cleanupCirculatingBuffers();		void cleanupCirculatingBuffers();

	@@ -459,13 +422,6 @@ private:

	sp<ANativeWindow> mPreviewWindow;		sp<ANativeWindow> mPreviewWindow;

	struct camera_preview_window {
	struct preview_stream_ops nw;
	void *user;
	};

	struct camera_preview_window mHalPreviewWindow;

	notify_callback mNotifyCb;		notify_callback mNotifyCb;
	data_callback mDataCb;		data_callback mDataCb;
	data_callback_timestamp mDataCbTimestamp;		data_callback_timestamp mDataCbTimestamp;
	@@ -479,7 +435,7 @@ private:
	int mPreviewWidth;		int mPreviewWidth;
	int mPreviewHeight;		int mPreviewHeight;
	int mPreviewFormat;		int mPreviewFormat;
	int mPreviewUsage;		uint64_t mPreviewUsage;
	int mPreviewSwapInterval;		int mPreviewSwapInterval;
	android_native_rect_t mPreviewCrop;		android_native_rect_t mPreviewCrop;