QCameraParameters.cpp revision 3f92cbaa5bde0dba1e4a9a67e5aa60fc0af2dfa0 
1/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 *     * Redistributions of source code must retain the above copyright
7 *       notice, this list of conditions and the following disclaimer.
8 *     * Redistributions in binary form must reproduce the above
9 *       copyright notice, this list of conditions and the following
10 *       disclaimer in the documentation and/or other materials provided
11 *       with the distribution.
12 *     * Neither the name of The Linux Foundation nor the names of its
13 *       contributors may be used to endorse or promote products derived
14 *       from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30#define LOG_TAG "QCameraParameters"
31
32#include <cutils/properties.h>
33#include <math.h>
34#include <utils/Errors.h>
35#include <string.h>
36#include <stdlib.h>
37#include <gralloc_priv.h>
38#include "QCamera2HWI.h"
39#include "QCameraParameters.h"
40
41#define ASPECT_TOLERANCE 0.001
42#define FLIP_V_H (FLIP_H | FLIP_V)
43
44namespace qcamera {
45// Parameter keys to communicate between camera application and driver.
46const char QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES[] = "hfr-size-values";
47const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_MODE[] = "preview-frame-rate-mode";
48const char QCameraParameters::KEY_QC_SUPPORTED_PREVIEW_FRAME_RATE_MODES[] = "preview-frame-rate-modes";
49const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE[] = "frame-rate-auto";
50const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE[] = "frame-rate-fixed";
51const char QCameraParameters::KEY_QC_TOUCH_AF_AEC[] = "touch-af-aec";
52const char QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC[] = "touch-af-aec-values";
53const char QCameraParameters::KEY_QC_TOUCH_INDEX_AEC[] = "touch-index-aec";
54const char QCameraParameters::KEY_QC_TOUCH_INDEX_AF[] = "touch-index-af";
55const char QCameraParameters::KEY_QC_SCENE_DETECT[] = "scene-detect";
56const char QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT[] = "scene-detect-values";
57const char QCameraParameters::KEY_QC_ISO_MODE[] = "iso";
58const char QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES[] = "iso-values";
59const char QCameraParameters::KEY_QC_LENSSHADE[] = "lensshade";
60const char QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES[] = "lensshade-values";
61const char QCameraParameters::KEY_QC_AUTO_EXPOSURE[] = "auto-exposure";
62const char QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE[] = "auto-exposure-values";
63const char QCameraParameters::KEY_QC_DENOISE[] = "denoise";
64const char QCameraParameters::KEY_QC_SUPPORTED_DENOISE[] = "denoise-values";
65const char QCameraParameters::KEY_QC_FOCUS_ALGO[] = "selectable-zone-af";
66const char QCameraParameters::KEY_QC_SUPPORTED_FOCUS_ALGOS[] = "selectable-zone-af-values";
67const char QCameraParameters::KEY_QC_FACE_DETECTION[] = "face-detection";
68const char QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION[] = "face-detection-values";
69const char QCameraParameters::KEY_QC_FACE_RECOGNITION[] = "face-recognition";
70const char QCameraParameters::KEY_QC_SUPPORTED_FACE_RECOGNITION[] = "face-recognition-values";
71const char QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT[] = "mce";
72const char QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES[] = "mce-values";
73const char QCameraParameters::KEY_QC_DIS[] = "dis";
74const char QCameraParameters::KEY_QC_SUPPORTED_DIS_MODES[] = "dis-values";
75const char QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE[] = "video-hfr";
76const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[] = "video-hfr-values";
77const char QCameraParameters::KEY_QC_REDEYE_REDUCTION[] = "redeye-reduction";
78const char QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION[] = "redeye-reduction-values";
79const char QCameraParameters::KEY_QC_HIGH_DYNAMIC_RANGE_IMAGING[] = "hdr";
80const char QCameraParameters::KEY_QC_SUPPORTED_HDR_IMAGING_MODES[] = "hdr-values";
81const char QCameraParameters::KEY_QC_ZSL[] = "zsl";
82const char QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES[] = "zsl-values";
83const char QCameraParameters::KEY_QC_ZSL_BURST_INTERVAL[] = "capture-burst-interval";
84const char QCameraParameters::KEY_QC_ZSL_BURST_LOOKBACK[] = "capture-burst-retroactive";
85const char QCameraParameters::KEY_QC_ZSL_QUEUE_DEPTH[] = "capture-burst-queue-depth";
86const char QCameraParameters::KEY_QC_CAMERA_MODE[] = "camera-mode";
87const char QCameraParameters::KEY_QC_AE_BRACKET_HDR[] = "ae-bracket-hdr";
88const char QCameraParameters::KEY_QC_SUPPORTED_AE_BRACKET_MODES[] = "ae-bracket-hdr-values";
89const char QCameraParameters::KEY_QC_SUPPORTED_RAW_FORMATS[] = "raw-format-values";
90const char QCameraParameters::KEY_QC_RAW_FORMAT[] = "raw-format";
91const char QCameraParameters::KEY_QC_ORIENTATION[] = "orientation";
92const char QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF[] = "selectable-zone-af";
93const char QCameraParameters::KEY_QC_CAPTURE_BURST_EXPOSURE[] = "capture-burst-exposures";
94const char QCameraParameters::KEY_QC_NUM_SNAPSHOT_PER_SHUTTER[] = "num-snaps-per-shutter";
95const char QCameraParameters::KEY_QC_NO_DISPLAY_MODE[] = "no-display-mode";
96const char QCameraParameters::KEY_QC_RAW_PICUTRE_SIZE[] = "raw-size";
97const char QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] = "skinToneEnhancement-values";
98const char QCameraParameters::KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES[] = "supported-live-snapshot-sizes";
99const char QCameraParameters::KEY_QC_HDR_NEED_1X[] = "hdr-need-1x";
100const char QCameraParameters::KEY_QC_PREVIEW_FLIP[] = "preview-flip";
101const char QCameraParameters::KEY_QC_VIDEO_FLIP[] = "video-flip";
102const char QCameraParameters::KEY_QC_SNAPSHOT_PICTURE_FLIP[] = "snapshot-picture-flip";
103const char QCameraParameters::KEY_QC_SUPPORTED_FLIP_MODES[] = "flip-mode-values";
104const char QCameraParameters::KEY_QC_VIDEO_HDR[] = "video-hdr";
105const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HDR_MODES[] = "video-hdr-values";
106
107// Values for effect settings.
108const char QCameraParameters::EFFECT_EMBOSS[] = "emboss";
109const char QCameraParameters::EFFECT_SKETCH[] = "sketch";
110const char QCameraParameters::EFFECT_NEON[] = "neon";
111
112// Values for auto exposure settings.
113const char QCameraParameters::TOUCH_AF_AEC_OFF[] = "touch-off";
114const char QCameraParameters::TOUCH_AF_AEC_ON[] = "touch-on";
115
116// Values for scene mode settings.
117const char QCameraParameters::SCENE_MODE_ASD[] = "asd";   // corresponds to CAMERA_BESTSHOT_AUTO in HAL
118const char QCameraParameters::SCENE_MODE_BACKLIGHT[] = "backlight";
119const char QCameraParameters::SCENE_MODE_FLOWERS[] = "flowers";
120const char QCameraParameters::SCENE_MODE_AR[] = "AR";
121const char QCameraParameters::SCENE_MODE_HDR[] = "hdr";
122
123// Formats for setPreviewFormat and setPictureFormat.
124const char QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO[] = "yuv420sp-adreno";
125const char QCameraParameters::PIXEL_FORMAT_YV12[] = "yuv420p";
126const char QCameraParameters::PIXEL_FORMAT_NV12[] = "nv12";
127
128// Values for raw image formats
129const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV[] = "yuv-raw8-yuyv";
130const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU[] = "yuv-raw8-yvyu";
131const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY[] = "yuv-raw8-uyvy";
132const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY[] = "yuv-raw8-vyuy";
133const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG[] = "bayer-qcom-8gbrg";
134const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG[] = "bayer-qcom-8grbg";
135const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB[] = "bayer-qcom-8rggb";
136const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR[] = "bayer-qcom-8bggr";
137const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG[] = "bayer-qcom-10gbrg";
138const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG[] = "bayer-qcom-10grbg";
139const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB[] = "bayer-qcom-10rggb";
140const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR[] = "bayer-qcom-10bggr";
141const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG[] = "bayer-qcom-12gbrg";
142const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG[] = "bayer-qcom-12grbg";
143const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB[] = "bayer-qcom-12rggb";
144const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR[] = "bayer-qcom-12bggr";
145const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG[] = "bayer-mipi-8gbrg";
146const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG[] = "bayer-mipi-8grbg";
147const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB[] = "bayer-mipi-8rggb";
148const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR[] = "bayer-mipi-8bggr";
149const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG[] = "bayer-mipi-10gbrg";
150const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG[] = "bayer-mipi-10grbg";
151const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB[] = "bayer-mipi-10rggb";
152const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR[] = "bayer-mipi-10bggr";
153const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG[] = "bayer-mipi-12gbrg";
154const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG[] = "bayer-mipi-12grbg";
155const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB[] = "bayer-mipi-12rggb";
156const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR[] = "bayer-mipi-12bggr";
157const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG[] = "bayer-ideal-qcom-8gbrg";
158const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG[] = "bayer-ideal-qcom-8grbg";
159const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB[] = "bayer-ideal-qcom-8rggb";
160const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR[] = "bayer-ideal-qcom-8bggr";
161const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG[] = "bayer-ideal-qcom-10gbrg";
162const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG[] = "bayer-ideal-qcom-10grbg";
163const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB[] = "bayer-ideal-qcom-10rggb";
164const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR[] = "bayer-ideal-qcom-10bggr";
165const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG[] = "bayer-ideal-qcom-12gbrg";
166const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG[] = "bayer-ideal-qcom-12grbg";
167const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB[] = "bayer-ideal-qcom-12rggb";
168const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR[] = "bayer-ideal-qcom-12bggr";
169const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG[] = "bayer-ideal-mipi-8gbrg";
170const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG[] = "bayer-ideal-mipi-8grbg";
171const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB[] = "bayer-ideal-mipi-8rggb";
172const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR[] = "bayer-ideal-mipi-8bggr";
173const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG[] = "bayer-ideal-mipi-10gbrg";
174const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG[] = "bayer-ideal-mipi-10grbg";
175const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB[] = "bayer-ideal-mipi-10rggb";
176const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR[] = "bayer-ideal-mipi-10bggr";
177const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG[] = "bayer-ideal-mipi-12gbrg";
178const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG[] = "bayer-ideal-mipi-12grbg";
179const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB[] = "bayer-ideal-mipi-12rggb";
180const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR[] = "bayer-ideal-mipi-12bggr";
181const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG[] = "bayer-ideal-plain8-8gbrg";
182const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG[] = "bayer-ideal-plain8-8grbg";
183const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB[] = "bayer-ideal-plain8-8rggb";
184const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR[] = "bayer-ideal-plain8-8bggr";
185const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG[] = "bayer-ideal-plain16-8gbrg";
186const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG[] = "bayer-ideal-plain16-8grbg";
187const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB[] = "bayer-ideal-plain16-8rggb";
188const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR[] = "bayer-ideal-plain16-8bggr";
189const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG[] = "bayer-ideal-plain16-10gbrg";
190const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG[] = "bayer-ideal-plain16-10grbg";
191const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB[] = "bayer-ideal-plain16-10rggb";
192const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR[] = "bayer-ideal-plain16-10bggr";
193const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG[] = "bayer-ideal-plain16-12gbrg";
194const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG[] = "bayer-ideal-plain16-12grbg";
195const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB[] = "bayer-ideal-plain16-12rggb";
196const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR[] = "bayer-ideal-plain16-12bggr";
197
198// Values for ISO Settings
199const char QCameraParameters::ISO_AUTO[] = "auto";
200const char QCameraParameters::ISO_HJR[] = "ISO_HJR";
201const char QCameraParameters::ISO_100[] = "ISO100";
202const char QCameraParameters::ISO_200[] = "ISO200";
203const char QCameraParameters::ISO_400[] = "ISO400";
204const char QCameraParameters::ISO_800[] = "ISO800";
205const char QCameraParameters::ISO_1600[] = "ISO1600";
206
207// Values for auto exposure settings.
208const char QCameraParameters::AUTO_EXPOSURE_FRAME_AVG[] = "frame-average";
209const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED[] = "center-weighted";
210const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING[] = "spot-metering";
211const char QCameraParameters::AUTO_EXPOSURE_SMART_METERING[] = "smart-metering";
212const char QCameraParameters::AUTO_EXPOSURE_USER_METERING[] = "user-metering";
213const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING_ADV[] = "spot-metering-adv";
214const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED_ADV[] = "center-weighted-adv";
215
216const char QCameraParameters::KEY_QC_GPS_LATITUDE_REF[] = "gps-latitude-ref";
217const char QCameraParameters::KEY_QC_GPS_LONGITUDE_REF[] = "gps-longitude-ref";
218const char QCameraParameters::KEY_QC_GPS_ALTITUDE_REF[] = "gps-altitude-ref";
219const char QCameraParameters::KEY_QC_GPS_STATUS[] = "gps-status";
220
221const char QCameraParameters::KEY_QC_HISTOGRAM[] = "histogram";
222const char QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES[] = "histogram-values";
223
224const char QCameraParameters::VALUE_ENABLE[] = "enable";
225const char QCameraParameters::VALUE_DISABLE[] = "disable";
226const char QCameraParameters::VALUE_OFF[] = "off";
227const char QCameraParameters::VALUE_ON[] = "on";
228const char QCameraParameters::VALUE_TRUE[] = "true";
229const char QCameraParameters::VALUE_FALSE[] = "false";
230
231const char QCameraParameters::KEY_QC_SHARPNESS[] = "sharpness";
232const char QCameraParameters::KEY_QC_MIN_SHARPNESS[] = "min-sharpness";
233const char QCameraParameters::KEY_QC_MAX_SHARPNESS[] = "max-sharpness";
234const char QCameraParameters::KEY_QC_SHARPNESS_STEP[] = "sharpness-step";
235const char QCameraParameters::KEY_QC_CONTRAST[] = "contrast";
236const char QCameraParameters::KEY_QC_MIN_CONTRAST[] = "min-contrast";
237const char QCameraParameters::KEY_QC_MAX_CONTRAST[] = "max-contrast";
238const char QCameraParameters::KEY_QC_CONTRAST_STEP[] = "contrast-step";
239const char QCameraParameters::KEY_QC_SATURATION[] = "saturation";
240const char QCameraParameters::KEY_QC_MIN_SATURATION[] = "min-saturation";
241const char QCameraParameters::KEY_QC_MAX_SATURATION[] = "max-saturation";
242const char QCameraParameters::KEY_QC_SATURATION_STEP[] = "saturation-step";
243const char QCameraParameters::KEY_QC_BRIGHTNESS[] = "luma-adaptation";
244const char QCameraParameters::KEY_QC_MIN_BRIGHTNESS[] = "min-brightness";
245const char QCameraParameters::KEY_QC_MAX_BRIGHTNESS[] = "max-brightness";
246const char QCameraParameters::KEY_QC_BRIGHTNESS_STEP[] = "brightness-step";
247const char QCameraParameters::KEY_QC_SCE_FACTOR[] = "skinToneEnhancement";
248const char QCameraParameters::KEY_QC_MIN_SCE_FACTOR[] = "min-sce-factor";
249const char QCameraParameters::KEY_QC_MAX_SCE_FACTOR[] = "max-sce-factor";
250const char QCameraParameters::KEY_QC_SCE_FACTOR_STEP[] = "sce-factor-step";
251
252const char QCameraParameters::KEY_QC_SUPPORTED_CAMERA_FEATURES[] = "qc-camera-features";
253const char QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES[] = "qc-max-num-requested-faces";
254
255//Values for DENOISE
256const char QCameraParameters::DENOISE_OFF[] = "denoise-off";
257const char QCameraParameters::DENOISE_ON[] = "denoise-on";
258
259// Values for selectable zone af Settings
260const char QCameraParameters::FOCUS_ALGO_AUTO[] = "auto";
261const char QCameraParameters::FOCUS_ALGO_SPOT_METERING[] = "spot-metering";
262const char QCameraParameters::FOCUS_ALGO_CENTER_WEIGHTED[] = "center-weighted";
263const char QCameraParameters::FOCUS_ALGO_FRAME_AVERAGE[] = "frame-average";
264
265// Values for HFR settings.
266const char QCameraParameters::VIDEO_HFR_OFF[] = "off";
267const char QCameraParameters::VIDEO_HFR_2X[] = "60";
268const char QCameraParameters::VIDEO_HFR_3X[] = "90";
269const char QCameraParameters::VIDEO_HFR_4X[] = "120";
270const char QCameraParameters::VIDEO_HFR_5X[] = "150";
271
272// Values for HDR Bracketing settings.
273const char QCameraParameters::AE_BRACKET_OFF[] = "Off";
274const char QCameraParameters::AE_BRACKET[] = "AE-Bracket";
275
276// Values for FLIP settings.
277const char QCameraParameters::FLIP_MODE_OFF[] = "off";
278const char QCameraParameters::FLIP_MODE_V[] = "flip-v";
279const char QCameraParameters::FLIP_MODE_H[] = "flip-h";
280const char QCameraParameters::FLIP_MODE_VH[] = "flip-vh";
281
282static const char* portrait = "portrait";
283static const char* landscape = "landscape";
284
285const cam_dimension_t QCameraParameters::THUMBNAIL_SIZES_MAP[] = {
286    { 512, 288 }, //1.777778
287    { 480, 288 }, //1.666667
288    { 256, 154 }, //1.66233
289    { 432, 288 }, //1.5
290    { 320, 240 }, //1.33333
291    { 176, 144 }, //1.222222
292    { 0, 0 }      // required by Android SDK
293};
294
295const QCameraParameters::QCameraMap QCameraParameters::AUTO_EXPOSURE_MAP[] = {
296    { AUTO_EXPOSURE_FRAME_AVG,           CAM_AEC_MODE_FRAME_AVERAGE },
297    { AUTO_EXPOSURE_CENTER_WEIGHTED,     CAM_AEC_MODE_CENTER_WEIGHTED },
298    { AUTO_EXPOSURE_SPOT_METERING,       CAM_AEC_MODE_SPOT_METERING },
299    { AUTO_EXPOSURE_SMART_METERING,      CAM_AEC_MODE_SMART_METERING },
300    { AUTO_EXPOSURE_USER_METERING,       CAM_AEC_MODE_USER_METERING },
301    { AUTO_EXPOSURE_SPOT_METERING_ADV,   CAM_AEC_MODE_SPOT_METERING_ADV },
302    { AUTO_EXPOSURE_CENTER_WEIGHTED_ADV, CAM_AEC_MODE_CENTER_WEIGHTED_ADV },
303};
304
305const QCameraParameters::QCameraMap QCameraParameters::PREVIEW_FORMATS_MAP[] = {
306    {PIXEL_FORMAT_YUV420SP,        CAM_FORMAT_YUV_420_NV21},
307    {PIXEL_FORMAT_YUV420P,         CAM_FORMAT_YUV_420_YV12},
308    {PIXEL_FORMAT_YUV420SP_ADRENO, CAM_FORMAT_YUV_420_NV21_ADRENO},
309    {PIXEL_FORMAT_YV12,            CAM_FORMAT_YUV_420_YV12},
310    {PIXEL_FORMAT_NV12,            CAM_FORMAT_YUV_420_NV12}
311};
312
313const QCameraParameters::QCameraMap QCameraParameters::PICTURE_TYPES_MAP[] = {
314    {PIXEL_FORMAT_JPEG,                          CAM_FORMAT_JPEG},
315    {QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV,          CAM_FORMAT_YUV_RAW_8BIT_YUYV},
316    {QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU,          CAM_FORMAT_YUV_RAW_8BIT_YVYU},
317    {QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY,          CAM_FORMAT_YUV_RAW_8BIT_UYVY},
318    {QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY,          CAM_FORMAT_YUV_RAW_8BIT_VYUY},
319    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GBRG},
320    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GRBG},
321    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_RGGB},
322    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_BGGR},
323    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GBRG},
324    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GRBG},
325    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_RGGB},
326    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_BGGR},
327    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GBRG},
328    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GRBG},
329    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_RGGB},
330    {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_BGGR},
331    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GBRG},
332    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GRBG},
333    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_RGGB},
334    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_BGGR},
335    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG},
336    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GRBG},
337    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_RGGB},
338    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_BGGR},
339    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GBRG},
340    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GRBG},
341    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_RGGB},
342    {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_BGGR},
343    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GBRG},
344    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GRBG},
345    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_RGGB},
346    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_BGGR},
347    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GBRG},
348    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GRBG},
349    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_RGGB},
350    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_BGGR},
351    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GBRG},
352    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GRBG},
353    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_RGGB},
354    {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_BGGR},
355    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GBRG},
356    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GRBG},
357    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_RGGB},
358    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_BGGR},
359    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GBRG},
360    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GRBG},
361    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_RGGB},
362    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_BGGR},
363    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GBRG},
364    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GRBG},
365    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_RGGB},
366    {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_BGGR},
367    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GBRG},
368    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GRBG},
369    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_RGGB},
370    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_BGGR},
371    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GBRG},
372    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GRBG},
373    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_RGGB},
374    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_BGGR},
375    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GBRG},
376    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GRBG},
377    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_RGGB},
378    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_BGGR},
379    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GBRG},
380    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GRBG},
381    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_RGGB},
382    {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_BGGR}
383};
384
385const QCameraParameters::QCameraMap QCameraParameters::RAW_FORMATS_MAP[] = {
386};
387
388const QCameraParameters::QCameraMap QCameraParameters::FOCUS_MODES_MAP[] = {
389    { FOCUS_MODE_AUTO,               CAM_FOCUS_MODE_AUTO },
390    { FOCUS_MODE_INFINITY,           CAM_FOCUS_MODE_INFINITY },
391    { FOCUS_MODE_MACRO,              CAM_FOCUS_MODE_MACRO },
392    { FOCUS_MODE_FIXED,              CAM_FOCUS_MODE_FIXED },
393    { FOCUS_MODE_EDOF,               CAM_FOCUS_MODE_EDOF },
394    { FOCUS_MODE_CONTINUOUS_PICTURE, CAM_FOCUS_MODE_CONTINOUS_PICTURE },
395    { FOCUS_MODE_CONTINUOUS_VIDEO,   CAM_FOCUS_MODE_CONTINOUS_VIDEO }
396};
397
398const QCameraParameters::QCameraMap QCameraParameters::EFFECT_MODES_MAP[] = {
399    { EFFECT_NONE,       CAM_EFFECT_MODE_OFF },
400    { EFFECT_MONO,       CAM_EFFECT_MODE_MONO },
401    { EFFECT_NEGATIVE,   CAM_EFFECT_MODE_NEGATIVE },
402    { EFFECT_SOLARIZE,   CAM_EFFECT_MODE_SOLARIZE },
403    { EFFECT_SEPIA,      CAM_EFFECT_MODE_SEPIA },
404    { EFFECT_POSTERIZE,  CAM_EFFECT_MODE_POSTERIZE },
405    { EFFECT_WHITEBOARD, CAM_EFFECT_MODE_WHITEBOARD },
406    { EFFECT_BLACKBOARD, CAM_EFFECT_MODE_BLACKBOARD },
407    { EFFECT_AQUA,       CAM_EFFECT_MODE_AQUA },
408    { EFFECT_EMBOSS,     CAM_EFFECT_MODE_EMBOSS },
409    { EFFECT_SKETCH,     CAM_EFFECT_MODE_SKETCH },
410    { EFFECT_NEON,       CAM_EFFECT_MODE_NEON }
411};
412
413const QCameraParameters::QCameraMap QCameraParameters::SCENE_MODES_MAP[] = {
414    { SCENE_MODE_AUTO,           CAM_SCENE_MODE_OFF },
415    { SCENE_MODE_ACTION,         CAM_SCENE_MODE_ACTION },
416    { SCENE_MODE_PORTRAIT,       CAM_SCENE_MODE_PORTRAIT },
417    { SCENE_MODE_LANDSCAPE,      CAM_SCENE_MODE_LANDSCAPE },
418    { SCENE_MODE_NIGHT,          CAM_SCENE_MODE_NIGHT },
419    { SCENE_MODE_NIGHT_PORTRAIT, CAM_SCENE_MODE_NIGHT_PORTRAIT },
420    { SCENE_MODE_THEATRE,        CAM_SCENE_MODE_THEATRE },
421    { SCENE_MODE_BEACH,          CAM_SCENE_MODE_BEACH },
422    { SCENE_MODE_SNOW,           CAM_SCENE_MODE_SNOW },
423    { SCENE_MODE_SUNSET,         CAM_SCENE_MODE_SUNSET },
424    { SCENE_MODE_STEADYPHOTO,    CAM_SCENE_MODE_ANTISHAKE },
425    { SCENE_MODE_FIREWORKS ,     CAM_SCENE_MODE_FIREWORKS },
426    { SCENE_MODE_SPORTS ,        CAM_SCENE_MODE_SPORTS },
427    { SCENE_MODE_PARTY,          CAM_SCENE_MODE_PARTY },
428    { SCENE_MODE_CANDLELIGHT,    CAM_SCENE_MODE_CANDLELIGHT },
429    { SCENE_MODE_ASD,            CAM_SCENE_MODE_AUTO },
430    { SCENE_MODE_BACKLIGHT,      CAM_SCENE_MODE_BACKLIGHT },
431    { SCENE_MODE_FLOWERS,        CAM_SCENE_MODE_FLOWERS },
432    { SCENE_MODE_AR,             CAM_SCENE_MODE_AR },
433    { SCENE_MODE_HDR,            CAM_SCENE_MODE_OFF },
434};
435
436const QCameraParameters::QCameraMap QCameraParameters::FLASH_MODES_MAP[] = {
437    { FLASH_MODE_OFF,   CAM_FLASH_MODE_OFF },
438    { FLASH_MODE_AUTO,  CAM_FLASH_MODE_AUTO },
439    { FLASH_MODE_ON,    CAM_FLASH_MODE_ON },
440    { FLASH_MODE_TORCH, CAM_FLASH_MODE_TORCH }
441};
442
443const QCameraParameters::QCameraMap QCameraParameters::FOCUS_ALGO_MAP[] = {
444    { FOCUS_ALGO_AUTO,            CAM_FOCUS_ALGO_AUTO },
445    { FOCUS_ALGO_SPOT_METERING,   CAM_FOCUS_ALGO_SPOT },
446    { FOCUS_ALGO_CENTER_WEIGHTED, CAM_FOCUS_ALGO_CENTER_WEIGHTED },
447    { FOCUS_ALGO_FRAME_AVERAGE,   CAM_FOCUS_ALGO_AVERAGE }
448};
449
450const QCameraParameters::QCameraMap QCameraParameters::WHITE_BALANCE_MODES_MAP[] = {
451    { WHITE_BALANCE_AUTO,            CAM_WB_MODE_AUTO },
452    { WHITE_BALANCE_INCANDESCENT,    CAM_WB_MODE_INCANDESCENT },
453    { WHITE_BALANCE_FLUORESCENT,     CAM_WB_MODE_FLUORESCENT },
454    { WHITE_BALANCE_WARM_FLUORESCENT,CAM_WB_MODE_WARM_FLUORESCENT},
455    { WHITE_BALANCE_DAYLIGHT,        CAM_WB_MODE_DAYLIGHT },
456    { WHITE_BALANCE_CLOUDY_DAYLIGHT, CAM_WB_MODE_CLOUDY_DAYLIGHT },
457    { WHITE_BALANCE_TWILIGHT,        CAM_WB_MODE_TWILIGHT },
458    { WHITE_BALANCE_SHADE,           CAM_WB_MODE_SHADE }
459};
460
461const QCameraParameters::QCameraMap QCameraParameters::ANTIBANDING_MODES_MAP[] = {
462    { ANTIBANDING_OFF,  CAM_ANTIBANDING_MODE_OFF },
463    { ANTIBANDING_50HZ, CAM_ANTIBANDING_MODE_50HZ },
464    { ANTIBANDING_60HZ, CAM_ANTIBANDING_MODE_60HZ },
465    { ANTIBANDING_AUTO, CAM_ANTIBANDING_MODE_AUTO }
466};
467
468const QCameraParameters::QCameraMap QCameraParameters::ISO_MODES_MAP[] = {
469    { ISO_AUTO,  CAM_ISO_MODE_AUTO },
470    { ISO_HJR,   CAM_ISO_MODE_DEBLUR },
471    { ISO_100,   CAM_ISO_MODE_100 },
472    { ISO_200,   CAM_ISO_MODE_200 },
473    { ISO_400,   CAM_ISO_MODE_400 },
474    { ISO_800,   CAM_ISO_MODE_800 },
475    { ISO_1600,  CAM_ISO_MODE_1600 }
476};
477
478const QCameraParameters::QCameraMap QCameraParameters::HFR_MODES_MAP[] = {
479    { VIDEO_HFR_OFF, CAM_HFR_MODE_OFF },
480    { VIDEO_HFR_2X,  CAM_HFR_MODE_60FPS },
481    { VIDEO_HFR_3X,  CAM_HFR_MODE_90FPS },
482    { VIDEO_HFR_4X,  CAM_HFR_MODE_120FPS },
483    { VIDEO_HFR_5X,  CAM_HFR_MODE_150FPS }
484};
485
486const QCameraParameters::QCameraMap QCameraParameters::BRACKETING_MODES_MAP[] = {
487    { AE_BRACKET_OFF, CAM_EXP_BRACKETING_OFF },
488    { AE_BRACKET,         CAM_EXP_BRACKETING_ON }
489};
490
491const QCameraParameters::QCameraMap QCameraParameters::ON_OFF_MODES_MAP[] = {
492    { VALUE_OFF, 0 },
493    { VALUE_ON,  1 }
494};
495
496const QCameraParameters::QCameraMap QCameraParameters::TOUCH_AF_AEC_MODES_MAP[] = {
497    { QCameraParameters::TOUCH_AF_AEC_OFF, 0 },
498    { QCameraParameters::TOUCH_AF_AEC_ON, 1 }
499};
500
501const QCameraParameters::QCameraMap QCameraParameters::ENABLE_DISABLE_MODES_MAP[] = {
502    { VALUE_ENABLE,  1 },
503    { VALUE_DISABLE, 0 }
504};
505
506const QCameraParameters::QCameraMap QCameraParameters::DENOISE_ON_OFF_MODES_MAP[] = {
507    { DENOISE_OFF, 0 },
508    { DENOISE_ON,  1 }
509};
510
511const QCameraParameters::QCameraMap QCameraParameters::TRUE_FALSE_MODES_MAP[] = {
512    { VALUE_FALSE, 0},
513    { VALUE_TRUE,  1}
514};
515
516const QCameraParameters::QCameraMap QCameraParameters::FLIP_MODES_MAP[] = {
517    {FLIP_MODE_OFF, 0},
518    {FLIP_MODE_V, FLIP_V},
519    {FLIP_MODE_H, FLIP_H},
520    {FLIP_MODE_VH, FLIP_V_H}
521};
522
523#define DEFAULT_CAMERA_AREA "(0, 0, 0, 0, 0)"
524#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
525
526/*===========================================================================
527 * FUNCTION   : QCameraParameters
528 *
529 * DESCRIPTION: default constructor of QCameraParameters
530 *
531 * PARAMETERS : none
532 *
533 * RETURN     : None
534 *==========================================================================*/
535QCameraParameters::QCameraParameters()
536    : CameraParameters(),
537      m_pCapability(NULL),
538      m_pCamOpsTbl(NULL),
539      m_pParamHeap(NULL),
540      m_pParamBuf(NULL),
541      m_bZslMode(false),
542      m_bRecordingHint(false),
543      m_bHistogramEnabled(false),
544      m_nFaceProcMask(0),
545      m_bDebugFps(false),
546      mFocusMode(CAM_FOCUS_MODE_MAX),
547      mPreviewFormat(CAM_FORMAT_YUV_420_NV21),
548      mPictureFormat(CAM_FORMAT_JPEG),
549      m_bNeedRestart(false),
550      m_bNoDisplayMode(false),
551      m_bWNROn(false),
552      m_bNeedLockCAF(false),
553      m_bCAFLocked(false),
554      m_bAFRunning(false),
555      m_tempMap()
556{
557    char value[32];
558    // TODO: may move to parameter instead of sysprop
559    property_get("persist.debug.sf.showfps", value, "0");
560    m_bDebugFps = atoi(value) > 0 ? true : false;
561
562    // For thermal mode, it should be set as system property
563    // because system property applies to all applications, while
564    // parameters only apply to specific app.
565    property_get("persist.camera.thermal.mode", value, "fps");
566    if (!strcmp(value, "frameskip")) {
567        m_ThermalMode = QCAMERA_THERMAL_ADJUST_FRAMESKIP;
568    } else {
569        if (strcmp(value, "fps"))
570            ALOGE("%s: Invalid camera thermal mode %s", __func__, value);
571        m_ThermalMode = QCAMERA_THERMAL_ADJUST_FPS;
572    }
573
574    memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize));
575}
576
577/*===========================================================================
578 * FUNCTION   : QCameraParameters
579 *
580 * DESCRIPTION: constructor of QCameraParameters
581 *
582 * PARAMETERS :
583 *   @params  : parameters in string
584 *
585 * RETURN     : None
586 *==========================================================================*/
587QCameraParameters::QCameraParameters(const String8 &params)
588    : CameraParameters(params),
589    m_pCapability(NULL),
590    m_pCamOpsTbl(NULL),
591    m_pParamHeap(NULL),
592    m_pParamBuf(NULL),
593    m_bZslMode(false),
594    m_bRecordingHint(false),
595    m_bHistogramEnabled(false),
596    m_nFaceProcMask(0),
597    m_bDebugFps(false),
598    mFocusMode(CAM_FOCUS_MODE_MAX),
599    mPreviewFormat(CAM_FORMAT_YUV_420_NV21),
600    mPictureFormat(CAM_FORMAT_JPEG),
601    m_bNeedRestart(false),
602    m_bNoDisplayMode(false),
603    m_bWNROn(false),
604    m_bNeedLockCAF(false),
605    m_bCAFLocked(false),
606    m_bAFRunning(false),
607    m_tempMap()
608{
609    memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize));
610}
611
612/*===========================================================================
613 * FUNCTION   : ~QCameraParameters
614 *
615 * DESCRIPTION: deconstructor of QCameraParameters
616 *
617 * PARAMETERS : none
618 *
619 * RETURN     : None
620 *==========================================================================*/
621QCameraParameters::~QCameraParameters()
622{
623    deinit();
624}
625
626/*===========================================================================
627 * FUNCTION   : createSizesString
628 *
629 * DESCRIPTION: create string obj contains array of dimensions
630 *
631 * PARAMETERS :
632 *   @sizes   : array of dimensions
633 *   @len     : size of dimension array
634 *
635 * RETURN     : string obj
636 *==========================================================================*/
637String8 QCameraParameters::createSizesString(const cam_dimension_t *sizes, int len)
638{
639    String8 str;
640    char buffer[32];
641
642    if (len > 0) {
643        snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height);
644        str.append(buffer);
645    }
646    for (int i = 1; i < len; i++) {
647        snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height);
648        str.append(buffer);
649    }
650    return str;
651}
652
653/*===========================================================================
654 * FUNCTION   : createValuesString
655 *
656 * DESCRIPTION: create string obj contains array of values from map when matched
657 *              from input values array
658 *
659 * PARAMETERS :
660 *   @values  : array of values
661 *   @len     : size of values array
662 *   @map     : map contains the mapping between values and enums
663 *   @map_len : size of the map
664 *
665 * RETURN     : string obj
666 *==========================================================================*/
667String8 QCameraParameters::createValuesString(const int *values,
668                                              int len,
669                                              const QCameraMap* map,
670                                              int map_len)
671{
672    String8 str;
673    int count = 0;
674
675    for (int i = 0; i < len; i++ ) {
676        for (int j = 0; j < map_len; j ++)
677            if (map[j].val == values[i]) {
678                if (NULL != map[j].desc) {
679                    if (count > 0) {
680                        str.append(",");
681                    }
682                    str.append(map[j].desc);
683                    count++;
684                    break; //loop j
685                }
686            }
687    }
688    return str;
689}
690
691/*===========================================================================
692 * FUNCTION   : createValuesStringFromMap
693 *
694 * DESCRIPTION: create string obj contains array of values directly from map
695 *
696 * PARAMETERS :
697 *   @map     : map contains the mapping between values and enums
698 *   @map_len : size of the map
699 *
700 * RETURN     : string obj
701 *==========================================================================*/
702String8 QCameraParameters::createValuesStringFromMap(const QCameraMap* map,
703                                                     int map_len)
704{
705    String8 str;
706
707    for (int i = 0; i < map_len; i++) {
708        if (NULL != map[i].desc) {
709            if (i > 0) {
710                str.append(",");
711            }
712            str.append(map[i].desc);
713        }
714    }
715    return str;
716}
717
718/*===========================================================================
719 * FUNCTION   : createZoomRatioValuesString
720 *
721 * DESCRIPTION: create string obj contains array of zoom ratio values
722 *
723 * PARAMETERS :
724 *   @zoomRaios  : array of zoom ratios
725 *   @length     : size of the array
726 *
727 * RETURN     : string obj
728 *==========================================================================*/
729String8 QCameraParameters::createZoomRatioValuesString(int *zoomRatios, int length)
730{
731    String8 str;
732    char buffer[32] = {0};
733
734    if(length > 0){
735        snprintf(buffer, sizeof(buffer), "%d", zoomRatios[0]);
736        str.append(buffer);
737    }
738
739    for (int i =1;i<length;i++){
740        memset(buffer, 0, sizeof(buffer));
741        snprintf(buffer, sizeof(buffer), ",%d", zoomRatios[i]);
742        str.append(buffer);
743    }
744    return str;
745}
746
747/*===========================================================================
748 * FUNCTION   : createHfrValuesString
749 *
750 * DESCRIPTION: create string obj contains array of hfr values from map when
751 *              matched from input hfr values
752 *
753 * PARAMETERS :
754 *   @values  : array of hfr info
755 *   @len     : size of the array
756 *   @map     : map of hfr string value and enum
757 *   map_len  : size of map
758 *
759 * RETURN     : string obj
760 *==========================================================================*/
761String8 QCameraParameters::createHfrValuesString(
762                                const cam_hfr_info_t *values,
763                                int len,
764                                const QCameraMap* map,
765                                int map_len)
766{
767    String8 str;
768    int count = 0;
769
770    for (int i = 0; i < len; i++ ) {
771        for (int j = 0; j < map_len; j ++)
772            if (map[j].val == (int)values[i].mode) {
773                if (NULL != map[j].desc) {
774                    if (count > 0) {
775                        str.append(",");
776                    }
777                     str.append(map[j].desc);
778                     count++;
779                     break; //loop j
780                }
781            }
782    }
783    return str;
784}
785
786/*===========================================================================
787 * FUNCTION   : createHfrSizesString
788 *
789 * DESCRIPTION: create string obj contains array of hfr sizes
790 *
791 * PARAMETERS :
792 *   @values  : array of hfr info
793 *   @len     : size of the array
794 *
795 * RETURN     : string obj
796 *==========================================================================*/
797String8 QCameraParameters::createHfrSizesString(
798                                const cam_hfr_info_t *values,
799                                int len)
800{
801    String8 str;
802    char buffer[32];
803
804    if (len > 0) {
805        snprintf(buffer, sizeof(buffer), "%dx%d",
806                 values[0].dim.width, values[0].dim.height);
807        str.append(buffer);
808    }
809    for (int i = 1; i < len; i++) {
810        snprintf(buffer, sizeof(buffer), ",%dx%d",
811                 values[i].dim.width, values[i].dim.height);
812        str.append(buffer);
813    }
814    return str;
815}
816
817/*===========================================================================
818 * FUNCTION   : createFpsString
819 *
820 * DESCRIPTION: create string obj contains array of FPS rates
821 *
822 * PARAMETERS :
823 *   @fps     : array of fps ranges
824 *   @len     : size of the array
825 *
826 * RETURN     : string obj
827 *==========================================================================*/
828String8 QCameraParameters::createFpsString(const cam_fps_range_t *fps, int len)
829{
830    String8 str;
831    char buffer[32];
832
833    for (int i = 0; i < len; i++ ) {
834        snprintf(buffer, sizeof(buffer), "%d", int(fps[i].max_fps * 1000));
835        str.append(buffer);
836        if (i < len-1)
837            str.append(",");
838    }
839    return str;
840}
841
842/*===========================================================================
843 * FUNCTION   : createFpsRangeString
844 *
845 * DESCRIPTION: create string obj contains array of FPS ranges
846 *
847 * PARAMETERS :
848 *   @fps     : array of fps ranges
849 *   @len     : size of the array
850 *   @default_fps_index : reference to index of default fps range
851 *
852 * RETURN     : string obj
853 *==========================================================================*/
854String8 QCameraParameters::createFpsRangeString(const cam_fps_range_t* fps,
855                                                int len,
856                                                int &default_fps_index)
857{
858    String8 str;
859    char buffer[32];
860    int max_range = 0;
861    int min_fps, max_fps;
862
863    if (len > 0) {
864        min_fps = int(fps[0].min_fps * 1000);
865        max_fps = int(fps[0].max_fps * 1000);
866        max_range = max_fps - min_fps;
867        default_fps_index = 0;
868        snprintf(buffer, sizeof(buffer), "(%d,%d)", min_fps, max_fps);
869        str.append(buffer);
870    }
871    for (int i = 1; i < len; i++) {
872        min_fps = int(fps[i].min_fps * 1000);
873        max_fps = int(fps[i].max_fps * 1000);
874        if (max_range < (max_fps - min_fps)) {
875            max_range = max_fps - min_fps;
876            default_fps_index = i;
877        }
878        snprintf(buffer, sizeof(buffer), ",(%d,%d)", min_fps, max_fps);
879        str.append(buffer);
880    }
881    return str;
882}
883
884/*===========================================================================
885 * FUNCTION   : lookupAttr
886 *
887 * DESCRIPTION: lookup a value by its name
888 *
889 * PARAMETERS :
890 *   @attr    : map contains <name, value>
891 *   @len     : size of the map
892 *   @name    : name to be looked up
893 *
894 * RETURN     : valid value if found
895 *              NAME_NOT_FOUND if not found
896 *==========================================================================*/
897int QCameraParameters::lookupAttr(const QCameraMap arr[], int len, const char *name)
898{
899    if (name) {
900        for (int i = 0; i < len; i++) {
901            if (!strcmp(arr[i].desc, name))
902                return arr[i].val;
903        }
904    }
905    return NAME_NOT_FOUND;
906}
907
908/*===========================================================================
909 * FUNCTION   : lookupNameByValue
910 *
911 * DESCRIPTION: lookup a name by its value
912 *
913 * PARAMETERS :
914 *   @attr    : map contains <name, value>
915 *   @len     : size of the map
916 *   @value   : value to be looked up
917 *
918 * RETURN     : name str or NULL if not found
919 *==========================================================================*/
920const char *QCameraParameters::lookupNameByValue(const QCameraMap arr[], int len, int value)
921{
922    for (int i = 0; i < len; i++) {
923        if (arr[i].val == value) {
924            return arr[i].desc;
925        }
926    }
927    return NULL;
928}
929
930/*===========================================================================
931 * FUNCTION   : setPreviewSize
932 *
933 * DESCRIPTION: set preview size from user setting
934 *
935 * PARAMETERS :
936 *   @params  : user setting parameters
937 *
938 * RETURN     : int32_t type of status
939 *              NO_ERROR  -- success
940 *              none-zero failure code
941 *==========================================================================*/
942int32_t QCameraParameters::setPreviewSize(const QCameraParameters& params)
943{
944    int width, height;
945    params.getPreviewSize(&width, &height);
946    ALOGV("Requested preview size %d x %d", width, height);
947
948    // Validate the preview size
949    for (size_t i = 0; i < m_pCapability->preview_sizes_tbl_cnt; ++i) {
950        if (width ==  m_pCapability->preview_sizes_tbl[i].width
951           && height ==  m_pCapability->preview_sizes_tbl[i].height) {
952            // check if need to restart preview in case of preview size change
953            int old_width, old_height;
954            CameraParameters::getPreviewSize(&old_width, &old_height);
955            if (width != old_width || height != old_height) {
956                m_bNeedRestart = true;
957            }
958
959            // set the new value
960            char val[32];
961            sprintf(val, "%dx%d", width, height);
962            updateParamEntry(KEY_PREVIEW_SIZE, val);
963            ALOGV("%s: %s", __func__, val);
964            return NO_ERROR;
965        }
966    }
967    ALOGE("Invalid preview size requested: %dx%d", width, height);
968    return BAD_VALUE;
969}
970
971/*===========================================================================
972 * FUNCTION   : setPictureSize
973 *
974 * DESCRIPTION: set picture size from user setting
975 *
976 * PARAMETERS :
977 *   @params  : user setting parameters
978 *
979 * RETURN     : int32_t type of status
980 *              NO_ERROR  -- success
981 *              none-zero failure code
982 *==========================================================================*/
983int32_t QCameraParameters::setPictureSize(const QCameraParameters& params)
984{
985    int width, height;
986    params.getPictureSize(&width, &height);
987    ALOGV("Requested picture size %d x %d", width, height);
988
989    // Validate the picture size
990    for (size_t i = 0; i < m_pCapability->picture_sizes_tbl_cnt; ++i) {
991        if (width ==  m_pCapability->picture_sizes_tbl[i].width
992           && height ==  m_pCapability->picture_sizes_tbl[i].height) {
993            // check if need to restart preview in case of picture size change
994            int old_width, old_height;
995            CameraParameters::getPictureSize(&old_width, &old_height);
996            if ((m_bZslMode || m_bRecordingHint) &&
997                (width != old_width || height != old_height)) {
998                m_bNeedRestart = true;
999            }
1000
1001            // set the new value
1002            char val[32];
1003            sprintf(val, "%dx%d", width, height);
1004            updateParamEntry(KEY_PICTURE_SIZE, val);
1005            ALOGV("%s: %s", __func__, val);
1006            return NO_ERROR;
1007        }
1008    }
1009    ALOGE("Invalid picture size requested: %dx%d", width, height);
1010    return BAD_VALUE;
1011}
1012
1013/*===========================================================================
1014 * FUNCTION   : setVideoSize
1015 *
1016 * DESCRIPTION: set video size from user setting
1017 *
1018 * PARAMETERS :
1019 *   @params  : user setting parameters
1020 *
1021 * RETURN     : int32_t type of status
1022 *              NO_ERROR  -- success
1023 *              none-zero failure code
1024 *==========================================================================*/
1025int32_t QCameraParameters::setVideoSize(const QCameraParameters& params)
1026{
1027    const char *str= NULL;
1028    int width, height;
1029    str = params.get(KEY_VIDEO_SIZE);
1030    if(!str) {
1031        //If application didn't set this parameter string, use the values from
1032        //getPreviewSize() as video dimensions.
1033        params.getPreviewSize(&width, &height);
1034        ALOGE("No Record Size requested, use the preview dimensions");
1035    } else {
1036        params.getVideoSize(&width, &height);
1037    }
1038
1039    // Validate the video size
1040    for (size_t i = 0; i < m_pCapability->video_sizes_tbl_cnt; ++i) {
1041        if (width ==  m_pCapability->video_sizes_tbl[i].width
1042                && height ==  m_pCapability->video_sizes_tbl[i].height) {
1043            // check if need to restart preview in case of video size change
1044            int old_width, old_height;
1045            CameraParameters::getVideoSize(&old_width, &old_height);
1046            if (m_bRecordingHint &&
1047               (width != old_width || height != old_height)) {
1048                m_bNeedRestart = true;
1049            }
1050
1051            // set the new value
1052            char val[32];
1053            sprintf(val, "%dx%d", width, height);
1054            updateParamEntry(KEY_VIDEO_SIZE, val);
1055            ALOGV("%s: %s", __func__, val);
1056            return NO_ERROR;
1057        }
1058    }
1059
1060    ALOGE("Invalid video size requested: %dx%d", width, height);
1061    return BAD_VALUE;
1062}
1063
1064/*===========================================================================
1065 * FUNCTION   : setLiveSnapshotSize
1066 *
1067 * DESCRIPTION: set live snapshot size
1068 *
1069 * PARAMETERS :
1070 *   @params  : user setting parameters
1071 *
1072 * RETURN     : int32_t type of status
1073 *              NO_ERROR  -- success
1074 *              none-zero failure code
1075 *==========================================================================*/
1076int32_t QCameraParameters::setLiveSnapshotSize(const QCameraParameters& params)
1077{
1078    char value[32];
1079    property_get("persist.camera.opt.livepic", value, "1");
1080    bool useOptimal = atoi(value) > 0 ? true : false;
1081
1082    // use picture size from user setting
1083    params.getPictureSize(&m_LiveSnapshotSize.width, &m_LiveSnapshotSize.height);
1084
1085    uint8_t livesnapshot_sizes_tbl_cnt = m_pCapability->livesnapshot_sizes_tbl_cnt;
1086    cam_dimension_t *livesnapshot_sizes_tbl = &m_pCapability->livesnapshot_sizes_tbl[0];
1087
1088    // check if HFR is enabled
1089    const char *hfrStr = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE);
1090    cam_hfr_mode_t hfrMode = CAM_HFR_MODE_OFF;
1091    if (hfrStr != NULL) {
1092        int32_t value = lookupAttr(HFR_MODES_MAP,
1093                                   sizeof(HFR_MODES_MAP)/sizeof(QCameraMap),
1094                                   hfrStr);
1095        if (value != NAME_NOT_FOUND) {
1096            // if HFR is enabled, change live snapshot size
1097            if (value > CAM_HFR_MODE_OFF) {
1098                for (int i = 0; i < m_pCapability->hfr_tbl_cnt; i++) {
1099                    if (m_pCapability->hfr_tbl[i].mode == value) {
1100                        livesnapshot_sizes_tbl_cnt =
1101                            m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl_cnt;
1102                        livesnapshot_sizes_tbl =
1103                            &m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl[0];
1104                        hfrMode = m_pCapability->hfr_tbl[i].mode;
1105                        break;
1106                    }
1107                }
1108            }
1109        }
1110    }
1111
1112    if (useOptimal || hfrMode != CAM_HFR_MODE_OFF) {
1113        bool found = false;
1114
1115        // first check if picture size is within the list of supported sizes
1116        for (int i = 0; i < livesnapshot_sizes_tbl_cnt; ++i) {
1117            if (m_LiveSnapshotSize.width == livesnapshot_sizes_tbl[i].width &&
1118                m_LiveSnapshotSize.height == livesnapshot_sizes_tbl[i].height) {
1119                found = true;
1120                break;
1121            }
1122        }
1123
1124        if (!found) {
1125            // use optimal live snapshot size from supported list,
1126            // that has same preview aspect ratio
1127            int width = 0, height = 0;
1128            params.getPreviewSize(&width, &height);
1129
1130            double previewAspectRatio = (double)width / height;
1131            for (int i = 0; i < livesnapshot_sizes_tbl_cnt; ++i) {
1132                double ratio = (double)livesnapshot_sizes_tbl[i].width /
1133                                livesnapshot_sizes_tbl[i].height;
1134                if (fabs(previewAspectRatio - ratio) <= ASPECT_TOLERANCE) {
1135                    m_LiveSnapshotSize = livesnapshot_sizes_tbl[i];
1136                    found = true;
1137                    break;
1138                }
1139            }
1140
1141            if (!found && hfrMode != CAM_HFR_MODE_OFF) {
1142                // Cannot find matching aspect ration from supported live snapshot list
1143                // choose the max dim from preview and video size
1144                ALOGI("%s: Cannot find matching aspect ratio, choose max of preview or video size", __func__);
1145                params.getVideoSize(&m_LiveSnapshotSize.width, &m_LiveSnapshotSize.height);
1146                if (m_LiveSnapshotSize.width < width && m_LiveSnapshotSize.height < height) {
1147                    m_LiveSnapshotSize.width = width;
1148                    m_LiveSnapshotSize.height = height;
1149                }
1150            }
1151        }
1152    }
1153    ALOGI("%s: live snapshot size %d x %d", __func__,
1154          m_LiveSnapshotSize.width, m_LiveSnapshotSize.height);
1155
1156    return NO_ERROR;
1157}
1158
1159/*===========================================================================
1160 * FUNCTION   : setPreviewFormat
1161 *
1162 * DESCRIPTION: set preview format from user setting
1163 *
1164 * PARAMETERS :
1165 *   @params  : user setting parameters
1166 *
1167 * RETURN     : int32_t type of status
1168 *              NO_ERROR  -- success
1169 *              none-zero failure code
1170 *==========================================================================*/
1171int32_t QCameraParameters::setPreviewFormat(const QCameraParameters& params)
1172{
1173    const char *str = params.getPreviewFormat();
1174    int32_t previewFormat =
1175        lookupAttr(PREVIEW_FORMATS_MAP,
1176                   sizeof(PREVIEW_FORMATS_MAP) / sizeof(QCameraMap),
1177                   str);
1178    if (previewFormat != NAME_NOT_FOUND) {
1179        mPreviewFormat = (cam_format_t)previewFormat;
1180
1181        updateParamEntry(KEY_PREVIEW_FORMAT, str);
1182        ALOGV("%s: format %d\n", __func__, mPreviewFormat);
1183        return NO_ERROR;
1184    }
1185    ALOGE("Invalid preview format value: %s", (str == NULL) ? "NULL" : str);
1186    return BAD_VALUE;
1187}
1188
1189/*===========================================================================
1190 * FUNCTION   : setPictureFormat
1191 *
1192 * DESCRIPTION: set picture format from user setting
1193 *
1194 * PARAMETERS :
1195 *   @params  : user setting parameters
1196 *
1197 * RETURN     : int32_t type of status
1198 *              NO_ERROR  -- success
1199 *              none-zero failure code
1200 *==========================================================================*/
1201int32_t QCameraParameters::setPictureFormat(const QCameraParameters& params)
1202{
1203    const char *str = params.getPictureFormat();
1204    int32_t pictureFormat =
1205        lookupAttr(PICTURE_TYPES_MAP,
1206                   sizeof(PICTURE_TYPES_MAP) / sizeof(QCameraMap),
1207                   str);
1208    if (pictureFormat != NAME_NOT_FOUND) {
1209        mPictureFormat = pictureFormat;
1210
1211        updateParamEntry(KEY_PICTURE_FORMAT, str);
1212        ALOGE("%s: format %d\n", __func__, mPictureFormat);
1213        return NO_ERROR;
1214    }
1215    ALOGE("Invalid picture format value: %s", (str == NULL) ? "NULL" : str);
1216    return BAD_VALUE;
1217}
1218
1219/*===========================================================================
1220 * FUNCTION   : setJpegThumbnailSize
1221 *
1222 * DESCRIPTION: set jpeg thumbnail size from user setting
1223 *
1224 * PARAMETERS :
1225 *   @params  : user setting parameters
1226 *
1227 * RETURN     : int32_t type of status
1228 *              NO_ERROR  -- success
1229 *              none-zero failure code
1230 *==========================================================================*/
1231int32_t QCameraParameters::setJpegThumbnailSize(const QCameraParameters& params)
1232{
1233    int width = params.getInt(KEY_JPEG_THUMBNAIL_WIDTH);
1234    int height = params.getInt(KEY_JPEG_THUMBNAIL_HEIGHT);
1235
1236    ALOGV("requested jpeg thumbnail size %d x %d", width, height);
1237
1238    int sizes_cnt = sizeof(THUMBNAIL_SIZES_MAP) / sizeof(cam_dimension_t);
1239
1240    int pic_width = 0, pic_height = 0;
1241    params.getPictureSize(&pic_width, &pic_height);
1242    if (pic_height == 0) {
1243        ALOGE("%s: picture size is invalid (%d x %d)", __func__, pic_width, pic_height);
1244        return BAD_VALUE;
1245    }
1246    double picAspectRatio = (double)pic_width / pic_height;
1247
1248    int optimalWidth = 0, optimalHeight = 0;
1249    if (width != 0 || height != 0) {
1250        // If input jpeg thumnmail size is (0,0), meaning no thumbnail needed
1251        // hornor this setting.
1252        // Otherwise, find optimal jpeg thumbnail size that has same aspect ration
1253        // as picture size
1254
1255        // Try to find a size matches aspect ratio and has the largest width
1256        for (int i = 0; i < sizes_cnt; i++) {
1257            if (THUMBNAIL_SIZES_MAP[i].height == 0) {
1258                // No thumbnail case, just skip
1259                continue;
1260            }
1261            double ratio =
1262                (double)THUMBNAIL_SIZES_MAP[i].width / THUMBNAIL_SIZES_MAP[i].height;
1263            if (fabs(ratio - picAspectRatio) > ASPECT_TOLERANCE)  {
1264                continue;
1265            }
1266            if (THUMBNAIL_SIZES_MAP[i].width > optimalWidth) {
1267                optimalWidth = THUMBNAIL_SIZES_MAP[i].width;
1268                optimalHeight = THUMBNAIL_SIZES_MAP[i].height;
1269            }
1270        }
1271    }
1272
1273    char val[16];
1274    sprintf(val, "%d", optimalWidth);
1275    updateParamEntry(KEY_JPEG_THUMBNAIL_WIDTH, val);
1276    sprintf(val, "%d", optimalHeight);
1277    updateParamEntry(KEY_JPEG_THUMBNAIL_HEIGHT, val);
1278    return NO_ERROR;
1279}
1280
1281/*===========================================================================
1282 * FUNCTION   : setJpegQuality
1283 *
1284 * DESCRIPTION: set jpeg encpding quality from user setting
1285 *
1286 * PARAMETERS :
1287 *   @params  : user setting parameters
1288 *
1289 * RETURN     : int32_t type of status
1290 *              NO_ERROR  -- success
1291 *              none-zero failure code
1292 *==========================================================================*/
1293int32_t QCameraParameters::setJpegQuality(const QCameraParameters& params)
1294{
1295    int32_t rc = NO_ERROR;
1296    int quality = params.getInt(KEY_JPEG_QUALITY);
1297    if (quality >= 0 && quality <= 100) {
1298        set(KEY_JPEG_QUALITY, quality);
1299    } else {
1300        ALOGE("%s: Invalid jpeg quality=%d", __func__, quality);
1301        rc = BAD_VALUE;
1302    }
1303
1304    quality = params.getInt(KEY_JPEG_THUMBNAIL_QUALITY);
1305    if (quality >= 0 && quality <= 100) {
1306        char val[16];
1307        sprintf(val, "%d", quality);
1308        updateParamEntry(KEY_JPEG_THUMBNAIL_QUALITY, val);
1309    } else {
1310        ALOGE("%s: Invalid jpeg thumbnail quality=%d", __func__, quality);
1311        rc = BAD_VALUE;
1312    }
1313    return rc;
1314}
1315
1316/*===========================================================================
1317 * FUNCTION   : setOrientaion
1318 *
1319 * DESCRIPTION: set orientaion from user setting
1320 *
1321 * PARAMETERS :
1322 *   @params  : user setting parameters
1323 *
1324 * RETURN     : int32_t type of status
1325 *              NO_ERROR  -- success
1326 *              none-zero failure code
1327 *==========================================================================*/
1328int32_t QCameraParameters::setOrientation(const QCameraParameters& params)
1329{
1330    const char *str = params.get(KEY_QC_ORIENTATION);
1331
1332    if (str != NULL) {
1333        if (strcmp(str, portrait) == 0 || strcmp(str, landscape) == 0) {
1334            // Camera service needs this to decide if the preview frames and raw
1335            // pictures should be rotated.
1336            updateParamEntry(KEY_QC_ORIENTATION, str);
1337        } else {
1338            ALOGE("%s: Invalid orientation value: %s", __func__, str);
1339            return BAD_VALUE;
1340        }
1341    }
1342    return NO_ERROR;
1343}
1344
1345/*===========================================================================
1346 * FUNCTION   : setAutoExposure
1347 *
1348 * DESCRIPTION: set auto exposure value from user setting
1349 *
1350 * PARAMETERS :
1351 *   @params  : user setting parameters
1352 *
1353 * RETURN     : int32_t type of status
1354 *              NO_ERROR  -- success
1355 *              none-zero failure code
1356 *==========================================================================*/
1357int32_t QCameraParameters::setAutoExposure(const QCameraParameters& params)
1358{
1359    const char *str = params.get(KEY_QC_AUTO_EXPOSURE);
1360    const char *prev_str = get(KEY_QC_AUTO_EXPOSURE);
1361    if (str != NULL) {
1362        if (prev_str == NULL ||
1363            strcmp(str, prev_str) != 0) {
1364            return setAutoExposure(str);
1365        }
1366    }
1367    return NO_ERROR;
1368}
1369
1370/*===========================================================================
1371 * FUNCTION   : setPreviewFpsRange
1372 *
1373 * DESCRIPTION: set preview FPS range from user setting
1374 *
1375 * PARAMETERS :
1376 *   @params  : user setting parameters
1377 *
1378 * RETURN     : int32_t type of status
1379 *              NO_ERROR  -- success
1380 *              none-zero failure code
1381 *==========================================================================*/
1382int32_t QCameraParameters::setPreviewFpsRange(const QCameraParameters& params)
1383{
1384    int minFps,maxFps;
1385    int prevMinFps, prevMaxFps;
1386    int rc = NO_ERROR;
1387    bool found = false;
1388
1389    CameraParameters::getPreviewFpsRange(&prevMinFps, &prevMaxFps);
1390    ALOGV("%s: Existing FpsRange Values:(%d, %d)", __func__, prevMinFps, prevMaxFps);
1391    params.getPreviewFpsRange(&minFps, &maxFps);
1392    ALOGV("%s: Requested FpsRange Values:(%d, %d)", __func__, minFps, maxFps);
1393
1394    if(minFps == prevMinFps && maxFps == prevMaxFps) {
1395        ALOGV("%s: No change in FpsRange", __func__);
1396        rc = NO_ERROR;
1397        goto end;
1398    }
1399    for(int i = 0; i < m_pCapability->fps_ranges_tbl_cnt; i++) {
1400        // if the value is in the supported list
1401        if(minFps >= m_pCapability->fps_ranges_tbl[i].min_fps * 1000 &&
1402           maxFps <= m_pCapability->fps_ranges_tbl[i].max_fps * 1000) {
1403            found = true;
1404            ALOGV("%s: FPS i=%d : minFps = %d, maxFps = %d ", __func__, i, minFps, maxFps);
1405            setPreviewFpsRange(minFps, maxFps);
1406            break;
1407        }
1408    }
1409    if(found == false){
1410        ALOGE("%s: error: FPS range value not supported", __func__);
1411        rc = BAD_VALUE;
1412    }
1413end:
1414    return rc;
1415}
1416
1417/*===========================================================================
1418 * FUNCTION   : setPreviewFrameRate
1419 *
1420 * DESCRIPTION: set preview frame rate from user setting
1421 *
1422 * PARAMETERS :
1423 *   @params  : user setting parameters
1424 *
1425 * RETURN     : int32_t type of status
1426 *              NO_ERROR  -- success
1427 *              none-zero failure code
1428 *==========================================================================*/
1429int32_t QCameraParameters::setPreviewFrameRate(const QCameraParameters& params)
1430{
1431    uint16_t fps = (uint16_t)params.getPreviewFrameRate();
1432    ALOGV("%s: requested preview frame rate is %d", __func__, fps);
1433    CameraParameters::setPreviewFrameRate(fps);
1434    return NO_ERROR;
1435}
1436
1437/*===========================================================================
1438 * FUNCTION   : setEffect
1439 *
1440 * DESCRIPTION: set effect value from user setting
1441 *
1442 * PARAMETERS :
1443 *   @params  : user setting parameters
1444 *
1445 * RETURN     : int32_t type of status
1446 *              NO_ERROR  -- success
1447 *              none-zero failure code
1448 *==========================================================================*/
1449int32_t QCameraParameters::setEffect(const QCameraParameters& params)
1450{
1451    const char *str = params.get(KEY_EFFECT);
1452    const char *prev_str = get(KEY_EFFECT);
1453    if (str != NULL) {
1454        if (prev_str == NULL ||
1455            strcmp(str, prev_str) != 0) {
1456            return setEffect(str);
1457        }
1458    }
1459    return NO_ERROR;
1460}
1461
1462/*===========================================================================
1463 * FUNCTION   : setFocusMode
1464 *
1465 * DESCRIPTION: set focus mode from user setting
1466 *
1467 * PARAMETERS :
1468 *   @params  : user setting parameters
1469 *
1470 * RETURN     : int32_t type of status
1471 *              NO_ERROR  -- success
1472 *              none-zero failure code
1473 *==========================================================================*/
1474int32_t QCameraParameters::setFocusMode(const QCameraParameters& params)
1475{
1476    const char *str = params.get(KEY_FOCUS_MODE);
1477    const char *prev_str = get(KEY_FOCUS_MODE);
1478    if (str != NULL) {
1479        if (prev_str == NULL ||
1480            strcmp(str, prev_str) != 0) {
1481            return setFocusMode(str);
1482        }
1483    }
1484    return NO_ERROR;
1485}
1486
1487/*===========================================================================
1488 * FUNCTION   : setBrightness
1489 *
1490 * DESCRIPTION: set brightness control value from user setting
1491 *
1492 * PARAMETERS :
1493 *   @params  : user setting parameters
1494 *
1495 * RETURN     : int32_t type of status
1496 *              NO_ERROR  -- success
1497 *              none-zero failure code
1498 *==========================================================================*/
1499int32_t QCameraParameters::setBrightness(const QCameraParameters& params)
1500{
1501    int currentBrightness = getInt(KEY_QC_BRIGHTNESS);
1502    int brightness = params.getInt(KEY_QC_BRIGHTNESS);
1503    if (currentBrightness !=  brightness) {
1504        if (brightness >= m_pCapability->brightness_ctrl.min_value &&
1505            brightness <= m_pCapability->brightness_ctrl.max_value) {
1506            ALOGV(" new brightness value : %d ", brightness);
1507            return setBrightness(brightness);
1508        } else {
1509            ALOGE("%s: invalid value %d out of (%d, %d)",
1510                  __func__, brightness,
1511                  m_pCapability->brightness_ctrl.min_value,
1512                  m_pCapability->brightness_ctrl.max_value);
1513            return BAD_VALUE;
1514        }
1515    } else {
1516        ALOGV("%s: No brightness value changed.", __func__);
1517        return NO_ERROR;
1518    }
1519}
1520
1521/*===========================================================================
1522 * FUNCTION   : setSharpness
1523 *
1524 * DESCRIPTION: set sharpness control value from user setting
1525 *
1526 * PARAMETERS :
1527 *   @params  : user setting parameters
1528 *
1529 * RETURN     : int32_t type of status
1530 *              NO_ERROR  -- success
1531 *              none-zero failure code
1532 *==========================================================================*/
1533int32_t QCameraParameters::setSharpness(const QCameraParameters& params)
1534{
1535    int shaprness = params.getInt(KEY_QC_SHARPNESS);
1536    int prev_sharp = getInt(KEY_QC_SHARPNESS);
1537    if (prev_sharp !=  shaprness) {
1538        if((shaprness >= m_pCapability->sharpness_ctrl.min_value) &&
1539           (shaprness <= m_pCapability->sharpness_ctrl.max_value)) {
1540            ALOGV(" new sharpness value : %d ", shaprness);
1541            return setSharpness(shaprness);
1542        } else {
1543            ALOGE("%s: invalid value %d out of (%d, %d)",
1544                  __func__, shaprness,
1545                  m_pCapability->sharpness_ctrl.min_value,
1546                  m_pCapability->sharpness_ctrl.max_value);
1547            return BAD_VALUE;
1548        }
1549    } else {
1550        ALOGV("%s: No value change in shaprness", __func__);
1551        return NO_ERROR;
1552    }
1553}
1554
1555/*===========================================================================
1556 * FUNCTION   : setSkintoneEnahancement
1557 *
1558 * DESCRIPTION: set skin tone enhancement factor from user setting
1559 *
1560 * PARAMETERS :
1561 *   @params  : user setting parameters
1562 *
1563 * RETURN     : int32_t type of status
1564 *              NO_ERROR  -- success
1565 *              none-zero failure code
1566 *==========================================================================*/
1567int32_t QCameraParameters::setSkinToneEnhancement(const QCameraParameters& params)
1568{
1569    int sceFactor = params.getInt(KEY_QC_SCE_FACTOR);
1570    int prev_sceFactor = getInt(KEY_QC_SCE_FACTOR);
1571    if (prev_sceFactor !=  sceFactor) {
1572        if((sceFactor >= m_pCapability->sce_ctrl.min_value) &&
1573           (sceFactor <= m_pCapability->sce_ctrl.max_value)) {
1574            ALOGV(" new Skintone Enhancement value : %d ", sceFactor);
1575            return setSkinToneEnhancement(sceFactor);
1576        } else {
1577            ALOGE("%s: invalid value %d out of (%d, %d)",
1578                  __func__, sceFactor,
1579                  m_pCapability->sce_ctrl.min_value,
1580                  m_pCapability->sce_ctrl.max_value);
1581            return BAD_VALUE;
1582        }
1583    } else {
1584        ALOGV("%s: No value change in skintone enhancement factor", __func__);
1585        return NO_ERROR;
1586    }
1587}
1588
1589/*===========================================================================
1590 * FUNCTION   : setSaturation
1591 *
1592 * DESCRIPTION: set saturation control value from user setting
1593 *
1594 * PARAMETERS :
1595 *   @params  : user setting parameters
1596 *
1597 * RETURN     : int32_t type of status
1598 *              NO_ERROR  -- success
1599 *              none-zero failure code
1600 *==========================================================================*/
1601int32_t QCameraParameters::setSaturation(const QCameraParameters& params)
1602{
1603    int saturation = params.getInt(KEY_QC_SATURATION);
1604    int prev_sat = getInt(KEY_QC_SATURATION);
1605    if (prev_sat !=  saturation) {
1606        if((saturation >= m_pCapability->saturation_ctrl.min_value) &&
1607           (saturation <= m_pCapability->saturation_ctrl.max_value)) {
1608            ALOGV(" new saturation value : %d ", saturation);
1609            return setSaturation(saturation);
1610        } else {
1611            ALOGE("%s: invalid value %d out of (%d, %d)",
1612                  __func__, saturation,
1613                  m_pCapability->saturation_ctrl.min_value,
1614                  m_pCapability->saturation_ctrl.max_value);
1615            return BAD_VALUE;
1616        }
1617    } else {
1618        ALOGV("%s: No value change in saturation factor", __func__);
1619        return NO_ERROR;
1620    }
1621}
1622
1623/*===========================================================================
1624 * FUNCTION   : setContrast
1625 *
1626 * DESCRIPTION: set contrast control value from user setting
1627 *
1628 * PARAMETERS :
1629 *   @params  : user setting parameters
1630 *
1631 * RETURN     : int32_t type of status
1632 *              NO_ERROR  -- success
1633 *              none-zero failure code
1634 *==========================================================================*/
1635int32_t QCameraParameters::setContrast(const QCameraParameters& params)
1636{
1637    int contrast = params.getInt(KEY_QC_CONTRAST);
1638    int prev_contrast = getInt(KEY_QC_CONTRAST);
1639    if (prev_contrast !=  contrast) {
1640        if((contrast >= m_pCapability->contrast_ctrl.min_value) &&
1641           (contrast <= m_pCapability->contrast_ctrl.max_value)) {
1642            ALOGV(" new contrast value : %d ", contrast);
1643            int32_t rc = setContrast(contrast);
1644            return rc;
1645        } else {
1646            ALOGE("%s: invalid value %d out of (%d, %d)",
1647                  __func__, contrast,
1648                  m_pCapability->contrast_ctrl.min_value,
1649                  m_pCapability->contrast_ctrl.max_value);
1650            return BAD_VALUE;
1651        }
1652    } else {
1653        ALOGV("%s: No value change in contrast", __func__);
1654        return NO_ERROR;
1655    }
1656}
1657
1658/*===========================================================================
1659 * FUNCTION   : setExposureCompensation
1660 *
1661 * DESCRIPTION: set exposure compensation value from user setting
1662 *
1663 * PARAMETERS :
1664 *   @params  : user setting parameters
1665 *
1666 * RETURN     : int32_t type of status
1667 *              NO_ERROR  -- success
1668 *              none-zero failure code
1669 *==========================================================================*/
1670int32_t QCameraParameters::setExposureCompensation(const QCameraParameters & params)
1671{
1672    int expComp = params.getInt(KEY_EXPOSURE_COMPENSATION);
1673    int prev_expComp = getInt(KEY_EXPOSURE_COMPENSATION);
1674    if (prev_expComp !=  expComp) {
1675        if((expComp >= m_pCapability->exposure_compensation_min) &&
1676           (expComp <= m_pCapability->exposure_compensation_max)) {
1677            ALOGV(" new Exposure Compensation value : %d ", expComp);
1678            return setExposureCompensation(expComp);
1679        } else {
1680            ALOGE("%s: invalid value %d out of (%d, %d)",
1681                  __func__, expComp,
1682                  m_pCapability->exposure_compensation_min,
1683                  m_pCapability->exposure_compensation_max);
1684            return BAD_VALUE;
1685        }
1686    } else {
1687        ALOGV("%s: No value change in Exposure Compensation", __func__);
1688        return NO_ERROR;
1689    }
1690}
1691
1692/*===========================================================================
1693 * FUNCTION   : setWhiteBalance
1694 *
1695 * DESCRIPTION: set white balance value from user setting
1696 *
1697 * PARAMETERS :
1698 *   @params  : user setting parameters
1699 *
1700 * RETURN     : int32_t type of status
1701 *              NO_ERROR  -- success
1702 *              none-zero failure code
1703 *==========================================================================*/
1704int32_t QCameraParameters::setWhiteBalance(const QCameraParameters& params)
1705{
1706    const char *str = params.get(KEY_WHITE_BALANCE);
1707    const char *prev_str = get(KEY_WHITE_BALANCE);
1708    if (str != NULL) {
1709        if (prev_str == NULL ||
1710            strcmp(str, prev_str) != 0) {
1711            return setWhiteBalance(str);
1712        }
1713    }
1714    return NO_ERROR;
1715}
1716
1717/*===========================================================================
1718 * FUNCTION   : setAntibanding
1719 *
1720 * DESCRIPTION: set antibanding value from user setting
1721 *
1722 * PARAMETERS :
1723 *   @params  : user setting parameters
1724 *
1725 * RETURN     : int32_t type of status
1726 *              NO_ERROR  -- success
1727 *              none-zero failure code
1728 *==========================================================================*/
1729int32_t QCameraParameters::setAntibanding(const QCameraParameters& params)
1730{
1731    const char *str = params.get(KEY_ANTIBANDING);
1732    const char *prev_str = get(KEY_ANTIBANDING);
1733    if (str != NULL) {
1734        if (prev_str == NULL ||
1735            strcmp(str, prev_str) != 0) {
1736            return setAntibanding(str);
1737        }
1738    }
1739    return NO_ERROR;
1740}
1741
1742/*===========================================================================
1743 * FUNCTION   : setSceneDetect
1744 *
1745 * DESCRIPTION: set scenen detect value from user setting
1746 *
1747 * PARAMETERS :
1748 *   @params  : user setting parameters
1749 *
1750 * RETURN     : int32_t type of status
1751 *              NO_ERROR  -- success
1752 *              none-zero failure code
1753 *==========================================================================*/
1754int32_t QCameraParameters::setSceneDetect(const QCameraParameters& params)
1755{
1756    const char *str = params.get(KEY_QC_SCENE_DETECT);
1757    const char *prev_str = get(KEY_QC_SCENE_DETECT);
1758    if (str != NULL) {
1759        if (prev_str == NULL ||
1760            strcmp(str, prev_str) != 0) {
1761            return setSceneDetect(str);
1762        }
1763    }
1764    return NO_ERROR;
1765}
1766
1767/*===========================================================================
1768 * FUNCTION   : setVideoHDR
1769 *
1770 * DESCRIPTION: set video HDR value from user setting
1771 *
1772 * PARAMETERS :
1773 *   @params  : user setting parameters
1774 *
1775 * RETURN     : int32_t type of status
1776 *              NO_ERROR  -- success
1777 *              none-zero failure code
1778 *==========================================================================*/
1779int32_t QCameraParameters::setVideoHDR(const QCameraParameters& params)
1780{
1781    const char *str = params.get(KEY_QC_VIDEO_HDR);
1782    const char *prev_str = get(KEY_QC_VIDEO_HDR);
1783    if (str != NULL) {
1784        if (prev_str == NULL ||
1785            strcmp(str, prev_str) != 0) {
1786            return setVideoHDR(str);
1787        }
1788    }
1789    return NO_ERROR;
1790}
1791
1792/*===========================================================================
1793 * FUNCTION   : setFaceRecognition
1794 *
1795 * DESCRIPTION: set face recognition mode from user setting
1796 *
1797 * PARAMETERS :
1798 *   @params  : user setting parameters
1799 *
1800 * RETURN     : int32_t type of status
1801 *              NO_ERROR  -- success
1802 *              none-zero failure code
1803 *==========================================================================*/
1804int32_t QCameraParameters::setFaceRecognition(const QCameraParameters& params)
1805{
1806    const char *str = params.get(KEY_QC_FACE_RECOGNITION);
1807    const char *prev_str = get(KEY_QC_FACE_RECOGNITION);
1808    if (str != NULL) {
1809        if (prev_str == NULL ||
1810            strcmp(str, prev_str) != 0) {
1811            int maxFaces = params.getInt(KEY_QC_MAX_NUM_REQUESTED_FACES);
1812            return setFaceRecognition(str, maxFaces);
1813        }
1814    }
1815    return NO_ERROR;
1816}
1817
1818/*===========================================================================
1819 * FUNCTION   : setZoom
1820 *
1821 * DESCRIPTION: set zoom value from user setting
1822 *
1823 * PARAMETERS :
1824 *   @params  : user setting parameters
1825 *
1826 * RETURN     : int32_t type of status
1827 *              NO_ERROR  -- success
1828 *              none-zero failure code
1829 *==========================================================================*/
1830int32_t QCameraParameters::setZoom(const QCameraParameters& params)
1831{
1832    if ((m_pCapability->zoom_supported == 0 ||
1833         m_pCapability->zoom_ratio_tbl_cnt == 0)) {
1834        ALOGD("%s: no zoom support", __func__);
1835        return NO_ERROR;
1836    }
1837
1838    int zoomLevel = params.getInt(KEY_ZOOM);
1839    if((zoomLevel < 0) ||
1840       (zoomLevel >= m_pCapability->zoom_ratio_tbl_cnt)) {
1841        ALOGE("%s: invalid value %d out of (%d, %d)",
1842              __func__, zoomLevel,
1843              0, m_pCapability->zoom_ratio_tbl_cnt-1);
1844        return BAD_VALUE;
1845    }
1846
1847    int prevZoomLevel = getInt(KEY_ZOOM);
1848    if (prevZoomLevel == zoomLevel) {
1849        ALOGV("%s: No value change in contrast", __func__);
1850        return NO_ERROR;
1851    }
1852
1853    return setZoom(zoomLevel);
1854}
1855
1856/*===========================================================================
1857 * FUNCTION   : setISOValue
1858 *
1859 * DESCRIPTION: set ISO value from user setting
1860 *
1861 * PARAMETERS :
1862 *   @params  : user setting parameters
1863 *
1864 * RETURN     : int32_t type of status
1865 *              NO_ERROR  -- success
1866 *              none-zero failure code
1867 *==========================================================================*/
1868int32_t  QCameraParameters::setISOValue(const QCameraParameters& params)
1869{
1870    const char *str = params.get(KEY_QC_ISO_MODE);
1871    const char *prev_str = get(KEY_QC_ISO_MODE);
1872    if (str != NULL) {
1873        if (prev_str == NULL ||
1874            strcmp(str, prev_str) != 0) {
1875            return setISOValue(str);
1876        }
1877    }
1878    return NO_ERROR;
1879}
1880
1881/*===========================================================================
1882 * FUNCTION   : setRotation
1883 *
1884 * DESCRIPTION: set rotation value from user setting
1885 *
1886 * PARAMETERS :
1887 *   @params  : user setting parameters
1888 *
1889 * RETURN     : int32_t type of status
1890 *              NO_ERROR  -- success
1891 *              none-zero failure code
1892 *==========================================================================*/
1893int32_t QCameraParameters::setRotation(const QCameraParameters& params)
1894{
1895    int rotation = params.getInt(KEY_ROTATION);
1896    if (rotation != -1) {
1897        if (rotation == 0 || rotation == 90 ||
1898            rotation == 180 || rotation == 270) {
1899            set(KEY_ROTATION, rotation);
1900        } else {
1901            ALOGE("Invalid rotation value: %d", rotation);
1902            return BAD_VALUE;
1903        }
1904    }
1905    return NO_ERROR;
1906}
1907
1908/*===========================================================================
1909 * FUNCTION   : setFlash
1910 *
1911 * DESCRIPTION: set flash mode from user setting
1912 *
1913 * PARAMETERS :
1914 *   @params  : user setting parameters
1915 *
1916 * RETURN     : int32_t type of status
1917 *              NO_ERROR  -- success
1918 *              none-zero failure code
1919 *==========================================================================*/
1920int32_t QCameraParameters::setFlash(const QCameraParameters& params)
1921{
1922    const char *str = params.get(KEY_FLASH_MODE);
1923    const char *prev_str = get(KEY_FLASH_MODE);
1924    if (str != NULL) {
1925        if (prev_str == NULL ||
1926            strcmp(str, prev_str) != 0) {
1927            return setFlash(str);
1928        }
1929    }
1930    return NO_ERROR;
1931}
1932
1933/*===========================================================================
1934 * FUNCTION   : setAecLock
1935 *
1936 * DESCRIPTION: set AEC lock value from user setting
1937 *
1938 * PARAMETERS :
1939 *   @params  : user setting parameters
1940 *
1941 * RETURN     : int32_t type of status
1942 *              NO_ERROR  -- success
1943 *              none-zero failure code
1944 *==========================================================================*/
1945int32_t QCameraParameters::setAecLock(const QCameraParameters& params)
1946{
1947    const char *str = params.get(KEY_AUTO_EXPOSURE_LOCK);
1948    const char *prev_str = get(KEY_AUTO_EXPOSURE_LOCK);
1949    if (str != NULL) {
1950        if (prev_str == NULL ||
1951            strcmp(str, prev_str) != 0) {
1952            return setAecLock(str);
1953        }
1954    }
1955    return NO_ERROR;
1956}
1957
1958/*===========================================================================
1959 * FUNCTION   : setAwbLock
1960 *
1961 * DESCRIPTION: set AWB lock from user setting
1962 *
1963 * PARAMETERS :
1964 *   @params  : user setting parameters
1965 *
1966 * RETURN     : int32_t type of status
1967 *              NO_ERROR  -- success
1968 *              none-zero failure code
1969 *==========================================================================*/
1970int32_t QCameraParameters::setAwbLock(const QCameraParameters& params)
1971{
1972    const char *str = params.get(KEY_AUTO_WHITEBALANCE_LOCK);
1973    const char *prev_str = get(KEY_AUTO_WHITEBALANCE_LOCK);
1974    if (str != NULL) {
1975        if (prev_str == NULL ||
1976            strcmp(str, prev_str) != 0) {
1977            return setAwbLock(str);
1978        }
1979    }
1980    return NO_ERROR;
1981}
1982
1983/*===========================================================================
1984 * FUNCTION   : setMCEValue
1985 *
1986 * DESCRIPTION: set memory color enhancement value from user setting
1987 *
1988 * PARAMETERS :
1989 *   @params  : user setting parameters
1990 *
1991 * RETURN     : int32_t type of status
1992 *              NO_ERROR  -- success
1993 *              none-zero failure code
1994 *==========================================================================*/
1995int32_t QCameraParameters::setMCEValue(const QCameraParameters& params)
1996{
1997    const char *str = params.get(KEY_QC_MEMORY_COLOR_ENHANCEMENT);
1998    const char *prev_str = get(KEY_QC_MEMORY_COLOR_ENHANCEMENT);
1999    if (str != NULL) {
2000        if (prev_str == NULL ||
2001            strcmp(str, prev_str) != 0) {
2002            return setMCEValue(str);
2003        }
2004    }
2005    return NO_ERROR;
2006}
2007
2008/*===========================================================================
2009 * FUNCTION   : setDISValue
2010 *
2011 * DESCRIPTION: enable/disable DIS from user setting
2012 *
2013 * PARAMETERS :
2014 *   @params  : user setting parameters
2015 *
2016 * RETURN     : int32_t type of status
2017 *              NO_ERROR  -- success
2018 *              none-zero failure code
2019 *==========================================================================*/
2020int32_t QCameraParameters::setDISValue(const QCameraParameters& params)
2021{
2022    const char *str = params.get(KEY_QC_DIS);
2023    const char *prev_str = get(KEY_QC_DIS);
2024    if (str != NULL) {
2025        if (prev_str == NULL ||
2026            strcmp(str, prev_str) != 0) {
2027            return setDISValue(str);
2028        }
2029    }
2030    return NO_ERROR;
2031}
2032
2033/*===========================================================================
2034 * FUNCTION   : setHighFrameRate
2035 *
2036 * DESCRIPTION: set hight frame rate value from user setting
2037 *
2038 * PARAMETERS :
2039 *   @params  : user setting parameters
2040 *
2041 * RETURN     : int32_t type of status
2042 *              NO_ERROR  -- success
2043 *              none-zero failure code
2044 *==========================================================================*/
2045int32_t QCameraParameters::setHighFrameRate(const QCameraParameters& params)
2046{
2047    const char *str = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE);
2048    const char *prev_str = get(KEY_QC_VIDEO_HIGH_FRAME_RATE);
2049    if (str != NULL) {
2050        if (prev_str == NULL ||
2051            strcmp(str, prev_str) != 0) {
2052            return setHighFrameRate(str);
2053        }
2054    }
2055    return NO_ERROR;
2056}
2057
2058/*===========================================================================
2059 * FUNCTION   : setLensShadeValue
2060 *
2061 * DESCRIPTION: set lens shade value from user setting
2062 *
2063 * PARAMETERS :
2064 *   @params  : user setting parameters
2065 *
2066 * RETURN     : int32_t type of status
2067 *              NO_ERROR  -- success
2068 *              none-zero failure code
2069 *==========================================================================*/
2070int32_t QCameraParameters::setLensShadeValue(const QCameraParameters& params)
2071{
2072    const char *str = params.get(KEY_QC_LENSSHADE);
2073    const char *prev_str = get(KEY_QC_LENSSHADE);
2074    if (str != NULL) {
2075        if (prev_str == NULL ||
2076            strcmp(str, prev_str) != 0) {
2077            return setLensShadeValue(str);
2078        }
2079    }
2080    return NO_ERROR;
2081}
2082
2083/*===========================================================================
2084 * FUNCTION   : setFocusAreas
2085 *
2086 * DESCRIPTION: set focus areas from user setting
2087 *
2088 * PARAMETERS :
2089 *   @params  : user setting parameters
2090 *
2091 * RETURN     : int32_t type of status
2092 *              NO_ERROR  -- success
2093 *              none-zero failure code
2094 *==========================================================================*/
2095int32_t QCameraParameters::setFocusAreas(const QCameraParameters& params)
2096{
2097    const char *str = params.get(KEY_FOCUS_AREAS);
2098    if (str != NULL) {
2099        int max_num_af_areas = getInt(KEY_MAX_NUM_FOCUS_AREAS);
2100        if(max_num_af_areas == 0) {
2101            ALOGE("%s: max num of AF area is 0, cannot set focus areas", __func__);
2102            return BAD_VALUE;
2103        }
2104
2105        const char *prev_str = get(KEY_FOCUS_AREAS);
2106        if (prev_str == NULL ||
2107            strcmp(str, prev_str) != 0) {
2108            return setFocusAreas(str);
2109        }
2110    }
2111    return NO_ERROR;
2112}
2113
2114/*===========================================================================
2115 * FUNCTION   : setMeteringAreas
2116 *
2117 * DESCRIPTION: set metering areas from user setting
2118 *
2119 * PARAMETERS :
2120 *   @params  : user setting parameters
2121 *
2122 * RETURN     : int32_t type of status
2123 *              NO_ERROR  -- success
2124 *              none-zero failure code
2125 *==========================================================================*/
2126int32_t QCameraParameters::setMeteringAreas(const QCameraParameters& params)
2127{
2128    const char *str = params.get(KEY_METERING_AREAS);
2129    if (str != NULL) {
2130        int max_num_mtr_areas = getInt(KEY_MAX_NUM_METERING_AREAS);
2131        if(max_num_mtr_areas == 0) {
2132            ALOGE("%s: max num of metering areas is 0, cannot set focus areas", __func__);
2133            return BAD_VALUE;
2134        }
2135
2136        const char *prev_str = get(KEY_METERING_AREAS);
2137        if (prev_str == NULL ||
2138            strcmp(str, prev_str) != 0) {
2139            return setMeteringAreas(str);
2140        }
2141    }
2142    return NO_ERROR;
2143}
2144
2145/*===========================================================================
2146 * FUNCTION   : setSceneMode
2147 *
2148 * DESCRIPTION: set scenen mode from user setting
2149 *
2150 * PARAMETERS :
2151 *   @params  : user setting parameters
2152 *
2153 * RETURN     : int32_t type of status
2154 *              NO_ERROR  -- success
2155 *              none-zero failure code
2156 *==========================================================================*/
2157int32_t QCameraParameters::setSceneMode(const QCameraParameters& params)
2158{
2159    const char *str = params.get(KEY_SCENE_MODE);
2160    const char *prev_str = get(KEY_SCENE_MODE);
2161    if (str != NULL) {
2162        if (prev_str == NULL ||
2163            strcmp(str, prev_str) != 0) {
2164            if ((strcmp(str, SCENE_MODE_HDR) == 0) ||
2165                ((prev_str != NULL) && (strcmp(prev_str, SCENE_MODE_HDR) == 0))) {
2166                ALOGD("%s: scene mode changed between HDR and non-HDR, need restart", __func__);
2167                m_bNeedRestart = true;
2168
2169                // set if hdr 1x image is needed
2170                const char *need_hdr_1x = params.get(KEY_QC_HDR_NEED_1X);
2171                int32_t value = 0;
2172                if (need_hdr_1x != NULL && strcmp(need_hdr_1x, VALUE_TRUE) == 0) {
2173                    value = 1;
2174                    updateParamEntry(KEY_QC_HDR_NEED_1X, need_hdr_1x);
2175                    AddSetParmEntryToBatch(m_pParamBuf,
2176                                           CAM_INTF_PARM_HDR_NEED_1X,
2177                                           sizeof(value),
2178                                           &value);
2179                }
2180            }
2181            return setSceneMode(str);
2182        }
2183    }
2184    return NO_ERROR;
2185}
2186
2187/*===========================================================================
2188 * FUNCTION   : setSelectableZoneAf
2189 *
2190 * DESCRIPTION: set selectable zone auto focus value from user setting
2191 *
2192 * PARAMETERS :
2193 *   @params  : user setting parameters
2194 *
2195 * RETURN     : int32_t type of status
2196 *              NO_ERROR  -- success
2197 *              none-zero failure code
2198 *==========================================================================*/
2199int32_t QCameraParameters::setSelectableZoneAf(const QCameraParameters& params)
2200{
2201    const char *str = params.get(KEY_QC_SELECTABLE_ZONE_AF);
2202    const char *prev_str = get(KEY_QC_SELECTABLE_ZONE_AF);
2203    if (str != NULL) {
2204        if (prev_str == NULL ||
2205            strcmp(str, prev_str) != 0) {
2206            return setSelectableZoneAf(str);
2207        }
2208    }
2209    return NO_ERROR;
2210}
2211
2212/*===========================================================================
2213 * FUNCTION   : setAEBracket
2214 *
2215 * DESCRIPTION: set AE bracket from user setting
2216 *
2217 * PARAMETERS :
2218 *   @params  : user setting parameters
2219 *
2220 * RETURN     : int32_t type of status
2221 *              NO_ERROR  -- success
2222 *              none-zero failure code
2223 *==========================================================================*/
2224int32_t QCameraParameters::setAEBracket(const QCameraParameters& params)
2225{
2226    const char *scene_mode = params.get(KEY_SCENE_MODE);
2227    if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) {
2228        ALOGE("%s: scene mode is HDR, overwrite AE bracket setting to off", __func__);
2229        return setAEBracket(AE_BRACKET_OFF);
2230    }
2231
2232    const char *expStr = params.get(KEY_QC_CAPTURE_BURST_EXPOSURE);
2233    if (NULL != expStr && strlen(expStr) > 0) {
2234        set(KEY_QC_CAPTURE_BURST_EXPOSURE, expStr);
2235    } else {
2236        char prop[PROPERTY_VALUE_MAX];
2237        memset(prop, 0, sizeof(prop));
2238        property_get("persist.capture.burst.exposures", prop, "");
2239        if (strlen(prop) > 0) {
2240            set(KEY_QC_CAPTURE_BURST_EXPOSURE, prop);
2241        } else {
2242            remove(KEY_QC_CAPTURE_BURST_EXPOSURE);
2243        }
2244    }
2245
2246    const char *str = params.get(KEY_QC_AE_BRACKET_HDR);
2247    const char *prev_str = get(KEY_QC_AE_BRACKET_HDR);
2248    if (str != NULL) {
2249        if (prev_str == NULL ||
2250            strcmp(str, prev_str) != 0) {
2251            return setAEBracket(str);
2252        }
2253    }
2254    return NO_ERROR;
2255}
2256
2257/*===========================================================================
2258 * FUNCTION   : setRedeyeReduction
2259 *
2260 * DESCRIPTION: set red eye reduction setting from user setting
2261 *
2262 * PARAMETERS :
2263 *   @params  : user setting parameters
2264 *
2265 * RETURN     : int32_t type of status
2266 *              NO_ERROR  -- success
2267 *              none-zero failure code
2268 *==========================================================================*/
2269int32_t QCameraParameters::setRedeyeReduction(const QCameraParameters& params)
2270{
2271    const char *str = params.get(KEY_QC_REDEYE_REDUCTION);
2272    const char *prev_str = get(KEY_QC_REDEYE_REDUCTION);
2273    if (str != NULL) {
2274        if (prev_str == NULL ||
2275            strcmp(str, prev_str) != 0) {
2276            return setRedeyeReduction(str);
2277        }
2278    }
2279    return NO_ERROR;
2280}
2281
2282/*===========================================================================
2283 * FUNCTION   : setGpsLocation
2284 *
2285 * DESCRIPTION: set GPS location information from user setting
2286 *
2287 * PARAMETERS :
2288 *   @params  : user setting parameters
2289 *
2290 * RETURN     : int32_t type of status
2291 *              NO_ERROR  -- success
2292 *              none-zero failure code
2293 *==========================================================================*/
2294int32_t QCameraParameters::setGpsLocation(const QCameraParameters& params)
2295{
2296    const char *method = params.get(KEY_GPS_PROCESSING_METHOD);
2297    if (method) {
2298        set(KEY_GPS_PROCESSING_METHOD, method);
2299    }else {
2300        remove(KEY_GPS_PROCESSING_METHOD);
2301    }
2302
2303    const char *latitude = params.get(KEY_GPS_LATITUDE);
2304    if (latitude) {
2305        set(KEY_GPS_LATITUDE, latitude);
2306    }else {
2307        remove(KEY_GPS_LATITUDE);
2308    }
2309
2310    const char *latitudeRef = params.get(KEY_QC_GPS_LATITUDE_REF);
2311    if (latitudeRef) {
2312        set(KEY_QC_GPS_LATITUDE_REF, latitudeRef);
2313    }else {
2314        remove(KEY_QC_GPS_LATITUDE_REF);
2315    }
2316
2317    const char *longitude = params.get(KEY_GPS_LONGITUDE);
2318    if (longitude) {
2319        set(KEY_GPS_LONGITUDE, longitude);
2320    }else {
2321        remove(KEY_GPS_LONGITUDE);
2322    }
2323
2324    const char *longitudeRef = params.get(KEY_QC_GPS_LONGITUDE_REF);
2325    if (longitudeRef) {
2326        set(KEY_QC_GPS_LONGITUDE_REF, longitudeRef);
2327    }else {
2328        remove(KEY_QC_GPS_LONGITUDE_REF);
2329    }
2330
2331    const char *altitudeRef = params.get(KEY_QC_GPS_ALTITUDE_REF);
2332    if (altitudeRef) {
2333        set(KEY_QC_GPS_ALTITUDE_REF, altitudeRef);
2334    }else {
2335        remove(KEY_QC_GPS_ALTITUDE_REF);
2336    }
2337
2338    const char *altitude = params.get(KEY_GPS_ALTITUDE);
2339    if (altitude) {
2340        set(KEY_GPS_ALTITUDE, altitude);
2341    }else {
2342        remove(KEY_GPS_ALTITUDE);
2343    }
2344
2345    const char *status = params.get(KEY_QC_GPS_STATUS);
2346    if (status) {
2347        set(KEY_QC_GPS_STATUS, status);
2348    } else {
2349        remove(KEY_QC_GPS_STATUS);
2350    }
2351
2352    const char *timestamp = params.get(KEY_GPS_TIMESTAMP);
2353    if (timestamp) {
2354        set(KEY_GPS_TIMESTAMP, timestamp);
2355    }else {
2356        remove(KEY_GPS_TIMESTAMP);
2357    }
2358    return NO_ERROR;
2359}
2360
2361/*===========================================================================
2362 * FUNCTION   : setNumOfSnapshot
2363 *
2364 * DESCRIPTION: set number of snapshot per shutter from user setting
2365 *
2366 * PARAMETERS : none
2367 *
2368 * RETURN     : int32_t type of status
2369 *              NO_ERROR  -- success
2370 *              none-zero failure code
2371 *==========================================================================*/
2372int32_t QCameraParameters::setNumOfSnapshot()
2373{
2374    int nBurstNum = getBurstNum();
2375    uint8_t nExpnum = 0;
2376
2377    const char *scene_mode = get(KEY_SCENE_MODE);
2378    if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) {
2379        /* According to Android SDK, only one snapshot,
2380         * but OEM might have different requirement */
2381        const char *need_hdr_1x = get(KEY_QC_HDR_NEED_1X);
2382        if (need_hdr_1x != NULL && strcmp(need_hdr_1x, VALUE_TRUE) == 0) {
2383            nExpnum = 2; // HDR needs both 1X and processed img
2384        } else {
2385            nExpnum = 1; // HDR only needs processed img
2386        }
2387    } else {
2388        const char *bracket_str = get(KEY_QC_AE_BRACKET_HDR);
2389        if (bracket_str != NULL && strlen(bracket_str) > 0) {
2390            int value = lookupAttr(BRACKETING_MODES_MAP,
2391                                   sizeof(BRACKETING_MODES_MAP)/sizeof(QCameraMap),
2392                                   bracket_str);
2393            switch (value) {
2394            case CAM_EXP_BRACKETING_ON:
2395                {
2396                    nExpnum = 0;
2397                    const char *str_val = get(KEY_QC_CAPTURE_BURST_EXPOSURE);
2398                    if ((str_val != NULL) && (strlen(str_val) > 0)) {
2399                        char prop[PROPERTY_VALUE_MAX];
2400                        memset(prop, 0, sizeof(prop));
2401                        strcpy(prop, str_val);
2402                        char *saveptr = NULL;
2403                        char *token = strtok_r(prop, ",", &saveptr);
2404                        while (token != NULL) {
2405                            token = strtok_r(NULL, ",", &saveptr);
2406                            nExpnum++;
2407                        }
2408                    }
2409                    if (nExpnum == 0) {
2410                        nExpnum = 1;
2411                    }
2412                }
2413                break;
2414            default:
2415                nExpnum = 1;
2416                break;
2417            }
2418        }
2419    }
2420
2421    ALOGD("%s: nBurstNum = %d, nExpnum = %d", __func__, nBurstNum, nExpnum);
2422    set(KEY_QC_NUM_SNAPSHOT_PER_SHUTTER, nBurstNum * nExpnum);
2423    return NO_ERROR;
2424}
2425
2426/*===========================================================================
2427 * FUNCTION   : setRecordingHint
2428 *
2429 * DESCRIPTION: set recording hint value from user setting
2430 *
2431 * PARAMETERS :
2432 *   @params  : user setting parameters
2433 *
2434 * RETURN     : int32_t type of status
2435 *              NO_ERROR  -- success
2436 *              none-zero failure code
2437 *==========================================================================*/
2438int32_t QCameraParameters::setRecordingHint(const QCameraParameters& params)
2439{
2440    const char * str = params.get(KEY_RECORDING_HINT);
2441    const char *prev_str = get(KEY_RECORDING_HINT);
2442    if (str != NULL) {
2443        if (prev_str == NULL || strcmp(str, prev_str) != 0) {
2444            int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP,
2445                                       sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap),
2446                                       str);
2447            if(value != NAME_NOT_FOUND){
2448                updateParamEntry(KEY_RECORDING_HINT, str);
2449                setRecordingHintValue(value);
2450                return NO_ERROR;
2451            } else {
2452                ALOGE("Invalid recording hint value: %s", str);
2453                return BAD_VALUE;
2454            }
2455        }
2456    }
2457    return NO_ERROR;
2458}
2459
2460/*===========================================================================
2461 * FUNCTION   : setNoDisplayMode
2462 *
2463 * DESCRIPTION: set no display mode from user setting
2464 *
2465 * PARAMETERS :
2466 *   @params  : user setting parameters
2467 *
2468 * RETURN     : int32_t type of status
2469 *              NO_ERROR  -- success
2470 *              none-zero failure code
2471 *==========================================================================*/
2472int32_t QCameraParameters::setNoDisplayMode(const QCameraParameters& params)
2473{
2474    const char *str_val  = params.get(KEY_QC_NO_DISPLAY_MODE);
2475    const char *prev_str = get(KEY_QC_NO_DISPLAY_MODE);
2476    if(str_val && strlen(str_val) > 0) {
2477        if (prev_str == NULL || strcmp(str_val, prev_str) != 0) {
2478            m_bNoDisplayMode = atoi(str_val);
2479            updateParamEntry(KEY_QC_NO_DISPLAY_MODE, str_val);
2480            m_bNeedRestart = true;
2481        }
2482    } else {
2483        m_bNoDisplayMode = false;
2484    }
2485    ALOGD("Param m_bNoDisplayMode = %d", m_bNoDisplayMode);
2486    return NO_ERROR;
2487}
2488
2489/*===========================================================================
2490 * FUNCTION   : setZslMode
2491 *
2492 * DESCRIPTION: set ZSL mode from user setting
2493 *
2494 * PARAMETERS :
2495 *   @params  : user setting parameters
2496 *
2497 * RETURN     : int32_t type of status
2498 *              NO_ERROR  -- success
2499 *              none-zero failure code
2500 *==========================================================================*/
2501int32_t QCameraParameters::setZslMode(const QCameraParameters& params)
2502{
2503    const char *str_val  = params.get(KEY_QC_ZSL);
2504    const char *prev_val  = get(KEY_QC_ZSL);
2505
2506    if (str_val != NULL) {
2507        if (prev_val == NULL || strcmp(str_val, prev_val) != 0) {
2508            int32_t value = lookupAttr(ON_OFF_MODES_MAP,
2509                                       sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap),
2510                                       str_val);
2511            if (value != NAME_NOT_FOUND) {
2512                updateParamEntry(KEY_QC_ZSL, str_val);
2513                m_bZslMode = (value > 0)? true : false;
2514
2515                // ZSL mode changed, need restart preview
2516                m_bNeedRestart = true;
2517
2518                return AddSetParmEntryToBatch(m_pParamBuf,
2519                                              CAM_INTF_PARM_ZSL_MODE,
2520                                              sizeof(value),
2521                                              &value);
2522            } else {
2523                ALOGE("Invalid ZSL mode value: %s", str_val);
2524                return BAD_VALUE;
2525            }
2526        }
2527    }
2528    return NO_ERROR;
2529}
2530
2531/*===========================================================================
2532 * FUNCTION   : setWaveletDenoise
2533 *
2534 * DESCRIPTION: set wavelet denoise value from user setting
2535 *
2536 * PARAMETERS :
2537 *   @params  : user setting parameters
2538 *
2539 * RETURN     : int32_t type of status
2540 *              NO_ERROR  -- success
2541 *              none-zero failure code
2542 *==========================================================================*/
2543int32_t QCameraParameters::setWaveletDenoise(const QCameraParameters& params)
2544{
2545    const char *str = params.get(KEY_QC_DENOISE);
2546    const char *prev_str = get(KEY_QC_DENOISE);
2547    if (str != NULL) {
2548        if (prev_str == NULL ||
2549            strcmp(str, prev_str) != 0) {
2550            return setWaveletDenoise(str);
2551        }
2552    }
2553    return NO_ERROR;
2554}
2555
2556/*===========================================================================
2557 * FUNCTION   : setCameraMode
2558 *
2559 * DESCRIPTION: set camera mode from user setting
2560 *
2561 * PARAMETERS :
2562 *   @params  : user setting parameters
2563 *
2564 * RETURN     : int32_t type of status
2565 *              NO_ERROR  -- success
2566 *              none-zero failure code
2567 *==========================================================================*/
2568int32_t QCameraParameters::setCameraMode(const QCameraParameters& params)
2569{
2570    const char *str = params.get(KEY_QC_CAMERA_MODE);
2571    if (str != NULL) {
2572        set(KEY_QC_CAMERA_MODE, str);
2573    } else {
2574        remove(KEY_QC_CAMERA_MODE);
2575    }
2576    return NO_ERROR;
2577}
2578
2579/*===========================================================================
2580 * FUNCTION   : setZslAttributes
2581 *
2582 * DESCRIPTION: set ZSL related attributes from user setting
2583 *
2584 * PARAMETERS :
2585 *   @params  : user setting parameters
2586 *
2587 * RETURN     : int32_t type of status
2588 *              NO_ERROR  -- success
2589 *              none-zero failure code
2590 *==========================================================================*/
2591int32_t QCameraParameters::setZslAttributes(const QCameraParameters& params)
2592{
2593    // TODO: may switch to pure param instead of sysprop
2594    char prop[32];
2595
2596    const char *str = params.get(KEY_QC_ZSL_BURST_INTERVAL);
2597    if (str != NULL) {
2598        set(KEY_QC_ZSL_BURST_INTERVAL, str);
2599    } else {
2600        memset(prop, 0, sizeof(prop));
2601        property_get("persist.camera.zsl.interval", prop, "1");
2602        set(KEY_QC_ZSL_BURST_INTERVAL, prop);
2603    }
2604
2605    str = params.get(KEY_QC_ZSL_BURST_LOOKBACK);
2606    if (str != NULL) {
2607        set(KEY_QC_ZSL_BURST_LOOKBACK, str);
2608    } else {
2609        memset(prop, 0, sizeof(prop));
2610        property_get("persist.camera.zsl.backlookcnt", prop, "2");
2611        set(KEY_QC_ZSL_BURST_LOOKBACK, prop);
2612    }
2613
2614    str = params.get(KEY_QC_ZSL_QUEUE_DEPTH);
2615    if (str != NULL) {
2616        set(KEY_QC_ZSL_QUEUE_DEPTH, str);
2617    } else {
2618        memset(prop, 0, sizeof(prop));
2619        property_get("persist.camera.zsl.queuedepth", prop, "2");
2620        set(KEY_QC_ZSL_QUEUE_DEPTH, prop);
2621    }
2622
2623    return NO_ERROR;
2624}
2625
2626/*===========================================================================
2627 * FUNCTION   : setFlip
2628 *
2629 * DESCRIPTION: set preview/ video/ picture flip mode from user setting
2630 *
2631 * PARAMETERS :
2632 *   @params  : user setting parameters
2633 *
2634 * RETURN     : int32_t type of status
2635 *              NO_ERROR  -- success
2636 *              none-zero failure code
2637 *==========================================================================*/
2638int32_t QCameraParameters::setFlip(const QCameraParameters& params)
2639{
2640    if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_FLIP) == 0) {
2641        ALOGD("%s: flip is not supported.", __func__);
2642        return NO_ERROR;
2643    }
2644
2645    //check preview flip setting
2646    const char *str = params.get(KEY_QC_PREVIEW_FLIP);
2647    if(str != NULL){
2648        int32_t value = lookupAttr(FLIP_MODES_MAP,
2649                                   sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap),
2650                                   str);
2651        if(value != NAME_NOT_FOUND){
2652            set(KEY_QC_PREVIEW_FLIP, str);
2653        }
2654    }
2655
2656    // check video filp setting
2657    str = params.get(KEY_QC_VIDEO_FLIP);
2658    if(str != NULL){
2659        int32_t value = lookupAttr(FLIP_MODES_MAP,
2660                                   sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap),
2661                                   str);
2662        if(value != NAME_NOT_FOUND){
2663            set(KEY_QC_VIDEO_FLIP, str);
2664        }
2665    }
2666
2667    // check picture filp setting
2668    str = params.get(KEY_QC_SNAPSHOT_PICTURE_FLIP);
2669    if(str != NULL){
2670        int32_t value = lookupAttr(FLIP_MODES_MAP,
2671                                   sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap),
2672                                   str);
2673        if(value != NAME_NOT_FOUND){
2674            set(KEY_QC_SNAPSHOT_PICTURE_FLIP, str);
2675        }
2676    }
2677
2678    return NO_ERROR;
2679}
2680
2681/*===========================================================================
2682 * FUNCTION   : updateParameters
2683 *
2684 * DESCRIPTION: update parameters from user setting
2685 *
2686 * PARAMETERS :
2687 *   @params  : user setting parameters
2688 *   @needRestart : [output] if preview need restart upon setting changes
2689 *
2690 * RETURN     : int32_t type of status
2691 *              NO_ERROR  -- success
2692 *              none-zero failure code
2693 *==========================================================================*/
2694int32_t QCameraParameters::updateParameters(QCameraParameters& params,
2695                                            bool &needRestart)
2696{
2697    int32_t final_rc = NO_ERROR;
2698    int32_t rc;
2699    m_bNeedRestart = false;
2700
2701    if(initBatchUpdate(m_pParamBuf) < 0 ) {
2702        ALOGE("%s:Failed to initialize group update table",__func__);
2703        rc = BAD_TYPE;
2704        goto UPDATE_PARAM_DONE;
2705    }
2706
2707    if ((rc = setPreviewSize(params)))                  final_rc = rc;
2708    if ((rc = setVideoSize(params)))                    final_rc = rc;
2709    if ((rc = setPictureSize(params)))                  final_rc = rc;
2710    if ((rc = setPreviewFormat(params)))                final_rc = rc;
2711    if ((rc = setPictureFormat(params)))                final_rc = rc;
2712    if ((rc = setJpegThumbnailSize(params)))            final_rc = rc;
2713    if ((rc = setJpegQuality(params)))                  final_rc = rc;
2714    if ((rc = setOrientation(params)))                  final_rc = rc;
2715    if ((rc = setRotation(params)))                     final_rc = rc;
2716    if ((rc = setNoDisplayMode(params)))                final_rc = rc;
2717    if ((rc = setZslMode(params)))                      final_rc = rc;
2718    if ((rc = setZslAttributes(params)))                final_rc = rc;
2719    if ((rc = setCameraMode(params)))                   final_rc = rc;
2720    if ((rc = setRecordingHint(params)))                final_rc = rc;
2721
2722    if ((rc = setPreviewFpsRange(params)))              final_rc = rc;
2723    if ((rc = setPreviewFrameRate(params)))             final_rc = rc;
2724    if ((rc = setAutoExposure(params)))                 final_rc = rc;
2725    if ((rc = setEffect(params)))                       final_rc = rc;
2726    if ((rc = setBrightness(params)))                   final_rc = rc;
2727    if ((rc = setZoom(params)))                         final_rc = rc;
2728    if ((rc = setSharpness(params)))                    final_rc = rc;
2729    if ((rc = setSaturation(params)))                   final_rc = rc;
2730    if ((rc = setContrast(params)))                     final_rc = rc;
2731    if ((rc = setFocusMode(params)))                    final_rc = rc;
2732    if ((rc = setISOValue(params)))                     final_rc = rc;
2733    if ((rc = setSkinToneEnhancement(params)))          final_rc = rc;
2734    if ((rc = setFlash(params)))                        final_rc = rc;
2735    if ((rc = setAecLock(params)))                      final_rc = rc;
2736    if ((rc = setAwbLock(params)))                      final_rc = rc;
2737    if ((rc = setLensShadeValue(params)))               final_rc = rc;
2738    if ((rc = setMCEValue(params)))                     final_rc = rc;
2739    if ((rc = setDISValue(params)))                     final_rc = rc;
2740    if ((rc = setHighFrameRate(params)))                final_rc = rc;
2741    if ((rc = setAntibanding(params)))                  final_rc = rc;
2742    if ((rc = setExposureCompensation(params)))         final_rc = rc;
2743    if ((rc = setWhiteBalance(params)))                 final_rc = rc;
2744    if ((rc = setSceneMode(params)))                    final_rc = rc;
2745    if ((rc = setFocusAreas(params)))                   final_rc = rc;
2746    if ((rc = setMeteringAreas(params)))                final_rc = rc;
2747    if ((rc = setSelectableZoneAf(params)))             final_rc = rc;
2748    if ((rc = setRedeyeReduction(params)))              final_rc = rc;
2749    if ((rc = setAEBracket(params)))                    final_rc = rc;
2750    if ((rc = setGpsLocation(params)))                  final_rc = rc;
2751    if ((rc = setWaveletDenoise(params)))               final_rc = rc;
2752    if ((rc = setFaceRecognition(params)))              final_rc = rc;
2753    if ((rc = setFlip(params)))                         final_rc = rc;
2754    if ((rc = setVideoHDR(params)))                     final_rc = rc;
2755
2756    // update live snapshot size after all other parameters are set
2757    if ((rc = setLiveSnapshotSize(params)))             final_rc = rc;
2758
2759UPDATE_PARAM_DONE:
2760    needRestart = m_bNeedRestart;
2761    return final_rc;
2762}
2763
2764/*===========================================================================
2765 * FUNCTION   : commitParameters
2766 *
2767 * DESCRIPTION: commit parameter changes to backend
2768 *
2769 * PARAMETERS : none
2770 *
2771 * RETURN     : int32_t type of status
2772 *              NO_ERROR  -- success
2773 *              none-zero failure code
2774 *==========================================================================*/
2775int32_t QCameraParameters::commitParameters()
2776{
2777    return commitSetBatch();
2778}
2779
2780/*===========================================================================
2781 * FUNCTION   : initDefaultParameters
2782 *
2783 * DESCRIPTION: initialize default parameters for the first time
2784 *
2785 * PARAMETERS : none
2786 *
2787 * RETURN     : int32_t type of status
2788 *              NO_ERROR  -- success
2789 *              none-zero failure code
2790 *==========================================================================*/
2791int32_t QCameraParameters::initDefaultParameters()
2792{
2793    if(initBatchUpdate(m_pParamBuf) < 0 ) {
2794        ALOGE("%s:Failed to initialize group update table", __func__);
2795        return BAD_TYPE;
2796    }
2797
2798    /*************************Initialize Values******************************/
2799    // Set read only parameters from camera capability
2800    set(KEY_SMOOTH_ZOOM_SUPPORTED,
2801        m_pCapability->smooth_zoom_supported? VALUE_TRUE : VALUE_FALSE);
2802    set(KEY_ZOOM_SUPPORTED,
2803        m_pCapability->zoom_supported? VALUE_TRUE : VALUE_FALSE);
2804    set(KEY_VIDEO_SNAPSHOT_SUPPORTED,
2805        m_pCapability->video_snapshot_supported? VALUE_TRUE : VALUE_FALSE);
2806    set(KEY_VIDEO_STABILIZATION_SUPPORTED,
2807        m_pCapability->video_stablization_supported? VALUE_TRUE : VALUE_FALSE);
2808    set(KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
2809        m_pCapability->auto_exposure_lock_supported? VALUE_TRUE : VALUE_FALSE);
2810    set(KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
2811        m_pCapability->auto_wb_lock_supported? VALUE_TRUE : VALUE_FALSE);
2812    set(KEY_QC_SUPPORTED_CAMERA_FEATURES,
2813        m_pCapability->qcom_supported_feature_mask);
2814    set(KEY_MAX_NUM_DETECTED_FACES_HW, m_pCapability->max_num_roi);
2815    set(KEY_MAX_NUM_DETECTED_FACES_SW, m_pCapability->max_num_roi);
2816    set(KEY_QC_MAX_NUM_REQUESTED_FACES, m_pCapability->max_num_roi);
2817    // Set focal length, horizontal view angle, and vertical view angle
2818    setFloat(KEY_FOCAL_LENGTH, m_pCapability->focal_length);
2819    setFloat(KEY_HORIZONTAL_VIEW_ANGLE, m_pCapability->hor_view_angle);
2820    setFloat(KEY_VERTICAL_VIEW_ANGLE, m_pCapability->ver_view_angle);
2821
2822    // Set supported preview sizes
2823    if (m_pCapability->preview_sizes_tbl_cnt > 0 &&
2824        m_pCapability->preview_sizes_tbl_cnt <= MAX_SIZES_CNT) {
2825        String8 previewSizeValues = createSizesString(
2826                m_pCapability->preview_sizes_tbl, m_pCapability->preview_sizes_tbl_cnt);
2827        set(KEY_SUPPORTED_PREVIEW_SIZES, previewSizeValues.string());
2828        ALOGD("%s: supported preview sizes: %s", __func__, previewSizeValues.string());
2829        // Set default preview size
2830        CameraParameters::setPreviewSize(m_pCapability->preview_sizes_tbl[0].width,
2831                                         m_pCapability->preview_sizes_tbl[0].height);
2832    } else {
2833        ALOGE("%s: supported preview sizes cnt is 0 or exceeds max!!!", __func__);
2834    }
2835
2836    // Set supported video sizes
2837    if (m_pCapability->video_sizes_tbl_cnt > 0 &&
2838        m_pCapability->video_sizes_tbl_cnt <= MAX_SIZES_CNT) {
2839        String8 videoSizeValues = createSizesString(
2840                m_pCapability->video_sizes_tbl, m_pCapability->video_sizes_tbl_cnt);
2841        set(KEY_SUPPORTED_VIDEO_SIZES, videoSizeValues.string());
2842        ALOGD("%s: supported video sizes: %s", __func__, videoSizeValues.string());
2843        // Set default video size
2844        CameraParameters::setVideoSize(m_pCapability->video_sizes_tbl[0].width,
2845                                       m_pCapability->video_sizes_tbl[0].height);
2846
2847        //Set preferred Preview size for video
2848        String8 vSize = createSizesString(&m_pCapability->video_sizes_tbl[0], 1);
2849        set(KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, vSize.string());
2850    } else {
2851        ALOGE("%s: supported video sizes cnt is 0 or exceeds max!!!", __func__);
2852    }
2853
2854    // Set supported picture sizes
2855    if (m_pCapability->picture_sizes_tbl_cnt > 0 &&
2856        m_pCapability->picture_sizes_tbl_cnt <= MAX_SIZES_CNT) {
2857        String8 pictureSizeValues = createSizesString(
2858                m_pCapability->picture_sizes_tbl, m_pCapability->picture_sizes_tbl_cnt);
2859        set(KEY_SUPPORTED_PICTURE_SIZES, pictureSizeValues.string());
2860        ALOGD("%s: supported pic sizes: %s", __func__, pictureSizeValues.string());
2861        // Set default picture size to the smallest resolution
2862        CameraParameters::setPictureSize(
2863           m_pCapability->picture_sizes_tbl[m_pCapability->picture_sizes_tbl_cnt-1].width,
2864           m_pCapability->picture_sizes_tbl[m_pCapability->picture_sizes_tbl_cnt-1].height);
2865    } else {
2866        ALOGE("%s: supported picture sizes cnt is 0 or exceeds max!!!", __func__);
2867    }
2868
2869    // Set supported thumbnail sizes
2870    String8 thumbnailSizeValues = createSizesString(
2871            THUMBNAIL_SIZES_MAP,
2872            sizeof(THUMBNAIL_SIZES_MAP)/sizeof(cam_dimension_t));
2873    set(KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, thumbnailSizeValues.string());
2874    // Set default thumnail size
2875    set(KEY_JPEG_THUMBNAIL_WIDTH, THUMBNAIL_SIZES_MAP[0].width);
2876    set(KEY_JPEG_THUMBNAIL_HEIGHT, THUMBNAIL_SIZES_MAP[0].height);
2877
2878    // Set supported livesnapshot sizes
2879    if (m_pCapability->livesnapshot_sizes_tbl_cnt > 0 &&
2880        m_pCapability->livesnapshot_sizes_tbl_cnt <= MAX_SIZES_CNT) {
2881        String8 liveSnpashotSizeValues = createSizesString(
2882                m_pCapability->livesnapshot_sizes_tbl,
2883                m_pCapability->livesnapshot_sizes_tbl_cnt);
2884        set(KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES, liveSnpashotSizeValues.string());
2885        ALOGI("%s: supported live snapshot sizes: %s", __func__, liveSnpashotSizeValues.string());
2886        m_LiveSnapshotSize =
2887            m_pCapability->livesnapshot_sizes_tbl[m_pCapability->livesnapshot_sizes_tbl_cnt-1];
2888    }
2889
2890    // Set supported preview formats
2891    String8 previewFormatValues = createValuesString(
2892            (int *)m_pCapability->supported_preview_fmts,
2893            m_pCapability->supported_preview_fmt_cnt,
2894            PREVIEW_FORMATS_MAP,
2895            sizeof(PREVIEW_FORMATS_MAP)/sizeof(QCameraMap));
2896    set(KEY_SUPPORTED_PREVIEW_FORMATS, previewFormatValues.string());
2897    // Set default preview format
2898    CameraParameters::setPreviewFormat(PIXEL_FORMAT_YUV420SP);
2899
2900    // Set default Video Format
2901    set(KEY_VIDEO_FRAME_FORMAT, PIXEL_FORMAT_YUV420SP);
2902
2903    // Set supported picture formats
2904    String8 pictureTypeValues(PIXEL_FORMAT_JPEG);
2905    String8 str = createValuesString(
2906            (int *)m_pCapability->supported_raw_fmts,
2907            m_pCapability->supported_raw_fmt_cnt,
2908            PICTURE_TYPES_MAP,
2909            sizeof(PICTURE_TYPES_MAP)/sizeof(QCameraMap));
2910    if (str.string() != NULL) {
2911        pictureTypeValues.append(",");
2912        pictureTypeValues.append(str);
2913    }
2914
2915    set(KEY_SUPPORTED_PICTURE_FORMATS, pictureTypeValues.string());
2916    // Set default picture Format
2917    CameraParameters::setPictureFormat(PIXEL_FORMAT_JPEG);
2918    // Set raw image size
2919    char raw_size_str[32];
2920    snprintf(raw_size_str, sizeof(raw_size_str), "%dx%d",
2921             m_pCapability->raw_dim.width, m_pCapability->raw_dim.height);
2922    set(KEY_QC_RAW_PICUTRE_SIZE, raw_size_str);
2923
2924    //set default jpeg quality and thumbnail quality
2925    set(KEY_JPEG_QUALITY, 85);
2926    set(KEY_JPEG_THUMBNAIL_QUALITY, 85);
2927
2928    // Set FPS ranges
2929    if (m_pCapability->fps_ranges_tbl_cnt > 0 &&
2930        m_pCapability->fps_ranges_tbl_cnt <= MAX_SIZES_CNT) {
2931        int default_fps_index = 0;
2932        String8 fpsRangeValues = createFpsRangeString(m_pCapability->fps_ranges_tbl,
2933                                                      m_pCapability->fps_ranges_tbl_cnt,
2934                                                      default_fps_index);
2935        set(KEY_SUPPORTED_PREVIEW_FPS_RANGE, fpsRangeValues.string());
2936
2937        int min_fps =
2938            int(m_pCapability->fps_ranges_tbl[default_fps_index].min_fps * 1000);
2939        int max_fps =
2940            int(m_pCapability->fps_ranges_tbl[default_fps_index].max_fps * 1000);
2941        setPreviewFpsRange(min_fps, max_fps);
2942
2943        // Set legacy preview fps
2944        String8 fpsValues = createFpsString(m_pCapability->fps_ranges_tbl,
2945                                            m_pCapability->fps_ranges_tbl_cnt);
2946        set(KEY_SUPPORTED_PREVIEW_FRAME_RATES, fpsValues.string());
2947        CameraParameters::setPreviewFrameRate(max_fps);
2948    } else {
2949        ALOGE("%s: supported fps ranges cnt is 0 or exceeds max!!!", __func__);
2950    }
2951
2952    // Set supported focus modes
2953    if (m_pCapability->supported_focus_modes_cnt > 0) {
2954        String8 focusModeValues = createValuesString(
2955                (int *)m_pCapability->supported_focus_modes,
2956                m_pCapability->supported_focus_modes_cnt,
2957                FOCUS_MODES_MAP,
2958                sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap));
2959        set(KEY_SUPPORTED_FOCUS_MODES, focusModeValues);
2960
2961        // Set default focus mode and update corresponding parameter buf
2962        const char *focusMode = lookupNameByValue(FOCUS_MODES_MAP,
2963                                             sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap),
2964                                             m_pCapability->supported_focus_modes[0]);
2965        if (focusMode != NULL) {
2966            setFocusMode(focusMode);
2967        } else {
2968            setFocusMode(FOCUS_MODE_FIXED);
2969        }
2970    } else {
2971        ALOGE("%s: supported focus modes cnt is 0!!!", __func__);
2972    }
2973
2974    // Set focus areas
2975    if (m_pCapability->max_num_focus_areas > MAX_ROI) {
2976        m_pCapability->max_num_focus_areas = MAX_ROI;
2977    }
2978    set(KEY_MAX_NUM_FOCUS_AREAS, m_pCapability->max_num_focus_areas);
2979    if (m_pCapability->max_num_focus_areas > 0) {
2980        setFocusAreas(DEFAULT_CAMERA_AREA);
2981    }
2982
2983    // Set metering areas
2984    if (m_pCapability->max_num_metering_areas > MAX_ROI) {
2985        m_pCapability->max_num_metering_areas = MAX_ROI;
2986    }
2987    set(KEY_MAX_NUM_METERING_AREAS, m_pCapability->max_num_metering_areas);
2988    if (m_pCapability->max_num_metering_areas > 0) {
2989        setMeteringAreas(DEFAULT_CAMERA_AREA);
2990    }
2991
2992    // Set Saturation
2993    set(KEY_QC_MIN_SATURATION, m_pCapability->saturation_ctrl.min_value);
2994    set(KEY_QC_MAX_SATURATION, m_pCapability->saturation_ctrl.max_value);
2995    set(KEY_QC_SATURATION_STEP, m_pCapability->saturation_ctrl.step);
2996    setSaturation(m_pCapability->saturation_ctrl.def_value);
2997
2998    // Set Sharpness
2999    set(KEY_QC_MIN_SHARPNESS, m_pCapability->sharpness_ctrl.min_value);
3000    set(KEY_QC_MAX_SHARPNESS, m_pCapability->sharpness_ctrl.max_value);
3001    set(KEY_QC_SHARPNESS_STEP, m_pCapability->sharpness_ctrl.step);
3002    setSharpness(m_pCapability->sharpness_ctrl.def_value);
3003
3004    // Set Contrast
3005    set(KEY_QC_MIN_CONTRAST, m_pCapability->contrast_ctrl.min_value);
3006    set(KEY_QC_MAX_CONTRAST, m_pCapability->contrast_ctrl.max_value);
3007    set(KEY_QC_CONTRAST_STEP, m_pCapability->contrast_ctrl.step);
3008    setContrast(m_pCapability->contrast_ctrl.def_value);
3009
3010    // Set SCE factor
3011    set(KEY_QC_MIN_SCE_FACTOR, m_pCapability->sce_ctrl.min_value); // -100
3012    set(KEY_QC_MAX_SCE_FACTOR, m_pCapability->sce_ctrl.max_value); // 100
3013    set(KEY_QC_SCE_FACTOR_STEP, m_pCapability->sce_ctrl.step);     // 10
3014    setSkinToneEnhancement(m_pCapability->sce_ctrl.def_value);     // 0
3015
3016    // Set Brightness
3017    set(KEY_QC_MIN_BRIGHTNESS, m_pCapability->brightness_ctrl.min_value); // 0
3018    set(KEY_QC_MAX_BRIGHTNESS, m_pCapability->brightness_ctrl.max_value); // 6
3019    set(KEY_QC_BRIGHTNESS_STEP, m_pCapability->brightness_ctrl.step);     // 1
3020    setBrightness(m_pCapability->brightness_ctrl.def_value);
3021
3022    // Set Auto exposure
3023    String8 autoExposureValues = createValuesString(
3024            (int *)m_pCapability->supported_aec_modes,
3025            m_pCapability->supported_aec_modes_cnt,
3026            AUTO_EXPOSURE_MAP,
3027            sizeof(AUTO_EXPOSURE_MAP) / sizeof(QCameraMap));
3028    set(KEY_QC_SUPPORTED_AUTO_EXPOSURE, autoExposureValues.string());
3029    setAutoExposure(AUTO_EXPOSURE_FRAME_AVG);
3030
3031    // Set Exposure Compensation
3032    set(KEY_MAX_EXPOSURE_COMPENSATION, m_pCapability->exposure_compensation_max); // 12
3033    set(KEY_MIN_EXPOSURE_COMPENSATION, m_pCapability->exposure_compensation_min); // -12
3034    setFloat(KEY_EXPOSURE_COMPENSATION_STEP, m_pCapability->exposure_compensation_step); // 1/6
3035    setExposureCompensation(m_pCapability->exposure_compensation_default); // 0
3036
3037    // Set Antibanding
3038    String8 antibandingValues = createValuesString(
3039            (int *)m_pCapability->supported_antibandings,
3040            m_pCapability->supported_antibandings_cnt,
3041            ANTIBANDING_MODES_MAP,
3042            sizeof(ANTIBANDING_MODES_MAP) / sizeof(QCameraMap));
3043    set(KEY_SUPPORTED_ANTIBANDING, antibandingValues);
3044    setAntibanding(ANTIBANDING_OFF);
3045
3046    // Set Effect
3047    String8 effectValues = createValuesString(
3048            (int *)m_pCapability->supported_effects,
3049            m_pCapability->supported_effects_cnt,
3050            EFFECT_MODES_MAP,
3051            sizeof(EFFECT_MODES_MAP) / sizeof(QCameraMap));
3052    set(KEY_SUPPORTED_EFFECTS, effectValues);
3053    setEffect(EFFECT_NONE);
3054
3055    // Set WhiteBalance
3056    String8 whitebalanceValues = createValuesString(
3057            (int *)m_pCapability->supported_white_balances,
3058            m_pCapability->supported_white_balances_cnt,
3059            WHITE_BALANCE_MODES_MAP,
3060            sizeof(WHITE_BALANCE_MODES_MAP) / sizeof(QCameraMap));
3061    set(KEY_SUPPORTED_WHITE_BALANCE, whitebalanceValues);
3062    setWhiteBalance(WHITE_BALANCE_AUTO);
3063
3064    // Set Flash mode
3065    String8 flashValues = createValuesString(
3066            (int *)m_pCapability->supported_flash_modes,
3067            m_pCapability->supported_flash_modes_cnt,
3068            FLASH_MODES_MAP,
3069            sizeof(FLASH_MODES_MAP) / sizeof(QCameraMap));
3070    set(KEY_SUPPORTED_FLASH_MODES, flashValues);
3071    setFlash(FLASH_MODE_OFF);
3072
3073    // Set Scene Mode
3074    String8 sceneModeValues = createValuesString(
3075            (int *)m_pCapability->supported_scene_modes,
3076            m_pCapability->supported_scene_modes_cnt,
3077            SCENE_MODES_MAP,
3078            sizeof(SCENE_MODES_MAP) / sizeof(QCameraMap));
3079    set(KEY_SUPPORTED_SCENE_MODES, sceneModeValues);
3080    setSceneMode(SCENE_MODE_AUTO);
3081
3082    // Set ISO Mode
3083    String8 isoValues = createValuesString(
3084            (int *)m_pCapability->supported_iso_modes,
3085            m_pCapability->supported_iso_modes_cnt,
3086            ISO_MODES_MAP,
3087            sizeof(ISO_MODES_MAP) / sizeof(QCameraMap));
3088    set(KEY_QC_SUPPORTED_ISO_MODES, isoValues);
3089    setISOValue(ISO_AUTO);
3090
3091    // Set HFR
3092    String8 hfrValues = createHfrValuesString(
3093            m_pCapability->hfr_tbl,
3094            m_pCapability->hfr_tbl_cnt,
3095            HFR_MODES_MAP,
3096            sizeof(HFR_MODES_MAP) / sizeof(QCameraMap));
3097    set(KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES, hfrValues.string());
3098    String8 hfrSizeValues = createHfrSizesString(
3099            m_pCapability->hfr_tbl,
3100            m_pCapability->hfr_tbl_cnt);
3101    set(KEY_QC_SUPPORTED_HFR_SIZES, hfrSizeValues.string());
3102    setHighFrameRate(VIDEO_HFR_OFF);
3103
3104    // Set Focus algorithms
3105    String8 focusAlgoValues = createValuesString(
3106            (int *)m_pCapability->supported_focus_algos,
3107            m_pCapability->supported_focus_algos_cnt,
3108            FOCUS_ALGO_MAP,
3109            sizeof(FOCUS_ALGO_MAP) / sizeof(QCameraMap));
3110    set(KEY_QC_SUPPORTED_FOCUS_ALGOS, focusAlgoValues);
3111    setSelectableZoneAf(FOCUS_ALGO_AUTO);
3112
3113    // Set Zoom Ratios
3114    if (m_pCapability->zoom_supported > 0) {
3115        String8 zoomRatioValues = createZoomRatioValuesString(
3116                m_pCapability->zoom_ratio_tbl,
3117                m_pCapability->zoom_ratio_tbl_cnt);
3118        set(KEY_ZOOM_RATIOS, zoomRatioValues);
3119        set(KEY_MAX_ZOOM, m_pCapability->zoom_ratio_tbl_cnt - 1);
3120        setZoom(0);
3121    }
3122
3123    // Set Bracketing/HDR
3124    char prop[PROPERTY_VALUE_MAX];
3125    memset(prop, 0, sizeof(prop));
3126    property_get("persist.capture.burst.exposures", prop, "");
3127    if (strlen(prop) > 0) {
3128        set(KEY_QC_CAPTURE_BURST_EXPOSURE, prop);
3129    }
3130    String8 bracketingValues = createValuesStringFromMap(
3131            BRACKETING_MODES_MAP,
3132            sizeof(BRACKETING_MODES_MAP) / sizeof(QCameraMap));
3133    set(KEY_QC_SUPPORTED_AE_BRACKET_MODES, bracketingValues);
3134    setAEBracket(AE_BRACKET_OFF);
3135
3136    // Set Denoise
3137    String8 denoiseValues = createValuesStringFromMap(
3138       DENOISE_ON_OFF_MODES_MAP, sizeof(DENOISE_ON_OFF_MODES_MAP) / sizeof(QCameraMap));
3139    set(KEY_QC_SUPPORTED_DENOISE, denoiseValues.string());
3140    setWaveletDenoise(DENOISE_OFF);
3141
3142    // Set feature enable/disable
3143    String8 enableDisableValues = createValuesStringFromMap(
3144        ENABLE_DISABLE_MODES_MAP, sizeof(ENABLE_DISABLE_MODES_MAP) / sizeof(QCameraMap));
3145
3146    // Set Lens Shading
3147    set(KEY_QC_SUPPORTED_LENSSHADE_MODES, enableDisableValues);
3148    setLensShadeValue(VALUE_ENABLE);
3149
3150    // Set MCE
3151    set(KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES, enableDisableValues);
3152    setMCEValue(VALUE_ENABLE);
3153
3154    // Set DIS
3155    set(KEY_QC_SUPPORTED_DIS_MODES, enableDisableValues);
3156    setDISValue(VALUE_DISABLE);
3157
3158    // Set Histogram
3159    set(KEY_QC_SUPPORTED_HISTOGRAM_MODES, enableDisableValues);
3160    set(KEY_QC_HISTOGRAM, VALUE_DISABLE);
3161
3162    //Set Red Eye Reduction
3163    set(KEY_QC_SUPPORTED_REDEYE_REDUCTION, enableDisableValues);
3164    setRedeyeReduction(VALUE_DISABLE);
3165
3166    //Set SkinTone Enhancement
3167    set(KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES, enableDisableValues);
3168
3169    // Set feature on/off
3170    String8 onOffValues = createValuesStringFromMap(
3171        ON_OFF_MODES_MAP, sizeof(ON_OFF_MODES_MAP) / sizeof(QCameraMap));
3172
3173    //Set Scene Detection
3174    set(KEY_QC_SUPPORTED_SCENE_DETECT, onOffValues);
3175    setSceneDetect(VALUE_OFF);
3176
3177    //Set Face Detection
3178    set(KEY_QC_SUPPORTED_FACE_DETECTION, onOffValues);
3179    set(KEY_QC_FACE_DETECTION, VALUE_OFF);
3180
3181    //Set Face Recognition
3182    set(KEY_QC_SUPPORTED_FACE_RECOGNITION, onOffValues);
3183    set(KEY_QC_FACE_RECOGNITION, VALUE_OFF);
3184
3185    //Set ZSL
3186    set(KEY_QC_SUPPORTED_ZSL_MODES, onOffValues);
3187    set(KEY_QC_ZSL, VALUE_OFF);
3188    m_bZslMode =true;
3189
3190    //Set video HDR
3191    if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_VIDEO_HDR) > 0) {
3192        set(KEY_QC_SUPPORTED_VIDEO_HDR_MODES, onOffValues);
3193        set(KEY_QC_VIDEO_HDR, VALUE_OFF);
3194    }
3195
3196    //Set Touch AF/AEC
3197    String8 touchValues = createValuesStringFromMap(
3198       TOUCH_AF_AEC_MODES_MAP, sizeof(TOUCH_AF_AEC_MODES_MAP) / sizeof(QCameraMap));
3199
3200    set(KEY_QC_SUPPORTED_TOUCH_AF_AEC, touchValues);
3201    set(KEY_QC_TOUCH_AF_AEC, TOUCH_AF_AEC_OFF);
3202
3203    //set flip mode
3204    if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_FLIP) > 0) {
3205        String8 flipModes = createValuesStringFromMap(
3206           FLIP_MODES_MAP, sizeof(FLIP_MODES_MAP) / sizeof(QCameraMap));
3207        set(KEY_QC_SUPPORTED_FLIP_MODES, flipModes);
3208        set(KEY_QC_PREVIEW_FLIP, FLIP_MODE_OFF);
3209        set(KEY_QC_VIDEO_FLIP, FLIP_MODE_OFF);
3210        set(KEY_QC_SNAPSHOT_PICTURE_FLIP, FLIP_MODE_OFF);
3211    }
3212
3213    // Set default Auto Exposure lock value
3214    setAecLock(VALUE_FALSE);
3215
3216    // Set default AWB_LOCK lock value
3217    setAwbLock(VALUE_FALSE);
3218
3219    // Set default Camera mode
3220    set(KEY_QC_CAMERA_MODE, 0);
3221
3222    // TODO: hardcode for now until mctl add support for min_num_pp_bufs
3223    m_pCapability->min_num_pp_bufs = 3;
3224
3225    int32_t rc = commitParameters();
3226    if (rc == NO_ERROR) {
3227        rc = setNumOfSnapshot();
3228    }
3229    return rc;
3230}
3231
3232/*===========================================================================
3233 * FUNCTION   : init
3234 *
3235 * DESCRIPTION: initialize parameter obj
3236 *
3237 * PARAMETERS :
3238 *   @capabilities  : ptr to camera capabilities
3239 *   @mmops         : ptr to memory ops table for mapping/unmapping
3240 *
3241 * RETURN     : int32_t type of status
3242 *              NO_ERROR  -- success
3243 *              none-zero failure code
3244 *==========================================================================*/
3245int32_t QCameraParameters::init(cam_capability_t *capabilities, mm_camera_vtbl_t *mmOps)
3246{
3247    int32_t rc = NO_ERROR;
3248
3249    m_pCapability = capabilities;
3250    m_pCamOpsTbl = mmOps;
3251
3252    //Allocate Set Param Buffer
3253    m_pParamHeap = new QCameraHeapMemory();
3254    rc = m_pParamHeap->allocate(1, sizeof(parm_buffer_t));
3255    if(rc != OK) {
3256        rc = NO_MEMORY;
3257        ALOGE("Failed to allocate SETPARM Heap memory");
3258        goto TRANS_INIT_ERROR1;
3259    }
3260
3261    //Map memory for parameters buffer
3262    rc = m_pCamOpsTbl->ops->map_buf(m_pCamOpsTbl->camera_handle,
3263                             CAM_MAPPING_BUF_TYPE_PARM_BUF,
3264                             m_pParamHeap->getFd(0),
3265                             sizeof(parm_buffer_t));
3266    if(rc < 0) {
3267        ALOGE("%s:failed to map SETPARM buffer",__func__);
3268        rc = FAILED_TRANSACTION;
3269        goto TRANS_INIT_ERROR2;
3270    }
3271    m_pParamBuf = (parm_buffer_t*) DATA_PTR(m_pParamHeap,0);
3272
3273    initDefaultParameters();
3274
3275    goto TRANS_INIT_DONE;
3276
3277TRANS_INIT_ERROR2:
3278    m_pParamHeap->deallocate();
3279
3280TRANS_INIT_ERROR1:
3281    delete m_pParamHeap;
3282    m_pParamHeap = NULL;
3283
3284TRANS_INIT_DONE:
3285    return rc;
3286}
3287
3288/*===========================================================================
3289 * FUNCTION   : deinit
3290 *
3291 * DESCRIPTION: deinitialize
3292 *
3293 * PARAMETERS : none
3294 *
3295 * RETURN     : none
3296 *==========================================================================*/
3297void QCameraParameters::deinit()
3298{
3299    //clear all entries in the map
3300    String8 emptyStr;
3301    QCameraParameters::unflatten(emptyStr);
3302
3303    if (NULL != m_pCamOpsTbl) {
3304        m_pCamOpsTbl->ops->unmap_buf(
3305                             m_pCamOpsTbl->camera_handle,
3306                             CAM_MAPPING_BUF_TYPE_PARM_BUF);
3307        m_pCamOpsTbl = NULL;
3308    }
3309    m_pCapability = NULL;
3310    if (NULL != m_pParamHeap) {
3311        m_pParamHeap->deallocate();
3312        delete m_pParamHeap;
3313        m_pParamHeap = NULL;
3314        m_pParamBuf = NULL;
3315    }
3316
3317    m_tempMap.clear();
3318}
3319
3320/*===========================================================================
3321 * FUNCTION   : parse_pair
3322 *
3323 * DESCRIPTION: helper function to parse string like "640x480" or "10000,20000"
3324 *
3325 * PARAMETERS :
3326 *   @str     : input string to be parse
3327 *   @first   : [output] first value of the pair
3328 *   @second  : [output]  second value of the pair
3329 *   @delim   : [input] delimeter to seperate the pair
3330 *   @endptr  : [output] ptr to the end of the pair string
3331 *
3332 * RETURN     : int32_t type of status
3333 *              NO_ERROR  -- success
3334 *              none-zero failure code
3335 *==========================================================================*/
3336int32_t QCameraParameters::parse_pair(const char *str,
3337                                      int *first,
3338                                      int *second,
3339                                      char delim,
3340                                      char **endptr = NULL)
3341{
3342    // Find the first integer.
3343    char *end;
3344    int w = (int)strtol(str, &end, 10);
3345    // If a delimeter does not immediately follow, give up.
3346    if (*end != delim) {
3347        ALOGE("Cannot find delimeter (%c) in str=%s", delim, str);
3348        return BAD_VALUE;
3349    }
3350
3351    // Find the second integer, immediately after the delimeter.
3352    int h = (int)strtol(end+1, &end, 10);
3353
3354    *first = w;
3355    *second = h;
3356
3357    if (endptr) {
3358        *endptr = end;
3359    }
3360
3361    return NO_ERROR;
3362}
3363
3364/*===========================================================================
3365 * FUNCTION   : parseSizesList
3366 *
3367 * DESCRIPTION: helper function to parse string containing sizes
3368 *
3369 * PARAMETERS :
3370 *   @sizesStr: [input] input string to be parse
3371 *   @sizes   : [output] reference to store parsed sizes
3372 *
3373 * RETURN     : none
3374 *==========================================================================*/
3375void QCameraParameters::parseSizesList(const char *sizesStr, Vector<Size> &sizes)
3376{
3377    if (sizesStr == 0) {
3378        return;
3379    }
3380
3381    char *sizeStartPtr = (char *)sizesStr;
3382
3383    while (true) {
3384        int width, height;
3385        int success = parse_pair(sizeStartPtr, &width, &height, 'x',
3386                                 &sizeStartPtr);
3387        if (success == -1 || (*sizeStartPtr != ',' && *sizeStartPtr != '\0')) {
3388            ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
3389            return;
3390        }
3391        sizes.push(Size(width, height));
3392
3393        if (*sizeStartPtr == '\0') {
3394            return;
3395        }
3396        sizeStartPtr++;
3397    }
3398}
3399
3400/*===========================================================================
3401 * FUNCTION   : getSupportedHfrSizes
3402 *
3403 * DESCRIPTION: return supported HFR sizes
3404 *
3405 * PARAMETERS :
3406 *   @sizes  : [output] reference to a vector storing supported HFR sizes
3407 *
3408 * RETURN     : none
3409 *==========================================================================*/
3410void QCameraParameters::getSupportedHfrSizes(Vector<Size> &sizes)
3411{
3412    const char *hfrSizesStr = get(KEY_QC_SUPPORTED_HFR_SIZES);
3413    parseSizesList(hfrSizesStr, sizes);
3414}
3415
3416/*===========================================================================
3417 * FUNCTION   : adjustPreviewFpsRanges
3418 *
3419 * DESCRIPTION: adjust preview FPS ranges
3420 *              according to external events
3421 *
3422 * PARAMETERS :
3423 *   @minFPS  : min FPS value
3424 *   @maxFPS  : max FPS value
3425 *
3426 * RETURN     : int32_t type of status
3427 *              NO_ERROR  -- success
3428 *              none-zero failure code
3429 *==========================================================================*/
3430int32_t QCameraParameters::adjustPreviewFpsRange(cam_fps_range_t *fpsRange)
3431{
3432    if ( fpsRange == NULL ) {
3433        return BAD_VALUE;
3434    }
3435
3436    int32_t rc = initBatchUpdate(m_pParamBuf);
3437    if ( rc != NO_ERROR ) {
3438        ALOGE("%s:Failed to initialize group update table", __func__);
3439        return rc;
3440    }
3441
3442    rc = AddSetParmEntryToBatch(m_pParamBuf,
3443                                  CAM_INTF_PARM_FPS_RANGE,
3444                                  sizeof(cam_fps_range_t),
3445                                  fpsRange);
3446    if ( rc != NO_ERROR ) {
3447        ALOGE("%s: Parameters batch failed",__func__);
3448        return rc;
3449    }
3450
3451    rc = commitSetBatch();
3452    if ( rc != NO_ERROR ) {
3453        ALOGE("%s:Failed to commit batch parameters", __func__);
3454        return rc;
3455    }
3456
3457    return rc;
3458}
3459
3460/*===========================================================================
3461 * FUNCTION   : setPreviewFpsRanges
3462 *
3463 * DESCRIPTION: set preview FPS ranges
3464 *
3465 * PARAMETERS :
3466 *   @minFPS  : min FPS value
3467 *   @maxFPS  : max FPS value
3468 *
3469 * RETURN     : int32_t type of status
3470 *              NO_ERROR  -- success
3471 *              none-zero failure code
3472 *==========================================================================*/
3473int32_t QCameraParameters::setPreviewFpsRange(int minFPS, int maxFPS)
3474{
3475    char str[32];
3476    snprintf(str, sizeof(str), "%d,%d", minFPS, maxFPS);
3477    ALOGD("%s: Setting preview fps range %s", __func__, str);
3478    updateParamEntry(KEY_PREVIEW_FPS_RANGE, str);
3479    cam_fps_range_t fps_range = {(float)(minFPS / 1000.0), (float)(maxFPS / 1000.0)};
3480    return AddSetParmEntryToBatch(m_pParamBuf,
3481                                  CAM_INTF_PARM_FPS_RANGE,
3482                                  sizeof(cam_fps_range_t),
3483                                  &fps_range);
3484}
3485
3486/*===========================================================================
3487 * FUNCTION   : setAutoExposure
3488 *
3489 * DESCRIPTION: set auto exposure
3490 *
3491 * PARAMETERS :
3492 *   @autoExp : auto exposure value string
3493 *
3494 * RETURN     : int32_t type of status
3495 *              NO_ERROR  -- success
3496 *              none-zero failure code
3497 *==========================================================================*/
3498int32_t QCameraParameters::setAutoExposure(const char *autoExp)
3499{
3500    if (autoExp != NULL) {
3501        int32_t value = lookupAttr(AUTO_EXPOSURE_MAP,
3502                                   sizeof(AUTO_EXPOSURE_MAP)/sizeof(AUTO_EXPOSURE_MAP[0]),
3503                                   autoExp);
3504        if (value != NAME_NOT_FOUND) {
3505            ALOGD("%s: Setting auto exposure %s", __func__, autoExp);
3506            updateParamEntry(KEY_QC_AUTO_EXPOSURE, autoExp);
3507            return AddSetParmEntryToBatch(m_pParamBuf,
3508                                          CAM_INTF_PARM_AEC_ALGO_TYPE,
3509                                          sizeof(value),
3510                                          &value);
3511        }
3512    }
3513    ALOGE("Invalid auto exposure value: %s", (autoExp == NULL) ? "NULL" : autoExp);
3514    return BAD_VALUE;
3515}
3516
3517/*===========================================================================
3518 * FUNCTION   : setEffect
3519 *
3520 * DESCRIPTION: set effect
3521 *
3522 * PARAMETERS :
3523 *   @effect  : effect value string
3524 *
3525 * RETURN     : int32_t type of status
3526 *              NO_ERROR  -- success
3527 *              none-zero failure code
3528 *==========================================================================*/
3529int32_t QCameraParameters::setEffect(const char *effect)
3530{
3531    if (effect != NULL) {
3532        int32_t value = lookupAttr(EFFECT_MODES_MAP,
3533                                   sizeof(EFFECT_MODES_MAP)/sizeof(QCameraMap),
3534                                   effect);
3535        if (value != NAME_NOT_FOUND) {
3536            ALOGD("%s: Setting effect %s", __func__, effect);
3537            updateParamEntry(KEY_EFFECT, effect);
3538            return AddSetParmEntryToBatch(m_pParamBuf,
3539                                          CAM_INTF_PARM_EFFECT,
3540                                          sizeof(value),
3541                                          &value);
3542        }
3543    }
3544    ALOGE("Invalid effect value: %s", (effect == NULL) ? "NULL" : effect);
3545    return BAD_VALUE;
3546}
3547
3548/*===========================================================================
3549 * FUNCTION   : setBrightness
3550 *
3551 * DESCRIPTION: set brightness control value
3552 *
3553 * PARAMETERS :
3554 *   @brightness  : brightness control value
3555 *
3556 * RETURN     : int32_t type of status
3557 *              NO_ERROR  -- success
3558 *              none-zero failure code
3559 *==========================================================================*/
3560int32_t QCameraParameters::setBrightness(int brightness)
3561{
3562    char val[16];
3563    sprintf(val, "%d", brightness);
3564    updateParamEntry(KEY_QC_BRIGHTNESS, val);
3565
3566    int32_t value = brightness;
3567    ALOGD("%s: Setting brightness %s", __func__, val);
3568    return AddSetParmEntryToBatch(m_pParamBuf,
3569                                  CAM_INTF_PARM_BRIGHTNESS,
3570                                  sizeof(value),
3571                                  &value);
3572}
3573
3574/*===========================================================================
3575 * FUNCTION   : setFocusMode
3576 *
3577 * DESCRIPTION: set focus mode
3578 *
3579 * PARAMETERS :
3580 *   @focusMode  : focus mode value string
3581 *
3582 * RETURN     : int32_t type of status
3583 *              NO_ERROR  -- success
3584 *              none-zero failure code
3585 *==========================================================================*/
3586int32_t QCameraParameters::setFocusMode(const char *focusMode)
3587{
3588    if (focusMode != NULL) {
3589        int32_t value = lookupAttr(FOCUS_MODES_MAP,
3590                                   sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap),
3591                                   focusMode);
3592        if (value != NAME_NOT_FOUND) {
3593            ALOGD("%s: Setting focus mode %s", __func__, focusMode);
3594            mFocusMode = (cam_focus_mode_type)value;
3595
3596            // reset need lock CAF flag
3597            m_bNeedLockCAF = false;
3598            m_bCAFLocked = false;
3599            m_bAFRunning = false;
3600
3601            updateParamEntry(KEY_FOCUS_MODE, focusMode);
3602            return AddSetParmEntryToBatch(m_pParamBuf,
3603                                          CAM_INTF_PARM_FOCUS_MODE,
3604                                          sizeof(value),
3605                                          &value);
3606        }
3607    }
3608    ALOGE("Invalid focus mode value: %s", (focusMode == NULL) ? "NULL" : focusMode);
3609    return BAD_VALUE;
3610}
3611
3612/*===========================================================================
3613 * FUNCTION   : setSharpness
3614 *
3615 * DESCRIPTION: set sharpness control value
3616 *
3617 * PARAMETERS :
3618 *   @sharpness  : sharpness control value
3619 *
3620 * RETURN     : int32_t type of status
3621 *              NO_ERROR  -- success
3622 *              none-zero failure code
3623 *==========================================================================*/
3624int32_t QCameraParameters::setSharpness(int sharpness)
3625{
3626    char val[16];
3627    sprintf(val, "%d", sharpness);
3628    updateParamEntry(KEY_QC_SHARPNESS, val);
3629    ALOGD("%s: Setting sharpness %s", __func__, val);
3630
3631    int32_t value = sharpness;
3632    return AddSetParmEntryToBatch(m_pParamBuf,
3633                                  CAM_INTF_PARM_SHARPNESS,
3634                                  sizeof(value),
3635                                  &value);
3636}
3637
3638/*===========================================================================
3639 * FUNCTION   : setSkinToneEnhancement
3640 *
3641 * DESCRIPTION: set skin tone enhancement value
3642 *
3643 * PARAMETERS :
3644 *   @sceFactore  : skin tone enhancement factor value
3645 *
3646 * RETURN     : int32_t type of status
3647 *              NO_ERROR  -- success
3648 *              none-zero failure code
3649 *==========================================================================*/
3650int32_t QCameraParameters::setSkinToneEnhancement(int sceFactor)
3651{
3652    char val[16];
3653    sprintf(val, "%d", sceFactor);
3654    updateParamEntry(KEY_QC_SCE_FACTOR, val);
3655    ALOGD("%s: Setting skintone enhancement %s", __func__, val);
3656
3657    int32_t value = sceFactor;
3658    return AddSetParmEntryToBatch(m_pParamBuf,
3659                                  CAM_INTF_PARM_SCE_FACTOR,
3660                                  sizeof(value),
3661                                  &value);
3662}
3663
3664/*===========================================================================
3665 * FUNCTION   : setSaturation
3666 *
3667 * DESCRIPTION: set saturation control value
3668 *
3669 * PARAMETERS :
3670 *   @saturation : saturation control value
3671 *
3672 * RETURN     : int32_t type of status
3673 *              NO_ERROR  -- success
3674 *              none-zero failure code
3675 *==========================================================================*/
3676int32_t QCameraParameters::setSaturation(int saturation)
3677{
3678    char val[16];
3679    sprintf(val, "%d", saturation);
3680    updateParamEntry(KEY_QC_SATURATION, val);
3681    ALOGD("%s: Setting saturation %s", __func__, val);
3682
3683    int32_t value = saturation;
3684    return AddSetParmEntryToBatch(m_pParamBuf,
3685                                  CAM_INTF_PARM_SATURATION,
3686                                  sizeof(value),
3687                                  &value);
3688}
3689
3690/*===========================================================================
3691 * FUNCTION   : setContrast
3692 *
3693 * DESCRIPTION: set contrast control value
3694 *
3695 * PARAMETERS :
3696 *   @contrast : contrast control value
3697 *
3698 * RETURN     : int32_t type of status
3699 *              NO_ERROR  -- success
3700 *              none-zero failure code
3701 *==========================================================================*/
3702int32_t QCameraParameters::setContrast(int contrast)
3703{
3704    char val[16];
3705    sprintf(val, "%d", contrast);
3706    updateParamEntry(KEY_QC_CONTRAST, val);
3707    ALOGD("%s: Setting contrast %s", __func__, val);
3708
3709    int32_t value = contrast;
3710    return AddSetParmEntryToBatch(m_pParamBuf,
3711                                  CAM_INTF_PARM_CONTRAST,
3712                                  sizeof(value),
3713                                  &value);
3714}
3715
3716/*===========================================================================
3717 * FUNCTION   : setSceneDetect
3718 *
3719 * DESCRIPTION: set scenen detect value
3720 *
3721 * PARAMETERS :
3722 *   @sceneDetect  : scene detect value string
3723 *
3724 * RETURN     : int32_t type of status
3725 *              NO_ERROR  -- success
3726 *              none-zero failure code
3727 *==========================================================================*/
3728int32_t QCameraParameters::setSceneDetect(const char *sceneDetect)
3729{
3730    if (sceneDetect != NULL) {
3731        int32_t value = lookupAttr(ON_OFF_MODES_MAP,
3732                                   sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap),
3733                                   sceneDetect);
3734        if (value != NAME_NOT_FOUND) {
3735            ALOGD("%s: Setting Scene Detect %s", __func__, sceneDetect);
3736            updateParamEntry(KEY_QC_SCENE_DETECT, sceneDetect);
3737            return AddSetParmEntryToBatch(m_pParamBuf,
3738                                          CAM_INTF_PARM_ASD_ENABLE,
3739                                          sizeof(value),
3740                                          &value);
3741        }
3742    }
3743    ALOGE("Invalid Scene Detect value: %s",
3744          (sceneDetect == NULL) ? "NULL" : sceneDetect);
3745    return BAD_VALUE;
3746}
3747
3748/*===========================================================================
3749 * FUNCTION   : setVideoHDR
3750 *
3751 * DESCRIPTION: set video HDR value
3752 *
3753 * PARAMETERS :
3754 *   @videoHDR  : svideo HDR value string
3755 *
3756 * RETURN     : int32_t type of status
3757 *              NO_ERROR  -- success
3758 *              none-zero failure code
3759 *==========================================================================*/
3760int32_t QCameraParameters::setVideoHDR(const char *videoHDR)
3761{
3762    if (videoHDR != NULL) {
3763        int32_t value = lookupAttr(ON_OFF_MODES_MAP,
3764                                   sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap),
3765                                   videoHDR);
3766        if (value != NAME_NOT_FOUND) {
3767            ALOGD("%s: Setting Video HDR %s", __func__, videoHDR);
3768            updateParamEntry(KEY_QC_VIDEO_HDR, videoHDR);
3769            return AddSetParmEntryToBatch(m_pParamBuf,
3770                                          CAM_INTF_PARM_VIDEO_HDR,
3771                                          sizeof(value),
3772                                          &value);
3773        }
3774    }
3775    ALOGE("Invalid Video HDR value: %s",
3776          (videoHDR == NULL) ? "NULL" : videoHDR);
3777    return BAD_VALUE;
3778}
3779
3780/*===========================================================================
3781 * FUNCTION   : setFaceRecognition
3782 *
3783 * DESCRIPTION: set face recognition value
3784 *
3785 * PARAMETERS :
3786 *   @faceRecog  : face recognition value string
3787 *   @maxFaces   : number of max faces to be detected/recognized
3788 *
3789 * RETURN     : int32_t type of status
3790 *              NO_ERROR  -- success
3791 *              none-zero failure code
3792 *==========================================================================*/
3793int32_t QCameraParameters::setFaceRecognition(const char *faceRecog, int maxFaces)
3794{
3795    if (faceRecog != NULL) {
3796        int32_t value = lookupAttr(ON_OFF_MODES_MAP,
3797                                   sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap),
3798                                   faceRecog);
3799        if (value != NAME_NOT_FOUND) {
3800            ALOGD("%s: Setting face recognition %s", __func__, faceRecog);
3801            updateParamEntry(KEY_QC_FACE_RECOGNITION, faceRecog);
3802
3803            int faceProcMask = m_nFaceProcMask;
3804            if (value > 0) {
3805                faceProcMask |= CAM_FACE_PROCESS_MASK_RECOGNITION;
3806            } else {
3807                faceProcMask &= ~CAM_FACE_PROCESS_MASK_RECOGNITION;
3808            }
3809
3810            if(m_nFaceProcMask == faceProcMask) {
3811                ALOGD("%s: face process mask not changed, no ops here", __func__);
3812                return NO_ERROR;
3813            }
3814            m_nFaceProcMask = faceProcMask;
3815            ALOGD("%s: FaceProcMask -> %d", __func__, m_nFaceProcMask);
3816
3817            // set parm for face process
3818            cam_fd_set_parm_t fd_set_parm;
3819            memset(&fd_set_parm, 0, sizeof(cam_fd_set_parm_t));
3820            fd_set_parm.fd_mode = m_nFaceProcMask;
3821            fd_set_parm.num_fd = maxFaces;
3822
3823            return AddSetParmEntryToBatch(m_pParamBuf,
3824                                        CAM_INTF_PARM_FD,
3825                                        sizeof(fd_set_parm),
3826                                        &fd_set_parm);
3827        }
3828    }
3829    ALOGE("Invalid face recognition value: %s", (faceRecog == NULL) ? "NULL" : faceRecog);
3830    return BAD_VALUE;
3831}
3832
3833/*===========================================================================
3834 * FUNCTION   : setZoom
3835 *
3836 * DESCRIPTION: set zoom level
3837 *
3838 * PARAMETERS :
3839 *   @zoom_level : zoom level
3840 *
3841 * RETURN     : int32_t type of status
3842 *              NO_ERROR  -- success
3843 *              none-zero failure code
3844 *==========================================================================*/
3845int32_t QCameraParameters::setZoom(int zoom_level)
3846{
3847    char val[16];
3848    sprintf(val, "%d", zoom_level);
3849    updateParamEntry(KEY_ZOOM, val);
3850
3851    return AddSetParmEntryToBatch(m_pParamBuf,
3852                                  CAM_INTF_PARM_ZOOM,
3853                                  sizeof(zoom_level),
3854                                  &zoom_level);
3855}
3856
3857/*===========================================================================
3858 * FUNCTION   : setISOValue
3859 *
3860 * DESCRIPTION: set ISO value
3861 *
3862 * PARAMETERS :
3863 *   @isoValue : ISO value string
3864 *
3865 * RETURN     : int32_t type of status
3866 *              NO_ERROR  -- success
3867 *              none-zero failure code
3868 *==========================================================================*/
3869int32_t  QCameraParameters::setISOValue(const char *isoValue)
3870{
3871    if (isoValue != NULL) {
3872        int32_t value = lookupAttr(ISO_MODES_MAP,
3873                                   sizeof(ISO_MODES_MAP)/sizeof(QCameraMap),
3874                                   isoValue);
3875        if (value != NAME_NOT_FOUND) {
3876            ALOGD("%s: Setting ISO value %s", __func__, isoValue);
3877            updateParamEntry(KEY_QC_ISO_MODE, isoValue);
3878            return AddSetParmEntryToBatch(m_pParamBuf,
3879                                          CAM_INTF_PARM_ISO,
3880                                          sizeof(value),
3881                                          &value);
3882        }
3883    }
3884    ALOGE("Invalid ISO value: %s",
3885          (isoValue == NULL) ? "NULL" : isoValue);
3886    return BAD_VALUE;
3887}
3888
3889/*===========================================================================
3890 * FUNCTION   : setFlash
3891 *
3892 * DESCRIPTION: set f;ash mode
3893 *
3894 * PARAMETERS :
3895 *   @flashStr : LED flash mode value string
3896 *
3897 * RETURN     : int32_t type of status
3898 *              NO_ERROR  -- success
3899 *              none-zero failure code
3900 *==========================================================================*/
3901int32_t QCameraParameters::setFlash(const char *flashStr)
3902{
3903    if (flashStr != NULL) {
3904        int32_t value = lookupAttr(FLASH_MODES_MAP,
3905                                   sizeof(FLASH_MODES_MAP)/sizeof(QCameraMap),
3906                                   flashStr);
3907        if (value != NAME_NOT_FOUND) {
3908            ALOGD("%s: Setting Flash value %s", __func__, flashStr);
3909            updateParamEntry(KEY_FLASH_MODE, flashStr);
3910            return AddSetParmEntryToBatch(m_pParamBuf,
3911                                          CAM_INTF_PARM_LED_MODE,
3912                                          sizeof(value),
3913                                          &value);
3914        }
3915    }
3916    ALOGE("Invalid flash value: %s", (flashStr == NULL) ? "NULL" : flashStr);
3917    return BAD_VALUE;
3918}
3919
3920/*===========================================================================
3921 * FUNCTION   : setAecLock
3922 *
3923 * DESCRIPTION: set AEC lock value
3924 *
3925 * PARAMETERS :
3926 *   @aecLockStr : AEC lock value string
3927 *
3928 * RETURN     : int32_t type of status
3929 *              NO_ERROR  -- success
3930 *              none-zero failure code
3931 *==========================================================================*/
3932int32_t QCameraParameters::setAecLock(const char *aecLockStr)
3933{
3934    if (aecLockStr != NULL) {
3935        int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP,
3936                                   sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap),
3937                                   aecLockStr);
3938        if (value != NAME_NOT_FOUND) {
3939            ALOGD("%s: Setting AECLock value %s", __func__, aecLockStr);
3940            updateParamEntry(KEY_AUTO_EXPOSURE_LOCK, aecLockStr);
3941            return AddSetParmEntryToBatch(m_pParamBuf,
3942                                          CAM_INTF_PARM_AEC_LOCK,
3943                                          sizeof(value),
3944                                          &value);
3945        }
3946    }
3947    ALOGE("Invalid AECLock value: %s", (aecLockStr == NULL) ? "NULL" : aecLockStr);
3948    return BAD_VALUE;
3949}
3950
3951/*===========================================================================
3952 * FUNCTION   : setAwbLock
3953 *
3954 * DESCRIPTION: set AWB lock value
3955 *
3956 * PARAMETERS :
3957 *   @awbLockStr : AWB lock value string
3958 *
3959 * RETURN     : int32_t type of status
3960 *              NO_ERROR  -- success
3961 *              none-zero failure code
3962 *==========================================================================*/
3963int32_t QCameraParameters::setAwbLock(const char *awbLockStr)
3964{
3965    if (awbLockStr != NULL) {
3966        int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP,
3967                                   sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap),
3968                                   awbLockStr);
3969        if (value != NAME_NOT_FOUND) {
3970            ALOGD("%s: Setting AWBLock value %s", __func__, awbLockStr);
3971            updateParamEntry(KEY_AUTO_WHITEBALANCE_LOCK, awbLockStr);
3972            return AddSetParmEntryToBatch(m_pParamBuf,
3973                                          CAM_INTF_PARM_AWB_LOCK,
3974                                          sizeof(value),
3975                                          &value);
3976        }
3977    }
3978    ALOGE("Invalid AWBLock value: %s", (awbLockStr == NULL) ? "NULL" : awbLockStr);
3979    return BAD_VALUE;
3980}
3981
3982/*===========================================================================
3983 * FUNCTION   : setMCEValue
3984 *
3985 * DESCRIPTION: set memory color enhancement value
3986 *
3987 * PARAMETERS :
3988 *   @mceStr : MCE value string
3989 *
3990 * RETURN     : int32_t type of status
3991 *              NO_ERROR  -- success
3992 *              none-zero failure code
3993 *==========================================================================*/
3994int32_t QCameraParameters::setMCEValue(const char *mceStr)
3995{
3996    if (mceStr != NULL) {
3997        int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
3998                                   sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap),
3999                                   mceStr);
4000        if (value != NAME_NOT_FOUND) {
4001            ALOGD("%s: Setting AWBLock value %s", __func__, mceStr);
4002            updateParamEntry(KEY_QC_MEMORY_COLOR_ENHANCEMENT, mceStr);
4003            return AddSetParmEntryToBatch(m_pParamBuf,
4004                                          CAM_INTF_PARM_MCE,
4005                                          sizeof(value),
4006                                          &value);
4007        }
4008    }
4009    ALOGE("Invalid MCE value: %s", (mceStr == NULL) ? "NULL" : mceStr);
4010    return BAD_VALUE;
4011}
4012
4013/*===========================================================================
4014 * FUNCTION   : setDISValue
4015 *
4016 * DESCRIPTION: set DIS value
4017 *
4018 * PARAMETERS :
4019 *   @disStr : DIS value string
4020 *
4021 * RETURN     : int32_t type of status
4022 *              NO_ERROR  -- success
4023 *              none-zero failure code
4024 *==========================================================================*/
4025int32_t QCameraParameters::setDISValue(const char *disStr)
4026{
4027    if (disStr != NULL) {
4028        int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
4029                                   sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap),
4030                                   disStr);
4031        if (value != NAME_NOT_FOUND) {
4032            ALOGD("%s: Setting DIS value %s", __func__, disStr);
4033            updateParamEntry(KEY_QC_DIS, disStr);
4034            return AddSetParmEntryToBatch(m_pParamBuf,
4035                                          CAM_INTF_PARM_DIS_ENABLE,
4036                                          sizeof(value),
4037                                          &value);
4038        }
4039    }
4040    ALOGE("Invalid DIS value: %s", (disStr == NULL) ? "NULL" : disStr);
4041    return BAD_VALUE;
4042}
4043
4044/*===========================================================================
4045 * FUNCTION   : setHighFrameRate
4046 *
4047 * DESCRIPTION: set high frame rate
4048 *
4049 * PARAMETERS :
4050 *   @hfrStr : HFR value string
4051 *
4052 * RETURN     : int32_t type of status
4053 *              NO_ERROR  -- success
4054 *              none-zero failure code
4055 *==========================================================================*/
4056int32_t QCameraParameters::setHighFrameRate(const char *hfrStr)
4057{
4058    if (hfrStr != NULL) {
4059        int32_t value = lookupAttr(HFR_MODES_MAP,
4060                                   sizeof(HFR_MODES_MAP)/sizeof(QCameraMap),
4061                                   hfrStr);
4062        if (value != NAME_NOT_FOUND) {
4063            // HFR value changed, need to restart preview
4064            m_bNeedRestart = true;
4065            // Set HFR value
4066            ALOGD("%s: Setting HFR value %s", __func__, hfrStr);
4067            updateParamEntry(KEY_QC_VIDEO_HIGH_FRAME_RATE, hfrStr);
4068            return AddSetParmEntryToBatch(m_pParamBuf,
4069                                          CAM_INTF_PARM_HFR,
4070                                          sizeof(value),
4071                                          &value);
4072        }
4073    }
4074    ALOGE("Invalid HFR value: %s", (hfrStr == NULL) ? "NULL" : hfrStr);
4075    return BAD_VALUE;
4076}
4077
4078/*===========================================================================
4079 * FUNCTION   : setLensShadeValue
4080 *
4081 * DESCRIPTION: set lens shade value
4082 *
4083 * PARAMETERS :
4084 *   @lensSahdeStr : lens shade value string
4085 *
4086 * RETURN     : int32_t type of status
4087 *              NO_ERROR  -- success
4088 *              none-zero failure code
4089 *==========================================================================*/
4090int32_t QCameraParameters::setLensShadeValue(const char *lensShadeStr)
4091{
4092    if (lensShadeStr != NULL) {
4093        int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
4094                                   sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap),
4095                                   lensShadeStr);
4096        if (value != NAME_NOT_FOUND) {
4097            ALOGD("%s: Setting LensShade value %s", __func__, lensShadeStr);
4098            updateParamEntry(KEY_QC_LENSSHADE, lensShadeStr);
4099            return AddSetParmEntryToBatch(m_pParamBuf,
4100                                          CAM_INTF_PARM_ROLLOFF,
4101                                          sizeof(value),
4102                                          &value);
4103        }
4104    }
4105    ALOGE("Invalid LensShade value: %s",
4106          (lensShadeStr == NULL) ? "NULL" : lensShadeStr);
4107    return BAD_VALUE;
4108}
4109
4110/*===========================================================================
4111 * FUNCTION   : setExposureCompensation
4112 *
4113 * DESCRIPTION: set exposure compensation value
4114 *
4115 * PARAMETERS :
4116 *   @expComp : exposure compensation value
4117 *
4118 * RETURN     : int32_t type of status
4119 *              NO_ERROR  -- success
4120 *              none-zero failure code
4121 *==========================================================================*/
4122int32_t QCameraParameters::setExposureCompensation(int expComp)
4123{
4124    char val[16];
4125    sprintf(val, "%d", expComp);
4126    updateParamEntry(KEY_EXPOSURE_COMPENSATION, val);
4127
4128    // Don't need to pass step as part of setParameter because
4129    // camera daemon is already aware of it.
4130    return AddSetParmEntryToBatch(m_pParamBuf,
4131                                  CAM_INTF_PARM_EXPOSURE_COMPENSATION,
4132                                  sizeof(expComp),
4133                                  &expComp);
4134}
4135
4136/*===========================================================================
4137 * FUNCTION   : setWhiteBalance
4138 *
4139 * DESCRIPTION: set white balance mode
4140 *
4141 * PARAMETERS :
4142 *   @wbStr   : white balance mode value string
4143 *
4144 * RETURN     : int32_t type of status
4145 *              NO_ERROR  -- success
4146 *              none-zero failure code
4147 *==========================================================================*/
4148int32_t QCameraParameters::setWhiteBalance(const char *wbStr)
4149{
4150    if (wbStr != NULL) {
4151        int32_t value = lookupAttr(WHITE_BALANCE_MODES_MAP,
4152                                   sizeof(WHITE_BALANCE_MODES_MAP)/sizeof(QCameraMap),
4153                                   wbStr);
4154        if (value != NAME_NOT_FOUND) {
4155            ALOGD("%s: Setting WhiteBalance value %s", __func__, wbStr);
4156            updateParamEntry(KEY_WHITE_BALANCE, wbStr);
4157            return AddSetParmEntryToBatch(m_pParamBuf,
4158                                          CAM_INTF_PARM_WHITE_BALANCE,
4159                                          sizeof(value),
4160                                          &value);
4161        }
4162    }
4163    ALOGE("Invalid WhiteBalance value: %s", (wbStr == NULL) ? "NULL" : wbStr);
4164    return BAD_VALUE;
4165}
4166
4167/*===========================================================================
4168 * FUNCTION   : setAntibanding
4169 *
4170 * DESCRIPTION: set antibanding value
4171 *
4172 * PARAMETERS :
4173 *   @antiBandingStr : antibanding value string
4174 *
4175 * RETURN     : int32_t type of status
4176 *              NO_ERROR  -- success
4177 *              none-zero failure code
4178 *==========================================================================*/
4179int32_t QCameraParameters::setAntibanding(const char *antiBandingStr)
4180{
4181    if (antiBandingStr != NULL) {
4182        int32_t value = lookupAttr(ANTIBANDING_MODES_MAP,
4183                                   sizeof(ANTIBANDING_MODES_MAP)/sizeof(QCameraMap),
4184                                   antiBandingStr);
4185        if (value != NAME_NOT_FOUND) {
4186            ALOGD("%s: Setting AntiBanding value %s", __func__, antiBandingStr);
4187            updateParamEntry(KEY_ANTIBANDING, antiBandingStr);
4188            return AddSetParmEntryToBatch(m_pParamBuf,
4189                                          CAM_INTF_PARM_ANTIBANDING,
4190                                          sizeof(value),
4191                                          &value);
4192        }
4193    }
4194    ALOGE("Invalid AntiBanding value: %s",
4195          (antiBandingStr == NULL) ? "NULL" : antiBandingStr);
4196    return BAD_VALUE;
4197}
4198
4199/*===========================================================================
4200 * FUNCTION   : setFocusAreas
4201 *
4202 * DESCRIPTION: set focus areas
4203 *
4204 * PARAMETERS :
4205 *   @focusAreasStr : focus areas value string
4206 *
4207 * RETURN     : int32_t type of status
4208 *              NO_ERROR  -- success
4209 *              none-zero failure code
4210 *==========================================================================*/
4211int32_t QCameraParameters::setFocusAreas(const char *focusAreasStr)
4212{
4213    if (m_pCapability->max_num_focus_areas == 0 ||
4214        focusAreasStr == NULL) {
4215        ALOGI("%s: Parameter string is null", __func__);
4216        return NO_ERROR;
4217    }
4218
4219    cam_area_t *areas = (cam_area_t *)malloc(sizeof(cam_area_t) * m_pCapability->max_num_focus_areas);
4220    if (NULL == areas) {
4221        ALOGE("%s: No memory for areas", __func__);
4222        return NO_MEMORY;
4223    }
4224    memset(areas, 0, sizeof(cam_area_t) * m_pCapability->max_num_focus_areas);
4225    int num_areas_found = 0;
4226    if (parseCameraAreaString(focusAreasStr,
4227                              m_pCapability->max_num_focus_areas,
4228                              areas,
4229                              num_areas_found) != NO_ERROR) {
4230        ALOGE("%s: Failed to parse the string: %s", __func__, focusAreasStr);
4231        free(areas);
4232        return BAD_VALUE;
4233    }
4234
4235    if (validateCameraAreas(areas, num_areas_found) == false) {
4236        ALOGE("%s: invalid areas specified : %s", __func__, focusAreasStr);
4237        free(areas);
4238        return BAD_VALUE;
4239    }
4240
4241    updateParamEntry(KEY_FOCUS_AREAS, focusAreasStr);
4242
4243    //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
4244    //so no action is takenby the lower layer
4245    if (num_areas_found == 1 &&
4246        areas[0].rect.left == 0 &&
4247        areas[0].rect.top == 0 &&
4248        areas[0].rect.width == 0 &&
4249        areas[0].rect.height == 0 &&
4250        areas[0].weight == 0) {
4251        num_areas_found = 0;
4252    }
4253
4254    int previewWidth, previewHeight;
4255    getPreviewSize(&previewWidth, &previewHeight);
4256    cam_roi_info_t af_roi_value;
4257    memset(&af_roi_value, 0, sizeof(cam_roi_info_t));
4258    af_roi_value.num_roi = num_areas_found;
4259    for (int i = 0; i < num_areas_found; i++) {
4260        ALOGD("%s: FocusArea[%d] = (%d, %d, %d, %d)",
4261              __func__, i, (areas[i].rect.top), (areas[i].rect.left),
4262              (areas[i].rect.width), (areas[i].rect.height));
4263
4264        //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight)
4265        af_roi_value.roi[i].left = (int32_t)((areas[i].rect.left + 1000.0f) * (previewWidth / 2000.0f));
4266        af_roi_value.roi[i].top = (int32_t)((areas[i].rect.top + 1000.0f) * (previewHeight / 2000.0f));
4267        af_roi_value.roi[i].width = (int32_t)(areas[i].rect.width * previewWidth / 2000.0f);
4268        af_roi_value.roi[i].height = (int32_t)(areas[i].rect.height * previewHeight / 2000.0f);
4269        af_roi_value.weight[i] = areas[i].weight;
4270    }
4271    free(areas);
4272    return AddSetParmEntryToBatch(m_pParamBuf,
4273                                  CAM_INTF_PARM_AF_ROI,
4274                                  sizeof(af_roi_value),
4275                                  &af_roi_value);
4276}
4277
4278/*===========================================================================
4279 * FUNCTION   : setMeteringAreas
4280 *
4281 * DESCRIPTION: set metering areas value
4282 *
4283 * PARAMETERS :
4284 *   @meteringAreasStr : metering areas value string
4285 *
4286 * RETURN     : int32_t type of status
4287 *              NO_ERROR  -- success
4288 *              none-zero failure code
4289 *==========================================================================*/
4290int32_t QCameraParameters::setMeteringAreas(const char *meteringAreasStr)
4291{
4292    if (m_pCapability->max_num_metering_areas == 0 ||
4293        meteringAreasStr == NULL) {
4294        ALOGI("%s: Parameter string is null", __func__);
4295        return NO_ERROR;
4296    }
4297
4298    cam_area_t *areas = (cam_area_t *)malloc(sizeof(cam_area_t) * m_pCapability->max_num_metering_areas);
4299    if (NULL == areas) {
4300        ALOGE("%s: No memory for areas", __func__);
4301        return NO_MEMORY;
4302    }
4303    memset(areas, 0, sizeof(cam_area_t) * m_pCapability->max_num_metering_areas);
4304    int num_areas_found = 0;
4305    if (parseCameraAreaString(meteringAreasStr,
4306                              m_pCapability->max_num_metering_areas,
4307                              areas,
4308                              num_areas_found) < 0) {
4309        ALOGE("%s: Failed to parse the string: %s", __func__, meteringAreasStr);
4310        free(areas);
4311        return BAD_VALUE;
4312    }
4313
4314    if (validateCameraAreas(areas, num_areas_found) == false) {
4315        ALOGE("%s: invalid areas specified : %s", __func__, meteringAreasStr);
4316        free(areas);
4317        return BAD_VALUE;
4318    }
4319
4320    updateParamEntry(KEY_METERING_AREAS, meteringAreasStr);
4321
4322    //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
4323    //so no action is takenby the lower layer
4324    if (num_areas_found == 1 &&
4325        areas[0].rect.left == 0 &&
4326        areas[0].rect.top == 0 &&
4327        areas[0].rect.width == 0 &&
4328        areas[0].rect.height == 0 &&
4329        areas[0].weight == 0) {
4330        num_areas_found = 0;
4331    }
4332    cam_set_aec_roi_t aec_roi_value;
4333    int previewWidth, previewHeight;
4334    getPreviewSize(&previewWidth, &previewHeight);
4335
4336    memset(&aec_roi_value, 0, sizeof(cam_set_aec_roi_t));
4337    if (num_areas_found > 0) {
4338        aec_roi_value.aec_roi_enable = CAM_AEC_ROI_ON;
4339        aec_roi_value.aec_roi_type = CAM_AEC_ROI_BY_COORDINATE;
4340
4341        for (int i = 0; i < num_areas_found; i++) {
4342            ALOGD("%s: MeteringArea[%d] = (%d, %d, %d, %d)",
4343                  __func__, i, (areas[i].rect.top), (areas[i].rect.left),
4344                  (areas[i].rect.width), (areas[i].rect.height));
4345
4346            //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight)
4347            aec_roi_value.cam_aec_roi_position.coordinate[i].x =
4348                (uint32_t)(((areas[i].rect.left + areas[i].rect.width / 2) + 1000.0f) * previewWidth / 2000.0f) ;
4349            aec_roi_value.cam_aec_roi_position.coordinate[i].y =
4350                (uint32_t)(((areas[i].rect.top + areas[i].rect.height / 2) + 1000.0f) * previewHeight / 2000.0f) ;
4351        }
4352    } else {
4353        aec_roi_value.aec_roi_enable = CAM_AEC_ROI_OFF;
4354    }
4355    free(areas);
4356    return AddSetParmEntryToBatch(m_pParamBuf,
4357                                  CAM_INTF_PARM_AEC_ROI,
4358                                  sizeof(aec_roi_value),
4359                                  &aec_roi_value);
4360}
4361
4362/*===========================================================================
4363 * FUNCTION   : setSceneMode
4364 *
4365 * DESCRIPTION: set scene mode
4366 *
4367 * PARAMETERS :
4368 *   @sceneModeStr : scene mode value string
4369 *
4370 * RETURN     : int32_t type of status
4371 *              NO_ERROR  -- success
4372 *              none-zero failure code
4373 *==========================================================================*/
4374int32_t QCameraParameters::setSceneMode(const char *sceneModeStr)
4375{
4376    if (sceneModeStr != NULL) {
4377        int32_t value = lookupAttr(SCENE_MODES_MAP,
4378                                   sizeof(SCENE_MODES_MAP)/sizeof(QCameraMap),
4379                                   sceneModeStr);
4380        if (value != NAME_NOT_FOUND) {
4381            ALOGV("%s: Setting SceneMode %s", __func__, sceneModeStr);
4382            updateParamEntry(KEY_SCENE_MODE, sceneModeStr);
4383            int32_t rc = AddSetParmEntryToBatch(m_pParamBuf,
4384                                                CAM_INTF_PARM_BESTSHOT_MODE,
4385                                                sizeof(value),
4386                                                &value);
4387            return rc;
4388        }
4389    }
4390    ALOGE("%s: Invalid Secene Mode: %s",
4391          __func__, (sceneModeStr == NULL) ? "NULL" : sceneModeStr);
4392    return BAD_VALUE;
4393}
4394
4395/*===========================================================================
4396 * FUNCTION   : setSelectableZoneAf
4397 *
4398 * DESCRIPTION: set selectable zone AF algorithm
4399 *
4400 * PARAMETERS :
4401 *   @selZoneAFStr : selectable zone AF algorithm value string
4402 *
4403 * RETURN     : int32_t type of status
4404 *              NO_ERROR  -- success
4405 *              none-zero failure code
4406 *==========================================================================*/
4407int32_t QCameraParameters::setSelectableZoneAf(const char *selZoneAFStr)
4408{
4409    if (selZoneAFStr != NULL) {
4410        int32_t value = lookupAttr(FOCUS_ALGO_MAP,
4411                                   sizeof(FOCUS_ALGO_MAP)/sizeof(QCameraMap),
4412                                   selZoneAFStr);
4413        if (value != NAME_NOT_FOUND) {
4414            ALOGV("%s: Setting Selectable Zone AF value %s", __func__, selZoneAFStr);
4415            updateParamEntry(KEY_QC_SELECTABLE_ZONE_AF, selZoneAFStr);
4416            return AddSetParmEntryToBatch(m_pParamBuf,
4417                                          CAM_INTF_PARM_FOCUS_ALGO_TYPE,
4418                                          sizeof(value),
4419                                          &value);
4420        }
4421    }
4422    ALOGE("%s: Invalid selectable zone af value: %s",
4423          __func__, (selZoneAFStr == NULL) ? "NULL" : selZoneAFStr);
4424    return BAD_VALUE;
4425}
4426
4427/*===========================================================================
4428 * FUNCTION   : setAEBracket
4429 *
4430 * DESCRIPTION: set AE bracket value
4431 *
4432 * PARAMETERS :
4433 *   @aecBracketStr : AE bracket value string
4434 *
4435 * RETURN     : int32_t type of status
4436 *              NO_ERROR  -- success
4437 *              none-zero failure code
4438 *==========================================================================*/
4439int32_t QCameraParameters::setAEBracket(const char *aecBracketStr)
4440{
4441    if (aecBracketStr == NULL) {
4442        ALOGI("%s: setAEBracket with NULL value", __func__);
4443        return NO_ERROR;
4444    }
4445
4446    cam_exp_bracketing_t expBracket;
4447    memset(&expBracket, 0, sizeof(expBracket));
4448
4449    int value = lookupAttr(BRACKETING_MODES_MAP,
4450                           sizeof(BRACKETING_MODES_MAP)/sizeof(QCameraMap),
4451                           aecBracketStr);
4452    switch (value) {
4453    case CAM_EXP_BRACKETING_ON:
4454        {
4455            ALOGV("%s, EXP_BRACKETING_ON", __func__);
4456            const char *str_val = get(KEY_QC_CAPTURE_BURST_EXPOSURE);
4457            if ((str_val != NULL) && (strlen(str_val)>0)) {
4458                expBracket.mode = CAM_EXP_BRACKETING_ON;
4459                strlcpy(expBracket.values, str_val, MAX_EXP_BRACKETING_LENGTH);
4460                ALOGI("%s: setting Exposure Bracketing value of %s",
4461                      __func__, expBracket.values);
4462            }
4463            else {
4464                /* Apps not set capture-burst-exposures, error case fall into bracketing off mode */
4465                ALOGI("%s: capture-burst-exposures not set, back to HDR OFF mode", __func__);
4466                expBracket.mode = CAM_EXP_BRACKETING_OFF;
4467            }
4468        }
4469        break;
4470    default:
4471        {
4472            ALOGD("%s, EXP_BRACKETING_OFF", __func__);
4473            expBracket.mode = CAM_EXP_BRACKETING_OFF;
4474        }
4475        break;
4476    }
4477
4478    /* save the value*/
4479    updateParamEntry(KEY_QC_AE_BRACKET_HDR, aecBracketStr);
4480    return AddSetParmEntryToBatch(m_pParamBuf,
4481                                  CAM_INTF_PARM_HDR,
4482                                  sizeof(expBracket),
4483                                  &expBracket);
4484}
4485
4486/*===========================================================================
4487 * FUNCTION   : setRedeyeReduction
4488 *
4489 * DESCRIPTION: set red eye reduction value
4490 *
4491 * PARAMETERS :
4492 *   @redeyeStr : red eye reduction value string
4493 *
4494 * RETURN     : int32_t type of status
4495 *              NO_ERROR  -- success
4496 *              none-zero failure code
4497 *==========================================================================*/
4498int32_t QCameraParameters::setRedeyeReduction(const char *redeyeStr)
4499{
4500    if (redeyeStr != NULL) {
4501        int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
4502                                   sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap),
4503                                   redeyeStr);
4504        if (value != NAME_NOT_FOUND) {
4505            ALOGV("%s: Setting RedEye Reduce value %s", __func__, redeyeStr);
4506            updateParamEntry(KEY_QC_REDEYE_REDUCTION, redeyeStr);
4507            return AddSetParmEntryToBatch(m_pParamBuf,
4508                                          CAM_INTF_PARM_REDEYE_REDUCTION,
4509                                          sizeof(value),
4510                                          &value);
4511        }
4512    }
4513    ALOGE("%s: Invalid RedEye Reduce value: %s",
4514          __func__, (redeyeStr == NULL) ? "NULL" : redeyeStr);
4515    return BAD_VALUE;
4516}
4517
4518/*===========================================================================
4519 * FUNCTION   : getWaveletDenoiseProcessPlate
4520 *
4521 * DESCRIPTION: query wavelet denoise process plate
4522 *
4523 * PARAMETERS : None
4524 *
4525 * RETURN     : WNR prcocess plate vlaue
4526 *==========================================================================*/
4527cam_denoise_process_type_t QCameraParameters::getWaveletDenoiseProcessPlate()
4528{
4529    char prop[PROPERTY_VALUE_MAX];
4530    memset(prop, 0, sizeof(prop));
4531    property_get("persist.denoise.process.plates", prop, "0");
4532    int processPlate = atoi(prop);
4533    switch(processPlate) {
4534    case 0:
4535        return CAM_WAVELET_DENOISE_YCBCR_PLANE;
4536    case 1:
4537        return CAM_WAVELET_DENOISE_CBCR_ONLY;
4538    case 2:
4539        return CAM_WAVELET_DENOISE_STREAMLINE_YCBCR;
4540    case 3:
4541        return CAM_WAVELET_DENOISE_STREAMLINED_CBCR;
4542    default:
4543        return CAM_WAVELET_DENOISE_STREAMLINE_YCBCR;
4544    }
4545}
4546
4547/*===========================================================================
4548 * FUNCTION   : setWaveletDenoise
4549 *
4550 * DESCRIPTION: set wavelet denoise value
4551 *
4552 * PARAMETERS :
4553 *   @wnrStr : wavelet denoise value string
4554 *
4555 * RETURN     : int32_t type of status
4556 *              NO_ERROR  -- success
4557 *              none-zero failure code
4558 *==========================================================================*/
4559int32_t QCameraParameters::setWaveletDenoise(const char *wnrStr)
4560{
4561    if (wnrStr != NULL) {
4562        int value = lookupAttr(DENOISE_ON_OFF_MODES_MAP,
4563                               sizeof(DENOISE_ON_OFF_MODES_MAP)/sizeof(QCameraMap),
4564                               wnrStr);
4565        if (value != NAME_NOT_FOUND) {
4566            updateParamEntry(KEY_QC_DENOISE, wnrStr);
4567
4568            cam_denoise_param_t temp;
4569            memset(&temp, 0, sizeof(temp));
4570            temp.denoise_enable = value;
4571            m_bWNROn = (value != 0);
4572            if (m_bWNROn) {
4573                temp.process_plates = getWaveletDenoiseProcessPlate();
4574            }
4575            ALOGI("%s: Denoise enable=%d, plates=%d",
4576                  __func__, temp.denoise_enable, temp.process_plates);
4577            return AddSetParmEntryToBatch(m_pParamBuf,
4578                                          CAM_INTF_PARM_WAVELET_DENOISE,
4579                                          sizeof(temp),
4580                                          &temp);
4581        }
4582    }
4583    ALOGE("%s: Invalid Denoise value: %s", __func__, (wnrStr == NULL) ? "NULL" : wnrStr);
4584    return BAD_VALUE;
4585}
4586
4587/*===========================================================================
4588 * FUNCTION   : setPreviewFrameRateMode
4589 *
4590 * DESCRIPTION: set preview frame rate mode
4591 *
4592 * PARAMETERS :
4593 *   @mode    : preview frame rate mode
4594 *
4595 * RETURN     : none
4596 *==========================================================================*/
4597void QCameraParameters::setPreviewFrameRateMode(const char *mode)
4598{
4599    set(KEY_QC_PREVIEW_FRAME_RATE_MODE, mode);
4600}
4601
4602/*===========================================================================
4603 * FUNCTION   : getPreviewFrameRateMode
4604 *
4605 * DESCRIPTION: get preview frame rate mode
4606 *
4607 * PARAMETERS : none
4608 *
4609 * RETURN     : preview frame rate mode string
4610 *==========================================================================*/
4611const char *QCameraParameters::getPreviewFrameRateMode() const
4612{
4613    return get(KEY_QC_PREVIEW_FRAME_RATE_MODE);
4614}
4615
4616/*===========================================================================
4617 * FUNCTION   : setTouchIndexAec
4618 *
4619 * DESCRIPTION: set touch index AEC
4620 *
4621 * PARAMETERS :
4622 *   @x,y     :
4623 *
4624 * RETURN     : none
4625 *==========================================================================*/
4626void QCameraParameters::setTouchIndexAec(int x, int y)
4627{
4628    char str[32];
4629    snprintf(str, sizeof(str), "%dx%d", x, y);
4630    set(KEY_QC_TOUCH_INDEX_AEC, str);
4631}
4632
4633/*===========================================================================
4634 * FUNCTION   : getTouchIndexAec
4635 *
4636 * DESCRIPTION: get touch index AEC
4637 *
4638 * PARAMETERS :
4639 *   @x,y     :
4640 *
4641 * RETURN     : none
4642 *==========================================================================*/
4643void QCameraParameters::getTouchIndexAec(int *x, int *y)
4644{
4645    *x = -1;
4646    *y = -1;
4647
4648    // Get the current string, if it doesn't exist, leave the -1x-1
4649    const char *p = get(KEY_QC_TOUCH_INDEX_AEC);
4650    if (p == 0)
4651        return;
4652
4653    int tempX, tempY;
4654    if (parse_pair(p, &tempX, &tempY, 'x') == 0) {
4655        *x = tempX;
4656        *y = tempY;
4657    }
4658}
4659
4660/*===========================================================================
4661 * FUNCTION   : setTouchIndexAf
4662 *
4663 * DESCRIPTION: set touch index AF
4664 *
4665 * PARAMETERS :
4666 *   @x,y     :
4667 *
4668 * RETURN     : none
4669 *==========================================================================*/
4670void QCameraParameters::setTouchIndexAf(int x, int y)
4671{
4672    char str[32];
4673    snprintf(str, sizeof(str), "%dx%d", x, y);
4674    set(KEY_QC_TOUCH_INDEX_AF, str);
4675}
4676
4677/*===========================================================================
4678 * FUNCTION   : getTouchIndexAf
4679 *
4680 * DESCRIPTION: get touch index AF
4681 *
4682 * PARAMETERS :
4683 *   @x,y     :
4684 *
4685 * RETURN     : none
4686 *==========================================================================*/
4687void QCameraParameters::getTouchIndexAf(int *x, int *y)
4688{
4689    *x = -1;
4690    *y = -1;
4691
4692    // Get the current string, if it doesn't exist, leave the -1x-1
4693    const char *p = get(KEY_QC_TOUCH_INDEX_AF);
4694    if (p == 0)
4695        return;
4696
4697    int tempX, tempY;
4698    if (parse_pair(p, &tempX, &tempY, 'x') == 0) {
4699        *x = tempX;
4700        *y = tempY;
4701	}
4702}
4703
4704/*===========================================================================
4705 * FUNCTION   : getStreamFormat
4706 *
4707 * DESCRIPTION: get stream format by its type
4708 *
4709 * PARAMETERS :
4710 *   @streamType : [input] stream type
4711 *   @format     : [output] stream format
4712 *
4713 * RETURN     : int32_t type of status
4714 *              NO_ERROR  -- success
4715 *              none-zero failure code
4716 *==========================================================================*/
4717int32_t QCameraParameters::getStreamFormat(cam_stream_type_t streamType,
4718                                            cam_format_t &format)
4719{
4720    int32_t ret = NO_ERROR;
4721
4722    format = CAM_FORMAT_MAX;
4723    switch (streamType) {
4724    case CAM_STREAM_TYPE_PREVIEW:
4725    case CAM_STREAM_TYPE_POSTVIEW:
4726        format = mPreviewFormat;
4727        break;
4728    case CAM_STREAM_TYPE_SNAPSHOT:
4729        format = CAM_FORMAT_YUV_420_NV21;
4730        break;
4731    case CAM_STREAM_TYPE_VIDEO:
4732        format = CAM_FORMAT_YUV_420_NV12;
4733        break;
4734    case CAM_STREAM_TYPE_RAW:
4735        if (mPictureFormat >= CAM_FORMAT_YUV_RAW_8BIT_YUYV) {
4736            format = (cam_format_t)mPictureFormat;
4737        } else {
4738            ALOGE("%s: invalid raw picture format: %d", __func__, mPictureFormat);
4739            ret = BAD_VALUE;
4740        }
4741        break;
4742    case CAM_STREAM_TYPE_METADATA:
4743    case CAM_STREAM_TYPE_OFFLINE_PROC:
4744    case CAM_STREAM_TYPE_DEFAULT:
4745    default:
4746        break;
4747    }
4748
4749    return ret;
4750}
4751
4752/*===========================================================================
4753 * FUNCTION   : getFlipMode
4754 *
4755 * DESCRIPTION: get flip mode
4756 *
4757 * PARAMETERS :
4758 *   @cam_intf_parm_type_t : [input] stream type
4759 *
4760 * RETURN     : int type of flip mode
4761 *              0 - no filp
4762 *              1 - FLIP_H
4763 *              2 - FLIP_V
4764 *              3 - FLIP_H | FLIP_V
4765 *==========================================================================*/
4766int QCameraParameters::getFlipMode(cam_stream_type_t type)
4767{
4768    const char *str = NULL;
4769    int flipMode = 0; // no flip
4770
4771    switch(type){
4772    case CAM_STREAM_TYPE_PREVIEW:
4773        str = get(KEY_QC_PREVIEW_FLIP);
4774        break;
4775    case CAM_STREAM_TYPE_VIDEO:
4776        str = get(KEY_QC_VIDEO_FLIP);
4777        break;
4778    case CAM_STREAM_TYPE_SNAPSHOT:
4779        str = get(KEY_QC_SNAPSHOT_PICTURE_FLIP);
4780        break;
4781    default:
4782        ALOGI("%s: No flip mode for stream type %d", __func__, type);
4783        break;
4784    }
4785
4786    if(str != NULL){
4787        //Need give corresponding filp value based on flip mode strings
4788        int value = lookupAttr(FLIP_MODES_MAP,
4789                sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap), str);
4790        if(value != NAME_NOT_FOUND)
4791            flipMode = value;
4792        }
4793
4794    ALOGD("%s: the filp mode of stream type %d is %d .", __func__, type, flipMode);
4795    return flipMode;
4796}
4797
4798/*===========================================================================
4799 * FUNCTION   : getStreamDimension
4800 *
4801 * DESCRIPTION: get stream dimension by its type
4802 *
4803 * PARAMETERS :
4804 *   @streamType : [input] stream type
4805 *   @dim        : [output] stream dimension
4806 *
4807 * RETURN     : int32_t type of status
4808 *              NO_ERROR  -- success
4809 *              none-zero failure code
4810 *==========================================================================*/
4811int32_t QCameraParameters::getStreamDimension(cam_stream_type_t streamType,
4812                                               cam_dimension_t &dim)
4813{
4814    int32_t ret = NO_ERROR;
4815
4816    memset(&dim, 0, sizeof(cam_dimension_t));
4817
4818    switch (streamType) {
4819    case CAM_STREAM_TYPE_PREVIEW:
4820        getPreviewSize(&dim.width, &dim.height);
4821        break;
4822    case CAM_STREAM_TYPE_POSTVIEW:
4823        getPreviewSize(&dim.width, &dim.height);
4824        break;
4825    case CAM_STREAM_TYPE_SNAPSHOT:
4826        if (getRecordingHintValue() == true) {
4827            // live snapshot
4828            getLiveSnapshotSize(dim);
4829        } else {
4830            getPictureSize(&dim.width, &dim.height);
4831        }
4832        break;
4833    case CAM_STREAM_TYPE_VIDEO:
4834        getVideoSize(&dim.width, &dim.height);
4835        break;
4836    case CAM_STREAM_TYPE_RAW:
4837        dim = m_pCapability->raw_dim;
4838        break;
4839    case CAM_STREAM_TYPE_METADATA:
4840        dim.width = sizeof(cam_metadata_info_t);
4841        dim.height = 1;
4842        break;
4843    case CAM_STREAM_TYPE_OFFLINE_PROC:
4844        break;
4845    case CAM_STREAM_TYPE_DEFAULT:
4846    default:
4847        ALOGE("%s: no dimension for unsupported stream type %d",
4848              __func__, streamType);
4849        ret = BAD_VALUE;
4850        break;
4851    }
4852    return ret;
4853}
4854
4855/*===========================================================================
4856 * FUNCTION   : getPreviewHalPixelFormat
4857 *
4858 * DESCRIPTION: get preview HAL pixel format
4859 *
4860 * PARAMETERS : none
4861 *
4862 * RETURN     : HAL pixel format
4863 *==========================================================================*/
4864int QCameraParameters::getPreviewHalPixelFormat() const
4865{
4866    int32_t halPixelFormat;
4867
4868    switch (mPreviewFormat) {
4869    case CAM_FORMAT_YUV_420_NV12:
4870        halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP;
4871        break;
4872    case CAM_FORMAT_YUV_420_NV21:
4873        halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
4874        break;
4875    case CAM_FORMAT_YUV_420_NV21_ADRENO:
4876        halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO;
4877        break;
4878    case CAM_FORMAT_YUV_420_YV12:
4879        halPixelFormat = HAL_PIXEL_FORMAT_YV12;
4880        break;
4881    case CAM_FORMAT_YUV_422_NV16:
4882    case CAM_FORMAT_YUV_422_NV61:
4883    default:
4884        halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
4885        break;
4886    }
4887    ALOGE("%s: format %d\n", __func__, halPixelFormat);
4888    return halPixelFormat;
4889}
4890
4891/*===========================================================================
4892 * FUNCTION   : getthumbnailSize
4893 *
4894 * DESCRIPTION: get thumbnail size
4895 *
4896 * PARAMETERS :
4897 *   @width, height : [output] thumbnail width and height
4898 *
4899 * RETURN     : none
4900 *==========================================================================*/
4901void QCameraParameters::getThumbnailSize(int *width, int *height) const
4902{
4903    *width = getInt(KEY_JPEG_THUMBNAIL_WIDTH);
4904    *height = getInt(KEY_JPEG_THUMBNAIL_HEIGHT);
4905}
4906
4907/*===========================================================================
4908 * FUNCTION   : getZSLBurstInterval
4909 *
4910 * DESCRIPTION: get ZSL burst interval setting
4911 *
4912 * PARAMETERS : none
4913 *
4914 * RETURN     : ZSL burst interval value
4915 *==========================================================================*/
4916int QCameraParameters::getZSLBurstInterval()
4917{
4918    int interval = getInt(KEY_QC_ZSL_BURST_INTERVAL);
4919    if (interval < 0) {
4920        interval = 1;
4921    }
4922    return interval;
4923}
4924
4925/*===========================================================================
4926 * FUNCTION   : getZSLQueueDepth
4927 *
4928 * DESCRIPTION: get ZSL queue depth
4929 *
4930 * PARAMETERS : none
4931 *
4932 * RETURN     : ZSL queue depth value
4933 *==========================================================================*/
4934int QCameraParameters::getZSLQueueDepth()
4935{
4936    int qdepth = getInt(KEY_QC_ZSL_QUEUE_DEPTH);
4937    if (qdepth < 0) {
4938        qdepth = 2;
4939    }
4940    return qdepth;
4941}
4942
4943/*===========================================================================
4944 * FUNCTION   : getZSLBackLookCount
4945 *
4946 * DESCRIPTION: get ZSL backlook count setting
4947 *
4948 * PARAMETERS : none
4949 *
4950 * RETURN     : ZSL backlook count value
4951 *==========================================================================*/
4952int QCameraParameters::getZSLBackLookCount()
4953{
4954    int look_back = getInt(KEY_QC_ZSL_BURST_LOOKBACK);
4955    if (look_back < 0) {
4956        look_back = 2;
4957    }
4958    return look_back;
4959}
4960
4961/*===========================================================================
4962 * FUNCTION   : getZSLMaxUnmatchedFrames
4963 *
4964 * DESCRIPTION: get allowed ZSL max unmatched frames number
4965 *
4966 * PARAMETERS : none
4967 *
4968 * RETURN     : ZSL backlook count value
4969 *==========================================================================*/
4970int QCameraParameters::getMaxUnmatchedFramesInQueue()
4971{
4972    return m_pCapability->min_num_pp_bufs;
4973}
4974
4975/*===========================================================================
4976 * FUNCTION   : setRecordingHintValue
4977 *
4978 * DESCRIPTION: set recording hint
4979 *
4980 * PARAMETERS :
4981 *   @value   : video hint value
4982 *
4983 * RETURN     : int32_t type of status
4984 *              NO_ERROR  -- success
4985 *              none-zero failure code
4986 *==========================================================================*/
4987int QCameraParameters::setRecordingHintValue(int32_t value)
4988{
4989    ALOGD("%s: VideoHint = %d", __func__, value);
4990    m_bRecordingHint = (value > 0)? true : false;
4991    return AddSetParmEntryToBatch(m_pParamBuf,
4992                                  CAM_INTF_PARM_RECORDING_HINT,
4993                                  sizeof(value),
4994                                  &value);
4995}
4996
4997/*===========================================================================
4998 * FUNCTION   : getNumOfSnapshots
4999 *
5000 * DESCRIPTION: get number of snapshot per shutter
5001 *
5002 * PARAMETERS : none
5003 *
5004 * RETURN     : number of snapshot per shutter
5005 *==========================================================================*/
5006uint8_t QCameraParameters::getNumOfSnapshots()
5007{
5008    int numOfSnapshot = getInt(KEY_QC_NUM_SNAPSHOT_PER_SHUTTER);
5009    if (numOfSnapshot <= 0) {
5010        numOfSnapshot = 1; // set to default value
5011    }
5012    return (uint8_t)numOfSnapshot;
5013}
5014
5015/*===========================================================================
5016 * FUNCTION   : getNumOfExtraHDRBufsIfNeeded
5017 *
5018 * DESCRIPTION: get number of extra buffers needed by HDR if HDR is enabled
5019 *
5020 * PARAMETERS : none
5021 *
5022 * RETURN     : number of extra buffer needed by HDR; 0 if not HDR enabled
5023 *==========================================================================*/
5024uint8_t QCameraParameters::getNumOfExtraHDRBufsIfNeeded()
5025{
5026    uint8_t numOfBufs = 0;
5027    const char *scene_mode = get(KEY_SCENE_MODE);
5028    if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) {
5029        // HDR mode
5030        numOfBufs = getBurstNum() * m_pCapability->min_num_hdr_bufs;
5031    }
5032    return numOfBufs;
5033}
5034
5035/*===========================================================================
5036 * FUNCTION   : getNumOfHDRBufsIfNeeded
5037 *
5038 * DESCRIPTION: get number of buffers needed by HDR if HDR is enabled
5039 *
5040 * PARAMETERS : none
5041 *
5042 * RETURN     : number of buffer needed by HDR; 0 if not HDR enabled
5043 *==========================================================================*/
5044uint8_t QCameraParameters::getNumOfHDRBufsIfNeeded()
5045{
5046    uint8_t numOfBufs = 0;
5047    const char *scene_mode = get(KEY_SCENE_MODE);
5048    if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) {
5049        // HDR mode
5050        const char *need_hdr_1x = get(KEY_QC_HDR_NEED_1X);
5051        if (need_hdr_1x != NULL && strcmp(need_hdr_1x, VALUE_TRUE) == 0) {
5052            numOfBufs = 2; // HDR needs both 1X and processed img
5053        } else {
5054            numOfBufs = 1; // HDR only needs processed img
5055        }
5056
5057        numOfBufs += m_pCapability->min_num_hdr_bufs;
5058    }
5059    return numOfBufs;
5060}
5061
5062/*===========================================================================
5063 * FUNCTION   : getBurstNum
5064 *
5065 * DESCRIPTION: get burst number of snapshot
5066 *
5067 * PARAMETERS : none
5068 *
5069 * RETURN     : number of burst
5070 *==========================================================================*/
5071int QCameraParameters::getBurstNum()
5072{
5073    char prop[PROPERTY_VALUE_MAX];
5074    memset(prop, 0, sizeof(prop));
5075    property_get("persist.camera.snapshot.number", prop, "0");
5076    int nBurstNum = atoi(prop);
5077    if (nBurstNum > 0) {
5078        ALOGD("%s: Reading burst number = %d from properties",
5079              __func__, nBurstNum);
5080    } else {
5081        nBurstNum = 1;
5082    }
5083    return nBurstNum;
5084}
5085
5086/*===========================================================================
5087 * FUNCTION   : getJpegQuality
5088 *
5089 * DESCRIPTION: get jpeg encoding quality
5090 *
5091 * PARAMETERS : none
5092 *
5093 * RETURN     : jpeg encoding quality
5094 *==========================================================================*/
5095int QCameraParameters::getJpegQuality()
5096{
5097    int quality = getInt(KEY_JPEG_QUALITY);
5098    if (quality < 0) {
5099        quality = 85; // set to default quality value
5100    }
5101    return quality;
5102}
5103
5104/*===========================================================================
5105 * FUNCTION   : getJpegRotation
5106 *
5107 * DESCRIPTION: get rotation value
5108 *
5109 * PARAMETERS : none
5110 *
5111 * RETURN     : rotation value
5112 *==========================================================================*/
5113int QCameraParameters::getJpegRotation() {
5114    int rotation = getInt(KEY_ROTATION);
5115    if (rotation < 0) {
5116        rotation = 0;
5117    }
5118    return rotation;
5119}
5120
5121/*===========================================================================
5122 * FUNCTION   : parseGPSCoordinate
5123 *
5124 * DESCRIPTION: parse GPS coordinate string
5125 *
5126 * PARAMETERS :
5127 *   @coord_str : [input] coordinate string
5128 *   @coord     : [output]  ptr to struct to store coordinate
5129 *
5130 * RETURN     : int32_t type of status
5131 *              NO_ERROR  -- success
5132 *              none-zero failure code
5133 *==========================================================================*/
5134int QCameraParameters::parseGPSCoordinate(const char *coord_str, rat_t* coord)
5135{
5136    if(coord == NULL) {
5137        ALOGE("%s: error, invalid argument coord == NULL", __func__);
5138        return BAD_VALUE;
5139    }
5140    float degF = atof(coord_str);
5141    if (degF < 0) {
5142        degF = -degF;
5143    }
5144    float minF = (degF - (int) degF) * 60;
5145    float secF = (minF - (int) minF) * 60;
5146
5147    getRational(&coord[0], (int)degF, 1);
5148    getRational(&coord[1], (int)minF, 1);
5149    getRational(&coord[2], (int)(secF * 10000), 10000);
5150    return NO_ERROR;
5151}
5152
5153/*===========================================================================
5154 * FUNCTION   : getExifDateTime
5155 *
5156 * DESCRIPTION: query exif date time
5157 *
5158 * PARAMETERS :
5159 *   @dateTime : string to store exif date time
5160 *   @count    : lenght of the dateTime string
5161 *
5162 * RETURN     : int32_t type of status
5163 *              NO_ERROR  -- success
5164 *              none-zero failure code
5165 *==========================================================================*/
5166int32_t QCameraParameters::getExifDateTime(char *dateTime, uint32_t &count)
5167{
5168    //get time and date from system
5169    time_t rawtime;
5170    struct tm * timeinfo;
5171    time(&rawtime);
5172    timeinfo = localtime (&rawtime);
5173    //Write datetime according to EXIF Spec
5174    //"YYYY:MM:DD HH:MM:SS" (20 chars including \0)
5175    snprintf(dateTime, 20, "%04d:%02d:%02d %02d:%02d:%02d",
5176             timeinfo->tm_year + 1900, timeinfo->tm_mon + 1,
5177             timeinfo->tm_mday, timeinfo->tm_hour,
5178             timeinfo->tm_min, timeinfo->tm_sec);
5179    count = 20;
5180
5181    return NO_ERROR;
5182}
5183
5184/*===========================================================================
5185 * FUNCTION   : getRational
5186 *
5187 * DESCRIPTION: compose rational struct
5188 *
5189 * PARAMETERS :
5190 *   @rat     : ptr to struct to store rational info
5191 *   @num     :num of the rational
5192 *   @denom   : denom of the rational
5193 *
5194 * RETURN     : int32_t type of status
5195 *              NO_ERROR  -- success
5196 *              none-zero failure code
5197 *==========================================================================*/
5198int32_t QCameraParameters::getRational(rat_t *rat, int num, int denom)
5199{
5200    if (NULL == rat) {
5201        ALOGE("%s: NULL rat input", __func__);
5202        return BAD_VALUE;
5203    }
5204    rat->num = num;
5205    rat->denom = denom;
5206    return NO_ERROR;
5207}
5208
5209/*===========================================================================
5210 * FUNCTION   : getExifFocalLength
5211 *
5212 * DESCRIPTION: get exif focal lenght
5213 *
5214 * PARAMETERS :
5215 *   @focalLength : ptr to rational strcut to store focal lenght
5216 *
5217 * RETURN     : int32_t type of status
5218 *              NO_ERROR  -- success
5219 *              none-zero failure code
5220 *==========================================================================*/
5221int32_t QCameraParameters::getExifFocalLength(rat_t *focalLength)
5222{
5223    int focalLengthValue =
5224        (int)(getFloat(QCameraParameters::KEY_FOCAL_LENGTH) * FOCAL_LENGTH_DECIMAL_PRECISION);
5225    return getRational(focalLength, focalLengthValue, FOCAL_LENGTH_DECIMAL_PRECISION);
5226}
5227
5228/*===========================================================================
5229 * FUNCTION   : getExifIsoSpeed
5230 *
5231 * DESCRIPTION: get exif ISO speed
5232 *
5233 * PARAMETERS : none
5234 *
5235 * RETURN     : ISO speed value
5236 *==========================================================================*/
5237uint16_t QCameraParameters::getExifIsoSpeed()
5238{
5239    uint16_t isoSpeed = 0;
5240    const char *iso_str = get(QCameraParameters::KEY_QC_ISO_MODE);
5241    int iso_index = lookupAttr(ISO_MODES_MAP,
5242        sizeof(ISO_MODES_MAP)/sizeof(ISO_MODES_MAP[0]), iso_str);
5243    switch (iso_index) {
5244    case CAM_ISO_MODE_AUTO:
5245        isoSpeed = 0;
5246        break;
5247    case CAM_ISO_MODE_DEBLUR:
5248        isoSpeed = 1;
5249        break;
5250    case CAM_ISO_MODE_100:
5251        isoSpeed = 100;
5252        break;
5253    case CAM_ISO_MODE_200:
5254        isoSpeed = 200;
5255        break;
5256    case CAM_ISO_MODE_400:
5257        isoSpeed = 400;
5258        break;
5259    case CAM_ISO_MODE_800:
5260        isoSpeed = 800;
5261        break;
5262    case CAM_ISO_MODE_1600:
5263        isoSpeed = 1600;
5264        break;
5265    }
5266    return isoSpeed;
5267}
5268
5269/*===========================================================================
5270 * FUNCTION   : getExifGpsProcessingMethod
5271 *
5272 * DESCRIPTION: get GPS processing method
5273 *
5274 * PARAMETERS :
5275 *   @gpsProcessingMethod : string to store GPS process method
5276 *   @count               : lenght of the string
5277 *
5278 * RETURN     : int32_t type of status
5279 *              NO_ERROR  -- success
5280 *              none-zero failure code
5281 *==========================================================================*/
5282int32_t QCameraParameters::getExifGpsProcessingMethod(char *gpsProcessingMethod,
5283                                                      uint32_t &count)
5284{
5285    const char *str = get(KEY_GPS_PROCESSING_METHOD);
5286    if(str != NULL) {
5287        memcpy(gpsProcessingMethod, ExifAsciiPrefix, EXIF_ASCII_PREFIX_SIZE);
5288        count = EXIF_ASCII_PREFIX_SIZE;
5289        strncpy(gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE, str, strlen(str));
5290        count += strlen(str);
5291        gpsProcessingMethod[count++] = '\0'; // increase 1 for the last NULL char
5292        return NO_ERROR;
5293    } else {
5294        return BAD_VALUE;
5295    }
5296}
5297
5298/*===========================================================================
5299 * FUNCTION   : getExifLatitude
5300 *
5301 * DESCRIPTION: get exif latitude
5302 *
5303 * PARAMETERS :
5304 *   @latitude : ptr to rational struct to store latitude info
5305 *   @ladRef   : charater to indicate latitude reference
5306 *
5307 * RETURN     : int32_t type of status
5308 *              NO_ERROR  -- success
5309 *              none-zero failure code
5310 *==========================================================================*/
5311int32_t QCameraParameters::getExifLatitude(rat_t *latitude,
5312                                           char *latRef)
5313{
5314    const char *str = get(KEY_GPS_LATITUDE);
5315    if(str != NULL) {
5316        parseGPSCoordinate(str, latitude);
5317
5318        //set Latitude Ref
5319        float latitudeValue = getFloat(KEY_GPS_LATITUDE);
5320        if(latitudeValue < 0.0f) {
5321            latRef[0] = 'S';
5322        } else {
5323            latRef[0] = 'N';
5324        }
5325        latRef[1] = '\0';
5326        return NO_ERROR;
5327    }else{
5328        return BAD_VALUE;
5329    }
5330}
5331
5332/*===========================================================================
5333 * FUNCTION   : getExifLongitude
5334 *
5335 * DESCRIPTION: get exif longitude
5336 *
5337 * PARAMETERS :
5338 *   @longitude : ptr to rational struct to store longitude info
5339 *   @lonRef    : charater to indicate longitude reference
5340 *
5341 * RETURN     : int32_t type of status
5342 *              NO_ERROR  -- success
5343 *              none-zero failure code
5344 *==========================================================================*/
5345int32_t QCameraParameters::getExifLongitude(rat_t *longitude,
5346                                            char *lonRef)
5347{
5348    const char *str = get(KEY_GPS_LONGITUDE);
5349    if(str != NULL) {
5350        parseGPSCoordinate(str, longitude);
5351
5352        //set Longitude Ref
5353        float longitudeValue = getFloat(KEY_GPS_LONGITUDE);
5354        if(longitudeValue < 0.0f) {
5355            lonRef[0] = 'W';
5356        } else {
5357            lonRef[0] = 'E';
5358        }
5359        lonRef[1] = '\0';
5360        return NO_ERROR;
5361    }else{
5362        return BAD_VALUE;
5363    }
5364}
5365
5366/*===========================================================================
5367 * FUNCTION   : getExifAltitude
5368 *
5369 * DESCRIPTION: get exif altitude
5370 *
5371 * PARAMETERS :
5372 *   @altitude : ptr to rational struct to store altitude info
5373 *   @altRef   : charater to indicate altitude reference
5374 *
5375 * RETURN     : int32_t type of status
5376 *              NO_ERROR  -- success
5377 *              none-zero failure code
5378 *==========================================================================*/
5379int32_t QCameraParameters::getExifAltitude(rat_t *altitude,
5380                                           char *altRef)
5381{
5382    const char *str = get(KEY_GPS_ALTITUDE);
5383    if(str != NULL) {
5384        double value = atof(str);
5385        *altRef = 0;
5386        if(value < 0){
5387            *altRef = 1;
5388            value = -value;
5389        }
5390        return getRational(altitude, value*1000, 1000);
5391    }else{
5392        return BAD_VALUE;
5393    }
5394}
5395
5396/*===========================================================================
5397 * FUNCTION   : getExifGpsDateTimeStamp
5398 *
5399 * DESCRIPTION: get exif GPS date time stamp
5400 *
5401 * PARAMETERS :
5402 *   @gpsDateStamp : GPS date time stamp string
5403 *   @bufLen       : length of the string
5404 *   @gpsTimeStamp : ptr to rational struct to store time stamp info
5405 *
5406 * RETURN     : int32_t type of status
5407 *              NO_ERROR  -- success
5408 *              none-zero failure code
5409 *==========================================================================*/
5410int32_t QCameraParameters::getExifGpsDateTimeStamp(char *gpsDateStamp,
5411                                                   uint32_t bufLen,
5412                                                   rat_t *gpsTimeStamp)
5413{
5414    const char *str = get(KEY_GPS_TIMESTAMP);
5415    if(str != NULL) {
5416        time_t unixTime = (time_t)atol(str);
5417        struct tm *UTCTimestamp = gmtime(&unixTime);
5418
5419        strftime(gpsDateStamp, bufLen, "%Y:%m:%d", UTCTimestamp);
5420
5421        getRational(&gpsTimeStamp[0], UTCTimestamp->tm_hour, 1);
5422        getRational(&gpsTimeStamp[1], UTCTimestamp->tm_min, 1);
5423        getRational(&gpsTimeStamp[2], UTCTimestamp->tm_sec, 1);
5424
5425        return NO_ERROR;
5426    } else {
5427        return BAD_VALUE;
5428    }
5429}
5430
5431/*===========================================================================
5432 * FUNCTION   : updateFocusDistances
5433 *
5434 * DESCRIPTION: update focus distances
5435 *
5436 * PARAMETERS :
5437 *   @focusDistances : ptr to focus distance info
5438 *
5439 * RETURN     : int32_t type of status
5440 *              NO_ERROR  -- success
5441 *              none-zero failure code
5442 *==========================================================================*/
5443int32_t QCameraParameters::updateFocusDistances(cam_focus_distances_info_t *focusDistances)
5444{
5445    String8 str;
5446    char buffer[32] = {0};
5447    //set all distances to infinity if focus mode is infinity
5448    if(mFocusMode == CAM_FOCUS_MODE_INFINITY) {
5449        str.append("Infinity,Infinity,Infinity");
5450    } else {
5451        snprintf(buffer, sizeof(buffer), "%f", focusDistances->focus_distance[0]);
5452        str.append(buffer);
5453        snprintf(buffer, sizeof(buffer), ",%f", focusDistances->focus_distance[1]);
5454        str.append(buffer);
5455        snprintf(buffer, sizeof(buffer), ",%f", focusDistances->focus_distance[2]);
5456        str.append(buffer);
5457    }
5458    ALOGD("%s: setting KEY_FOCUS_DISTANCES as %s", __FUNCTION__, str.string());
5459    set(QCameraParameters::KEY_FOCUS_DISTANCES, str.string());
5460    return NO_ERROR;
5461}
5462
5463/*===========================================================================
5464 * FUNCTION   : setHistogram
5465 *
5466 * DESCRIPTION: set histogram
5467 *
5468 * PARAMETERS :
5469 *   @enabled : if histogram is enabled
5470 *
5471 * RETURN     : int32_t type of status
5472 *              NO_ERROR  -- success
5473 *              none-zero failure code
5474 *==========================================================================*/
5475int32_t QCameraParameters::setHistogram(bool enabled)
5476{
5477    if(m_bHistogramEnabled == enabled) {
5478        ALOGD("%s: histogram flag not changed, no ops here", __func__);
5479        return NO_ERROR;
5480    }
5481
5482    // set parm for histogram
5483    if(initBatchUpdate(m_pParamBuf) < 0 ) {
5484        ALOGE("%s:Failed to initialize group update table", __func__);
5485        return BAD_TYPE;
5486    }
5487
5488    int32_t value = enabled;
5489    int32_t rc = NO_ERROR;
5490    rc = AddSetParmEntryToBatch(m_pParamBuf,
5491                                CAM_INTF_PARM_HISTOGRAM,
5492                                sizeof(value),
5493                                &value);
5494    if (rc != NO_ERROR) {
5495        ALOGE("%s:Failed to update table", __func__);
5496        return rc;
5497    }
5498
5499    rc = commitSetBatch();
5500    if (rc != NO_ERROR) {
5501        ALOGE("%s:Failed to set histogram", __func__);
5502        return rc;
5503    }
5504
5505    m_bHistogramEnabled = enabled;
5506
5507    ALOGD(" Histogram -> %s", m_bHistogramEnabled ? "Enabled" : "Disabled");
5508
5509    return rc;
5510}
5511
5512/*===========================================================================
5513 * FUNCTION   : setFaceDetection
5514 *
5515 * DESCRIPTION: set face detection
5516 *
5517 * PARAMETERS :
5518 *   @enabled : if face detection is enabled
5519 *
5520 * RETURN     : int32_t type of status
5521 *              NO_ERROR  -- success
5522 *              none-zero failure code
5523 *==========================================================================*/
5524int32_t QCameraParameters::setFaceDetection(bool enabled)
5525{
5526    int faceProcMask = m_nFaceProcMask;
5527    // set face detection mask
5528    if (enabled) {
5529        faceProcMask |= CAM_FACE_PROCESS_MASK_DETECTION;
5530    } else {
5531        faceProcMask &= ~CAM_FACE_PROCESS_MASK_DETECTION;
5532    }
5533
5534    if(m_nFaceProcMask == faceProcMask) {
5535        ALOGD("%s: face process mask not changed, no ops here", __func__);
5536        return NO_ERROR;
5537    }
5538
5539    // set parm for face detection
5540    int requested_faces = getInt(KEY_QC_MAX_NUM_REQUESTED_FACES);
5541    cam_fd_set_parm_t fd_set_parm;
5542    memset(&fd_set_parm, 0, sizeof(cam_fd_set_parm_t));
5543    fd_set_parm.fd_mode = faceProcMask;
5544    fd_set_parm.num_fd = requested_faces;
5545
5546    if(initBatchUpdate(m_pParamBuf) < 0 ) {
5547        ALOGE("%s:Failed to initialize group update table", __func__);
5548        return BAD_TYPE;
5549    }
5550    int32_t rc = NO_ERROR;
5551
5552    rc = AddSetParmEntryToBatch(m_pParamBuf,
5553                                CAM_INTF_PARM_FD,
5554                                sizeof(fd_set_parm),
5555                                &fd_set_parm);
5556    if (rc != NO_ERROR) {
5557        ALOGE("%s:Failed to update table", __func__);
5558        return rc;
5559    }
5560
5561    rc = commitSetBatch();
5562    if (rc != NO_ERROR) {
5563        ALOGE("%s:Failed to set face detection parm", __func__);
5564        return rc;
5565    }
5566
5567    m_nFaceProcMask = faceProcMask;
5568    ALOGD("%s: FaceProcMask -> %d", __func__, m_nFaceProcMask);
5569
5570    return rc;
5571}
5572
5573/*===========================================================================
5574 * FUNCTION   : setLockCAF
5575 *
5576 * DESCRIPTION: Lock CAF
5577 *
5578 * PARAMETERS :
5579 *   @bLock : if CAF needs to be locked
5580 *
5581 * RETURN     : int32_t type of status
5582 *              NO_ERROR  -- success
5583 *              none-zero failure code
5584 *==========================================================================*/
5585int32_t QCameraParameters::setLockCAF(bool bLock)
5586{
5587    if(initBatchUpdate(m_pParamBuf) < 0 ) {
5588        ALOGE("%s:Failed to initialize group update table", __func__);
5589        return BAD_TYPE;
5590    }
5591    int32_t rc = NO_ERROR;
5592    int32_t value = bLock;
5593
5594    rc = AddSetParmEntryToBatch(m_pParamBuf,
5595                                CAM_INTF_PARM_LOCK_CAF,
5596                                sizeof(value),
5597                                &value);
5598    if (rc != NO_ERROR) {
5599        ALOGE("%s:Failed to update table", __func__);
5600        return rc;
5601    }
5602
5603    rc = commitSetBatch();
5604    if (rc != NO_ERROR) {
5605        ALOGE("%s:Failed to set lock CAF parm", __func__);
5606        return rc;
5607    } else {
5608        m_bCAFLocked = bLock;
5609        return NO_ERROR;
5610    }
5611}
5612
5613/*===========================================================================
5614 * FUNCTION   : setBundleInfo
5615 *
5616 * DESCRIPTION: send bundle info of a channel to backend
5617 *
5618 * PARAMETERS :
5619 *   @bundle_info : reference to bundle info struct
5620 *
5621 * RETURN     : int32_t type of status
5622 *              NO_ERROR  -- success
5623 *              none-zero failure code
5624 *==========================================================================*/
5625int32_t QCameraParameters::setBundleInfo(cam_bundle_config_t &bundle_info)
5626{
5627    int32_t rc = NO_ERROR;
5628
5629    if(initBatchUpdate(m_pParamBuf) < 0 ) {
5630        ALOGE("%s:Failed to initialize group update table", __func__);
5631        return BAD_TYPE;
5632    }
5633
5634    rc = AddSetParmEntryToBatch(m_pParamBuf,
5635                                CAM_INTF_PARM_SET_BUNDLE,
5636                                sizeof(cam_bundle_config_t),
5637                                &bundle_info);
5638    if (rc != NO_ERROR) {
5639        ALOGE("%s:Failed to update table", __func__);
5640        return rc;
5641    }
5642
5643    rc = commitSetBatch();
5644    if (rc != NO_ERROR) {
5645        ALOGE("%s:Failed to set bundle info parm", __func__);
5646        return rc;
5647    }
5648
5649    return rc;
5650}
5651
5652/*===========================================================================
5653 * FUNCTION   : setFrameSkip
5654 *
5655 * DESCRIPTION: send ISP frame skip pattern to camera daemon
5656 *
5657 * PARAMETERS :
5658 *   @pattern : skip pattern for ISP
5659 *
5660 * RETURN     : int32_t type of status
5661 *              NO_ERROR  -- success
5662 *              none-zero failure code
5663 *==========================================================================*/
5664int32_t QCameraParameters::setFrameSkip(enum msm_vfe_frame_skip_pattern pattern)
5665{
5666    int32_t rc = NO_ERROR;
5667    int32_t value = (int32_t)pattern;
5668
5669    if(initBatchUpdate(m_pParamBuf) < 0 ) {
5670        ALOGE("%s:Failed to initialize group update table", __func__);
5671        return BAD_TYPE;
5672    }
5673
5674    rc = AddSetParmEntryToBatch(m_pParamBuf,
5675                                CAM_INTF_PARM_FRAMESKIP,
5676                                sizeof(value),
5677                                &value);
5678    if (rc != NO_ERROR) {
5679        ALOGE("%s:Failed to update table", __func__);
5680        return rc;
5681    }
5682
5683    rc = commitSetBatch();
5684    if (rc != NO_ERROR) {
5685        ALOGE("%s:Failed to set frameskip info parm", __func__);
5686        return rc;
5687    }
5688
5689    return rc;
5690}
5691
5692/*===========================================================================
5693 * FUNCTION   : parseNDimVector
5694 *
5695 * DESCRIPTION: helper function to parse a string like "(1, 2, 3, 4, ..., N)"
5696 *              into N-dimension vector
5697 *
5698 * PARAMETERS :
5699 *   @str     : string to be parsed
5700 *   @num     : output array of size N to store vector element values
5701 *   @N       : number of dimension
5702 *   @delim   : delimeter to seperete string
5703 *
5704 * RETURN     : int32_t type of status
5705 *              NO_ERROR  -- success
5706 *              none-zero failure code
5707 *==========================================================================*/
5708int32_t QCameraParameters::parseNDimVector(const char *str, int *num, int N, char delim = ',')
5709{
5710    char *start, *end;
5711    if (num == NULL) {
5712        ALOGE("%s: Invalid output array (num == NULL)", __func__);
5713        return BAD_VALUE;
5714    }
5715
5716    //check if string starts and ends with parantheses
5717    if(str[0] != '(' || str[strlen(str)-1] != ')') {
5718        ALOGE("%s: Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)",
5719              __func__, str);
5720        return BAD_VALUE;
5721    }
5722    start = (char*) str;
5723    start++;
5724    for(int i=0; i<N; i++) {
5725        *(num+i) = (int) strtol(start, &end, 10);
5726        if(*end != delim && i < N-1) {
5727            ALOGE("%s: Cannot find delimeter '%c' in string \"%s\". end = %c",
5728                  __func__, delim, str, *end);
5729            return -1;
5730        }
5731        start = end+1;
5732    }
5733    return NO_ERROR;
5734}
5735
5736/*===========================================================================
5737 * FUNCTION   : parseCameraAreaString
5738 *
5739 * DESCRIPTION: helper function to parse a string of camera areas like
5740 *              "(1, 2, 3, 4, 5),(1, 2, 3, 4, 5),..."
5741 *
5742 * PARAMETERS :
5743 *   @str             : string to be parsed
5744 *   @max_num_areas   : max number of areas
5745 *   @pAreas          : ptr to struct to store areas
5746 *   @num_areas_found : number of areas found
5747 *
5748 * RETURN     : int32_t type of status
5749 *              NO_ERROR  -- success
5750 *              none-zero failure code
5751 *==========================================================================*/
5752int32_t QCameraParameters::parseCameraAreaString(const char *str,
5753                                                 int max_num_areas,
5754                                                 cam_area_t *pAreas,
5755                                                 int& num_areas_found)
5756{
5757    char area_str[32];
5758    const char *start, *end, *p;
5759    start = str; end = NULL;
5760    int values[5], index=0;
5761    num_areas_found = 0;
5762
5763    memset(values, 0, sizeof(values));
5764    while(start != NULL) {
5765       if(*start != '(') {
5766            ALOGE("%s: error: Ill formatted area string: %s", __func__, str);
5767            return BAD_VALUE;
5768       }
5769       end = strchr(start, ')');
5770       if(end == NULL) {
5771            ALOGE("%s: error: Ill formatted area string: %s", __func__, str);
5772            return BAD_VALUE;
5773       }
5774       int i;
5775       for (i=0,p=start; p<=end; p++, i++) {
5776           area_str[i] = *p;
5777       }
5778       area_str[i] = '\0';
5779       if(parseNDimVector(area_str, values, 5) < 0){
5780            ALOGE("%s: error: Failed to parse the area string: %s", __func__, area_str);
5781            return BAD_VALUE;
5782       }
5783       // no more areas than max_num_areas are accepted.
5784       if(index >= max_num_areas) {
5785            ALOGE("%s: error: too many areas specified %s", __func__, str);
5786            return BAD_VALUE;
5787       }
5788       pAreas[index].rect.left = values[0];
5789       pAreas[index].rect.top = values[1];
5790       pAreas[index].rect.width = values[2] - values[0];
5791       pAreas[index].rect.height = values[3] - values[1];
5792       pAreas[index].weight = values[4];
5793
5794       index++;
5795       start = strchr(end, '('); // serach for next '('
5796    }
5797    num_areas_found = index;
5798    return 0;
5799}
5800
5801/*===========================================================================
5802 * FUNCTION   : validateCameraAreas
5803 *
5804 * DESCRIPTION: helper function to validate camera areas within (-1000, 1000)
5805 *
5806 * PARAMETERS :
5807 *   @areas     : ptr to array of areas
5808 *   @num_areas : number of areas
5809 *
5810 * RETURN     : true --  area is in valid range
5811 *              false -- not valid
5812 *==========================================================================*/
5813bool QCameraParameters::validateCameraAreas(cam_area_t *areas, int num_areas)
5814{
5815    // special case: default area
5816    if (num_areas == 1 &&
5817        areas[0].rect.left == 0 &&
5818        areas[0].rect.top == 0 &&
5819        areas[0].rect.width == 0 &&
5820        areas[0].rect.height == 0 &&
5821        areas[0].weight == 0) {
5822        return true;
5823    }
5824
5825    for(int i = 0; i < num_areas; i++) {
5826        // left should be >= -1000
5827        if(areas[i].rect.left < -1000) {
5828            return false;
5829        }
5830
5831        // top  should be >= -1000
5832        if(areas[i].rect.top < -1000) {
5833            return false;
5834        }
5835
5836        // width or height should be > 0
5837        if (areas[i].rect.width <= 0 || areas[i].rect.height <= 0) {
5838            return false;
5839        }
5840
5841        // right  should be <= 1000
5842        if(areas[i].rect.left + areas[i].rect.width > 1000) {
5843            return false;
5844        }
5845
5846        // bottom should be <= 1000
5847        if(areas[i].rect.top + areas[i].rect.height > 1000) {
5848            return false;
5849        }
5850
5851        // weight should be within (1, 1000)
5852        if (areas[i].weight < 1 || areas[i].weight > 1000) {
5853            return false;
5854        }
5855    }
5856    return true;
5857}
5858
5859/*===========================================================================
5860 * FUNCTION   : initBatchUpdate
5861 *
5862 * DESCRIPTION: init camera parameters buf entries
5863 *
5864 * PARAMETERS :
5865 *   @p_table : ptr to parameter buffer
5866 *
5867 * RETURN     : int32_t type of status
5868 *              NO_ERROR  -- success
5869 *              none-zero failure code
5870 *==========================================================================*/
5871int32_t QCameraParameters::initBatchUpdate(parm_buffer_t *p_table)
5872{
5873    m_tempMap.clear();
5874
5875    memset(p_table, 0, sizeof(parm_buffer_t));
5876    p_table->first_flagged_entry = CAM_INTF_PARM_MAX;
5877    return NO_ERROR;
5878}
5879
5880/*===========================================================================
5881 * FUNCTION   : AddSetParmEntryToBatch
5882 *
5883 * DESCRIPTION: add set parameter entry into batch
5884 *
5885 * PARAMETERS :
5886 *   @p_table     : ptr to parameter buffer
5887 *   @paramType   : parameter type
5888 *   @paramLength : length of parameter value
5889 *   @paramValue  : ptr to parameter value
5890 *
5891 * RETURN     : int32_t type of status
5892 *              NO_ERROR  -- success
5893 *              none-zero failure code
5894 *==========================================================================*/
5895int32_t QCameraParameters::AddSetParmEntryToBatch(parm_buffer_t *p_table,
5896                                                  cam_intf_parm_type_t paramType,
5897                                                  uint32_t paramLength,
5898                                                  void *paramValue)
5899{
5900    int position = paramType;
5901    int current, next;
5902
5903    /*************************************************************************
5904    *                 Code to take care of linking next flags                *
5905    *************************************************************************/
5906    current = GET_FIRST_PARAM_ID(p_table);
5907    if (position == current){
5908        //DO NOTHING
5909    } else if (position < current){
5910        SET_NEXT_PARAM_ID(position, p_table, current);
5911        SET_FIRST_PARAM_ID(p_table, position);
5912    } else {
5913        /* Search for the position in the linked list where we need to slot in*/
5914        while (position > GET_NEXT_PARAM_ID(current, p_table))
5915            current = GET_NEXT_PARAM_ID(current, p_table);
5916
5917        /*If node already exists no need to alter linking*/
5918        if (position != GET_NEXT_PARAM_ID(current, p_table)) {
5919            next = GET_NEXT_PARAM_ID(current, p_table);
5920            SET_NEXT_PARAM_ID(current, p_table, position);
5921            SET_NEXT_PARAM_ID(position, p_table, next);
5922        }
5923    }
5924
5925    /*************************************************************************
5926    *                   Copy contents into entry                             *
5927    *************************************************************************/
5928
5929    if (paramLength > sizeof(parm_type_t)) {
5930        ALOGE("%s:Size of input larger than max entry size",__func__);
5931        return BAD_VALUE;
5932    }
5933    memcpy(POINTER_OF(paramType,p_table), paramValue, paramLength);
5934    return NO_ERROR;
5935}
5936
5937/*===========================================================================
5938 * FUNCTION   : AddGetParmEntryToBatch
5939 *
5940 * DESCRIPTION: add get parameter entry into batch
5941 *
5942 * PARAMETERS :
5943 *   @p_table     : ptr to parameter buffer
5944 *   @paramType   : parameter type
5945 *
5946 * RETURN     : int32_t type of status
5947 *              NO_ERROR  -- success
5948 *              none-zero failure code
5949 *==========================================================================*/
5950int32_t QCameraParameters::AddGetParmEntryToBatch(parm_buffer_t *p_table,
5951                                                  cam_intf_parm_type_t paramType)
5952{
5953    int position = paramType;
5954    int current, next;
5955
5956    /*************************************************************************
5957    *                 Code to take care of linking next flags                *
5958    *************************************************************************/
5959    current = GET_FIRST_PARAM_ID(p_table);
5960    if (position == current){
5961        //DO NOTHING
5962    } else if (position < current){
5963        SET_NEXT_PARAM_ID(position, p_table, current);
5964        SET_FIRST_PARAM_ID(p_table, position);
5965    } else {
5966        /* Search for the position in the linked list where we need to slot in*/
5967        while (position > GET_NEXT_PARAM_ID(current, p_table))
5968            current = GET_NEXT_PARAM_ID(current, p_table);
5969
5970        /*If node already exists no need to alter linking*/
5971        if (position != GET_NEXT_PARAM_ID(current, p_table)) {
5972            next=GET_NEXT_PARAM_ID(current, p_table);
5973            SET_NEXT_PARAM_ID(current, p_table, position);
5974            SET_NEXT_PARAM_ID(position, p_table, next);
5975        }
5976    }
5977
5978    return NO_ERROR;
5979}
5980
5981/*===========================================================================
5982 * FUNCTION   : commitSetBatch
5983 *
5984 * DESCRIPTION: commit all set parameters in the batch work to backend
5985 *
5986 * PARAMETERS : none
5987 *
5988 * RETURN     : int32_t type of status
5989 *              NO_ERROR  -- success
5990 *              none-zero failure code
5991 *==========================================================================*/
5992int32_t QCameraParameters::commitSetBatch()
5993{
5994    int32_t rc = NO_ERROR;
5995    if (m_pParamBuf->first_flagged_entry < CAM_INTF_PARM_MAX) {
5996        rc = m_pCamOpsTbl->ops->set_parms(m_pCamOpsTbl->camera_handle, m_pParamBuf);
5997    }
5998    if (rc == NO_ERROR) {
5999        // commit change from temp storage into param map
6000        rc = commitParamChanges();
6001    }
6002    return rc;
6003}
6004
6005/*===========================================================================
6006 * FUNCTION   : commitGetBatch
6007 *
6008 * DESCRIPTION: commit all get parameters in the batch work to backend
6009 *
6010 * PARAMETERS : none
6011 *
6012 * RETURN     : int32_t type of status
6013 *              NO_ERROR  -- success
6014 *              none-zero failure code
6015 *==========================================================================*/
6016int32_t QCameraParameters::commitGetBatch()
6017{
6018    if (m_pParamBuf->first_flagged_entry < CAM_INTF_PARM_MAX) {
6019        return m_pCamOpsTbl->ops->get_parms(m_pCamOpsTbl->camera_handle, m_pParamBuf);
6020    } else {
6021        return NO_ERROR;
6022    }
6023}
6024
6025/*===========================================================================
6026 * FUNCTION   : updateParamEntry
6027 *
6028 * DESCRIPTION: update a parameter entry in the local temp map obj
6029 *
6030 * PARAMETERS :
6031 *   @key     : key of the entry
6032 *   @value   : value of the entry
6033 *
6034 * RETURN     : int32_t type of status
6035 *              NO_ERROR  -- success
6036 *              none-zero failure code
6037 *==========================================================================*/
6038int32_t QCameraParameters::updateParamEntry(const char *key, const char *value)
6039{
6040    m_tempMap.replaceValueFor(String8(key), String8(value));
6041    return NO_ERROR;
6042}
6043
6044/*===========================================================================
6045 * FUNCTION   : commitParamChanges
6046 *
6047 * DESCRIPTION: commit all changes in local temp map obj into parameter obj
6048 *
6049 * PARAMETERS : none
6050 *
6051 * RETURN     : int32_t type of status
6052 *              NO_ERROR  -- success
6053 *              none-zero failure code
6054 *==========================================================================*/
6055int32_t QCameraParameters::commitParamChanges()
6056{
6057    size_t size = m_tempMap.size();
6058    for (size_t i = 0; i < size; i++) {
6059        String8 k, v;
6060        k = m_tempMap.keyAt(i);
6061        v = m_tempMap.valueAt(i);
6062        set(k, v);
6063    }
6064    m_tempMap.clear();
6065    return NO_ERROR;
6066}
6067
6068}; // namespace qcamera
6069