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