am 0370be96: DO NOT MERGE: camera: Fix setParameters for Preview FPS single/range values (65550a0e) · Commits · e / os / android_frameworks_av

camera/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -8,6 +8,7 @@ LOCAL_SRC_FILES:= \
		Camera.cpp \
		CameraMetadata.cpp \
		CameraParameters.cpp \
		CameraParameters2.cpp \
		ICamera.cpp \
		ICameraClient.cpp \
		ICameraService.cpp \

camera/CameraParameters2.cpp

0 → 100644

+381 −0

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2008, The Android Open Source Project
		**
		** Licensed under the Apache License, Version 2.0 (the "License");
		** you may not use this file except in compliance with the License.
		** You may obtain a copy of the License at
		**
		** http://www.apache.org/licenses/LICENSE-2.0
		**
		** Unless required by applicable law or agreed to in writing, software
		** distributed under the License is distributed on an "AS IS" BASIS,
		** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		** See the License for the specific language governing permissions and
		** limitations under the License.
		*/

		#define LOG_TAG "CameraParams2"
		// #define LOG_NDEBUG 0
		#include <utils/Log.h>

		#include <string.h>
		#include <stdlib.h>
		#include <camera/CameraParameters2.h>

		namespace android {

		CameraParameters2::CameraParameters2()
		: mMap()
		{
		}

		CameraParameters2::~CameraParameters2()
		{
		}

		String8 CameraParameters2::flatten() const
		{
		String8 flattened("");
		size_t size = mMap.size();

		for (size_t i = 0; i < size; i++) {
		String8 k, v;
		k = mMap.keyAt(i);
		v = mMap.valueAt(i);

		flattened += k;
		flattened += "=";
		flattened += v;
		if (i != size-1)
		flattened += ";";
		}

		ALOGV("%s: Flattened params = %s", __FUNCTION__, flattened.string());

		return flattened;
		}

		void CameraParameters2::unflatten(const String8 &params)
		{
		const char *a = params.string();
		const char *b;

		mMap.clear();

		for (;;) {
		// Find the bounds of the key name.
		b = strchr(a, '=');
		if (b == 0)
		break;

		// Create the key string.
		String8 k(a, (size_t)(b-a));

		// Find the value.
		a = b+1;
		b = strchr(a, ';');
		if (b == 0) {
		// If there's no semicolon, this is the last item.
		String8 v(a);
		mMap.add(k, v);
		break;
		}

		String8 v(a, (size_t)(b-a));
		mMap.add(k, v);
		a = b+1;
		}
		}


		void CameraParameters2::set(const char key, const char value)
		{
		// XXX i think i can do this with strspn()
		if (strchr(key, '=') \|\| strchr(key, ';')) {
		//XXX ALOGE("Key \"%s\"contains invalid character (= or ;)", key);
		return;
		}

		if (strchr(value, '=') \|\| strchr(value, ';')) {
		//XXX ALOGE("Value \"%s\"contains invalid character (= or ;)", value);
		return;
		}

		// Replacing a value updates the key's order to be the new largest order
		ssize_t res = mMap.replaceValueFor(String8(key), String8(value));
		LOG_ALWAYS_FATAL_IF(res < 0, "replaceValueFor(%s,%s) failed", key, value);
		}

		void CameraParameters2::set(const char *key, int value)
		{
		char str[16];
		sprintf(str, "%d", value);
		set(key, str);
		}

		void CameraParameters2::setFloat(const char *key, float value)
		{
		char str[16]; // 14 should be enough. We overestimate to be safe.
		snprintf(str, sizeof(str), "%g", value);
		set(key, str);
		}

		const char CameraParameters2::get(const char key) const
		{
		ssize_t idx = mMap.indexOfKey(String8(key));
		if (idx < 0) {
		return NULL;
		} else {
		return mMap.valueAt(idx).string();
		}
		}

		int CameraParameters2::getInt(const char *key) const
		{
		const char *v = get(key);
		if (v == 0)
		return -1;
		return strtol(v, 0, 0);
		}

		float CameraParameters2::getFloat(const char *key) const
		{
		const char *v = get(key);
		if (v == 0) return -1;
		return strtof(v, 0);
		}

		status_t CameraParameters2::compareSetOrder(const char key1, const char key2,
		int *order) const {
		if (key1 == NULL) {
		ALOGE("%s: key1 must not be NULL", __FUNCTION__);
		return BAD_VALUE;
		} else if (key2 == NULL) {
		ALOGE("%s: key2 must not be NULL", __FUNCTION__);
		return BAD_VALUE;
		} else if (order == NULL) {
		ALOGE("%s: order must not be NULL", __FUNCTION__);
		return BAD_VALUE;
		}

		ssize_t index1 = mMap.indexOfKey(String8(key1));
		ssize_t index2 = mMap.indexOfKey(String8(key2));
		if (index1 < 0) {
		ALOGW("%s: Key1 (%s) was not set", __FUNCTION__, key1);
		return NAME_NOT_FOUND;
		} else if (index2 < 0) {
		ALOGW("%s: Key2 (%s) was not set", __FUNCTION__, key2);
		return NAME_NOT_FOUND;
		}

		*order = (index1 == index2) ? 0 :
		(index1 < index2) ? -1 :
		1;

		return OK;
		}

		void CameraParameters2::remove(const char *key)
		{
		mMap.removeItem(String8(key));
		}

		// Parse string like "640x480" or "10000,20000"
		static int parse_pair(const char str, int first, int *second, char delim,
		char **endptr = NULL)
		{
		// Find the first integer.
		char *end;
		int w = (int)strtol(str, &end, 10);
		// If a delimeter does not immediately follow, give up.
		if (*end != delim) {
		ALOGE("Cannot find delimeter (%c) in str=%s", delim, str);
		return -1;
		}

		// Find the second integer, immediately after the delimeter.
		int h = (int)strtol(end+1, &end, 10);

		*first = w;
		*second = h;

		if (endptr) {
		*endptr = end;
		}

		return 0;
		}

		static void parseSizesList(const char *sizesStr, Vector<Size> &sizes)
		{
		if (sizesStr == 0) {
		return;
		}

		char sizeStartPtr = (char )sizesStr;

		while (true) {
		int width, height;
		int success = parse_pair(sizeStartPtr, &width, &height, 'x',
		&sizeStartPtr);
		if (success == -1 \|\| (sizeStartPtr != ',' && sizeStartPtr != '\0')) {
		ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
		return;
		}
		sizes.push(Size(width, height));

		if (*sizeStartPtr == '\0') {
		return;
		}
		sizeStartPtr++;
		}
		}

		void CameraParameters2::setPreviewSize(int width, int height)
		{
		char str[32];
		sprintf(str, "%dx%d", width, height);
		set(CameraParameters::KEY_PREVIEW_SIZE, str);
		}

		void CameraParameters2::getPreviewSize(int width, int height) const
		{
		width = height = -1;
		// Get the current string, if it doesn't exist, leave the -1x-1
		const char *p = get(CameraParameters::KEY_PREVIEW_SIZE);
		if (p == 0) return;
		parse_pair(p, width, height, 'x');
		}

		void CameraParameters2::getPreferredPreviewSizeForVideo(int width, int height) const
		{
		width = height = -1;
		const char *p = get(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO);
		if (p == 0) return;
		parse_pair(p, width, height, 'x');
		}

		void CameraParameters2::getSupportedPreviewSizes(Vector<Size> &sizes) const
		{
		const char *previewSizesStr = get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
		parseSizesList(previewSizesStr, sizes);
		}

		void CameraParameters2::setVideoSize(int width, int height)
		{
		char str[32];
		sprintf(str, "%dx%d", width, height);
		set(CameraParameters::KEY_VIDEO_SIZE, str);
		}

		void CameraParameters2::getVideoSize(int width, int height) const
		{
		width = height = -1;
		const char *p = get(CameraParameters::KEY_VIDEO_SIZE);
		if (p == 0) return;
		parse_pair(p, width, height, 'x');
		}

		void CameraParameters2::getSupportedVideoSizes(Vector<Size> &sizes) const
		{
		const char *videoSizesStr = get(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES);
		parseSizesList(videoSizesStr, sizes);
		}

		void CameraParameters2::setPreviewFrameRate(int fps)
		{
		set(CameraParameters::KEY_PREVIEW_FRAME_RATE, fps);
		}

		int CameraParameters2::getPreviewFrameRate() const
		{
		return getInt(CameraParameters::KEY_PREVIEW_FRAME_RATE);
		}

		void CameraParameters2::getPreviewFpsRange(int min_fps, int max_fps) const
		{
		min_fps = max_fps = -1;
		const char *p = get(CameraParameters::KEY_PREVIEW_FPS_RANGE);
		if (p == 0) return;
		parse_pair(p, min_fps, max_fps, ',');
		}

		void CameraParameters2::setPreviewFpsRange(int min_fps, int max_fps)
		{
		String8 str = String8::format("%d,%d", min_fps, max_fps);
		set(CameraParameters::KEY_PREVIEW_FPS_RANGE, str.string());
		}

		void CameraParameters2::setPreviewFormat(const char *format)
		{
		set(CameraParameters::KEY_PREVIEW_FORMAT, format);
		}

		const char *CameraParameters2::getPreviewFormat() const
		{
		return get(CameraParameters::KEY_PREVIEW_FORMAT);
		}

		void CameraParameters2::setPictureSize(int width, int height)
		{
		char str[32];
		sprintf(str, "%dx%d", width, height);
		set(CameraParameters::KEY_PICTURE_SIZE, str);
		}

		void CameraParameters2::getPictureSize(int width, int height) const
		{
		width = height = -1;
		// Get the current string, if it doesn't exist, leave the -1x-1
		const char *p = get(CameraParameters::KEY_PICTURE_SIZE);
		if (p == 0) return;
		parse_pair(p, width, height, 'x');
		}

		void CameraParameters2::getSupportedPictureSizes(Vector<Size> &sizes) const
		{
		const char *pictureSizesStr = get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES);
		parseSizesList(pictureSizesStr, sizes);
		}

		void CameraParameters2::setPictureFormat(const char *format)
		{
		set(CameraParameters::KEY_PICTURE_FORMAT, format);
		}

		const char *CameraParameters2::getPictureFormat() const
		{
		return get(CameraParameters::KEY_PICTURE_FORMAT);
		}

		void CameraParameters2::dump() const
		{
		ALOGD("dump: mMap.size = %d", mMap.size());
		for (size_t i = 0; i < mMap.size(); i++) {
		String8 k, v;
		k = mMap.keyAt(i);
		v = mMap.valueAt(i);
		ALOGD("%s: %s\n", k.string(), v.string());
		}
		}

		status_t CameraParameters2::dump(int fd, const Vector<String16>& args) const
		{
		const size_t SIZE = 256;
		char buffer[SIZE];
		String8 result;
		snprintf(buffer, 255, "CameraParameters2::dump: mMap.size = %zu\n", mMap.size());
		result.append(buffer);
		for (size_t i = 0; i < mMap.size(); i++) {
		String8 k, v;
		k = mMap.keyAt(i);
		v = mMap.valueAt(i);
		snprintf(buffer, 255, "\t%s: %s\n", k.string(), v.string());
		result.append(buffer);
		}
		write(fd, result.string(), result.size());
		return NO_ERROR;
		}

		}; // namespace android

