Merge "Revert "Camera2Client: handle slower jpeg stream sensor"" into mnc-dev (d228f0dc) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/api1/Camera2Client.cpp

+9 −43

Original line number	Original line	Diff line number	Diff line
	@@ -764,15 +764,10 @@ status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
	// first capture latency on HAL3 devices, and potentially on some HAL2		// first capture latency on HAL3 devices, and potentially on some HAL2
	// devices. So create it unconditionally at preview start. As a drawback,		// devices. So create it unconditionally at preview start. As a drawback,
	// this increases gralloc memory consumption for applications that don't		// this increases gralloc memory consumption for applications that don't
	// ever take a picture. Do not enter this mode when jpeg stream will slow		// ever take a picture.
	// down preview.
	// TODO: Find a better compromise, though this likely would involve HAL		// TODO: Find a better compromise, though this likely would involve HAL
	// changes.		// changes.
	int lastJpegStreamId = mJpegProcessor->getStreamId();		int lastJpegStreamId = mJpegProcessor->getStreamId();
	// If jpeg stream will slow down preview, make sure we remove it before starting preview
	if (params.slowJpegMode) {
	mJpegProcessor->deleteStream();
	} else {
	res = updateProcessorStream(mJpegProcessor, params);		res = updateProcessorStream(mJpegProcessor, params);
	if (res != OK) {		if (res != OK) {
	ALOGE("%s: Camera %d: Can't pre-configure still image "		ALOGE("%s: Camera %d: Can't pre-configure still image "
	@@ -780,7 +775,6 @@ status_t Camera2Client::startPreviewL(Parameters &params, bool restart) {
	__FUNCTION__, mCameraId, strerror(-res), res);		__FUNCTION__, mCameraId, strerror(-res), res);
	return res;		return res;
	}		}
	}
	bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;		bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;

	Vector<int32_t> outputStreams;		Vector<int32_t> outputStreams;
	@@ -1459,12 +1453,9 @@ status_t Camera2Client::takePicture(int msgType) {
	}		}

	ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);		ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId);

	int lastJpegStreamId = mJpegProcessor->getStreamId();		int lastJpegStreamId = mJpegProcessor->getStreamId();
	// slowJpegMode will create jpeg stream in CaptureSequencer before capturing
	if (!l.mParameters.slowJpegMode) {
	res = updateProcessorStream(mJpegProcessor, l.mParameters);		res = updateProcessorStream(mJpegProcessor, l.mParameters);
	}

	// If video snapshot fail to configureStream, try override video snapshot size to		// If video snapshot fail to configureStream, try override video snapshot size to
	// video size		// video size
	if (res == BAD_VALUE && l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {		if (res == BAD_VALUE && l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
	@@ -1952,31 +1943,6 @@ status_t Camera2Client::stopStream() {
	return mStreamingProcessor->stopStream();		return mStreamingProcessor->stopStream();
	}		}

	status_t Camera2Client::createJpegStreamL(Parameters &params) {
	status_t res = OK;
	int lastJpegStreamId = mJpegProcessor->getStreamId();
	if (lastJpegStreamId != NO_STREAM) {
	return INVALID_OPERATION;
	}

	res = mStreamingProcessor->togglePauseStream(/pause/true);
	if (res != OK) {
	ALOGE("%s: Camera %d: Can't pause streaming: %s (%d)",
	__FUNCTION__, mCameraId, strerror(-res), res);
	return res;
	}

	res = mDevice->flush();
	if (res != OK) {
	ALOGE("%s: Camera %d: Unable flush device: %s (%d)",
	__FUNCTION__, mCameraId, strerror(-res), res);
	return res;
	}

	res = updateProcessorStream(mJpegProcessor, params);
	return res;
	}

	const int32_t Camera2Client::kPreviewRequestIdStart;		const int32_t Camera2Client::kPreviewRequestIdStart;
	const int32_t Camera2Client::kPreviewRequestIdEnd;		const int32_t Camera2Client::kPreviewRequestIdEnd;
	const int32_t Camera2Client::kRecordingRequestIdStart;		const int32_t Camera2Client::kRecordingRequestIdStart;

services/camera/libcameraservice/api1/Camera2Client.h

+3 −6

Original line number	Original line	Diff line number	Diff line
	@@ -129,9 +129,6 @@ public:

	status_t stopStream();		status_t stopStream();

	// For the slowJpegMode to create jpeg stream when precapture sequence is done
	status_t createJpegStreamL(camera2::Parameters &params);

	static size_t calculateBufferSize(int width, int height,		static size_t calculateBufferSize(int width, int height,
	int format, int stride);		int format, int stride);

	@@ -148,9 +145,6 @@ public:
	static const char* kAutofocusLabel;		static const char* kAutofocusLabel;
	static const char* kTakepictureLabel;		static const char* kTakepictureLabel;

	// Used with stream IDs
	static const int NO_STREAM = -1;

	private:		private:
	/** ICamera interface-related private members */		/** ICamera interface-related private members */
	typedef camera2::Parameters Parameters;		typedef camera2::Parameters Parameters;
	@@ -183,6 +177,9 @@ private:
	void setPreviewCallbackFlagL(Parameters &params, int flag);		void setPreviewCallbackFlagL(Parameters &params, int flag);
	status_t updateRequests(Parameters &params);		status_t updateRequests(Parameters &params);

			// Used with stream IDs
			static const int NO_STREAM = -1;

	template <typename ProcessorT>		template <typename ProcessorT>
	status_t updateProcessorStream(sp<ProcessorT> processor, Parameters params);		status_t updateProcessorStream(sp<ProcessorT> processor, Parameters params);
	template <typename ProcessorT,		template <typename ProcessorT,

services/camera/libcameraservice/api1/client2/CaptureSequencer.cpp

+0 −11

Original line number	Original line	Diff line number	Diff line
	@@ -504,17 +504,6 @@ CaptureSequencer::CaptureState CaptureSequencer::manageStandardCapture(
	* - recording (if recording enabled)		* - recording (if recording enabled)
	*/		*/
	outputStreams.push(client->getPreviewStreamId());		outputStreams.push(client->getPreviewStreamId());

	int captureStreamId = client->getCaptureStreamId();
	if (captureStreamId == Camera2Client::NO_STREAM) {
	res = client->createJpegStreamL(l.mParameters);
	if (res != OK \|\| client->getCaptureStreamId() == Camera2Client::NO_STREAM) {
	ALOGE("%s: Camera %d: cannot create jpeg stream for slowJpeg mode: %s (%d)",
	__FUNCTION__, client->getCameraId(), strerror(-res), res);
	return DONE;
	}
	}

	outputStreams.push(client->getCaptureStreamId());		outputStreams.push(client->getCaptureStreamId());

	if (l.mParameters.previewCallbackFlags &		if (l.mParameters.previewCallbackFlags &

services/camera/libcameraservice/api1/client2/Parameters.cpp

+6 −72

Original line number	Original line	Diff line number	Diff line
	@@ -889,30 +889,15 @@ status_t Parameters::initialize(const CameraMetadata *info, int deviceVersion) {
	previewCallbackOneShot = false;		previewCallbackOneShot = false;
	previewCallbackSurface = false;		previewCallbackSurface = false;

	Size maxJpegSize = getMaxSize(getAvailableJpegSizes());
	int64_t minFrameDurationNs = getJpegStreamMinFrameDurationNs(maxJpegSize);

	slowJpegMode = false;
	if (minFrameDurationNs > kSlowJpegModeThreshold) {
	slowJpegMode = true;
	// Slow jpeg devices does not support video snapshot without
	// slowing down preview.
	// TODO: support video size video snapshot only?
	params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
	CameraParameters::FALSE);
	}

	char value[PROPERTY_VALUE_MAX];		char value[PROPERTY_VALUE_MAX];
	property_get("camera.disable_zsl_mode", value, "0");		property_get("camera.disable_zsl_mode", value, "0");
	if (!strcmp(value,"1") \|\| slowJpegMode) {		if (!strcmp(value,"1")) {
	ALOGI("Camera %d: Disabling ZSL mode", cameraId);		ALOGI("Camera %d: Disabling ZSL mode", cameraId);
	zslMode = false;		zslMode = false;
	} else {		} else {
	zslMode = true;		zslMode = true;
	}		}

	ALOGI("%s: zslMode: %d slowJpegMode %d", __FUNCTION__, zslMode, slowJpegMode);

	lightFx = LIGHTFX_NONE;		lightFx = LIGHTFX_NONE;

	state = STOPPED;		state = STOPPED;
	@@ -2793,17 +2778,6 @@ Parameters::Size Parameters::getMaxSizeForRatio(
	return maxSize;		return maxSize;
	}		}

	Parameters::Size Parameters::getMaxSize(const Vector<Parameters::Size> &sizes) {
	Size maxSize = {-1, -1};
	for (size_t i = 0; i < sizes.size(); i++) {
	if (sizes[i].width > maxSize.width \|\|
	(sizes[i].width == maxSize.width && sizes[i].height > maxSize.height )) {
	maxSize = sizes[i];
	}
	}
	return maxSize;
	}

	Vector<Parameters::StreamConfiguration> Parameters::getStreamConfigurations() {		Vector<Parameters::StreamConfiguration> Parameters::getStreamConfigurations() {
	const int STREAM_CONFIGURATION_SIZE = 4;		const int STREAM_CONFIGURATION_SIZE = 4;
	const int STREAM_FORMAT_OFFSET = 0;		const int STREAM_FORMAT_OFFSET = 0;
	@@ -2829,46 +2803,6 @@ Vector<Parameters::StreamConfiguration> Parameters::getStreamConfigurations() {
	return scs;		return scs;
	}		}

	int64_t Parameters::getJpegStreamMinFrameDurationNs(Parameters::Size size) {
	if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {
	const int STREAM_DURATION_SIZE = 4;
	const int STREAM_FORMAT_OFFSET = 0;
	const int STREAM_WIDTH_OFFSET = 1;
	const int STREAM_HEIGHT_OFFSET = 2;
	const int STREAM_DURATION_OFFSET = 3;
	camera_metadata_ro_entry_t availableStreamMinDurations =
	staticInfo(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS);
	for (size_t i = 0; i < availableStreamMinDurations.count; i+= STREAM_DURATION_SIZE) {
	int64_t format = availableStreamMinDurations.data.i64[i + STREAM_FORMAT_OFFSET];
	int64_t width = availableStreamMinDurations.data.i64[i + STREAM_WIDTH_OFFSET];
	int64_t height = availableStreamMinDurations.data.i64[i + STREAM_HEIGHT_OFFSET];
	int64_t duration = availableStreamMinDurations.data.i64[i + STREAM_DURATION_OFFSET];
	if (format == HAL_PIXEL_FORMAT_BLOB && width == size.width && height == size.height) {
	return duration;
	}
	}
	} else {
	Vector<Size> availableJpegSizes = getAvailableJpegSizes();
	size_t streamIdx = availableJpegSizes.size();
	for (size_t i = 0; i < availableJpegSizes.size(); i++) {
	if (availableJpegSizes[i].width == size.width &&
	availableJpegSizes[i].height == size.height) {
	streamIdx = i;
	break;
	}
	}
	if (streamIdx != availableJpegSizes.size()) {
	camera_metadata_ro_entry_t jpegMinDurations =
	staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS);
	if (streamIdx < jpegMinDurations.count) {
	return jpegMinDurations.data.i64[streamIdx];
	}
	}
	}
	ALOGE("%s: cannot find jpeg size %dx%d", size.width, size.height);
	return -1;
	}

	SortedVector<int32_t> Parameters::getAvailableOutputFormats() {		SortedVector<int32_t> Parameters::getAvailableOutputFormats() {
	SortedVector<int32_t> outputFormats; // Non-duplicated output formats		SortedVector<int32_t> outputFormats; // Non-duplicated output formats
	if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {		if (mDeviceVersion >= CAMERA_DEVICE_API_VERSION_3_2) {

services/camera/libcameraservice/api1/client2/Parameters.h

+0 −13

Original line number	Original line	Diff line number	Diff line
	@@ -166,9 +166,6 @@ struct Parameters {
	bool previewCallbackSurface;		bool previewCallbackSurface;

	bool zslMode;		bool zslMode;
	// Whether the jpeg stream is slower than 30FPS and can slow down preview.
	// When slowJpegMode is true, zslMode must be false to avoid slowing down preview.
	bool slowJpegMode;

	// Overall camera state		// Overall camera state
	enum State {		enum State {
	@@ -193,8 +190,6 @@ struct Parameters {
	static const int MAX_INITIAL_PREVIEW_HEIGHT = 1080;		static const int MAX_INITIAL_PREVIEW_HEIGHT = 1080;
	// Aspect ratio tolerance		// Aspect ratio tolerance
	static const CONSTEXPR float ASPECT_RATIO_TOLERANCE = 0.001;		static const CONSTEXPR float ASPECT_RATIO_TOLERANCE = 0.001;
	// Threshold for slow jpeg mode
	static const int64_t kSlowJpegModeThreshold = 33400000LL; // 33.4 ms

	// Full static camera info, object owned by someone else, such as		// Full static camera info, object owned by someone else, such as
	// Camera2Device.		// Camera2Device.
	@@ -382,23 +377,15 @@ private:
	int32_t height;		int32_t height;
	int32_t isInput;		int32_t isInput;
	};		};

	// Helper function extract available stream configuration		// Helper function extract available stream configuration
	// Only valid since device HAL version 3.2		// Only valid since device HAL version 3.2
	// returns an empty Vector if device HAL version does support it		// returns an empty Vector if device HAL version does support it
	Vector<StreamConfiguration> getStreamConfigurations();		Vector<StreamConfiguration> getStreamConfigurations();

	// Helper function to get minimum frame duration for a jpeg size
	// return -1 if input jpeg size cannot be found in supported size list
	int64_t getJpegStreamMinFrameDurationNs(Parameters::Size size);

	// Helper function to get non-duplicated available output formats		// Helper function to get non-duplicated available output formats
	SortedVector<int32_t> getAvailableOutputFormats();		SortedVector<int32_t> getAvailableOutputFormats();
	// Helper function to get available output jpeg sizes		// Helper function to get available output jpeg sizes
	Vector<Size> getAvailableJpegSizes();		Vector<Size> getAvailableJpegSizes();
	// Helper function to get maximum size in input Size vector.
	// The maximum size is defined by comparing width first, when width ties comparing height.
	Size getMaxSize(const Vector<Size>& sizes);

	int mDeviceVersion;		int mDeviceVersion;
	};		};