include/camera/CameraParameters2.h

0 → 100644

+203 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_HARDWARE_CAMERA_PARAMETERS2_H
		#define ANDROID_HARDWARE_CAMERA_PARAMETERS2_H

		#include <utils/Vector.h>
		#include <utils/String8.h>
		#include "CameraParameters.h"

		namespace android {

		/**
		* A copy of CameraParameters plus ABI-breaking changes. Needed
		* because some camera HALs directly link to CameraParameters and cannot
		* tolerate an ABI change.
		*/
		class CameraParameters2
		{
		public:
		CameraParameters2();
		CameraParameters2(const String8 &params) { unflatten(params); }
		~CameraParameters2();

		String8 flatten() const;
		void unflatten(const String8 &params);

		void set(const char key, const char value);
		void set(const char *key, int value);
		void setFloat(const char *key, float value);
		// Look up string value by key.
		// -- The string remains valid until the next set/remove of the same key,
		// or until the map gets cleared.
		const char get(const char key) const;
		int getInt(const char *key) const;
		float getFloat(const char *key) const;

		// Compare the order that key1 was set vs the order that key2 was set.
		//
		// Sets the order parameter to an integer less than, equal to, or greater
		// than zero if key1's set order was respectively, to be less than, to
		// match, or to be greater than key2's set order.
		//
		// Error codes:
		// * NAME_NOT_FOUND - if either key has not been set previously
		// * BAD_VALUE - if any of the parameters are NULL
		status_t compareSetOrder(const char key1, const char key2,
		/out/
		int *order) const;

		void remove(const char *key);

		void setPreviewSize(int width, int height);
		void getPreviewSize(int width, int height) const;
		void getSupportedPreviewSizes(Vector<Size> &sizes) const;

		// Set the dimensions in pixels to the given width and height
		// for video frames. The given width and height must be one
		// of the supported dimensions returned from
		// getSupportedVideoSizes(). Must not be called if
		// getSupportedVideoSizes() returns an empty Vector of Size.
		void setVideoSize(int width, int height);
		// Retrieve the current dimensions (width and height)
		// in pixels for video frames, which must be one of the
		// supported dimensions returned from getSupportedVideoSizes().
		// Must not be called if getSupportedVideoSizes() returns an
		// empty Vector of Size.
		void getVideoSize(int width, int height) const;
		// Retrieve a Vector of supported dimensions (width and height)
		// in pixels for video frames. If sizes returned from the method
		// is empty, the camera does not support calls to setVideoSize()
		// or getVideoSize(). In adddition, it also indicates that
		// the camera only has a single output, and does not have
		// separate output for video frames and preview frame.
		void getSupportedVideoSizes(Vector<Size> &sizes) const;
		// Retrieve the preferred preview size (width and height) in pixels
		// for video recording. The given width and height must be one of
		// supported preview sizes returned from getSupportedPreviewSizes().
		// Must not be called if getSupportedVideoSizes() returns an empty
		// Vector of Size. If getSupportedVideoSizes() returns an empty
		// Vector of Size, the width and height returned from this method
		// is invalid, and is "-1x-1".
		void getPreferredPreviewSizeForVideo(int width, int height) const;

		void setPreviewFrameRate(int fps);
		int getPreviewFrameRate() const;
		void getPreviewFpsRange(int min_fps, int max_fps) const;
		void setPreviewFpsRange(int min_fps, int max_fps);
		void setPreviewFormat(const char *format);
		const char *getPreviewFormat() const;
		void setPictureSize(int width, int height);
		void getPictureSize(int width, int height) const;
		void getSupportedPictureSizes(Vector<Size> &sizes) const;
		void setPictureFormat(const char *format);
		const char *getPictureFormat() const;

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

		private:

		// Quick and dirty map that maintains insertion order
		template <typename KeyT, typename ValueT>
		struct OrderedKeyedVector {

		ssize_t add(const KeyT& key, const ValueT& value) {
		return mList.add(Pair(key, value));
		}

		size_t size() const {
		return mList.size();
		}

		const KeyT& keyAt(size_t idx) const {
		return mList[idx].mKey;
		}

		const ValueT& valueAt(size_t idx) const {
		return mList[idx].mValue;
		}

		const ValueT& valueFor(const KeyT& key) const {
		ssize_t i = indexOfKey(key);
		LOG_ALWAYS_FATAL_IF(i<0, "%s: key not found", __PRETTY_FUNCTION__);

		return valueAt(i);
		}

		ssize_t indexOfKey(const KeyT& key) const {
		size_t vectorIdx = 0;
		for (; vectorIdx < mList.size(); ++vectorIdx) {
		if (mList[vectorIdx].mKey == key) {
		return (ssize_t) vectorIdx;
		}
		}

		return NAME_NOT_FOUND;
		}

		ssize_t removeItem(const KeyT& key) {
		size_t vectorIdx = (size_t) indexOfKey(key);

		if (vectorIdx < 0) {
		return vectorIdx;
		}

		return mList.removeAt(vectorIdx);
		}

		void clear() {
		mList.clear();
		}

		// Same as removing and re-adding. The key's index changes to max.
		ssize_t replaceValueFor(const KeyT& key, const ValueT& value) {
		removeItem(key);
		return add(key, value);
		}

		private:

		struct Pair {
		Pair() : mKey(), mValue() {}
		Pair(const KeyT& key, const ValueT& value) :
		mKey(key),
		mValue(value) {}
		KeyT mKey;
		ValueT mValue;
		};

		Vector<Pair> mList;
		};

		/**
		* Order matters: Keys that are set() later are stored later in the map.
		*
		* If two keys have meaning that conflict, then the later-set key
		* wins.
		*
		* For example, preview FPS and preview FPS range conflict since only
		* we only want to use the FPS range if that's the last thing that was set.
		* So in that case, only use preview FPS range if it was set later than
		* the preview FPS.
		*/
		OrderedKeyedVector<String8,String8> mMap;
		};

		}; // namespace android

		#endif

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

+118 −42

File changed.

Preview size limit exceeded, changes collapsed.

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

+3 −2

Original line number	Diff line number	Diff line
		@@ -25,6 +25,7 @@
		#include <utils/Vector.h>
		#include <utils/KeyedVector.h>
		#include <camera/CameraParameters.h>
		#include <camera/CameraParameters2.h>
		#include <camera/CameraMetadata.h>

		namespace android {
		@@ -32,7 +33,7 @@ namespace camera2 {

		/**
		* Current camera state; this is the full state of the Camera under the old
		* camera API (contents of the CameraParameters object in a more-efficient
		* camera API (contents of the CameraParameters2 object in a more-efficient
		* format, plus other state). The enum values are mostly based off the
		* corresponding camera2 enums, not the camera1 strings. A few are defined here
		* if they don't cleanly map to camera2 values.
		@@ -128,7 +129,7 @@ struct Parameters {
		LIGHTFX_HDR
		} lightFx;

		CameraParameters params;
		CameraParameters2 params;
		String8 paramsFlattened;

		// These parameters are also part of the camera API-visible state, but not