1 /*
2 ** Copyright (c) 2012 The Linux Foundation. All rights reserved.
3 **
4 ** Not a Contribution, Apache license notifications and license are retained
5 ** for attribution purposes only.
6 **
7 ** Licensed under the Apache License, Version 2.0 (the "License");
8 ** you may not use this file except in compliance with the License.
9 ** You may obtain a copy of the License at
10 **
11 ** http://www.apache.org/licenses/LICENSE-2.0
12 **
13 ** Unless required by applicable law or agreed to in writing, software
14 ** distributed under the License is distributed on an "AS IS" BASIS,
15 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 ** See the License for the specific language governing permissions and
17 ** limitations under the License.
18 */
19
20 //#define ALOG_NDEBUG 0
21 #define ALOG_NIDEBUG 0
22 #define LOG_TAG "QCameraHWI_Parm"
23 #include <utils/Log.h>
24
25 #include <utils/Errors.h>
26 #include <utils/threads.h>
27 #include <utils/String16.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <unistd.h>
31 #include <fcntl.h>
32 #include <cutils/properties.h>
33 #include <math.h>
34 #if HAVE_ANDROID_OS
35 #include <linux/android_pmem.h>
36 #endif
37 #include <linux/ioctl.h>
38 #include <camera/QCameraParameters.h>
39 #include <media/mediarecorder.h>
40 #include <gralloc_priv.h>
41
42 #include "linux/msm_mdp.h"
43 #include <linux/fb.h>
44 #include <limits.h>
45
46
47 extern "C" {
48 #include <fcntl.h>
49 #include <time.h>
50 #include <pthread.h>
51 #include <stdio.h>
52 #include <string.h>
53 #include <unistd.h>
54 #include <termios.h>
55 #include <assert.h>
56 #include <stdlib.h>
57 #include <ctype.h>
58 #include <signal.h>
59 #include <errno.h>
60 #include <sys/mman.h>
61 #include <sys/system_properties.h>
62 #include <sys/time.h>
63 #include <stdlib.h>
64 #include <linux/msm_ion.h>
65 #include <camera.h>
66 #include <cam_fifo.h>
67 #include <jpege.h>
68
69 } // extern "C"
70
71 #include "QCameraHWI.h"
72
73 /* QCameraHardwareInterface class implementation goes here*/
74 /* following code implements the parameter logic of this class*/
75 #define EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR 12
76 #define EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR -12
77 #define EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR 0
78 #define EXPOSURE_COMPENSATION_DENOMINATOR 6
79 #define EXPOSURE_COMPENSATION_STEP ((float (1))/EXPOSURE_COMPENSATION_DENOMINATOR)
80 #define DEFAULT_CAMERA_AREA "(0, 0, 0, 0, 0)"
81
82 #define HDR_HAL_FRAME 2
83
84 #define BURST_INTREVAL_MIN 1
85 #define BURST_INTREVAL_MAX 10
86 #define BURST_INTREVAL_DEFAULT 1
87
88 //Default FPS
89 #define MINIMUM_FPS 5
90 #define MAXIMUM_FPS 120
91 #define DEFAULT_FIXED_FPS 30
92 #define DEFAULT_FPS MAXIMUM_FPS
93
94 //Default Picture Width
95 #define DEFAULT_PICTURE_WIDTH 640
96 #define DEFAULT_PICTURE_HEIGHT 480
97
98 //Default Video Width
99 #define DEFAULT_VIDEO_WIDTH 1920
100 #define DEFAULT_VIDEO_HEIGHT 1080
101
102 #define THUMBNAIL_SIZE_COUNT (sizeof(thumbnail_sizes)/sizeof(thumbnail_size_type))
103 #define DEFAULT_THUMBNAIL_SETTING 4
104 #define THUMBNAIL_WIDTH_STR "512"
105 #define THUMBNAIL_HEIGHT_STR "384"
106 #define THUMBNAIL_SMALL_HEIGHT 144
107
108 #define DONT_CARE_COORDINATE -1
109
110 // All fps ranges which can be supported. This list will be filtered according
111 // to the min and max fps supported by hardware
112 // this list must be sorted first by max_fps and then min_fps
113 // fps values are multiplied by 1000
114 static android::FPSRange allFpsRanges[] = {
115 android::FPSRange(7500, 7500),
116 android::FPSRange(10000, 10000),
117 android::FPSRange(7500, 15000),
118 android::FPSRange(15000, 15000),
119 android::FPSRange(7500, 20000),
120 android::FPSRange(20000, 20000),
121 android::FPSRange(7500, 30000),
122 android::FPSRange(10000, 30000),
123 android::FPSRange(15000, 30000),
124 android::FPSRange(30000, 30000)
125 };
126 #define ALL_FPS_RANGES_COUNT (sizeof(allFpsRanges)/sizeof(android::FPSRange))
127
128 typedef struct {
129 uint32_t aspect_ratio;
130 uint32_t width;
131 uint32_t height;
132 } thumbnail_size_type;
133
134 static thumbnail_size_type thumbnail_sizes[] = {
135 { 7281, 512, 288 }, //1.777778
136 { 6826, 480, 288 }, //1.666667
137 { 6808, 256, 154 }, //1.66233
138 { 6144, 432, 288 }, //1.5
139 { 5461, 512, 384 }, //1.333333
140 { 5006, 352, 288 }, //1.222222
141 { 5461, 320, 240 }, //1.33333
142 { 5006, 176, 144 }, //1.222222
143
144 };
145
146 static struct camera_size_type zsl_picture_sizes[] = {
147 { 1024, 768}, // 1MP XGA
148 { 800, 600}, //SVGA
149 { 800, 480}, // WVGA
150 { 640, 480}, // VGA
151 { 352, 288}, //CIF
152 { 320, 240}, // QVGA
153 { 176, 144} // QCIF
154 };
155
156 static camera_size_type default_picture_sizes[] = {
157 { 4000, 3000}, // 12MP
158 { 3200, 2400}, // 8MP
159 { 2592, 1944}, // 5MP
160 { 2048, 1536}, // 3MP QXGA
161 { 1920, 1080}, //HD1080
162 { 1600, 1200}, // 2MP UXGA
163 { 1280, 768}, //WXGA
164 { 1280, 720}, //HD720
165 { 1024, 768}, // 1MP XGA
166 { 800, 600}, //SVGA
167 { 800, 480}, // WVGA
168 { 720, 480},
169 { 640, 480}, // VGA
170 { 352, 288}, //CIF
171 { 320, 240}, // QVGA
172 { 176, 144} // QCIF
173 };
174
175 static int iso_speed_values[] = {
176 0, 1, 100, 200, 400, 800, 1600
177 };
178
179 extern int HAL_numOfCameras;
180 extern camera_info_t HAL_cameraInfo[MSM_MAX_CAMERA_SENSORS];
181 extern mm_camera_info_t * HAL_camerahandle[MSM_MAX_CAMERA_SENSORS];
182
183 namespace android {
184
185 static uint32_t HFR_SIZE_COUNT=2;
186 static const int PICTURE_FORMAT_JPEG = 1;
187 static const int PICTURE_FORMAT_RAW = 2;
188
189 /********************************************************************/
190 static const str_map effects[] = {
191 { QCameraParameters::EFFECT_NONE, CAMERA_EFFECT_OFF },
192 { QCameraParameters::EFFECT_MONO, CAMERA_EFFECT_MONO },
193 { QCameraParameters::EFFECT_NEGATIVE, CAMERA_EFFECT_NEGATIVE },
194 { QCameraParameters::EFFECT_SOLARIZE, CAMERA_EFFECT_SOLARIZE },
195 { QCameraParameters::EFFECT_SEPIA, CAMERA_EFFECT_SEPIA },
196 { QCameraParameters::EFFECT_POSTERIZE, CAMERA_EFFECT_POSTERIZE },
197 { QCameraParameters::EFFECT_WHITEBOARD, CAMERA_EFFECT_WHITEBOARD },
198 { QCameraParameters::EFFECT_BLACKBOARD, CAMERA_EFFECT_BLACKBOARD },
199 { QCameraParameters::EFFECT_AQUA, CAMERA_EFFECT_AQUA },
200 { QCameraParameters::EFFECT_EMBOSS, CAMERA_EFFECT_EMBOSS },
201 { QCameraParameters::EFFECT_SKETCH, CAMERA_EFFECT_SKETCH },
202 { QCameraParameters::EFFECT_NEON, CAMERA_EFFECT_NEON }
203 };
204
205 static const str_map iso[] = {
206 { QCameraParameters::ISO_AUTO, CAMERA_ISO_AUTO},
207 { QCameraParameters::ISO_HJR, CAMERA_ISO_DEBLUR},
208 { QCameraParameters::ISO_100, CAMERA_ISO_100},
209 { QCameraParameters::ISO_200, CAMERA_ISO_200},
210 { QCameraParameters::ISO_400, CAMERA_ISO_400},
211 { QCameraParameters::ISO_800, CAMERA_ISO_800 },
212 { QCameraParameters::ISO_1600, CAMERA_ISO_1600 }
213 };
214
215 static const str_map scenemode[] = {
216 { QCameraParameters::SCENE_MODE_AUTO, CAMERA_BESTSHOT_OFF },
217 { QCameraParameters::SCENE_MODE_ASD, CAMERA_BESTSHOT_AUTO },
218 { QCameraParameters::SCENE_MODE_ACTION, CAMERA_BESTSHOT_ACTION },
219 { QCameraParameters::SCENE_MODE_PORTRAIT, CAMERA_BESTSHOT_PORTRAIT },
220 { QCameraParameters::SCENE_MODE_LANDSCAPE, CAMERA_BESTSHOT_LANDSCAPE },
221 { QCameraParameters::SCENE_MODE_NIGHT, CAMERA_BESTSHOT_NIGHT },
222 { QCameraParameters::SCENE_MODE_NIGHT_PORTRAIT, CAMERA_BESTSHOT_NIGHT_PORTRAIT },
223 { QCameraParameters::SCENE_MODE_THEATRE, CAMERA_BESTSHOT_THEATRE },
224 { QCameraParameters::SCENE_MODE_BEACH, CAMERA_BESTSHOT_BEACH },
225 { QCameraParameters::SCENE_MODE_SNOW, CAMERA_BESTSHOT_SNOW },
226 { QCameraParameters::SCENE_MODE_SUNSET, CAMERA_BESTSHOT_SUNSET },
227 { QCameraParameters::SCENE_MODE_STEADYPHOTO, CAMERA_BESTSHOT_ANTISHAKE },
228 { QCameraParameters::SCENE_MODE_FIREWORKS , CAMERA_BESTSHOT_FIREWORKS },
229 { QCameraParameters::SCENE_MODE_SPORTS , CAMERA_BESTSHOT_SPORTS },
230 { QCameraParameters::SCENE_MODE_PARTY, CAMERA_BESTSHOT_PARTY },
231 { QCameraParameters::SCENE_MODE_CANDLELIGHT, CAMERA_BESTSHOT_CANDLELIGHT },
232 { QCameraParameters::SCENE_MODE_BACKLIGHT, CAMERA_BESTSHOT_BACKLIGHT },
233 { QCameraParameters::SCENE_MODE_FLOWERS, CAMERA_BESTSHOT_FLOWERS },
234 { QCameraParameters::SCENE_MODE_AR, CAMERA_BESTSHOT_AR },
235 };
236
237 static const str_map scenedetect[] = {
238 { QCameraParameters::SCENE_DETECT_OFF, FALSE },
239 { QCameraParameters::SCENE_DETECT_ON, TRUE },
240 };
241
242 #define DONT_CARE AF_MODE_MAX
243 static const str_map focus_modes[] = {
244 { QCameraParameters::FOCUS_MODE_AUTO, AF_MODE_AUTO},
245 { QCameraParameters::FOCUS_MODE_INFINITY, AF_MODE_INFINITY },
246 { QCameraParameters::FOCUS_MODE_NORMAL, AF_MODE_NORMAL },
247 { QCameraParameters::FOCUS_MODE_MACRO, AF_MODE_MACRO },
248 { QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE, AF_MODE_CAF},
249 { QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO, AF_MODE_CAF }
250 };
251
252 static const str_map selectable_zone_af[] = {
253 { QCameraParameters::SELECTABLE_ZONE_AF_AUTO, AUTO },
254 { QCameraParameters::SELECTABLE_ZONE_AF_SPOT_METERING, SPOT },
255 { QCameraParameters::SELECTABLE_ZONE_AF_CENTER_WEIGHTED, CENTER_WEIGHTED },
256 { QCameraParameters::SELECTABLE_ZONE_AF_FRAME_AVERAGE, AVERAGE }
257 };
258
259 // from qcamera/common/camera.h
260 static const str_map autoexposure[] = {
261 { QCameraParameters::AUTO_EXPOSURE_FRAME_AVG, CAMERA_AEC_FRAME_AVERAGE },
262 { QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED, CAMERA_AEC_CENTER_WEIGHTED },
263 { QCameraParameters::AUTO_EXPOSURE_SPOT_METERING, CAMERA_AEC_SPOT_METERING }
264 };
265
266 // from aeecamera.h
267 static const str_map whitebalance[] = {
268 { QCameraParameters::WHITE_BALANCE_AUTO, CAMERA_WB_AUTO },
269 { QCameraParameters::WHITE_BALANCE_INCANDESCENT, CAMERA_WB_INCANDESCENT },
270 { QCameraParameters::WHITE_BALANCE_FLUORESCENT, CAMERA_WB_FLUORESCENT },
271 { QCameraParameters::WHITE_BALANCE_DAYLIGHT, CAMERA_WB_DAYLIGHT },
272 { QCameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT, CAMERA_WB_CLOUDY_DAYLIGHT }
273 };
274
275 static const str_map antibanding[] = {
276 { QCameraParameters::ANTIBANDING_OFF, CAMERA_ANTIBANDING_OFF },
277 { QCameraParameters::ANTIBANDING_50HZ, CAMERA_ANTIBANDING_50HZ },
278 { QCameraParameters::ANTIBANDING_60HZ, CAMERA_ANTIBANDING_60HZ },
279 { QCameraParameters::ANTIBANDING_AUTO, CAMERA_ANTIBANDING_AUTO }
280 };
281
282 static const str_map frame_rate_modes[] = {
283 {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE, FPS_MODE_AUTO},
284 {QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE, FPS_MODE_FIXED}
285 };
286
287 static const str_map touchafaec[] = {
288 { QCameraParameters::TOUCH_AF_AEC_OFF, FALSE },
289 { QCameraParameters::TOUCH_AF_AEC_ON, TRUE }
290 };
291
292 static const str_map hfr[] = {
293 { QCameraParameters::VIDEO_HFR_OFF, CAMERA_HFR_MODE_OFF },
294 { QCameraParameters::VIDEO_HFR_2X, CAMERA_HFR_MODE_60FPS },
295 { QCameraParameters::VIDEO_HFR_3X, CAMERA_HFR_MODE_90FPS },
296 { QCameraParameters::VIDEO_HFR_4X, CAMERA_HFR_MODE_120FPS },
297 };
298 static const int HFR_VALUES_COUNT = (sizeof(hfr)/sizeof(str_map));
299
300 static const str_map flash[] = {
301 { QCameraParameters::FLASH_MODE_OFF, LED_MODE_OFF },
302 { QCameraParameters::FLASH_MODE_AUTO, LED_MODE_AUTO },
303 { QCameraParameters::FLASH_MODE_ON, LED_MODE_ON },
304 { QCameraParameters::FLASH_MODE_TORCH, LED_MODE_TORCH}
305 };
306
307 static const str_map lensshade[] = {
308 { QCameraParameters::LENSSHADE_ENABLE, TRUE },
309 { QCameraParameters::LENSSHADE_DISABLE, FALSE }
310 };
311
312 static const str_map mce[] = {
313 { QCameraParameters::MCE_ENABLE, TRUE },
314 { QCameraParameters::MCE_DISABLE, FALSE }
315 };
316
317 static const str_map histogram[] = {
318 { QCameraParameters::HISTOGRAM_ENABLE, TRUE },
319 { QCameraParameters::HISTOGRAM_DISABLE, FALSE }
320 };
321
322 static const str_map skinToneEnhancement[] = {
323 { QCameraParameters::SKIN_TONE_ENHANCEMENT_ENABLE, TRUE },
324 { QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE, FALSE }
325 };
326
327 static const str_map denoise[] = {
328 { QCameraParameters::DENOISE_OFF, FALSE },
329 { QCameraParameters::DENOISE_ON, TRUE }
330 };
331
332 static const str_map facedetection[] = {
333 { QCameraParameters::FACE_DETECTION_OFF, FALSE },
334 { QCameraParameters::FACE_DETECTION_ON, TRUE }
335 };
336
337 static const str_map redeye_reduction[] = {
338 { QCameraParameters::REDEYE_REDUCTION_ENABLE, TRUE },
339 { QCameraParameters::REDEYE_REDUCTION_DISABLE, FALSE }
340 };
341
342 static const str_map picture_formats[] = {
343 {QCameraParameters::PIXEL_FORMAT_JPEG, PICTURE_FORMAT_JPEG},
344 {QCameraParameters::PIXEL_FORMAT_RAW, PICTURE_FORMAT_RAW}
345 };
346
347 static const str_map recording_Hints[] = {
348 {"false", FALSE},
349 {"true", TRUE}
350 };
351
352 static const str_map preview_formats[] = {
353 {QCameraParameters::PIXEL_FORMAT_YUV420SP, HAL_PIXEL_FORMAT_YCrCb_420_SP},
354 {QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO, HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO},
355 {QCameraParameters::PIXEL_FORMAT_YV12, HAL_PIXEL_FORMAT_YV12},
356 {QCameraParameters::PIXEL_FORMAT_YUV420P,HAL_PIXEL_FORMAT_YV12},
357 {QCameraParameters::PIXEL_FORMAT_NV12, HAL_PIXEL_FORMAT_YCbCr_420_SP}
358 };
359
360 static const preview_format_info_t preview_format_info_list[] = {
361 {HAL_PIXEL_FORMAT_YCrCb_420_SP, CAMERA_YUV_420_NV21, CAMERA_PAD_TO_WORD, 2},
362 {HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO, CAMERA_YUV_420_NV21, CAMERA_PAD_TO_4K, 2},
363 {HAL_PIXEL_FORMAT_YCbCr_420_SP, CAMERA_YUV_420_NV12, CAMERA_PAD_TO_WORD, 2},
364 {HAL_PIXEL_FORMAT_YV12, CAMERA_YUV_420_YV12, CAMERA_PAD_TO_WORD, 3}
365 };
366
367 static const str_map zsl_modes[] = {
368 { QCameraParameters::ZSL_OFF, FALSE },
369 { QCameraParameters::ZSL_ON, TRUE },
370 };
371
372
373 static const str_map hdr_bracket[] = {
374 { QCameraParameters::AE_BRACKET_HDR_OFF,HDR_BRACKETING_OFF},
375 { QCameraParameters::AE_BRACKET_HDR,HDR_MODE },
376 { QCameraParameters::AE_BRACKET,EXP_BRACKETING_MODE }
377 };
378
379 typedef enum {
380 NORMAL_POWER,
381 LOW_POWER
382 } power_mode;
383
384 static const str_map power_modes[] = {
385 { QCameraParameters::NORMAL_POWER,NORMAL_POWER },
386 { QCameraParameters::LOW_POWER,LOW_POWER }
387 };
388
389 /**************************************************************************/
attr_lookup(const str_map arr[],int len,const char * name)390 static int attr_lookup(const str_map arr[], int len, const char *name)
391 {
392 if (name) {
393 for (int i = 0; i < len; i++) {
394 if (!strcmp(arr[i].desc, name))
395 return arr[i].val;
396 }
397 }
398 return NOT_FOUND;
399 }
400
native_set_parms(mm_camera_parm_type_t type,uint16_t length,void * value)401 bool QCameraHardwareInterface::native_set_parms(
402 mm_camera_parm_type_t type, uint16_t length, void *value)
403 {
404 ALOGV("%s : type : %d Value : %d",__func__,type,*((int *)value));
405 if(mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, type,value ) < 0) {
406 ALOGE("native_set_parms failed: type %d length %d error %s",
407 type, length, strerror(errno));
408 return false;
409 }
410
411 return true;
412
413 }
414
native_set_parms(mm_camera_parm_type_t type,uint16_t length,void * value,int * result)415 bool QCameraHardwareInterface::native_set_parms(
416 mm_camera_parm_type_t type, uint16_t length, void *value, int *result)
417 {
418 *result= mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, type,value );
419 if( *result >=0 ) {
420 ALOGE("native_set_parms: succeeded : %d", *result);
421 return true;
422 }
423
424 ALOGV("native_set_parms failed: type %d length %d error str %s error# %d",
425 type, length, strerror(errno), errno);
426 return false;
427 }
428
429 //Filter Picture sizes based on max width and height
430 /* TBD: do we still need this - except for ZSL? */
filterPictureSizes()431 void QCameraHardwareInterface::filterPictureSizes(){
432 unsigned int i;
433 if(mPictureSizeCount <= 0)
434 return;
435 maxSnapshotWidth = mPictureSizes[0].width;
436 maxSnapshotHeight = mPictureSizes[0].height;
437 // Iterate through all the width and height to find the max value
438 for(i =0; i<mPictureSizeCount;i++){
439 if(((maxSnapshotWidth < mPictureSizes[i].width) &&
440 (maxSnapshotHeight <= mPictureSizes[i].height))){
441 maxSnapshotWidth = mPictureSizes[i].width;
442 maxSnapshotHeight = mPictureSizes[i].height;
443 }
444 }
445 if(myMode & CAMERA_ZSL_MODE){
446 // due to lack of PMEM we restrict to lower resolution
447 mPictureSizesPtr = zsl_picture_sizes;
448 mSupportedPictureSizesCount = 7;
449 }else{
450 mPictureSizesPtr = mPictureSizes;
451 mSupportedPictureSizesCount = mPictureSizeCount;
452 }
453 }
454
create_sizes_str(const camera_size_type * sizes,int len)455 static String8 create_sizes_str(const camera_size_type *sizes, int len) {
456 String8 str;
457 char buffer[32];
458
459 if (len > 0) {
460 snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height);
461 str.append(buffer);
462 }
463 for (int i = 1; i < len; i++) {
464 snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height);
465 str.append(buffer);
466 }
467 return str;
468 }
469
create_values_str(const str_map * values,int len)470 String8 QCameraHardwareInterface::create_values_str(const str_map *values, int len) {
471 String8 str;
472
473 if (len > 0) {
474 str.append(values[0].desc);
475 }
476 for (int i = 1; i < len; i++) {
477 str.append(",");
478 str.append(values[i].desc);
479 }
480 return str;
481 }
482
create_fps_str(const android::FPSRange * fps,int len)483 static String8 create_fps_str(const android:: FPSRange* fps, int len) {
484 String8 str;
485 char buffer[32];
486
487 if (len > 0) {
488 snprintf(buffer, sizeof(buffer), "(%d,%d)", fps[0].minFPS, fps[0].maxFPS);
489 str.append(buffer);
490 }
491 for (int i = 1; i < len; i++) {
492 snprintf(buffer, sizeof(buffer), ",(%d,%d)", fps[i].minFPS, fps[i].maxFPS);
493 str.append(buffer);
494 }
495 return str;
496 }
497
create_values_range_str(int min,int max)498 static String8 create_values_range_str(int min, int max){
499 String8 str;
500 char buffer[32];
501
502 if(min <= max){
503 snprintf(buffer, sizeof(buffer), "%d", min);
504 str.append(buffer);
505
506 for (int i = min + 1; i <= max; i++) {
507 snprintf(buffer, sizeof(buffer), ",%d", i);
508 str.append(buffer);
509 }
510 }
511 return str;
512 }
513
parse_size(const char * str,int & width,int & height)514 static int parse_size(const char *str, int &width, int &height)
515 {
516 // Find the width.
517 char *end;
518 int w = (int)strtol(str, &end, 10);
519 // If an 'x' or 'X' does not immediately follow, give up.
520 if ( (*end != 'x') && (*end != 'X') )
521 return -1;
522
523 // Find the height, immediately after the 'x'.
524 int h = (int)strtol(end+1, 0, 10);
525
526 width = w;
527 height = h;
528
529 return 0;
530 }
531
isValidDimension(int width,int height)532 bool QCameraHardwareInterface::isValidDimension(int width, int height) {
533 bool retVal = FALSE;
534 /* This function checks if a given resolution is valid or not.
535 * A particular resolution is considered valid if it satisfies
536 * the following conditions:
537 * 1. width & height should be multiple of 16.
538 * 2. width & height should be less than/equal to the dimensions
539 * supported by the camera sensor.
540 * 3. the aspect ratio is a valid aspect ratio and is among the
541 * commonly used aspect ratio as determined by the thumbnail_sizes
542 * data structure.
543 */
544
545 if( (width == CEILING16(width)) && (height == CEILING16(height))
546 && (width <= maxSnapshotWidth)
547 && (height <= maxSnapshotHeight) )
548 {
549 uint32_t pictureAspectRatio = (uint32_t)((width * Q12)/height);
550 for(uint32_t i = 0; i < THUMBNAIL_SIZE_COUNT; i++ ) {
551 if(thumbnail_sizes[i].aspect_ratio == pictureAspectRatio) {
552 retVal = TRUE;
553 break;
554 }
555 }
556 }
557 return retVal;
558 }
559
hasAutoFocusSupport()560 void QCameraHardwareInterface::hasAutoFocusSupport(){
561
562 ALOGV("%s",__func__);
563 mHasAutoFocusSupport = false;
564
565 if(isZSLMode()){
566 mHasAutoFocusSupport = false;
567 return;
568 }
569
570 if(mCameraHandle->ops->is_op_supported(mCameraHandle->camera_handle, MM_CAMERA_OPS_FOCUS)) {
571 mHasAutoFocusSupport = true;
572 }
573 else {
574 ALOGE("AutoFocus is not supported");
575 mHasAutoFocusSupport = false;
576 }
577 ALOGV("%s:rc= %d",__func__, mHasAutoFocusSupport);
578
579 }
580
supportsSceneDetection()581 bool QCameraHardwareInterface::supportsSceneDetection() {
582 bool rc ;
583 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_ASD_ENABLE,(uint8_t*)&rc,(uint8_t*)&rc);
584 return rc;
585 }
586
supportsFaceDetection()587 bool QCameraHardwareInterface::supportsFaceDetection() {
588 bool rc ;
589 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_FD,(uint8_t*)&rc,(uint8_t*)&rc);
590 return rc;
591 }
592
supportsSelectableZoneAf()593 bool QCameraHardwareInterface::supportsSelectableZoneAf() {
594 bool rc ;
595 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_FOCUS_RECT,(uint8_t*)&rc,(uint8_t*)&rc);
596 return rc;
597 }
598
supportsRedEyeReduction()599 bool QCameraHardwareInterface::supportsRedEyeReduction() {
600 bool rc ;
601 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,MM_CAMERA_PARM_REDEYE_REDUCTION,(uint8_t*)&rc,(uint8_t*)&rc);
602 return rc;
603 }
604
create_str(int16_t * arr,int length)605 static String8 create_str(int16_t *arr, int length){
606 String8 str;
607 char buffer[32] = {0};
608
609 if(length > 0){
610 snprintf(buffer, sizeof(buffer), "%d", arr[0]);
611 str.append(buffer);
612 }
613
614 for (int i =1;i<length;i++){
615 snprintf(buffer, sizeof(buffer), ",%d",arr[i]);
616 str.append(buffer);
617 }
618 return str;
619 }
620
getMaxPictureDimension(mm_camera_dimension_t * maxDim)621 bool QCameraHardwareInterface::getMaxPictureDimension(mm_camera_dimension_t *maxDim)
622 {
623 bool ret = NO_ERROR;
624 mm_camera_dimension_t dim;
625
626 ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
627 MM_CAMERA_PARM_MAX_PICTURE_SIZE, &dim);
628 if (ret != NO_ERROR)
629 return ret;
630
631 /* Find the first dimension in the mPictureSizes
632 * array which is smaller than the max dimension.
633 * This will be the valid max picture resolution */
634 for (unsigned int i = 0; i < mPictureSizeCount; i++) {
635 if ((mPictureSizes[i].width <= dim.width) &&
636 (mPictureSizes[i].height <= dim.height)) {
637 maxDim->height = mPictureSizes[i].height;
638 maxDim->width = mPictureSizes[i].width;
639 break;
640 }
641 }
642 ALOGD("%s: Found Max Picture dimension: %d x %d", __func__,
643 maxDim->width, maxDim->height);
644 return ret;
645 }
loadTables()646 void QCameraHardwareInterface::loadTables()
647 {
648
649 bool ret = NO_ERROR;
650 ALOGV("%s: E", __func__);
651
652 ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
653 MM_CAMERA_PARM_PREVIEW_SIZES_CNT, &preview_sizes_count);
654
655 default_sizes_tbl_t preview_sizes_tbl;
656 preview_sizes_tbl.tbl_size=preview_sizes_count;
657 preview_sizes_tbl.sizes_tbl=&default_preview_sizes[0];
658 if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
659 MM_CAMERA_PARM_DEF_PREVIEW_SIZES, &preview_sizes_tbl)<0){
660 ALOGE("%s:Failed to get default preview sizes",__func__);
661 }
662 ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
663 MM_CAMERA_PARM_VIDEO_SIZES_CNT, &video_sizes_count);
664
665 default_sizes_tbl_t video_sizes_tbl;
666 video_sizes_tbl.tbl_size=video_sizes_count;
667 video_sizes_tbl.sizes_tbl=&default_video_sizes[0];
668 if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
669 MM_CAMERA_PARM_DEF_VIDEO_SIZES, &video_sizes_tbl)<0){
670 ALOGE("%s:Failed to get default video sizes",__func__);
671 }
672
673 ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
674 MM_CAMERA_PARM_THUMB_SIZES_CNT, &thumbnail_sizes_count);
675
676 default_sizes_tbl_t thumbnail_sizes_tbl;
677 thumbnail_sizes_tbl.tbl_size=thumbnail_sizes_count;
678 thumbnail_sizes_tbl.sizes_tbl=&default_thumbnail_sizes[0];
679 if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
680 MM_CAMERA_PARM_DEF_THUMB_SIZES, &thumbnail_sizes_tbl)<0){
681 ALOGE("%s:Failed to get default thumbnail sizes",__func__);
682 }
683
684 ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
685 MM_CAMERA_PARM_HFR_SIZES_CNT, &hfr_sizes_count);
686
687 default_sizes_tbl_t hfr_sizes_tbl;
688 hfr_sizes_tbl.tbl_size=hfr_sizes_count;
689 hfr_sizes_tbl.sizes_tbl=&default_hfr_sizes[0];
690 if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
691 MM_CAMERA_PARM_DEF_HFR_SIZES, &hfr_sizes_tbl)<0){
692 ALOGE("%s:Failed to get default HFR sizes",__func__);
693 }
694 ALOGE("%s: X", __func__);
695 }
initDefaultParameters()696 void QCameraHardwareInterface::initDefaultParameters()
697 {
698 bool ret;
699 char prop[PROPERTY_VALUE_MAX];
700 mm_camera_dimension_t maxDim;
701 int rc = 0;
702 ALOGI("%s: E", __func__);
703 uint8_t supported;
704
705 memset(&maxDim, 0, sizeof(mm_camera_dimension_t));
706 ret = getMaxPictureDimension(&maxDim);
707
708 if (ret != NO_ERROR) {
709 ALOGE("%s: Cannot get Max picture size supported", __func__);
710 return;
711 }
712 if (!maxDim.width || !maxDim.height) {
713 maxDim.width = DEFAULT_LIVESHOT_WIDTH;
714 maxDim.height = DEFAULT_LIVESHOT_HEIGHT;
715 }
716
717 memset(prop, 0, sizeof(prop));
718 property_get("persist.camera.snap.format", prop, "0");
719 mSnapshotFormat = atoi(prop);
720 ALOGV("%s: prop =(%s), snap_format=%d", __func__, prop, mSnapshotFormat);
721
722 //cam_ctrl_dimension_t dim;
723 mHFRLevel = 0;
724 memset(&mDimension, 0, sizeof(cam_ctrl_dimension_t));
725 memset(&mPreviewFormatInfo, 0, sizeof(preview_format_info_t));
726 mDimension.video_width = DEFAULT_VIDEO_WIDTH;
727 mDimension.video_height = DEFAULT_VIDEO_HEIGHT;
728 mDimension.picture_width = maxDim.width;
729 mDimension.picture_height = maxDim.height;
730 mDimension.display_width = DEFAULT_STREAM_WIDTH;
731 mDimension.display_height = DEFAULT_STREAM_HEIGHT;
732 mDimension.orig_picture_dx = mDimension.picture_width;
733 mDimension.orig_picture_dy = mDimension.picture_height;
734 mDimension.ui_thumbnail_width = DEFAULT_STREAM_WIDTH;
735 mDimension.ui_thumbnail_height = DEFAULT_STREAM_HEIGHT;
736 mDimension.orig_video_width = DEFAULT_STREAM_WIDTH;
737 mDimension.orig_video_height = DEFAULT_STREAM_HEIGHT;
738
739 mDimension.prev_format = CAMERA_YUV_420_NV21;
740 mDimension.enc_format = CAMERA_YUV_420_NV12;
741 if (mSnapshotFormat == 1) {
742 mDimension.main_img_format = CAMERA_YUV_422_NV61;
743 } else {
744 mDimension.main_img_format = CAMERA_YUV_420_NV21;
745 }
746 mDimension.thumb_format = CAMERA_YUV_420_NV21;
747 ALOGV("%s: main_img_format =%d, thumb_format=%d", __func__,
748 mDimension.main_img_format, mDimension.thumb_format);
749 mDimension.prev_padding_format = CAMERA_PAD_TO_WORD;
750
751 ret = native_set_parms(MM_CAMERA_PARM_DIMENSION,
752 sizeof(cam_ctrl_dimension_t), (void *) &mDimension);
753 if(!ret) {
754 ALOGE("MM_CAMERA_PARM_DIMENSION Failed.");
755 return;
756 }
757
758 hasAutoFocusSupport();
759
760 // Initialize constant parameter strings. This will happen only once in the
761 // lifetime of the mediaserver process.
762 if (true/*!mParamStringInitialized*/) {
763 //filter picture sizes
764 filterPictureSizes();
765 mPictureSizeValues = create_sizes_str(
766 mPictureSizesPtr, mSupportedPictureSizesCount);
767 mPreviewSizeValues = create_sizes_str(
768 mPreviewSizes, mPreviewSizeCount);
769 mVideoSizeValues = create_sizes_str(
770 mVideoSizes, mVideoSizeCount);
771
772 //Query for max HFR value
773 camera_hfr_mode_t maxHFR;
774 mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_MAX_HFR_MODE, (void *)&maxHFR);
775 //Filter HFR values and build parameter string
776 String8 str;
777 for(int i=0; i<HFR_VALUES_COUNT; i++){
778 if(hfr[i].val <= maxHFR){
779 if(i>0) str.append(",");
780 str.append(hfr[i].desc);
781 }
782 }
783 mHfrValues = str;
784 mHfrSizeValues = create_sizes_str(
785 default_hfr_sizes, hfr_sizes_count);
786
787 //Query for min and max fps values from lower layer
788 if(MM_CAMERA_OK != mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
789 MM_CAMERA_PARM_FPS_RANGE, (void *)&mSensorFpsRange)){
790 ALOGE("error: failed to get fps range from sensor");
791 return;
792 } else {
793 ALOGD("sensor fps range = (%f, %f)", mSensorFpsRange.min_fps,
794 mSensorFpsRange.max_fps);
795
796 mSupportedFpsRanges = new android::FPSRange[ALL_FPS_RANGES_COUNT+1];
797
798 //min and max fps in android format
799 int minFps = (int)(mSensorFpsRange.min_fps * 1000);
800 int maxFps = (int)(mSensorFpsRange.max_fps * 1000);
801 int idx=0;
802 //filter supported fps ranges according to sensor fps range
803 for(int i=0; i<(int)ALL_FPS_RANGES_COUNT; i++) {
804 if(allFpsRanges[i].maxFPS <= maxFps && allFpsRanges[i].minFPS >= minFps) {
805 memcpy(&mSupportedFpsRanges[idx], &allFpsRanges[i], sizeof(android::FPSRange));
806 idx++;
807 }
808 }
809 mSupportedFpsRangesCount = idx;
810 //insert sensor absolute fps range as one entry, if
811 //its not already there in table
812 //find insertion point
813 int insertIndex = mSupportedFpsRangesCount;
814 for(int i=0; i<mSupportedFpsRangesCount; i++) {
815 if(mSupportedFpsRanges[i].maxFPS < maxFps) {
816 continue;
817 } else if (mSupportedFpsRanges[i].maxFPS == maxFps) {
818 if(mSupportedFpsRanges[i].minFPS > minFps) {
819 insertIndex = i;
820 break;
821 } else if (mSupportedFpsRanges[i].minFPS == minFps) {
822 //entry already exists, no need to insert
823 insertIndex = -1;
824 break;
825 }
826 }
827 }
828 if(insertIndex != -1) {
829 for(int i=mSupportedFpsRangesCount; i>=0; i--) {
830 if(insertIndex == i) {
831 mSupportedFpsRanges[i].maxFPS = maxFps;
832 mSupportedFpsRanges[i].minFPS = minFps;
833 mSupportedFpsRangesCount++;
834 break;
835 }
836 mSupportedFpsRanges[i].maxFPS = mSupportedFpsRanges[i-1].maxFPS;
837 mSupportedFpsRanges[i].minFPS = mSupportedFpsRanges[i-1].minFPS;
838 }
839 }
840 mFpsRangesSupportedValues = create_fps_str(mSupportedFpsRanges, mSupportedFpsRangesCount);
841
842 ALOGD("supported fps ranges = %s", mFpsRangesSupportedValues.string());
843 mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
844 mFpsRangesSupportedValues);
845 mParameters.setPreviewFpsRange(minFps, maxFps);
846 }
847
848 mFlashValues = create_values_str(
849 flash, sizeof(flash) / sizeof(str_map));
850 mLensShadeValues = create_values_str(
851 lensshade,sizeof(lensshade)/sizeof(str_map));
852 mMceValues = create_values_str(
853 mce,sizeof(mce)/sizeof(str_map));
854 mEffectValues = create_values_str(effects, sizeof(effects) / sizeof(str_map));
855 mAntibandingValues = create_values_str(
856 antibanding, sizeof(antibanding) / sizeof(str_map));
857 mIsoValues = create_values_str(iso,sizeof(iso)/sizeof(str_map));
858 mAutoExposureValues = create_values_str(
859 autoexposure, sizeof(autoexposure) / sizeof(str_map));
860 mWhitebalanceValues = create_values_str(
861 whitebalance, sizeof(whitebalance) / sizeof(str_map));
862
863 if(mHasAutoFocusSupport){
864 mFocusModeValues = create_values_str(
865 focus_modes, sizeof(focus_modes) / sizeof(str_map));
866 }
867
868 mSceneModeValues = create_values_str(scenemode, sizeof(scenemode) / sizeof(str_map));
869
870 if(mHasAutoFocusSupport){
871 mTouchAfAecValues = create_values_str(
872 touchafaec,sizeof(touchafaec)/sizeof(str_map));
873 }
874 //Currently Enabling Histogram for 8x60
875 mHistogramValues = create_values_str(
876 histogram,sizeof(histogram)/sizeof(str_map));
877
878 mSkinToneEnhancementValues = create_values_str(
879 skinToneEnhancement,sizeof(skinToneEnhancement)/sizeof(str_map));
880
881 mPictureFormatValues = create_values_str(
882 picture_formats, sizeof(picture_formats)/sizeof(str_map));
883
884 mZoomSupported=false;
885 mMaxZoom=0;
886 mm_camera_zoom_tbl_t zmt;
887 if( mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
888 MM_CAMERA_PARM_MAXZOOM, &mMaxZoom)<0){
889 ALOGE("%s:Failed to get max zoom",__func__);
890 }else{
891
892 ALOGE("Max Zoom:%d",mMaxZoom);
893 /* Kernel driver limits the max amount of data that can be retreived through a control
894 command to 260 bytes hence we conservatively limit to 110 zoom ratios */
895 if(mMaxZoom>MAX_ZOOM_RATIOS) {
896 ALOGE("%s:max zoom is larger than sizeof zoomRatios table",__func__);
897 mMaxZoom=MAX_ZOOM_RATIOS-1;
898 }
899 zmt.size=mMaxZoom;
900 zmt.zoom_ratio_tbl=&zoomRatios[0];
901 if( mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
902 MM_CAMERA_PARM_ZOOM_RATIO, &zmt)<0){
903 ALOGE("%s:Failed to get max zoom ratios",__func__);
904 }else{
905 mZoomSupported=true;
906 mZoomRatioValues = create_str(zoomRatios, mMaxZoom);
907 }
908 }
909
910 ALOGE("Zoom supported:%d",mZoomSupported);
911
912 denoise_value = create_values_str(
913 denoise, sizeof(denoise) / sizeof(str_map));
914
915 if(supportsFaceDetection()) {
916 mFaceDetectionValues = create_values_str(
917 facedetection, sizeof(facedetection) / sizeof(str_map));
918 }
919
920 if(mHasAutoFocusSupport){
921 mSelectableZoneAfValues = create_values_str(
922 selectable_zone_af, sizeof(selectable_zone_af) / sizeof(str_map));
923 }
924
925 mSceneDetectValues = create_values_str(scenedetect, sizeof(scenedetect) / sizeof(str_map));
926
927 mRedeyeReductionValues = create_values_str(
928 redeye_reduction, sizeof(redeye_reduction) / sizeof(str_map));
929
930 mZslValues = create_values_str(
931 zsl_modes,sizeof(zsl_modes)/sizeof(str_map));
932
933 mParamStringInitialized = true;
934 }
935
936 //set supported video sizes
937 mParameters.set(QCameraParameters::KEY_SUPPORTED_VIDEO_SIZES, mVideoSizeValues.string());
938
939 //set default video size to first one in supported table
940 String8 vSize = create_sizes_str(&mVideoSizes[0], 1);
941 mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, vSize.string());
942
943 //Set Preview size
944 int default_preview_width, default_preview_height;
945 mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH,
946 &default_preview_width);
947 mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT,
948 &default_preview_height);
949 mParameters.setPreviewSize(default_preview_width, default_preview_height);
950 mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
951 mPreviewSizeValues.string());
952 mDimension.display_width = default_preview_width;
953 mDimension.display_height = default_preview_height;
954
955 mPreviewFrameRateValues = create_values_range_str(
956 MINIMUM_FPS, MAXIMUM_FPS);
957
958
959 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle, MM_CAMERA_PARM_FPS,&supported,&supported);
960 if (supported) {
961 mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
962 mPreviewFrameRateValues.string());
963 } else {
964 mParameters.set(
965 QCameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
966 DEFAULT_FIXED_FPS);
967 }
968 //Set Preview Format
969 //mParameters.setPreviewFormat("yuv420sp"); // informative
970 mParameters.setPreviewFormat(QCameraParameters::PIXEL_FORMAT_YUV420SP);
971
972 mPreviewFormatValues = create_values_str(
973 preview_formats, sizeof(preview_formats) / sizeof(str_map));
974 mParameters.set(QCameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
975 mPreviewFormatValues.string());
976
977 //Set Overlay Format
978 mParameters.set("overlay-format", HAL_PIXEL_FORMAT_YCbCr_420_SP);
979 mParameters.set("max-num-detected-faces-hw", "2");
980
981 // Set supported max faces
982 int maxNumFaces = 0;
983 if (supportsFaceDetection()) {
984 //Query the maximum number of faces supported by hardware.
985 if(MM_CAMERA_OK != mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
986 MM_CAMERA_PARM_MAX_NUM_FACES_DECT, &maxNumFaces)){
987 ALOGE("%s:Failed to get max number of faces supported",__func__);
988 }
989 }
990 mParameters.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, maxNumFaces);
991 //This paramtere is set to default here. This will be changed by application
992 //if it needs to support specific number of faces. See also setParameters.
993 mParameters.set(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES, 2);
994
995 // Set camera features supported flag
996 int32_t featureFlag = 0;
997 if (supportsFaceDetection()) {
998 featureFlag |= 0x00000001; // bit 0 indicate faciral feature
999 }
1000 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_CAMERA_FEATURES, featureFlag);
1001
1002 //Set Picture Size
1003 mParameters.setPictureSize(DEFAULT_PICTURE_WIDTH, DEFAULT_PICTURE_HEIGHT);
1004 mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
1005 mPictureSizeValues.string());
1006
1007 //Set Preview Frame Rate
1008 if(mFps >= MINIMUM_FPS && mFps <= MAXIMUM_FPS) {
1009 mParameters.setPreviewFrameRate(mFps);
1010 }else{
1011 mParameters.setPreviewFrameRate(DEFAULT_FIXED_FPS);
1012 }
1013
1014 //Set Picture Format
1015 mParameters.setPictureFormat("jpeg"); // informative
1016 mParameters.set(QCameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
1017 mPictureFormatValues);
1018
1019 mParameters.set(QCameraParameters::KEY_JPEG_QUALITY, "85"); // max quality
1020 mJpegQuality = 85;
1021 //Set Video Format
1022 mParameters.set(QCameraParameters::KEY_VIDEO_FRAME_FORMAT, "yuv420sp");
1023
1024 //Set Thumbnail parameters
1025 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
1026 THUMBNAIL_WIDTH_STR); // informative
1027 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
1028 THUMBNAIL_HEIGHT_STR); // informative
1029 mDimension.ui_thumbnail_width =
1030 thumbnail_sizes[DEFAULT_THUMBNAIL_SETTING].width;
1031 mDimension.ui_thumbnail_height =
1032 thumbnail_sizes[DEFAULT_THUMBNAIL_SETTING].height;
1033 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "90");
1034 String8 valuesStr = create_sizes_str(default_thumbnail_sizes, thumbnail_sizes_count);
1035 mParameters.set(QCameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
1036 valuesStr.string());
1037 // Define CAMERA_SMOOTH_ZOOM in Android.mk file , to enable smoothzoom
1038 #ifdef CAMERA_SMOOTH_ZOOM
1039 mParameters.set(QCameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, "true");
1040 #endif
1041 if(mZoomSupported){
1042 mParameters.set(QCameraParameters::KEY_ZOOM_SUPPORTED, "true");
1043 ALOGE("max zoom is %d", mMaxZoom-1);
1044 /* mMaxZoom value that the query interface returns is the size
1045 ALOGV("max zoom is %d", mMaxZoom-1);
1046 * mMaxZoom value that the query interface returns is the size
1047 * of zoom table. So the actual max zoom value will be one
1048 * less than that value. */
1049
1050 mParameters.set("max-zoom",mMaxZoom-1);
1051 mParameters.set(QCameraParameters::KEY_ZOOM_RATIOS,
1052 mZoomRatioValues);
1053 } else
1054 {
1055 mParameters.set(QCameraParameters::KEY_ZOOM_SUPPORTED, "false");
1056 }
1057
1058 /* Enable zoom support for video application if VPE enabled */
1059 if(mZoomSupported) {
1060 mParameters.set("video-zoom-support", "true");
1061 } else {
1062 mParameters.set("video-zoom-support", "false");
1063 }
1064
1065 //8960 supports Power modes : Low power, Normal Power.
1066 mParameters.set("power-mode-supported", "true");
1067 //Set Live shot support
1068 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1069 MM_CAMERA_PARM_LIVESHOT_MAIN,
1070 &supported,&supported);
1071 if(!supported) {
1072 ALOGE("%s:LIVESHOT is not supported", __func__);
1073 mParameters.set("video-snapshot-supported", "false");
1074 mFullLiveshotEnabled = rc;
1075 } else {
1076 mParameters.set("video-snapshot-supported", "true");
1077 }
1078
1079 //Set default power mode
1080 mParameters.set(QCameraParameters::KEY_QC_POWER_MODE,"Normal_Power");
1081
1082 //Set Camera Mode
1083 mParameters.set(QCameraParameters::KEY_QC_CAMERA_MODE,0);
1084 mParameters.set(QCameraParameters::KEY_QC_AE_BRACKET_HDR,"Off");
1085
1086 //Set Antibanding
1087 mParameters.set(QCameraParameters::KEY_ANTIBANDING,
1088 QCameraParameters::ANTIBANDING_OFF);
1089 mParameters.set(QCameraParameters::KEY_SUPPORTED_ANTIBANDING,
1090 mAntibandingValues);
1091
1092 //Set Effect
1093 mParameters.set(QCameraParameters::KEY_EFFECT,
1094 QCameraParameters::EFFECT_NONE);
1095 mParameters.set(QCameraParameters::KEY_SUPPORTED_EFFECTS, mEffectValues);
1096
1097 //Set Auto Exposure
1098 mParameters.set(QCameraParameters::KEY_QC_AUTO_EXPOSURE,
1099 QCameraParameters::AUTO_EXPOSURE_FRAME_AVG);
1100 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE, mAutoExposureValues);
1101
1102 //Set WhiteBalance
1103 mParameters.set(QCameraParameters::KEY_WHITE_BALANCE,
1104 QCameraParameters::WHITE_BALANCE_AUTO);
1105 mParameters.set(QCameraParameters::KEY_SUPPORTED_WHITE_BALANCE,mWhitebalanceValues);
1106
1107 //Set AEC_LOCK
1108 mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, "false");
1109 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1110 MM_CAMERA_PARM_AEC_LOCK,&supported,&supported);
1111 if(supported){
1112 mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "true");
1113 } else {
1114 mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, "false");
1115 }
1116 //Set AWB_LOCK
1117 mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, "false");
1118 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1119 MM_CAMERA_PARM_AWB_LOCK,&supported,&supported);
1120 if(supported)
1121 mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "true");
1122 else
1123 mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, "false");
1124
1125 //Set Focus Mode
1126 if(mHasAutoFocusSupport){
1127 mParameters.set(QCameraParameters::KEY_FOCUS_MODE,
1128 QCameraParameters::FOCUS_MODE_AUTO);
1129 mFocusMode = AF_MODE_AUTO;
1130 mParameters.set(QCameraParameters::KEY_SUPPORTED_FOCUS_MODES,
1131 mFocusModeValues);
1132 mParameters.set(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "1");
1133 mParameters.set(QCameraParameters::KEY_MAX_NUM_METERING_AREAS, "1");
1134 } else {
1135 mParameters.set(QCameraParameters::KEY_FOCUS_MODE,
1136 QCameraParameters::FOCUS_MODE_INFINITY);
1137 mFocusMode = DONT_CARE;
1138 mParameters.set(QCameraParameters::KEY_SUPPORTED_FOCUS_MODES,
1139 QCameraParameters::FOCUS_MODE_INFINITY);
1140 mParameters.set(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS, "0");
1141 mParameters.set(QCameraParameters::KEY_MAX_NUM_METERING_AREAS, "0");
1142 }
1143
1144 mParameters.set(QCameraParameters::KEY_FOCUS_AREAS, DEFAULT_CAMERA_AREA);
1145 mParameters.set(QCameraParameters::KEY_METERING_AREAS, DEFAULT_CAMERA_AREA);
1146
1147 //Set Flash
1148 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1149 MM_CAMERA_PARM_LED_MODE,&supported,&supported);
1150 if(supported){
1151 mParameters.set(CameraParameters::KEY_FLASH_MODE,
1152 CameraParameters::FLASH_MODE_OFF);
1153 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
1154 mFlashValues);
1155 }
1156
1157 //Set Sharpness
1158 mParameters.set(QCameraParameters::KEY_QC_MAX_SHARPNESS,
1159 CAMERA_MAX_SHARPNESS);
1160 mParameters.set(QCameraParameters::KEY_QC_SHARPNESS,
1161 CAMERA_DEF_SHARPNESS);
1162
1163 //Set Contrast
1164 mParameters.set(QCameraParameters::KEY_QC_MAX_CONTRAST,
1165 CAMERA_MAX_CONTRAST);
1166 mParameters.set(QCameraParameters::KEY_QC_CONTRAST,
1167 CAMERA_DEF_CONTRAST);
1168
1169 //Set Saturation
1170 mParameters.set(QCameraParameters::KEY_QC_MAX_SATURATION,
1171 CAMERA_MAX_SATURATION);
1172 mParameters.set(QCameraParameters::KEY_QC_SATURATION,
1173 CAMERA_DEF_SATURATION);
1174
1175 //Set Brightness/luma-adaptaion
1176 mParameters.set("luma-adaptation", "3");
1177
1178 mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT,
1179 QCameraParameters::PIXEL_FORMAT_JPEG);
1180
1181 //Set Lensshading
1182 mParameters.set(QCameraParameters::KEY_QC_LENSSHADE,
1183 QCameraParameters::LENSSHADE_ENABLE);
1184 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES,
1185 mLensShadeValues);
1186
1187 //Set ISO Mode
1188 mParameters.set(QCameraParameters::KEY_QC_ISO_MODE,
1189 QCameraParameters::ISO_AUTO);
1190 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES,
1191 mIsoValues);
1192
1193 //Set MCE
1194 mParameters.set(QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT,
1195 QCameraParameters::MCE_ENABLE);
1196 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES,
1197 mMceValues);
1198
1199 //Set HFR
1200 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1201 MM_CAMERA_PARM_HFR,&supported,&supported);
1202 if(supported){
1203 mParameters.set(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE,
1204 QCameraParameters::VIDEO_HFR_OFF);
1205 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES,
1206 mHfrSizeValues.string());
1207 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES,
1208 mHfrValues);
1209 } else{
1210 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES,"");
1211 }
1212
1213 //Set Histogram
1214 mParameters.set(QCameraParameters::KEY_QC_HISTOGRAM,
1215 QCameraParameters::HISTOGRAM_DISABLE);
1216 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES,
1217 mHistogramValues);
1218
1219 //Set SkinTone Enhancement
1220 mParameters.set(QCameraParameters::KEY_QC_SKIN_TONE_ENHANCEMENT,
1221 QCameraParameters::SKIN_TONE_ENHANCEMENT_DISABLE);
1222 mParameters.set("skinToneEnhancement", "0");
1223 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES,
1224 mSkinToneEnhancementValues);
1225
1226 //Set Scene Mode
1227 mParameters.set(QCameraParameters::KEY_SCENE_MODE,
1228 QCameraParameters::SCENE_MODE_AUTO);
1229 mParameters.set(QCameraParameters::KEY_SUPPORTED_SCENE_MODES,
1230 mSceneModeValues);
1231
1232 //Set Streaming Textures
1233 mParameters.set("strtextures", "OFF");
1234
1235 //Set Denoise
1236 mParameters.set(QCameraParameters::KEY_QC_DENOISE,
1237 QCameraParameters::DENOISE_OFF);
1238 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_DENOISE,
1239 denoise_value);
1240 //Set Touch AF/AEC
1241 mParameters.set(QCameraParameters::KEY_QC_TOUCH_AF_AEC,
1242 QCameraParameters::TOUCH_AF_AEC_OFF);
1243 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC,
1244 mTouchAfAecValues);
1245 mParameters.set("touchAfAec-dx","100");
1246 mParameters.set("touchAfAec-dy","100");
1247
1248 //Set Scene Detection
1249 mParameters.set(QCameraParameters::KEY_QC_SCENE_DETECT,
1250 QCameraParameters::SCENE_DETECT_OFF);
1251 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT,
1252 mSceneDetectValues);
1253
1254 //Set Selectable Zone AF
1255 mParameters.set(QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF,
1256 QCameraParameters::SELECTABLE_ZONE_AF_AUTO);
1257 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_SELECTABLE_ZONE_AF,
1258 mSelectableZoneAfValues);
1259
1260 //Set Face Detection
1261 mParameters.set(QCameraParameters::KEY_QC_FACE_DETECTION,
1262 QCameraParameters::FACE_DETECTION_OFF);
1263 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION,
1264 mFaceDetectionValues);
1265
1266 //Set Red Eye Reduction
1267 mParameters.set(QCameraParameters::KEY_QC_REDEYE_REDUCTION,
1268 QCameraParameters::REDEYE_REDUCTION_DISABLE);
1269 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION,
1270 mRedeyeReductionValues);
1271
1272 //Set ZSL
1273 mParameters.set(QCameraParameters::KEY_QC_ZSL,
1274 QCameraParameters::ZSL_OFF);
1275 mParameters.set(QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES,
1276 mZslValues);
1277
1278 //Set Focal length, horizontal and vertical view angles
1279 float focalLength = 0.0f;
1280 float horizontalViewAngle = 0.0f;
1281 float verticalViewAngle = 0.0f;
1282 mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_FOCAL_LENGTH,
1283 (void *)&focalLength);
1284 mParameters.setFloat(QCameraParameters::KEY_FOCAL_LENGTH,
1285 focalLength);
1286 mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE,
1287 (void *)&horizontalViewAngle);
1288 mParameters.setFloat(QCameraParameters::KEY_HORIZONTAL_VIEW_ANGLE,
1289 horizontalViewAngle);
1290 mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE,
1291 (void *)&verticalViewAngle);
1292 mParameters.setFloat(QCameraParameters::KEY_VERTICAL_VIEW_ANGLE,
1293 verticalViewAngle);
1294
1295 //Set Exposure Compensation
1296 mParameters.set(
1297 QCameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
1298 EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR);
1299 mParameters.set(
1300 QCameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
1301 EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR);
1302 mParameters.set(
1303 QCameraParameters::KEY_EXPOSURE_COMPENSATION,
1304 EXPOSURE_COMPENSATION_DEFAULT_NUMERATOR);
1305 mParameters.setFloat(
1306 QCameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
1307 EXPOSURE_COMPENSATION_STEP);
1308
1309 mParameters.set("num-snaps-per-shutter", 1);
1310
1311 mParameters.set("capture-burst-captures-values", getZSLQueueDepth());
1312 mParameters.set("capture-burst-interval-supported", "true");
1313 mParameters.set("capture-burst-interval-max", BURST_INTREVAL_MAX); /*skip frames*/
1314 mParameters.set("capture-burst-interval-min", BURST_INTREVAL_MIN); /*skip frames*/
1315 mParameters.set("capture-burst-interval", BURST_INTREVAL_DEFAULT); /*skip frames*/
1316 mParameters.set("capture-burst-retroactive", 0);
1317 mParameters.set("capture-burst-retroactive-max", getZSLQueueDepth());
1318 mParameters.set("capture-burst-exposures", "");
1319 mParameters.set("capture-burst-exposures-values",
1320 "-12,-11,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,11,12");
1321 {
1322 String8 CamModeStr;
1323 char buffer[32];
1324 int flag = 0;
1325
1326 for (int i = 0; i < HAL_CAM_MODE_MAX; i++) {
1327 if ( 0 ) { /*exclude some conflicting case*/
1328 } else {
1329 if (flag == 0) { /*first item*/
1330 snprintf(buffer, sizeof(buffer), "%d", i);
1331 } else {
1332 snprintf(buffer, sizeof(buffer), ",%d", i);
1333 }
1334 flag = 1;
1335 CamModeStr.append(buffer);
1336 }
1337 }
1338 mParameters.set("camera-mode-values", CamModeStr);
1339 }
1340
1341 mParameters.set("ae-bracket-hdr-values",
1342 create_values_str(hdr_bracket, sizeof(hdr_bracket)/sizeof(str_map) ));
1343
1344 mParameters.set("no-display-mode", 0);
1345 mParameters.set("zoom", 0);
1346
1347 int mNuberOfVFEOutputs;
1348 ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
1349 MM_CAMERA_PARM_VFE_OUTPUT_ENABLE, &mNuberOfVFEOutputs);
1350 if(ret < 0) {
1351 ALOGE("get parm MM_CAMERA_PARM_VFE_OUTPUT_ENABLE failed");
1352 ret = BAD_VALUE;
1353 }
1354 if(mNuberOfVFEOutputs == 1)
1355 {
1356 mParameters.set(QCameraParameters::KEY_QC_SINGLE_ISP_OUTPUT_ENABLED, "true");
1357 } else {
1358 mParameters.set(QCameraParameters::KEY_QC_SINGLE_ISP_OUTPUT_ENABLED, "false");
1359 }
1360
1361 if (setParameters(mParameters) != NO_ERROR) {
1362 ALOGE("Failed to set default parameters?!");
1363 }
1364 mInitialized = true;
1365 strTexturesOn = false;
1366
1367 ALOGI("%s: X", __func__);
1368 return;
1369 }
1370
1371 /**
1372 * Set the camera parameters. This returns BAD_VALUE if any parameter is
1373 * invalid or not supported.
1374 */
1375
setParameters(const char * parms)1376 int QCameraHardwareInterface::setParameters(const char *parms)
1377 {
1378 QCameraParameters param;
1379 String8 str = String8(parms);
1380 param.unflatten(str);
1381 status_t ret = setParameters(param);
1382 if(ret == NO_ERROR)
1383 return 0;
1384 else
1385 return -1;
1386 }
1387
1388 /**
1389 * Set the camera parameters. This returns BAD_VALUE if any parameter is
1390 * invalid or not supported. */
setParameters(const QCameraParameters & params)1391 status_t QCameraHardwareInterface::setParameters(const QCameraParameters& params)
1392 {
1393 status_t ret = NO_ERROR;
1394
1395 ALOGI("%s: E", __func__);
1396 // Mutex::Autolock l(&mLock);
1397 status_t rc, final_rc = NO_ERROR;
1398 mRestartPreview = false;
1399
1400 if ((rc = setCameraMode(params))) final_rc = rc;
1401 // if ((rc = setChannelInterfaceMask(params))) final_rc = rc;
1402 if ((rc = setPowerMode(params))) final_rc = rc;
1403 if ((rc = setPreviewSize(params))) final_rc = rc;
1404 if ((rc = setVideoSize(params))) final_rc = rc;
1405 if ((rc = setPictureSize(params))) final_rc = rc;
1406 if ((rc = setJpegThumbnailSize(params))) final_rc = rc;
1407 if ((rc = setJpegQuality(params))) final_rc = rc;
1408 if ((rc = setEffect(params))) final_rc = rc;
1409 if ((rc = setGpsLocation(params))) final_rc = rc;
1410 if ((rc = setRotation(params))) final_rc = rc;
1411 if ((rc = setZoom(params))) final_rc = rc;
1412 if ((rc = setOrientation(params))) final_rc = rc;
1413 if ((rc = setLensshadeValue(params))) final_rc = rc;
1414 if ((rc = setMCEValue(params))) final_rc = rc;
1415 if ((rc = setPictureFormat(params))) final_rc = rc;
1416 if ((rc = setSharpness(params))) final_rc = rc;
1417 if ((rc = setSaturation(params))) final_rc = rc;
1418 if ((rc = setSceneMode(params))) final_rc = rc;
1419 if ((rc = setContrast(params))) final_rc = rc;
1420 if ((rc = setFaceDetect(params))) final_rc = rc;
1421 if ((rc = setStrTextures(params))) final_rc = rc;
1422 if ((rc = setPreviewFormat(params))) final_rc = rc;
1423 if ((rc = setSkinToneEnhancement(params))) final_rc = rc;
1424 if ((rc = setWaveletDenoise(params))) final_rc = rc;
1425 if ((rc = setAntibanding(params))) final_rc = rc;
1426 // if ((rc = setOverlayFormats(params))) final_rc = rc;
1427 if ((rc = setRedeyeReduction(params))) final_rc = rc;
1428 if ((rc = setCaptureBurstExp())) final_rc = rc;
1429 if ((rc = setRDIMode(params))) final_rc = rc;
1430
1431 const char *str_val = params.get("capture-burst-exposures");
1432 if ( str_val == NULL || strlen(str_val)==0 ) {
1433 char burst_exp[PROPERTY_VALUE_MAX];
1434 memset(burst_exp, 0, sizeof(burst_exp));
1435 property_get("persist.capture.burst.exposures", burst_exp, "");
1436 if ( strlen(burst_exp)>0 ) {
1437 mParameters.set("capture-burst-exposures", burst_exp);
1438 }
1439 } else {
1440 mParameters.set("capture-burst-exposures", str_val);
1441 }
1442 mParameters.set("num-snaps-per-shutter", params.get("num-snaps-per-shutter"));
1443
1444 if ((rc = setAEBracket(params))) final_rc = rc;
1445 // if ((rc = setDenoise(params))) final_rc = rc;
1446 if ((rc = setPreviewFpsRange(params))) final_rc = rc;
1447 if((rc = setRecordingHint(params))) final_rc = rc;
1448 if ((rc = setNumOfSnapshot(params))) final_rc = rc;
1449 if ((rc = setAecAwbLock(params))) final_rc = rc;
1450
1451 const char *str = params.get(QCameraParameters::KEY_SCENE_MODE);
1452 int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str);
1453
1454 if((value != NOT_FOUND) && (value == CAMERA_BESTSHOT_OFF )) {
1455 //if ((rc = setPreviewFrameRateMode(params))) final_rc = rc;
1456 if ((rc = setPreviewFrameRate(params))) final_rc = rc;
1457 if ((rc = setAutoExposure(params))) final_rc = rc;
1458 if ((rc = setExposureCompensation(params))) final_rc = rc;
1459 if ((rc = setWhiteBalance(params))) final_rc = rc;
1460 if ((rc = setFlash(params))) final_rc = rc;
1461 if ((rc = setFocusMode(params))) final_rc = rc;
1462 if ((rc = setBrightness(params))) final_rc = rc;
1463 if ((rc = setISOValue(params))) final_rc = rc;
1464 if ((rc = setFocusAreas(params))) final_rc = rc;
1465 if ((rc = setMeteringAreas(params))) final_rc = rc;
1466 }
1467 //selectableZoneAF needs to be invoked after continuous AF
1468 if ((rc = setSelectableZoneAf(params))) final_rc = rc;
1469 // setHighFrameRate needs to be done at end, as there can
1470 // be a preview restart, and need to use the updated parameters
1471 if ((rc = setHighFrameRate(params))) final_rc = rc;
1472 if ((rc = setZSLBurstLookBack(params))) final_rc = rc;
1473 if ((rc = setZSLBurstInterval(params))) final_rc = rc;
1474 if ((rc = setNoDisplayMode(params))) final_rc = rc;
1475 if ((rc = setMobiCat(params))) final_rc = rc;
1476
1477 //Update Exiftag values.
1478 setExifTags();
1479
1480 if (mRestartPreview) {
1481 ALOGI("%s: need to restart preview", __func__);
1482 restartPreview();
1483 mRestartPreview = false;
1484 }
1485
1486 ALOGI("%s: X", __func__);
1487 return final_rc;
1488 }
1489
1490 /** Retrieve the camera parameters. The buffer returned by the camera HAL
1491 must be returned back to it with put_parameters, if put_parameters
1492 is not NULL.
1493 */
getParameters(char ** parms)1494 int QCameraHardwareInterface::getParameters(char **parms)
1495 {
1496 char* rc = NULL;
1497 String8 str;
1498 QCameraParameters param = getParameters();
1499 //param.dump();
1500 str = param.flatten( );
1501 rc = (char *)malloc(sizeof(char)*(str.length()+1));
1502 if(rc != NULL){
1503 memset(rc, 0, sizeof(char)*(str.length()+1));
1504 strncpy(rc, str.string(), str.length());
1505 rc[str.length()] = 0;
1506 *parms = rc;
1507 }
1508 return 0;
1509 }
1510
1511 /** The camera HAL uses its own memory to pass us the parameters when we
1512 call get_parameters. Use this function to return the memory back to
1513 the camera HAL, if put_parameters is not NULL. If put_parameters
1514 is NULL, then you have to use free() to release the memory.
1515 */
putParameters(char * rc)1516 void QCameraHardwareInterface::putParameters(char *rc)
1517 {
1518 free(rc);
1519 rc = NULL;
1520 }
1521
getParameters()1522 QCameraParameters& QCameraHardwareInterface::getParameters()
1523 {
1524 Mutex::Autolock lock(mLock);
1525 mParameters.set(QCameraParameters::KEY_FOCUS_DISTANCES, mFocusDistance.string());
1526 return mParameters;
1527 }
1528
runFaceDetection()1529 status_t QCameraHardwareInterface::runFaceDetection()
1530 {
1531 bool ret = true;
1532
1533 const char *str = mParameters.get(QCameraParameters::KEY_QC_FACE_DETECTION);
1534 if (str != NULL) {
1535 int value = attr_lookup(facedetection,
1536 sizeof(facedetection) / sizeof(str_map), str);
1537 fd_set_parm_t fd_set_parm;
1538 int requested_faces = mParameters.getInt(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES);
1539 fd_set_parm.fd_mode = value;
1540 fd_set_parm.num_fd = requested_faces;
1541 ret = native_set_parms(MM_CAMERA_PARM_FD, sizeof(int8_t), (void *)&value);
1542 return ret ? NO_ERROR : UNKNOWN_ERROR;
1543 }
1544 ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str);
1545 return BAD_VALUE;
1546 }
1547
setSharpness(const QCameraParameters & params)1548 status_t QCameraHardwareInterface::setSharpness(const QCameraParameters& params)
1549 {
1550 bool ret = false;
1551 int rc = MM_CAMERA_OK;
1552 ALOGV("%s",__func__);
1553 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1554 MM_CAMERA_PARM_SHARPNESS,(uint8_t*)&rc,(uint8_t*)&rc);
1555 if(!rc) {
1556 ALOGE("%s:CONTRAST not supported", __func__);
1557 return NO_ERROR;
1558 }
1559 int sharpness = params.getInt(QCameraParameters::KEY_QC_SHARPNESS);
1560 if((sharpness < CAMERA_MIN_SHARPNESS
1561 || sharpness > CAMERA_MAX_SHARPNESS))
1562 return UNKNOWN_ERROR;
1563
1564 ALOGV("setting sharpness %d", sharpness);
1565 mParameters.set(QCameraParameters::KEY_QC_SHARPNESS, sharpness);
1566 ret = native_set_parms(MM_CAMERA_PARM_SHARPNESS, sizeof(sharpness),
1567 (void *)&sharpness);
1568 return ret ? NO_ERROR : UNKNOWN_ERROR;
1569 }
1570
setSaturation(const QCameraParameters & params)1571 status_t QCameraHardwareInterface::setSaturation(const QCameraParameters& params)
1572 {
1573 bool ret = false;
1574 int rc = MM_CAMERA_OK;
1575 ALOGV("%s",__func__);
1576 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1577 MM_CAMERA_PARM_SATURATION,(uint8_t*)&rc,(uint8_t*)&rc);
1578 if(!rc) {
1579 ALOGE("%s:MM_CAMERA_PARM_SATURATION not supported", __func__);
1580 return NO_ERROR;
1581 }
1582 int result;
1583 int saturation = params.getInt(QCameraParameters::KEY_QC_SATURATION);
1584
1585 if((saturation < CAMERA_MIN_SATURATION)
1586 || (saturation > CAMERA_MAX_SATURATION))
1587 return UNKNOWN_ERROR;
1588
1589 ALOGV("Setting saturation %d", saturation);
1590 mParameters.set(QCameraParameters::KEY_QC_SATURATION, saturation);
1591 ret = native_set_parms(MM_CAMERA_PARM_SATURATION, sizeof(saturation),
1592 (void *)&saturation, (int *)&result);
1593 if(result != MM_CAMERA_OK)
1594 ALOGI("Saturation Value: %d is not set as the selected value is not supported", saturation);
1595 return ret ? NO_ERROR : UNKNOWN_ERROR;
1596 }
1597
setContrast(const QCameraParameters & params)1598 status_t QCameraHardwareInterface::setContrast(const QCameraParameters& params)
1599 {
1600 ALOGV("%s E", __func__ );
1601 int rc = MM_CAMERA_OK;
1602 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1603 MM_CAMERA_PARM_CONTRAST,(uint8_t*)&rc,(uint8_t*)&rc);
1604 if(!rc) {
1605 ALOGE("%s:CONTRAST not supported", __func__);
1606 return NO_ERROR;
1607 }
1608 const char *str = params.get(QCameraParameters::KEY_SCENE_MODE);
1609 ALOGE("Contrast : %s",str);
1610 int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str);
1611 if(value == CAMERA_BESTSHOT_OFF) {
1612 int contrast = params.getInt(QCameraParameters::KEY_QC_CONTRAST);
1613 if((contrast < CAMERA_MIN_CONTRAST)
1614 || (contrast > CAMERA_MAX_CONTRAST))
1615 {
1616 ALOGE("Contrast Value not matching");
1617 return UNKNOWN_ERROR;
1618 }
1619 ALOGV("setting contrast %d", contrast);
1620 mParameters.set(QCameraParameters::KEY_QC_CONTRAST, contrast);
1621 ALOGE("Calling Contrast set on Lower layer");
1622 bool ret = native_set_parms(MM_CAMERA_PARM_CONTRAST, sizeof(contrast),
1623 (void *)&contrast);
1624 ALOGE("Lower layer returned %d", ret);
1625 int bestshot_reconfigure;
1626 mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
1627 MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
1628 &bestshot_reconfigure);
1629 if(bestshot_reconfigure) {
1630 if (mContrast != contrast) {
1631 mContrast = contrast;
1632 if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) {
1633 mRestartPreview = true;
1634 }
1635 }
1636 }
1637 return ret ? NO_ERROR : UNKNOWN_ERROR;
1638 } else {
1639 ALOGI(" Contrast value will not be set " \
1640 "when the scenemode selected is %s", str);
1641 return NO_ERROR;
1642 }
1643 return BAD_VALUE;
1644 }
1645
setSceneDetect(const QCameraParameters & params)1646 status_t QCameraHardwareInterface::setSceneDetect(const QCameraParameters& params)
1647 {
1648 ALOGV("%s",__func__);
1649 bool retParm;
1650 int rc = 0;
1651
1652 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1653 MM_CAMERA_PARM_ASD_ENABLE,(uint8_t*)&rc,(uint8_t*)&rc);
1654 if(!rc) {
1655 ALOGE("%s:MM_CAMERA_PARM_ASD_ENABLE not supported", __func__);
1656 return NO_ERROR;
1657 }
1658
1659 const char *str = params.get(QCameraParameters::KEY_QC_SCENE_DETECT);
1660 ALOGE("Scene Detect string : %s",str);
1661 if (str != NULL) {
1662 int32_t value = attr_lookup(scenedetect, sizeof(scenedetect) / sizeof(str_map), str);
1663 ALOGE("Scenedetect Value : %d",value);
1664 if (value != NOT_FOUND) {
1665 mParameters.set(QCameraParameters::KEY_QC_SCENE_DETECT, str);
1666
1667 retParm = native_set_parms(MM_CAMERA_PARM_ASD_ENABLE, sizeof(value),
1668 (void *)&value);
1669
1670 return retParm ? NO_ERROR : UNKNOWN_ERROR;
1671 }
1672 }
1673 return BAD_VALUE;
1674 }
1675
setZoom(const QCameraParameters & params)1676 status_t QCameraHardwareInterface::setZoom(const QCameraParameters& params)
1677 {
1678 status_t rc = NO_ERROR;
1679
1680 ALOGV("%s: E",__func__);
1681 uint8_t supported;
1682
1683 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1684 MM_CAMERA_PARM_ZOOM,&supported,&supported);
1685 if(!supported){
1686 ALOGE("%s:MM_CAMERA_PARM_ZOOM not supported", __func__);
1687 return NO_ERROR;
1688 }
1689 // No matter how many different zoom values the driver can provide, HAL
1690 // provides applictations the same number of zoom levels. The maximum driver
1691 // zoom value depends on sensor output (VFE input) and preview size (VFE
1692 // output) because VFE can only crop and cannot upscale. If the preview size
1693 // is bigger, the maximum zoom ratio is smaller. However, we want the
1694 // zoom ratio of each zoom level is always the same whatever the preview
1695 // size is. Ex: zoom level 1 is always 1.2x, zoom level 2 is 1.44x, etc. So,
1696 // we need to have a fixed maximum zoom value and do read it from the
1697 // driver.
1698 static const int ZOOM_STEP = 1;
1699 int32_t zoom_level = params.getInt("zoom");
1700 if(zoom_level >= 0 && zoom_level <= mMaxZoom-1) {
1701 mParameters.set("zoom", zoom_level);
1702 int32_t zoom_value = ZOOM_STEP * zoom_level;
1703 bool ret = native_set_parms(MM_CAMERA_PARM_ZOOM,
1704 sizeof(zoom_value), (void *)&zoom_value);
1705 if(ret) {
1706 mCurrentZoom=zoom_level;
1707 }
1708 rc = ret ? NO_ERROR : UNKNOWN_ERROR;
1709 } else {
1710 rc = BAD_VALUE;
1711 }
1712 ALOGV("%s X",__func__);
1713 return rc;
1714
1715 }
1716
setISOValue(const QCameraParameters & params)1717 status_t QCameraHardwareInterface::setISOValue(const QCameraParameters& params) {
1718
1719 ALOGV("%s",__func__);
1720 uint8_t supported;
1721 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
1722 MM_CAMERA_PARM_ISO,&supported,&supported);
1723 if(!supported) {
1724 ALOGE("%s:MM_CAMERA_PARM_ISO not supported", __func__);
1725 return NO_ERROR;
1726 }
1727 const char *str = params.get(QCameraParameters::KEY_QC_ISO_MODE);
1728 ALOGV("ISO string : %s",str);
1729 int8_t temp_hjr;
1730 if (str != NULL) {
1731 int value = (camera_iso_mode_type)attr_lookup(
1732 iso, sizeof(iso) / sizeof(str_map), str);
1733 ALOGE("ISO Value : %d",value);
1734 if (value != NOT_FOUND) {
1735 camera_iso_mode_type temp = (camera_iso_mode_type) value;
1736 if (value == CAMERA_ISO_DEBLUR) {
1737 temp_hjr = true;
1738 native_set_parms(MM_CAMERA_PARM_HJR, sizeof(int8_t), (void*)&temp_hjr);
1739 mHJR = value;
1740 }
1741 else {
1742 if (mHJR == CAMERA_ISO_DEBLUR) {
1743 temp_hjr = false;
1744 native_set_parms(MM_CAMERA_PARM_HJR, sizeof(int8_t), (void*)&temp_hjr);
1745 mHJR = value;
1746 }
1747 }
1748
1749 mParameters.set(QCameraParameters::KEY_QC_ISO_MODE, str);
1750 native_set_parms(MM_CAMERA_PARM_ISO, sizeof(camera_iso_mode_type), (void *)&temp);
1751 return NO_ERROR;
1752 }
1753 }
1754 return BAD_VALUE;
1755 }
1756
updateFocusDistances()1757 status_t QCameraHardwareInterface::updateFocusDistances()
1758 {
1759 ALOGV("%s: IN", __FUNCTION__);
1760 focus_distances_info_t focusDistances;
1761 if(mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_FOCUS_DISTANCES,
1762 &focusDistances) >= 0) {
1763 String8 str;
1764 char buffer[32] = {0};
1765 //set all distances to infinity if focus mode is infinity
1766 if(mFocusMode == AF_MODE_INFINITY) {
1767 snprintf(buffer, sizeof(buffer), "Infinity,");
1768 str.append(buffer);
1769 snprintf(buffer, sizeof(buffer), "Infinity,");
1770 str.append(buffer);
1771 snprintf(buffer, sizeof(buffer), "Infinity");
1772 str.append(buffer);
1773 } else {
1774 snprintf(buffer, sizeof(buffer), "%f", focusDistances.focus_distance[0]);
1775 str.append(buffer);
1776 snprintf(buffer, sizeof(buffer), ",%f", focusDistances.focus_distance[1]);
1777 str.append(buffer);
1778 snprintf(buffer, sizeof(buffer), ",%f", focusDistances.focus_distance[2]);
1779 str.append(buffer);
1780 }
1781 ALOGE("%s: setting KEY_FOCUS_DISTANCES as %s", __FUNCTION__, str.string());
1782 mFocusDistance = str;
1783 return NO_ERROR;
1784 }
1785 ALOGV("%s: get CAMERA_PARM_FOCUS_DISTANCES failed!!!", __FUNCTION__);
1786 return BAD_VALUE;
1787 }
1788
1789 // Parse string like "(1, 2, 3, 4, ..., N)"
1790 // num is pointer to an allocated array of size N
parseNDimVector(const char * str,int * num,int N,char delim=',')1791 static int parseNDimVector(const char *str, int *num, int N, char delim = ',')
1792 {
1793 char *start, *end;
1794 if(num == NULL) {
1795 ALOGE("Invalid output array (num == NULL)");
1796 return -1;
1797 }
1798 //check if string starts and ends with parantheses
1799 if(str[0] != '(' || str[strlen(str)-1] != ')') {
1800 ALOGE("Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)", str);
1801 return -1;
1802 }
1803 start = (char*) str;
1804 start++;
1805 for(int i=0; i<N; i++) {
1806 *(num+i) = (int) strtol(start, &end, 10);
1807 if(*end != delim && i < N-1) {
1808 ALOGE("Cannot find delimeter '%c' in string \"%s\". end = %c", delim, str, *end);
1809 return -1;
1810 }
1811 start = end+1;
1812 }
1813 return 0;
1814 }
1815
1816 // parse string like "(1, 2, 3, 4, 5),(1, 2, 3, 4, 5),..."
parseCameraAreaString(const char * str,int max_num_areas,camera_area_t * pAreas,int * num_areas_found)1817 static int parseCameraAreaString(const char* str, int max_num_areas,
1818 camera_area_t *pAreas, int *num_areas_found)
1819 {
1820 char area_str[32];
1821 const char *start, *end, *p;
1822 start = str; end = NULL;
1823 int values[5], index=0;
1824 *num_areas_found = 0;
1825
1826 while(start != NULL) {
1827 if(*start != '(') {
1828 ALOGE("%s: error: Ill formatted area string: %s", __func__, str);
1829 return -1;
1830 }
1831 end = strchr(start, ')');
1832 if(end == NULL) {
1833 ALOGE("%s: error: Ill formatted area string: %s", __func__, str);
1834 return -1;
1835 }
1836 int i;
1837 for (i=0,p=start; p<=end; p++, i++) {
1838 area_str[i] = *p;
1839 }
1840 area_str[i] = '\0';
1841 if(parseNDimVector(area_str, values, 5) < 0){
1842 ALOGE("%s: error: Failed to parse the area string: %s", __func__, area_str);
1843 return -1;
1844 }
1845 // no more areas than max_num_areas are accepted.
1846 if(index >= max_num_areas) {
1847 ALOGE("%s: error: too many areas specified %s", __func__, str);
1848 return -1;
1849 }
1850 pAreas[index].x1 = values[0];
1851 pAreas[index].y1 = values[1];
1852 pAreas[index].x2 = values[2];
1853 pAreas[index].y2 = values[3];
1854 pAreas[index].weight = values[4];
1855
1856 index++;
1857 start = strchr(end, '('); // serach for next '('
1858 }
1859 (*num_areas_found) = index;
1860 return 0;
1861 }
validateCameraAreas(camera_area_t * areas,int num_areas)1862 static bool validateCameraAreas(camera_area_t *areas, int num_areas)
1863 {
1864 for(int i=0; i<num_areas; i++) {
1865
1866 // handle special case (0, 0, 0, 0, 0)
1867 if((areas[i].x1 == 0) && (areas[i].y1 == 0)
1868 && (areas[i].x2 == 0) && (areas[i].y2 == 0) && (areas[i].weight == 0)) {
1869 continue;
1870 }
1871 if(areas[i].x1 < -1000) return false; // left should be >= -1000
1872 if(areas[i].y1 < -1000) return false; // top should be >= -1000
1873 if(areas[i].x2 > 1000) return false; // right should be <= 1000
1874 if(areas[i].y2 > 1000) return false; // bottom should be <= 1000
1875 if(areas[i].weight <= 0 || areas[i].weight > 1000) // weight should be in [1, 1000]
1876 return false;
1877 if(areas[i].x1 >= areas[i].x2) { // left should be < right
1878 return false;
1879 }
1880 if(areas[i].y1 >= areas[i].y2) // top should be < bottom
1881 return false;
1882 }
1883 return true;
1884 }
1885
setFocusAreas(const QCameraParameters & params)1886 status_t QCameraHardwareInterface::setFocusAreas(const QCameraParameters& params)
1887 {
1888 ALOGV("%s: E", __func__);
1889 status_t rc;
1890 int max_num_af_areas = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_FOCUS_AREAS);
1891 if(max_num_af_areas == 0) {
1892 return NO_ERROR;
1893 }
1894 const char *str = params.get(QCameraParameters::KEY_FOCUS_AREAS);
1895 if (str == NULL) {
1896 ALOGE("%s: Parameter string is null", __func__);
1897 rc = NO_ERROR;
1898 } else {
1899 camera_area_t *areas = new camera_area_t[max_num_af_areas];
1900 int num_areas_found=0;
1901 if(parseCameraAreaString(str, max_num_af_areas, areas, &num_areas_found) < 0) {
1902 ALOGE("%s: Failed to parse the string: %s", __func__, str);
1903 delete areas;
1904 return BAD_VALUE;
1905 }
1906 for(int i=0; i<num_areas_found; i++) {
1907 ALOGD("FocusArea[%d] = (%d, %d, %d, %d, %d)", i, (areas[i].x1), (areas[i].y1),
1908 (areas[i].x2), (areas[i].y2), (areas[i].weight));
1909 }
1910 if(validateCameraAreas(areas, num_areas_found) == false) {
1911 ALOGE("%s: invalid areas specified : %s", __func__, str);
1912 delete areas;
1913 return BAD_VALUE;
1914 }
1915 mParameters.set(QCameraParameters::KEY_FOCUS_AREAS, str);
1916 num_areas_found = 1; //temp; need to change after the multi-roi is enabled
1917
1918 //if the native_set_parms is called when preview is not started, it
1919 //crashes in lower layer, so return of preview is not started
1920 if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED) {
1921 delete areas;
1922 return NO_ERROR;
1923 }
1924
1925 //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
1926 //so no action is takenby the lower layer
1927 if(num_areas_found == 1 && (areas[0].x1 == 0) && (areas[0].y1 == 0)
1928 && (areas[0].x2 == 0) && (areas[0].y2 == 0) && (areas[0].weight == 0)) {
1929 num_areas_found = 0;
1930 }
1931 roi_info_t af_roi_value;
1932 memset(&af_roi_value, 0, sizeof(roi_info_t));
1933 uint16_t x1, x2, y1, y2, dx, dy;
1934 int previewWidth, previewHeight;
1935 this->getPreviewSize(&previewWidth, &previewHeight);
1936 //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight)
1937 x1 = (uint16_t)((areas[0].x1 + 1000.0f)*(previewWidth/2000.0f));
1938 y1 = (uint16_t)((areas[0].y1 + 1000.0f)*(previewHeight/2000.0f));
1939 x2 = (uint16_t)((areas[0].x2 + 1000.0f)*(previewWidth/2000.0f));
1940 y2 = (uint16_t)((areas[0].y2 + 1000.0f)*(previewHeight/2000.0f));
1941 dx = x2 - x1;
1942 dy = y2 - y1;
1943
1944 af_roi_value.num_roi = num_areas_found;
1945 af_roi_value.roi[0].x = x1;
1946 af_roi_value.roi[0].y = y1;
1947 af_roi_value.roi[0].dx = dx;
1948 af_roi_value.roi[0].dy = dy;
1949 af_roi_value.is_multiwindow = 0;
1950 if (native_set_parms(MM_CAMERA_PARM_AF_ROI, sizeof(roi_info_t), (void*)&af_roi_value))
1951 rc = NO_ERROR;
1952 else
1953 rc = BAD_VALUE;
1954 delete areas;
1955 }
1956 ALOGE("%s: X", __func__);
1957 return rc;
1958 }
1959
setMeteringAreas(const QCameraParameters & params)1960 status_t QCameraHardwareInterface::setMeteringAreas(const QCameraParameters& params)
1961 {
1962 ALOGV("%s: E", __func__);
1963 status_t rc;
1964 int max_num_mtr_areas = mParameters.getInt(QCameraParameters::KEY_MAX_NUM_METERING_AREAS);
1965 if(max_num_mtr_areas == 0) {
1966 return NO_ERROR;
1967 }
1968
1969 const char *str = params.get(QCameraParameters::KEY_METERING_AREAS);
1970 if (str == NULL) {
1971 ALOGE("%s: Parameter string is null", __func__);
1972 rc = NO_ERROR;
1973 } else {
1974 camera_area_t *areas = new camera_area_t[max_num_mtr_areas];
1975 int num_areas_found=0;
1976 if(parseCameraAreaString(str, max_num_mtr_areas, areas, &num_areas_found) < 0) {
1977 ALOGE("%s: Failed to parse the string: %s", __func__, str);
1978 delete areas;
1979 return BAD_VALUE;
1980 }
1981 for(int i=0; i<num_areas_found; i++) {
1982 ALOGD("MeteringArea[%d] = (%d, %d, %d, %d, %d)", i, (areas[i].x1), (areas[i].y1),
1983 (areas[i].x2), (areas[i].y2), (areas[i].weight));
1984 }
1985 if(validateCameraAreas(areas, num_areas_found) == false) {
1986 ALOGE("%s: invalid areas specified : %s", __func__, str);
1987 delete areas;
1988 return BAD_VALUE;
1989 }
1990 mParameters.set(QCameraParameters::KEY_METERING_AREAS, str);
1991
1992 //if the native_set_parms is called when preview is not started, it
1993 //crashes in lower layer, so return of preview is not started
1994 if(mPreviewState == QCAMERA_HAL_PREVIEW_STOPPED) {
1995 delete areas;
1996 return NO_ERROR;
1997 }
1998
1999 num_areas_found = 1; //temp; need to change after the multi-roi is enabled
2000
2001 //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
2002 //so no action is takenby the lower layer
2003 if(num_areas_found == 1 && (areas[0].x1 == 0) && (areas[0].y1 == 0)
2004 && (areas[0].x2 == 0) && (areas[0].y2 == 0) && (areas[0].weight == 0)) {
2005 num_areas_found = 0;
2006 }
2007 cam_set_aec_roi_t aec_roi_value;
2008 uint16_t x1, x2, y1, y2;
2009 int previewWidth, previewHeight;
2010 this->getPreviewSize(&previewWidth, &previewHeight);
2011 //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight)
2012 x1 = (uint16_t)((areas[0].x1 + 1000.0f)*(previewWidth/2000.0f));
2013 y1 = (uint16_t)((areas[0].y1 + 1000.0f)*(previewHeight/2000.0f));
2014 x2 = (uint16_t)((areas[0].x2 + 1000.0f)*(previewWidth/2000.0f));
2015 y2 = (uint16_t)((areas[0].y2 + 1000.0f)*(previewHeight/2000.0f));
2016 delete areas;
2017
2018 if(num_areas_found == 1) {
2019 aec_roi_value.aec_roi_enable = AEC_ROI_ON;
2020 aec_roi_value.aec_roi_type = AEC_ROI_BY_COORDINATE;
2021 aec_roi_value.aec_roi_position.coordinate.x = (x1+x2)/2;
2022 aec_roi_value.aec_roi_position.coordinate.y = (y1+y2)/2;
2023 } else {
2024 aec_roi_value.aec_roi_enable = AEC_ROI_OFF;
2025 aec_roi_value.aec_roi_type = AEC_ROI_BY_COORDINATE;
2026 aec_roi_value.aec_roi_position.coordinate.x = DONT_CARE_COORDINATE;
2027 aec_roi_value.aec_roi_position.coordinate.y = DONT_CARE_COORDINATE;
2028 }
2029
2030 if(native_set_parms(MM_CAMERA_PARM_AEC_ROI, sizeof(cam_set_aec_roi_t), (void *)&aec_roi_value))
2031 rc = NO_ERROR;
2032 else
2033 rc = BAD_VALUE;
2034 }
2035 ALOGV("%s: X", __func__);
2036 return rc;
2037 }
2038
setFocusMode(const QCameraParameters & params)2039 status_t QCameraHardwareInterface::setFocusMode(const QCameraParameters& params)
2040 {
2041 const char *str = params.get(QCameraParameters::KEY_FOCUS_MODE);
2042 const char *prev_str = mParameters.get(QCameraParameters::KEY_FOCUS_MODE);
2043 ALOGV("%s",__func__);
2044 if (str != NULL) {
2045 ALOGE("Focus mode %s",str);
2046 int32_t value = attr_lookup(focus_modes,
2047 sizeof(focus_modes) / sizeof(str_map), str);
2048 if (value != NOT_FOUND) {
2049 mParameters.set(QCameraParameters::KEY_FOCUS_MODE, str);
2050 mFocusMode = value;
2051
2052 if(updateFocusDistances() != NO_ERROR) {
2053 ALOGE("%s: updateFocusDistances failed for %s", __FUNCTION__, str);
2054 return UNKNOWN_ERROR;
2055 }
2056 mParameters.set(QCameraParameters::KEY_FOCUS_DISTANCES, mFocusDistance.string());
2057 if(mHasAutoFocusSupport){
2058 bool ret = native_set_parms(MM_CAMERA_PARM_FOCUS_MODE,
2059 sizeof(value),
2060 (void *)&value);
2061
2062 int cafSupport = FALSE;
2063 if(!strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ||
2064 !strcmp(str, QCameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)){
2065 cafSupport = TRUE;
2066 }
2067 ALOGE("Continuous Auto Focus %d", cafSupport);
2068 ret = native_set_parms(MM_CAMERA_PARM_CONTINUOUS_AF, sizeof(cafSupport),
2069 (void *)&cafSupport);
2070 }
2071
2072 return NO_ERROR;
2073 }
2074 ALOGE("%s:Could not look up str value",__func__);
2075 }
2076 ALOGE("Invalid focus mode value: %s", (str == NULL) ? "NULL" : str);
2077 return BAD_VALUE;
2078 }
2079
setSceneMode(const QCameraParameters & params)2080 status_t QCameraHardwareInterface::setSceneMode(const QCameraParameters& params)
2081 {
2082 ALOGV("%s",__func__);
2083 uint8_t supported;
2084 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2085 MM_CAMERA_PARM_BESTSHOT_MODE,&supported,&supported);
2086 if(!supported) {
2087 ALOGE("%s:Parameter Scenemode is not supported for this sensor", __func__);
2088 return NO_ERROR;
2089 }
2090 const char *str = params.get(QCameraParameters::KEY_SCENE_MODE);
2091 ALOGE("Scene Mode string : %s",str);
2092
2093 if (str != NULL) {
2094 int32_t value = attr_lookup(scenemode, sizeof(scenemode) / sizeof(str_map), str);
2095 ALOGE("Setting Scenemode value = %d",value );
2096 if (value != NOT_FOUND) {
2097 if((value != CAMERA_BESTSHOT_OFF ) && (mColorEffects != CAMERA_EFFECT_OFF )) {
2098 int result;
2099 mColorEffects = CAMERA_EFFECT_OFF;
2100 native_set_parms(MM_CAMERA_PARM_EFFECT, sizeof(mColorEffects),
2101 (void *)&mColorEffects,(int *)&result);
2102 if(result != MM_CAMERA_OK) {
2103 ALOGI("Camera Effect is not set as the EFFECT_NONE and result is not OK");
2104 }
2105 }
2106 mParameters.set(QCameraParameters::KEY_SCENE_MODE, str);
2107 bool ret = native_set_parms(MM_CAMERA_PARM_BESTSHOT_MODE, sizeof(value),
2108 (void *)&value);
2109 int bestshot_reconfigure;
2110 mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
2111 MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
2112 &bestshot_reconfigure);
2113 if(bestshot_reconfigure) {
2114 if (mBestShotMode != value) {
2115 mBestShotMode = value;
2116 if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) {
2117 mRestartPreview = true;
2118 }
2119 }
2120 }
2121 return ret ? NO_ERROR : UNKNOWN_ERROR;
2122 }
2123 }
2124 ALOGE("Invalid scenemode value: %s", (str == NULL) ? "NULL" : str);
2125 return BAD_VALUE;
2126 }
2127
setSelectableZoneAf(const QCameraParameters & params)2128 status_t QCameraHardwareInterface::setSelectableZoneAf(const QCameraParameters& params)
2129 {
2130 ALOGV("%s",__func__);
2131 uint8_t supported;
2132 if(mHasAutoFocusSupport) {
2133 const char *str = params.get(QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF);
2134 if (str != NULL) {
2135 int32_t value = attr_lookup(selectable_zone_af, sizeof(selectable_zone_af) / sizeof(str_map), str);
2136 if (value != NOT_FOUND) {
2137 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2138 MM_CAMERA_PARM_FOCUS_RECT,&supported,&supported);
2139 if(!supported) {
2140 ALOGE("SelectableZoneAF is not supported for this sensor");
2141 return NO_ERROR;
2142 }else {
2143 mParameters.set(QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF, str);
2144 bool ret = native_set_parms(MM_CAMERA_PARM_FOCUS_RECT, sizeof(value),
2145 (void *)&value);
2146 return ret ? NO_ERROR : UNKNOWN_ERROR;
2147 }
2148 }
2149 }
2150 ALOGE("Invalid selectable zone af value: %s", (str == NULL) ? "NULL" : str);
2151 return BAD_VALUE;
2152
2153 }
2154 return NO_ERROR;
2155 }
2156
setEffect(const QCameraParameters & params)2157 status_t QCameraHardwareInterface::setEffect(const QCameraParameters& params)
2158 {
2159 ALOGV("%s",__func__);
2160 uint8_t supported;
2161 const char *str = params.get(CameraParameters::KEY_EFFECT);
2162 int result;
2163 mColorEffects = CAMERA_EFFECT_OFF;
2164 if (str != NULL) {
2165 ALOGE("Setting effect %s",str);
2166 int32_t value = attr_lookup(effects, sizeof(effects) / sizeof(str_map), str);
2167 if (value != NOT_FOUND) {
2168 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2169 MM_CAMERA_PARM_EFFECT,&supported,&supported);
2170 if(!supported) {
2171 ALOGE("Camera Effect - %s mode is not supported for this sensor",str);
2172 return NO_ERROR;
2173 }else {
2174 mParameters.set(QCameraParameters::KEY_EFFECT, str);
2175 ALOGE("Setting effect to lower HAL : %d",value);
2176 mColorEffects = value;
2177 bool ret = native_set_parms(MM_CAMERA_PARM_EFFECT, sizeof(value),
2178 (void *)&value,(int *)&result);
2179 if(result != 0) {
2180 ALOGI("Camera Effect: %s is not set as the selected value is not supported ", str);
2181 }
2182 int bestshot_reconfigure;
2183 mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
2184 MM_CAMERA_PARM_BESTSHOT_RECONFIGURE,
2185 &bestshot_reconfigure);
2186 if(bestshot_reconfigure) {
2187 if (mEffects != value) {
2188 mEffects = value;
2189 if (mPreviewState == QCAMERA_HAL_PREVIEW_STARTED && ret) {
2190 mRestartPreview = true;
2191 }
2192 }
2193 }
2194 return ret ? NO_ERROR : UNKNOWN_ERROR;
2195 }
2196 }
2197 }
2198 ALOGE("Invalid effect value: %s", (str == NULL) ? "NULL" : str);
2199 ALOGV("setEffect X");
2200 return BAD_VALUE;
2201 }
2202
setBrightness(const QCameraParameters & params)2203 status_t QCameraHardwareInterface::setBrightness(const QCameraParameters& params) {
2204
2205 ALOGV("%s",__func__);
2206 uint8_t supported;
2207 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2208 MM_CAMERA_PARM_BRIGHTNESS,&supported,&supported);
2209 if(!supported) {
2210 ALOGE("MM_CAMERA_PARM_BRIGHTNESS mode is not supported for this sensor");
2211 return NO_ERROR;
2212 }
2213 int brightness = params.getInt("luma-adaptation");
2214 if (mBrightness != brightness) {
2215 ALOGV(" new brightness value : %d ", brightness);
2216 mBrightness = brightness;
2217 mParameters.set("luma-adaptation", brightness);
2218 bool ret = native_set_parms(MM_CAMERA_PARM_BRIGHTNESS, sizeof(mBrightness),
2219 (void *)&mBrightness);
2220 return ret ? NO_ERROR : UNKNOWN_ERROR;
2221 }
2222
2223 return NO_ERROR;
2224 }
2225
setAutoExposure(const QCameraParameters & params)2226 status_t QCameraHardwareInterface::setAutoExposure(const QCameraParameters& params)
2227 {
2228
2229 ALOGV("%s",__func__);
2230 uint8_t supported;
2231 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2232 MM_CAMERA_PARM_EXPOSURE,&supported,&supported);
2233 if(!supported) {
2234 ALOGE("MM_CAMERA_PARM_EXPOSURE mode is not supported for this sensor");
2235 return NO_ERROR;
2236 }
2237 const char *str = params.get(QCameraParameters::KEY_QC_AUTO_EXPOSURE);
2238 if (str != NULL) {
2239 int32_t value = attr_lookup(autoexposure, sizeof(autoexposure) / sizeof(str_map), str);
2240 if (value != NOT_FOUND) {
2241 mParameters.set(QCameraParameters::KEY_QC_AUTO_EXPOSURE, str);
2242 bool ret = native_set_parms(MM_CAMERA_PARM_EXPOSURE, sizeof(value),
2243 (void *)&value);
2244 return ret ? NO_ERROR : UNKNOWN_ERROR;
2245 }
2246 }
2247 ALOGE("Invalid auto exposure value: %s", (str == NULL) ? "NULL" : str);
2248 return BAD_VALUE;
2249 }
2250
setExposureCompensation(const QCameraParameters & params)2251 status_t QCameraHardwareInterface::setExposureCompensation(
2252 const QCameraParameters & params){
2253 ALOGV("%s",__func__);
2254 uint8_t supported;
2255 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2256 MM_CAMERA_PARM_EXPOSURE_COMPENSATION,&supported,&supported);
2257 if(!supported) {
2258 ALOGE("MM_CAMERA_PARM_EXPOSURE_COMPENSATION mode is not supported for this sensor");
2259 return NO_ERROR;
2260 }
2261 int numerator = params.getInt(QCameraParameters::KEY_EXPOSURE_COMPENSATION);
2262 if(EXPOSURE_COMPENSATION_MINIMUM_NUMERATOR <= numerator &&
2263 numerator <= EXPOSURE_COMPENSATION_MAXIMUM_NUMERATOR){
2264 int16_t numerator16 = (int16_t)(numerator & 0x0000ffff);
2265 uint16_t denominator16 = EXPOSURE_COMPENSATION_DENOMINATOR;
2266 uint32_t value = 0;
2267 value = numerator16 << 16 | denominator16;
2268
2269 mParameters.set(QCameraParameters::KEY_EXPOSURE_COMPENSATION,
2270 numerator);
2271 bool ret = native_set_parms(MM_CAMERA_PARM_EXPOSURE_COMPENSATION,
2272 sizeof(value), (void *)&value);
2273 return ret ? NO_ERROR : UNKNOWN_ERROR;
2274 }
2275 ALOGE("Invalid Exposure Compensation");
2276 return BAD_VALUE;
2277 }
2278
setWhiteBalance(const QCameraParameters & params)2279 status_t QCameraHardwareInterface::setWhiteBalance(const QCameraParameters& params)
2280 {
2281
2282 ALOGV("%s",__func__);
2283 status_t rc = NO_ERROR;
2284 uint8_t supported;
2285 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2286 MM_CAMERA_PARM_WHITE_BALANCE,&supported,&supported);
2287 if(!supported) {
2288 ALOGE("MM_CAMERA_PARM_WHITE_BALANCE mode is not supported for this sensor");
2289 return NO_ERROR;
2290 }
2291 int result;
2292
2293 const char *str = params.get(QCameraParameters::KEY_WHITE_BALANCE);
2294 if (str != NULL) {
2295 int32_t value = attr_lookup(whitebalance, sizeof(whitebalance) / sizeof(str_map), str);
2296 if (value != NOT_FOUND) {
2297 mParameters.set(QCameraParameters::KEY_WHITE_BALANCE, str);
2298 bool ret = native_set_parms(MM_CAMERA_PARM_WHITE_BALANCE, sizeof(value),
2299 (void *)&value, (int *)&result);
2300 if(result != MM_CAMERA_OK) {
2301 ALOGI("WhiteBalance Value: %s is not set as the selected value is not supported ", str);
2302 }
2303 return ret ? NO_ERROR : UNKNOWN_ERROR;
2304 }
2305 }
2306 ALOGE("Invalid whitebalance value: %s", (str == NULL) ? "NULL" : str);
2307 return BAD_VALUE;
2308 }
2309
getAutoFlickerMode()2310 int QCameraHardwareInterface::getAutoFlickerMode()
2311 {
2312 /* Enable Advanced Auto Antibanding where we can set
2313 any of the following option
2314 ie. CAMERA_ANTIBANDING_AUTO
2315 CAMERA_ANTIBANDING_AUTO_50HZ
2316 CAMERA_ANTIBANDING_AUTO_60HZ
2317 Currently setting it to default */
2318 return CAMERA_ANTIBANDING_AUTO;
2319 }
2320
setAntibanding(const QCameraParameters & params)2321 status_t QCameraHardwareInterface::setAntibanding(const QCameraParameters& params)
2322 {
2323 int result;
2324
2325 ALOGV("%s",__func__);
2326 status_t rc = NO_ERROR;
2327 uint8_t supported;
2328 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2329 MM_CAMERA_PARM_ANTIBANDING,&supported,&supported);
2330 if(!supported) {
2331 ALOGE("ANTIBANDING mode is not supported for this sensor");
2332 return NO_ERROR;
2333 }
2334 const char *str = params.get(QCameraParameters::KEY_ANTIBANDING);
2335 if (str != NULL) {
2336 int value = (camera_antibanding_type)attr_lookup(
2337 antibanding, sizeof(antibanding) / sizeof(str_map), str);
2338 if (value != NOT_FOUND) {
2339 camera_antibanding_type temp = (camera_antibanding_type) value;
2340 ALOGE("Antibanding Value : %d",value);
2341 mParameters.set(QCameraParameters::KEY_ANTIBANDING, str);
2342 if(value == CAMERA_ANTIBANDING_AUTO) {
2343 value = getAutoFlickerMode();
2344 }
2345 bool ret = native_set_parms(MM_CAMERA_PARM_ANTIBANDING,
2346 sizeof(camera_antibanding_type), (void *)&value ,(int *)&result);
2347 if(result != MM_CAMERA_OK) {
2348 ALOGI("AntiBanding Value: %s is not supported for the given BestShot Mode", str);
2349 }
2350 return ret ? NO_ERROR : UNKNOWN_ERROR;
2351 }
2352 }
2353 ALOGE("Invalid antibanding value: %s", (str == NULL) ? "NULL" : str);
2354
2355 return BAD_VALUE;
2356 }
2357
setPreviewFrameRate(const QCameraParameters & params)2358 status_t QCameraHardwareInterface::setPreviewFrameRate(const QCameraParameters& params)
2359 {
2360 ALOGV("%s: E",__func__);
2361 status_t rc = NO_ERROR;
2362 uint16_t fps = (uint16_t)params.getPreviewFrameRate();
2363 ALOGV("%s: requested preview frame rate is %d", __func__, fps);
2364
2365 mParameters.setPreviewFrameRate(fps);
2366 ALOGV("%s: X",__func__);
2367 return NO_ERROR;
2368 }
2369
setPreviewFrameRateMode(const QCameraParameters & params)2370 status_t QCameraHardwareInterface::setPreviewFrameRateMode(const QCameraParameters& params) {
2371
2372 ALOGV("%s",__func__);
2373 uint8_t supported;
2374 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2375 MM_CAMERA_PARM_FPS,&supported,&supported);
2376 if(!supported) {
2377 ALOGE(" CAMERA FPS mode is not supported for this sensor");
2378 return NO_ERROR;
2379 }
2380 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2381 MM_CAMERA_PARM_FPS_MODE,&supported,&supported);
2382 if(!supported) {
2383 ALOGE("CAMERA FPS MODE mode is not supported for this sensor");
2384 return NO_ERROR;
2385 }
2386
2387 const char *previousMode = mParameters.getPreviewFrameRateMode();
2388 const char *str = params.getPreviewFrameRateMode();
2389 if (NULL == previousMode) {
2390 ALOGE("Preview Frame Rate Mode is NULL\n");
2391 return NO_ERROR;
2392 }
2393 if (NULL == str) {
2394 ALOGE("Preview Frame Rate Mode is NULL\n");
2395 return NO_ERROR;
2396 }
2397 if( mInitialized && !strcmp(previousMode, str)) {
2398 ALOGE("frame rate mode same as previous mode %s", previousMode);
2399 return NO_ERROR;
2400 }
2401 int32_t frameRateMode = attr_lookup(frame_rate_modes, sizeof(frame_rate_modes) / sizeof(str_map),str);
2402 if(frameRateMode != NOT_FOUND) {
2403 ALOGV("setPreviewFrameRateMode: %s ", str);
2404 mParameters.setPreviewFrameRateMode(str);
2405 bool ret = native_set_parms(MM_CAMERA_PARM_FPS_MODE, sizeof(frameRateMode), (void *)&frameRateMode);
2406 if(!ret) return ret;
2407 //set the fps value when chaging modes
2408 int16_t fps = (uint16_t)params.getPreviewFrameRate();
2409 if(MINIMUM_FPS <= fps && fps <=MAXIMUM_FPS){
2410 mParameters.setPreviewFrameRate(fps);
2411 ret = native_set_parms(MM_CAMERA_PARM_FPS,
2412 sizeof(fps), (void *)&fps);
2413 return ret ? NO_ERROR : UNKNOWN_ERROR;
2414 }
2415 ALOGE("Invalid preview frame rate value: %d", fps);
2416 return BAD_VALUE;
2417 }
2418 ALOGE("Invalid preview frame rate mode value: %s", (str == NULL) ? "NULL" : str);
2419
2420 return BAD_VALUE;
2421 }
2422
setSkinToneEnhancement(const QCameraParameters & params)2423 status_t QCameraHardwareInterface::setSkinToneEnhancement(const QCameraParameters& params) {
2424 ALOGV("%s",__func__);
2425 uint8_t supported;
2426 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2427 MM_CAMERA_PARM_SCE_FACTOR,&supported,&supported);
2428 if(!supported) {
2429 ALOGE("SkinToneEnhancement is not supported for this sensor");
2430 return NO_ERROR;
2431 }
2432 int skinToneValue = params.getInt("skinToneEnhancement");
2433 if (mSkinToneEnhancement != skinToneValue) {
2434 ALOGV(" new skinTone correction value : %d ", skinToneValue);
2435 mSkinToneEnhancement = skinToneValue;
2436 mParameters.set("skinToneEnhancement", skinToneValue);
2437 bool ret = native_set_parms(MM_CAMERA_PARM_SCE_FACTOR, sizeof(mSkinToneEnhancement),
2438 (void *)&mSkinToneEnhancement);
2439 return ret ? NO_ERROR : UNKNOWN_ERROR;
2440 }
2441 return NO_ERROR;
2442 }
2443
setWaveletDenoise(const QCameraParameters & params)2444 status_t QCameraHardwareInterface::setWaveletDenoise(const QCameraParameters& params) {
2445 ALOGV("%s",__func__);
2446 uint8_t supported;
2447 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2448 MM_CAMERA_PARM_WAVELET_DENOISE,&supported,&supported);
2449 if( !supported ) {
2450 ALOGE("Wavelet Denoise is not supported for this sensor");
2451 /* TO DO */
2452 // return NO_ERROR;
2453 }
2454 const char *str = params.get(QCameraParameters::KEY_QC_DENOISE);
2455 if (str != NULL) {
2456 int value = attr_lookup(denoise,
2457 sizeof(denoise) / sizeof(str_map), str);
2458 if ((value != NOT_FOUND) && (mDenoiseValue != value)) {
2459 mDenoiseValue = value;
2460 mParameters.set(QCameraParameters::KEY_QC_DENOISE, str);
2461
2462 char prop[PROPERTY_VALUE_MAX];
2463 memset(prop, 0, sizeof(prop));
2464 property_get("persist.denoise.process.plates", prop, "0");
2465
2466 denoise_param_t temp;
2467 memset(&temp, 0, sizeof(denoise_param_t));
2468 temp.denoise_enable = value;
2469 switch(atoi(prop)) {
2470 case 0:
2471 temp.process_plates = WAVELET_DENOISE_YCBCR_PLANE;
2472 break;
2473 case 1:
2474 temp.process_plates = WAVELET_DENOISE_CBCR_ONLY;
2475 break;
2476 case 2:
2477 temp.process_plates = WAVELET_DENOISE_STREAMLINE_YCBCR;
2478 break;
2479 case 3:
2480 temp.process_plates = WAVELET_DENOISE_STREAMLINED_CBCR;
2481 break;
2482 default:
2483 temp.process_plates = WAVELET_DENOISE_STREAMLINE_YCBCR;
2484 break;
2485 }
2486 ALOGE("Denoise enable=%d, plates=%d", temp.denoise_enable, temp.process_plates);
2487 bool ret = native_set_parms(MM_CAMERA_PARM_WAVELET_DENOISE, sizeof(temp),
2488 (void *)&temp);
2489 return ret ? NO_ERROR : UNKNOWN_ERROR;
2490 }
2491 return NO_ERROR;
2492 }
2493 ALOGE("Invalid Denoise value: %s", (str == NULL) ? "NULL" : str);
2494 return BAD_VALUE;
2495 }
2496
setVideoSize(const QCameraParameters & params)2497 status_t QCameraHardwareInterface::setVideoSize(const QCameraParameters& params)
2498 {
2499 const char *str= NULL;
2500 const char *str_t= NULL;
2501 int old_vid_w = 0, old_vid_h = 0;
2502 ALOGV("%s: E", __func__);
2503 str = params.get(QCameraParameters::KEY_VIDEO_SIZE);
2504 str_t = mParameters.get(CameraParameters::KEY_VIDEO_SIZE);
2505 if(!str) {
2506 mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, "");
2507 //If application didn't set this parameter string, use the values from
2508 //getPreviewSize() as video dimensions.
2509 ALOGE("No Record Size requested, use the preview dimensions");
2510 videoWidth = mPreviewWidth;
2511 videoHeight = mPreviewHeight;
2512 } else {
2513 //Extract the record witdh and height that application requested.
2514 ALOGI("%s: requested record size %s", __func__, str);
2515 if(!parse_size(str, videoWidth, videoHeight)) {
2516 parse_size(str_t, old_vid_w, old_vid_h);
2517 mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, str);
2518 if((QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) &&
2519 (old_vid_w != videoWidth || old_vid_h != videoHeight)) {
2520 ALOGE("%s: Video sizes changes to %s, Restart preview...", __func__, str);
2521 mRestartPreview = true;
2522 }
2523 } else {
2524 mParameters.set(QCameraParameters::KEY_VIDEO_SIZE, "");
2525 ALOGE("%s: error :failed to parse parameter record-size (%s)", __func__, str);
2526 return BAD_VALUE;
2527 }
2528 }
2529 ALOGV("%s: preview dimensions: %dx%d", __func__, mPreviewWidth, mPreviewHeight);
2530 ALOGV("%s: video dimensions: %dx%d", __func__, videoWidth, videoHeight);
2531 mDimension.orig_video_width = videoWidth;
2532 mDimension.orig_video_height = videoHeight;
2533 mDimension.video_width = videoWidth;
2534 mDimension.video_height = videoHeight;
2535
2536 ALOGV("%s: X", __func__);
2537 return NO_ERROR;
2538 }
2539
setCameraMode(const QCameraParameters & params)2540 status_t QCameraHardwareInterface::setCameraMode(const QCameraParameters& params) {
2541 int32_t value = params.getInt(QCameraParameters::KEY_QC_CAMERA_MODE);
2542 mParameters.set(QCameraParameters::KEY_QC_CAMERA_MODE,value);
2543
2544 ALOGI("ZSL is enabled %d", value);
2545 if (value == 1) {
2546 myMode = (camera_mode_t)(myMode | CAMERA_ZSL_MODE);
2547 } else {
2548 myMode = (camera_mode_t)(myMode & ~CAMERA_ZSL_MODE);
2549 }
2550 return NO_ERROR;
2551 }
2552
setPowerMode(const QCameraParameters & params)2553 status_t QCameraHardwareInterface::setPowerMode(const QCameraParameters& params) {
2554 uint32_t value = NORMAL_POWER;
2555 const char *powermode = NULL;
2556
2557 powermode = params.get(QCameraParameters::KEY_QC_POWER_MODE);
2558 if (powermode != NULL) {
2559 value = attr_lookup(power_modes,
2560 sizeof(power_modes) / sizeof(str_map), powermode);
2561 if((value == LOW_POWER) || mHFRLevel > 1) {
2562 ALOGI("Enable Low Power Mode");
2563 value = LOW_POWER;
2564 mPowerMode = value;
2565 mParameters.set(QCameraParameters::KEY_QC_POWER_MODE,"Low_Power");
2566 } else {
2567 ALOGE("Enable Normal Power Mode");
2568 mPowerMode = value;
2569 mParameters.set(QCameraParameters::KEY_QC_POWER_MODE,"Normal_Power");
2570 }
2571 }
2572
2573 ALOGI("%s Low power mode %s value = %d", __func__,
2574 value ? "Enabled" : "Disabled", value);
2575 native_set_parms(MM_CAMERA_PARM_LOW_POWER_MODE, sizeof(value),
2576 (void *)&value);
2577 return NO_ERROR;
2578 }
2579
2580
setPreviewSize(const QCameraParameters & params)2581 status_t QCameraHardwareInterface::setPreviewSize(const QCameraParameters& params)
2582 {
2583 int width, height;
2584 params.getPreviewSize(&width, &height);
2585 ALOGV("################requested preview size %d x %d", width, height);
2586
2587 // Validate the preview size
2588 for (size_t i = 0; i < mPreviewSizeCount; ++i) {
2589 if (width == mPreviewSizes[i].width
2590 && height == mPreviewSizes[i].height) {
2591 mParameters.setPreviewSize(width, height);
2592 ALOGE("setPreviewSize: width: %d heigh: %d", width, height);
2593 mPreviewWidth = width;
2594 mPreviewHeight = height;
2595 mDimension.display_width = width;
2596 mDimension.display_height = height;
2597 return NO_ERROR;
2598 }
2599 }
2600 ALOGE("Invalid preview size requested: %dx%d", width, height);
2601 return BAD_VALUE;
2602 }
setPreviewFpsRange(const QCameraParameters & params)2603 status_t QCameraHardwareInterface::setPreviewFpsRange(const QCameraParameters& params)
2604 {
2605 ALOGV("%s: E", __func__);
2606 int minFps,maxFps;
2607 int prevMinFps, prevMaxFps;
2608 int rc = NO_ERROR;
2609 bool found = false;
2610
2611 mParameters.getPreviewFpsRange(&prevMinFps, &prevMaxFps);
2612 ALOGV("%s: Existing FpsRange Values:(%d, %d)", __func__, prevMinFps, prevMaxFps);
2613 params.getPreviewFpsRange(&minFps,&maxFps);
2614 ALOGV("%s: Requested FpsRange Values:(%d, %d)", __func__, minFps, maxFps);
2615
2616 if(mInitialized && (minFps == prevMinFps && maxFps == prevMaxFps)) {
2617 ALOGE("%s: No change in FpsRange", __func__);
2618 rc = NO_ERROR;
2619 goto end;
2620 }
2621 for(int i=0; i<mSupportedFpsRangesCount; i++) {
2622 // if the value is in the supported list
2623 if(minFps >= mSupportedFpsRanges[i].minFPS && maxFps <= mSupportedFpsRanges[i].maxFPS) {
2624 found = true;
2625 ALOGE("FPS: i=%d : minFps = %d, maxFps = %d ", i, minFps, maxFps);
2626 mParameters.setPreviewFpsRange(minFps,maxFps);
2627 // validate the values
2628 bool valid = true;
2629 // FPS can not be negative
2630 if(minFps < 0 || maxFps < 0) valid = false;
2631 // minFps must be >= maxFps
2632 if(minFps > maxFps) valid = false;
2633
2634 if(valid) {
2635 //Set the FPS mode
2636 const char *str = (minFps == maxFps) ?
2637 QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE:
2638 QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE;
2639 ALOGE("%s FPS_MODE = %s", __func__, str);
2640 int32_t frameRateMode = attr_lookup(frame_rate_modes,
2641 sizeof(frame_rate_modes) / sizeof(str_map),str);
2642 bool ret;
2643 ret = native_set_parms(MM_CAMERA_PARM_FPS_MODE, sizeof(int32_t),
2644 (void *)&frameRateMode);
2645
2646 //set FPS values
2647 uint32_t fps; //lower 2 bytes specify maxFps and higher 2 bytes specify minFps
2648 fps = ((uint32_t)(minFps/1000) << 16) + ((uint16_t)(maxFps/1000));
2649
2650 ret = native_set_parms(MM_CAMERA_PARM_FPS, sizeof(uint32_t), (void *)&fps);
2651 mParameters.setPreviewFpsRange(minFps, maxFps);
2652 if(ret)
2653 rc = NO_ERROR;
2654 else {
2655 rc = BAD_VALUE;
2656 ALOGE("%s: error: native_set_params failed", __func__);
2657 }
2658 } else {
2659 ALOGE("%s: error: invalid FPS range value", __func__);
2660 rc = BAD_VALUE;
2661 }
2662 }
2663 }
2664 if(found == false){
2665 ALOGE("%s: error: FPS range value not supported", __func__);
2666 rc = BAD_VALUE;
2667 }
2668 end:
2669 ALOGV("%s: X", __func__);
2670 return rc;
2671 }
2672
setJpegThumbnailSize(const QCameraParameters & params)2673 status_t QCameraHardwareInterface::setJpegThumbnailSize(const QCameraParameters& params){
2674 int width = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
2675 int height = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
2676
2677 ALOGV("requested jpeg thumbnail size %d x %d", width, height);
2678
2679 // Validate the picture size
2680 for (unsigned int i = 0; i < thumbnail_sizes_count; ++i) {
2681 if (width == default_thumbnail_sizes[i].width
2682 && height == default_thumbnail_sizes[i].height) {
2683 thumbnailWidth = width;
2684 thumbnailHeight = height;
2685 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
2686 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
2687 return NO_ERROR;
2688 }
2689 }
2690 ALOGE("error: setting jpeg thumbnail size");
2691 return BAD_VALUE;
2692 }
setPictureSize(const QCameraParameters & params)2693 status_t QCameraHardwareInterface::setPictureSize(const QCameraParameters& params)
2694 {
2695 int width, height;
2696 ALOGV("QualcommCameraHardware::setPictureSize E");
2697 params.getPictureSize(&width, &height);
2698 ALOGE("requested picture size %d x %d", width, height);
2699
2700 // Validate the picture size
2701 for (int i = 0; i < mSupportedPictureSizesCount; ++i) {
2702 if (width == mPictureSizesPtr[i].width
2703 && height == mPictureSizesPtr[i].height) {
2704 int old_width, old_height;
2705 mParameters.getPictureSize(&old_width,&old_height);
2706 mParameters.setPictureSize(width, height);
2707 mDimension.picture_width = width;
2708 mDimension.picture_height = height;
2709 if((QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) &&
2710 (width != old_width || height != old_height)) {
2711 mRestartPreview = true;
2712 }
2713 return NO_ERROR;
2714 }
2715 }
2716 /* Dimension not among the ones in the list. Check if
2717 * its a valid dimension, if it is, then configure the
2718 * camera accordingly. else reject it.
2719 */
2720 if( isValidDimension(width, height) ) {
2721 mParameters.setPictureSize(width, height);
2722 mDimension.picture_width = width;
2723 mDimension.picture_height = height;
2724 return NO_ERROR;
2725 } else
2726 ALOGE("Invalid picture size requested: %dx%d", width, height);
2727 return BAD_VALUE;
2728 }
2729
setJpegRotation(int isZsl)2730 status_t QCameraHardwareInterface::setJpegRotation(int isZsl) {
2731 // return mm_jpeg_encoder_setRotation(mRotation, isZsl);
2732 return NO_ERROR;
2733 }
2734
getJpegRotation(void)2735 int QCameraHardwareInterface::getJpegRotation(void) {
2736 ALOGE("%s : rotation is %d", __func__, mRotation);
2737 return mRotation;
2738 }
2739
getISOSpeedValue()2740 int QCameraHardwareInterface::getISOSpeedValue()
2741 {
2742 const char *iso_str = mParameters.get(QCameraParameters::KEY_QC_ISO_MODE);
2743 int iso_index = attr_lookup(iso, sizeof(iso) / sizeof(str_map), iso_str);
2744 int iso_value = iso_speed_values[iso_index];
2745 return iso_value;
2746 }
2747
2748
setJpegQuality(const QCameraParameters & params)2749 status_t QCameraHardwareInterface::setJpegQuality(const QCameraParameters& params) {
2750 status_t rc = NO_ERROR;
2751 int quality = params.getInt(QCameraParameters::KEY_JPEG_QUALITY);
2752 ALOGV("setJpegQuality E");
2753 if (quality >= 0 && quality <= 100) {
2754 mParameters.set(QCameraParameters::KEY_JPEG_QUALITY, quality);
2755 mJpegQuality = quality;
2756 } else {
2757 ALOGE("Invalid jpeg quality=%d", quality);
2758 rc = BAD_VALUE;
2759 }
2760
2761 quality = params.getInt(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
2762 if (quality >= 0 && quality <= 100) {
2763 mParameters.set(QCameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, quality);
2764 } else {
2765 ALOGE("Invalid jpeg thumbnail quality=%d", quality);
2766 rc = BAD_VALUE;
2767 }
2768 ALOGV("setJpegQuality X");
2769 return rc;
2770 }
2771
2772 status_t QCameraHardwareInterface::
setNumOfSnapshot(const QCameraParameters & params)2773 setNumOfSnapshot(const QCameraParameters& params) {
2774 status_t rc = NO_ERROR;
2775
2776 int num_of_snapshot = getNumOfSnapshots(params);
2777
2778 if (num_of_snapshot <= 0) {
2779 num_of_snapshot = 1;
2780 }
2781 ALOGI("number of snapshots = %d", num_of_snapshot);
2782 mParameters.set("num-snaps-per-shutter", num_of_snapshot);
2783
2784 bool result = native_set_parms(MM_CAMERA_PARM_SNAPSHOT_BURST_NUM,
2785 sizeof(int),
2786 (void *)&num_of_snapshot);
2787 if(!result)
2788 ALOGI("%s:Failure setting number of snapshots!!!", __func__);
2789 return rc;
2790 }
2791
setPreviewFormat(const QCameraParameters & params)2792 status_t QCameraHardwareInterface::setPreviewFormat(const QCameraParameters& params) {
2793 const char *str = params.getPreviewFormat();
2794 int32_t previewFormat = attr_lookup(preview_formats, sizeof(preview_formats) / sizeof(str_map), str);
2795 if(previewFormat != NOT_FOUND) {
2796 int num = sizeof(preview_format_info_list)/sizeof(preview_format_info_t);
2797 int i;
2798
2799 for (i = 0; i < num; i++) {
2800 if (preview_format_info_list[i].Hal_format == previewFormat) {
2801 mPreviewFormatInfo = preview_format_info_list[i];
2802 break;
2803 }
2804 }
2805
2806 if (i == num) {
2807 mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21;
2808 mPreviewFormatInfo.padding = CAMERA_PAD_TO_WORD;
2809 return BAD_VALUE;
2810 }
2811 bool ret = native_set_parms(MM_CAMERA_PARM_PREVIEW_FORMAT, sizeof(cam_format_t),
2812 (void *)&mPreviewFormatInfo.mm_cam_format);
2813 mParameters.set(QCameraParameters::KEY_PREVIEW_FORMAT, str);
2814 mPreviewFormat = mPreviewFormatInfo.mm_cam_format;
2815 ALOGI("Setting preview format to %d, i =%d, num=%d, hal_format=%d",
2816 mPreviewFormat, i, num, mPreviewFormatInfo.Hal_format);
2817 return NO_ERROR;
2818 } else if ( strTexturesOn ) {
2819 mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21;
2820 mPreviewFormatInfo.padding = CAMERA_PAD_TO_4K;
2821 } else {
2822 mPreviewFormatInfo.mm_cam_format = CAMERA_YUV_420_NV21;
2823 mPreviewFormatInfo.padding = CAMERA_PAD_TO_WORD;
2824 }
2825 ALOGE("Invalid preview format value: %s", (str == NULL) ? "NULL" : str);
2826 return BAD_VALUE;
2827 }
2828
setStrTextures(const QCameraParameters & params)2829 status_t QCameraHardwareInterface::setStrTextures(const QCameraParameters& params) {
2830 const char *str = params.get("strtextures");
2831 const char *prev_str = mParameters.get("strtextures");
2832
2833 if(str != NULL) {
2834 if(!strcmp(str,prev_str)) {
2835 return NO_ERROR;
2836 }
2837 int str_size = strlen(str);
2838 mParameters.set("strtextures", str);
2839 if(str_size == 2) {
2840 if(!strncmp(str, "on", str_size) || !strncmp(str, "ON", str_size)){
2841 ALOGI("Resetting mUseOverlay to false");
2842 strTexturesOn = true;
2843 mUseOverlay = false;
2844 }
2845 }else if(str_size == 3){
2846 if (!strncmp(str, "off", str_size) || !strncmp(str, "OFF", str_size)) {
2847 strTexturesOn = false;
2848 mUseOverlay = true;
2849 }
2850 }
2851
2852 }
2853 return NO_ERROR;
2854 }
2855
setFlash(const QCameraParameters & params)2856 status_t QCameraHardwareInterface::setFlash(const QCameraParameters& params)
2857 {
2858 ALOGI("%s: E",__func__);
2859 uint8_t supported;
2860 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2861 MM_CAMERA_PARM_LED_MODE,&supported,&supported);
2862 if(!supported) {
2863 ALOGE("%s:LED FLASH not supported", __func__);
2864 return NO_ERROR;
2865 }
2866
2867 const char *str = params.get(QCameraParameters::KEY_FLASH_MODE);
2868 if (str != NULL) {
2869 int32_t value = attr_lookup(flash, sizeof(flash) / sizeof(str_map), str);
2870 if (value != NOT_FOUND) {
2871 mParameters.set(QCameraParameters::KEY_FLASH_MODE, str);
2872 bool ret = native_set_parms(MM_CAMERA_PARM_LED_MODE,
2873 sizeof(value), (void *)&value);
2874 return ret ? NO_ERROR : UNKNOWN_ERROR;
2875 }
2876 }
2877 ALOGE("Invalid flash mode value: %s", (str == NULL) ? "NULL" : str);
2878
2879 return BAD_VALUE;
2880 }
2881
setAecAwbLock(const QCameraParameters & params)2882 status_t QCameraHardwareInterface::setAecAwbLock(const QCameraParameters & params)
2883 {
2884 ALOGD("%s : E", __func__);
2885 status_t rc = NO_ERROR;
2886 int32_t value;
2887 const char* str;
2888
2889 //for AEC lock
2890 str = params.get(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK);
2891 value = (strcmp(str, "true") == 0)? 1 : 0;
2892 mParameters.set(QCameraParameters::KEY_AUTO_EXPOSURE_LOCK, str);
2893 rc = (native_set_parms(MM_CAMERA_PARM_AEC_LOCK, sizeof(int32_t), (void *)(&value))) ?
2894 NO_ERROR : UNKNOWN_ERROR;
2895
2896 //for AWB lock
2897 str = params.get(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK);
2898 value = (strcmp(str, "true") == 0)? 1 : 0;
2899 mParameters.set(QCameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, str);
2900 rc = (native_set_parms(MM_CAMERA_PARM_AWB_LOCK, sizeof(int32_t), (void *)(&value))) ?
2901 NO_ERROR : UNKNOWN_ERROR;
2902 ALOGD("%s : X", __func__);
2903 return rc;
2904 }
2905
setOverlayFormats(const QCameraParameters & params)2906 status_t QCameraHardwareInterface::setOverlayFormats(const QCameraParameters& params)
2907 {
2908 mParameters.set("overlay-format", HAL_PIXEL_FORMAT_YCbCr_420_SP);
2909 if(mIs3DModeOn == true) {
2910 int ovFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP|HAL_3D_IN_SIDE_BY_SIDE_L_R|HAL_3D_OUT_SIDE_BY_SIDE;
2911 mParameters.set("overlay-format", ovFormat);
2912 }
2913 return NO_ERROR;
2914 }
2915
setMCEValue(const QCameraParameters & params)2916 status_t QCameraHardwareInterface::setMCEValue(const QCameraParameters& params)
2917 {
2918 ALOGE("%s",__func__);
2919 uint8_t supported;
2920
2921 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2922 MM_CAMERA_PARM_MCE,&supported,&supported);
2923 if(!supported) {
2924 ALOGE("MM_CAMERA_PARM_MCE mode is not supported for this sensor");
2925 return NO_ERROR;
2926 }
2927 const char *str = params.get(QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT);
2928 if (str != NULL) {
2929 int value = attr_lookup(mce, sizeof(mce) / sizeof(str_map), str);
2930 if (value != NOT_FOUND) {
2931 int temp = (int8_t)value;
2932 ALOGI("%s: setting MCE value of %s", __FUNCTION__, str);
2933 mParameters.set(QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT, str);
2934
2935 native_set_parms(MM_CAMERA_PARM_MCE, sizeof(int8_t), (void *)&temp);
2936 return NO_ERROR;
2937 }
2938 }
2939 ALOGE("Invalid MCE value: %s", (str == NULL) ? "NULL" : str);
2940
2941 return NO_ERROR;
2942 }
2943
setHighFrameRate(const QCameraParameters & params)2944 status_t QCameraHardwareInterface::setHighFrameRate(const QCameraParameters& params)
2945 {
2946 uint8_t supported;
2947 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2948 MM_CAMERA_PARM_HFR,&supported,&supported);
2949 if(!supported) {
2950 ALOGE("%s: MM_CAMERA_PARM_HFR not supported", __func__);
2951 return NO_ERROR;
2952 }
2953
2954 const char *str = params.get(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE);
2955 if (str != NULL) {
2956 int value = attr_lookup(hfr, sizeof(hfr) / sizeof(str_map), str);
2957 if (value != NOT_FOUND) {
2958 mHFRLevel = (int32_t)value;
2959 //Check for change in HFR value
2960 const char *oldHfr = mParameters.get(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE);
2961 if(strcmp(oldHfr, str)){
2962 mParameters.set(QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE, str);
2963 if(QCAMERA_HAL_PREVIEW_STARTED == mPreviewState) {
2964 stopPreviewInternal();
2965 mPreviewState = QCAMERA_HAL_PREVIEW_STOPPED;
2966 native_set_parms(MM_CAMERA_PARM_HFR, sizeof(int32_t), (void *)&mHFRLevel);
2967 mRestartPreview = true;
2968 return NO_ERROR;
2969 }
2970 }
2971 native_set_parms(MM_CAMERA_PARM_HFR, sizeof(int32_t), (void *)&mHFRLevel);
2972 return NO_ERROR;
2973 }
2974 }
2975 ALOGE("Invalid HFR value: %s", (str == NULL) ? "NULL" : str);
2976 return NO_ERROR;
2977 }
2978
setLensshadeValue(const QCameraParameters & params)2979 status_t QCameraHardwareInterface::setLensshadeValue(const QCameraParameters& params)
2980 {
2981
2982 uint8_t supported;
2983 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
2984 MM_CAMERA_PARM_ROLLOFF,&supported,&supported);
2985 if(!supported) {
2986 ALOGE("%s:LENS SHADING not supported", __func__);
2987 return NO_ERROR;
2988 }
2989
2990 const char *str = params.get(QCameraParameters::KEY_QC_LENSSHADE);
2991 if (str != NULL) {
2992 int value = attr_lookup(lensshade,
2993 sizeof(lensshade) / sizeof(str_map), str);
2994 if (value != NOT_FOUND) {
2995 int8_t temp = (int8_t)value;
2996 mParameters.set(QCameraParameters::KEY_QC_LENSSHADE, str);
2997 native_set_parms(MM_CAMERA_PARM_ROLLOFF, sizeof(int8_t), (void *)&temp);
2998 return NO_ERROR;
2999 }
3000 }
3001 ALOGE("Invalid lensShade value: %s", (str == NULL) ? "NULL" : str);
3002 return BAD_VALUE;
3003 }
3004
setFaceDetect(const QCameraParameters & params)3005 status_t QCameraHardwareInterface::setFaceDetect(const QCameraParameters& params)
3006 {
3007 int requested_faces = params.getInt(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES);
3008 int hardware_supported_faces = mParameters.getInt(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW);
3009 if (requested_faces > hardware_supported_faces) {
3010 requested_faces = hardware_supported_faces;
3011 }
3012 mParameters.set(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES, requested_faces);
3013 const char *str = params.get(QCameraParameters::KEY_QC_FACE_DETECTION);
3014 ALOGE("setFaceDetect: %s", str);
3015 if (str != NULL) {
3016 fd_set_parm_t fd_set_parm;
3017 int value = attr_lookup(facedetection,
3018 sizeof(facedetection) / sizeof(str_map), str);
3019 mFaceDetectOn = value;
3020 fd_set_parm.fd_mode = value;
3021 fd_set_parm.num_fd = requested_faces;
3022 ALOGE("%s Face detection value = %d, num_fd = %d",__func__, value, requested_faces);
3023 native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm);
3024 mParameters.set(QCameraParameters::KEY_QC_FACE_DETECTION, str);
3025 return NO_ERROR;
3026 }
3027 ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str);
3028 return BAD_VALUE;
3029 }
setFaceDetection(const char * str)3030 status_t QCameraHardwareInterface::setFaceDetection(const char *str)
3031 {
3032 if(supportsFaceDetection() == false){
3033 ALOGE("Face detection is not enabled");
3034 return NO_ERROR;
3035 }
3036 if (str != NULL) {
3037 int requested_faces = mParameters.getInt(QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES);
3038 int value = attr_lookup(facedetection,
3039 sizeof(facedetection) / sizeof(str_map), str);
3040 if (value != NOT_FOUND) {
3041 fd_set_parm_t fd_set_parm;
3042 mFaceDetectOn = value;
3043 fd_set_parm.fd_mode = value;
3044 fd_set_parm.num_fd = requested_faces;
3045 ALOGE("%s Face detection value = %d, num_fd = %d",__func__, value, requested_faces);
3046 native_set_parms(MM_CAMERA_PARM_FD, sizeof(fd_set_parm_t), (void *)&fd_set_parm);
3047 mParameters.set(QCameraParameters::KEY_QC_FACE_DETECTION, str);
3048 return NO_ERROR;
3049 }
3050 }
3051 ALOGE("Invalid Face Detection value: %s", (str == NULL) ? "NULL" : str);
3052 return BAD_VALUE;
3053 }
3054
setAEBracket(const QCameraParameters & params)3055 status_t QCameraHardwareInterface::setAEBracket(const QCameraParameters& params)
3056 {
3057 uint8_t supported;
3058 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
3059 MM_CAMERA_PARM_HDR,&supported,&supported);
3060 if(!supported || (myMode & CAMERA_ZSL_MODE)) {
3061 ALOGI("Parameter HDR is not supported for this sensor/ ZSL mode");
3062
3063 if (myMode & CAMERA_ZSL_MODE) {
3064 ALOGE("In ZSL mode, reset AEBBracket to HDR_OFF mode");
3065 exp_bracketing_t temp;
3066 memset(&temp, 0, sizeof(temp));
3067 mHdrMode = HDR_BRACKETING_OFF;
3068 temp.hdr_enable= FALSE;
3069 temp.mode = HDR_BRACKETING_OFF;
3070 native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
3071 }
3072 return NO_ERROR;
3073 }
3074 const char *str = params.get(QCameraParameters::KEY_QC_AE_BRACKET_HDR);
3075
3076 if (str != NULL) {
3077 int value = attr_lookup(hdr_bracket,
3078 sizeof(hdr_bracket) / sizeof(str_map), str);
3079 exp_bracketing_t temp;
3080 memset(&temp, 0, sizeof(temp));
3081 switch (value) {
3082 case HDR_MODE:
3083 {
3084 mHdrMode = HDR_MODE;
3085 ALOGE("%s, mHdrMode == HDR_MODE", __func__);
3086 /* temp.hdr_enable= TRUE;
3087 temp.mode = HDR_MODE;
3088 temp.total_frames = 3;
3089 temp.total_hal_frames = getNumOfSnapshots();
3090 ALOGI("%s: setting HDR frames (%d)", __FUNCTION__, temp.total_hal_frames);
3091 native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp); */
3092 }
3093 break;
3094 case EXP_BRACKETING_MODE:
3095 {
3096 ALOGE("%s, mHdrMode == EXP_BRACKETING_MODE", __func__);
3097 int numFrames = getNumOfSnapshots();
3098 const char *str_val = params.get("capture-burst-exposures");
3099 if ((str_val != NULL) && (strlen(str_val)>0)) {
3100 ALOGI("%s: capture-burst-exposures %s", __FUNCTION__, str_val);
3101
3102 mHdrMode = EXP_BRACKETING_MODE;
3103 temp.hdr_enable = FALSE;
3104 temp.mode = EXP_BRACKETING_MODE;
3105 temp.total_frames = (numFrames > MAX_SNAPSHOT_BUFFERS -2) ? MAX_SNAPSHOT_BUFFERS -2 : numFrames;
3106 temp.total_hal_frames = temp.total_frames;
3107 strlcpy(temp.values, str_val, MAX_EXP_BRACKETING_LENGTH);
3108 ALOGI("%s: setting Exposure Bracketing value of %s, frame (%d)", __FUNCTION__, temp.values, temp.total_hal_frames);
3109 native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
3110 }
3111 else {
3112 /* Apps not set capture-burst-exposures, error case fall into bracketing off mode */
3113 ALOGI("%s: capture-burst-exposures not set, back to HDR OFF mode", __FUNCTION__);
3114 mHdrMode = HDR_BRACKETING_OFF;
3115 temp.hdr_enable= FALSE;
3116 temp.mode = HDR_BRACKETING_OFF;
3117 native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
3118 }
3119 }
3120 break;
3121 case HDR_BRACKETING_OFF:
3122 ALOGE("%s, mHdrMode == HDR_BRACKETING_OFF", __func__);
3123 default:
3124 {
3125 ALOGE("%s, mHdrMode == HDR_BRACKETING_OFF", __func__);
3126 mHdrMode = HDR_BRACKETING_OFF;
3127 temp.hdr_enable= FALSE;
3128 temp.mode = HDR_BRACKETING_OFF;
3129 native_set_parms(MM_CAMERA_PARM_HDR, sizeof(exp_bracketing_t), (void *)&temp);
3130 }
3131 break;
3132 }
3133
3134 /* save the value*/
3135 mParameters.set(QCameraParameters::KEY_QC_AE_BRACKET_HDR, str);
3136 }
3137 return NO_ERROR;
3138 }
3139
setCaptureBurstExp()3140 status_t QCameraHardwareInterface::setCaptureBurstExp()
3141 {
3142 char burst_exp[PROPERTY_VALUE_MAX];
3143 memset(burst_exp, 0, sizeof(burst_exp));
3144 property_get("persist.capture.burst.exposures", burst_exp, "");
3145 if (NULL != burst_exp)
3146 mParameters.set("capture-burst-exposures", burst_exp);
3147 return NO_ERROR;
3148 }
3149
setRedeyeReduction(const QCameraParameters & params)3150 status_t QCameraHardwareInterface::setRedeyeReduction(const QCameraParameters& params)
3151 {
3152 if(supportsRedEyeReduction() == false) {
3153 ALOGE("Parameter Redeye Reduction is not supported for this sensor");
3154 return NO_ERROR;
3155 }
3156
3157 const char *str = params.get(QCameraParameters::KEY_QC_REDEYE_REDUCTION);
3158 if (str != NULL) {
3159 int value = attr_lookup(redeye_reduction, sizeof(redeye_reduction) / sizeof(str_map), str);
3160 if (value != NOT_FOUND) {
3161 int8_t temp = (int8_t)value;
3162 ALOGI("%s: setting Redeye Reduction value of %s", __FUNCTION__, str);
3163 mParameters.set(QCameraParameters::KEY_QC_REDEYE_REDUCTION, str);
3164
3165 native_set_parms(MM_CAMERA_PARM_REDEYE_REDUCTION, sizeof(int8_t), (void *)&temp);
3166 return NO_ERROR;
3167 }
3168 }
3169 ALOGE("Invalid Redeye Reduction value: %s", (str == NULL) ? "NULL" : str);
3170 return BAD_VALUE;
3171 }
3172
setGpsLocation(const QCameraParameters & params)3173 status_t QCameraHardwareInterface::setGpsLocation(const QCameraParameters& params)
3174 {
3175 const char *method = params.get(QCameraParameters::KEY_GPS_PROCESSING_METHOD);
3176 if (method) {
3177 mParameters.set(QCameraParameters::KEY_GPS_PROCESSING_METHOD, method);
3178 }else {
3179 mParameters.remove(QCameraParameters::KEY_GPS_PROCESSING_METHOD);
3180 }
3181
3182 const char *latitude = params.get(QCameraParameters::KEY_GPS_LATITUDE);
3183 if (latitude) {
3184 ALOGE("latitude %s",latitude);
3185 mParameters.set(QCameraParameters::KEY_GPS_LATITUDE, latitude);
3186 }else {
3187 mParameters.remove(QCameraParameters::KEY_GPS_LATITUDE);
3188 }
3189
3190 const char *latitudeRef = params.get(QCameraParameters::KEY_QC_GPS_LATITUDE_REF);
3191 if (latitudeRef) {
3192 mParameters.set(QCameraParameters::KEY_QC_GPS_LATITUDE_REF, latitudeRef);
3193 }else {
3194 mParameters.remove(QCameraParameters::KEY_QC_GPS_LATITUDE_REF);
3195 }
3196
3197 const char *longitude = params.get(QCameraParameters::KEY_GPS_LONGITUDE);
3198 if (longitude) {
3199 mParameters.set(QCameraParameters::KEY_GPS_LONGITUDE, longitude);
3200 }else {
3201 mParameters.remove(QCameraParameters::KEY_GPS_LONGITUDE);
3202 }
3203
3204 const char *longitudeRef = params.get(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF);
3205 if (longitudeRef) {
3206 mParameters.set(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF, longitudeRef);
3207 }else {
3208 mParameters.remove(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF);
3209 }
3210
3211 const char *altitudeRef = params.get(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF);
3212 if (altitudeRef) {
3213 mParameters.set(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF, altitudeRef);
3214 }else {
3215 mParameters.remove(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF);
3216 }
3217
3218 const char *altitude = params.get(QCameraParameters::KEY_GPS_ALTITUDE);
3219 if (altitude) {
3220 mParameters.set(QCameraParameters::KEY_GPS_ALTITUDE, altitude);
3221 }else {
3222 mParameters.remove(QCameraParameters::KEY_GPS_ALTITUDE);
3223 }
3224
3225 const char *status = params.get(QCameraParameters::KEY_QC_GPS_STATUS);
3226 if (status) {
3227 mParameters.set(QCameraParameters::KEY_QC_GPS_STATUS, status);
3228 }
3229
3230 const char *dateTime = params.get(QCameraParameters::KEY_QC_EXIF_DATETIME);
3231 if (dateTime) {
3232 mParameters.set(QCameraParameters::KEY_QC_EXIF_DATETIME, dateTime);
3233 }else {
3234 mParameters.remove(QCameraParameters::KEY_QC_EXIF_DATETIME);
3235 }
3236
3237 const char *timestamp = params.get(QCameraParameters::KEY_GPS_TIMESTAMP);
3238 if (timestamp) {
3239 mParameters.set(QCameraParameters::KEY_GPS_TIMESTAMP, timestamp);
3240 }else {
3241 mParameters.remove(QCameraParameters::KEY_GPS_TIMESTAMP);
3242 }
3243 ALOGE("setGpsLocation X");
3244 return NO_ERROR;
3245 }
3246
setRotation(const QCameraParameters & params)3247 status_t QCameraHardwareInterface::setRotation(const QCameraParameters& params)
3248 {
3249 status_t rc = NO_ERROR;
3250 int rotation = params.getInt(QCameraParameters::KEY_ROTATION);
3251 if (rotation != NOT_FOUND) {
3252 if (rotation == 0 || rotation == 90 || rotation == 180
3253 || rotation == 270) {
3254 mParameters.set(QCameraParameters::KEY_ROTATION, rotation);
3255 mRotation = rotation;
3256 } else {
3257 ALOGE("Invalid rotation value: %d", rotation);
3258 rc = BAD_VALUE;
3259 }
3260 }
3261 ALOGE("setRotation");
3262 return rc;
3263 }
3264
setDenoise(const QCameraParameters & params)3265 status_t QCameraHardwareInterface::setDenoise(const QCameraParameters& params)
3266 {
3267 return BAD_VALUE;
3268 }
3269
setOrientation(const QCameraParameters & params)3270 status_t QCameraHardwareInterface::setOrientation(const QCameraParameters& params)
3271 {
3272 const char *str = params.get("orientation");
3273
3274 if (str != NULL) {
3275 if (strcmp(str, "portrait") == 0 || strcmp(str, "landscape") == 0) {
3276 // Camera service needs this to decide if the preview frames and raw
3277 // pictures should be rotated.
3278 mParameters.set("orientation", str);
3279 } else {
3280 ALOGE("Invalid orientation value: %s", str);
3281 return BAD_VALUE;
3282 }
3283 }
3284 return NO_ERROR;
3285 }
3286
setPictureFormat(const QCameraParameters & params)3287 status_t QCameraHardwareInterface::setPictureFormat(const QCameraParameters& params)
3288 {
3289 const char * str = params.get(QCameraParameters::KEY_PICTURE_FORMAT);
3290 if(str != NULL){
3291 int32_t value = attr_lookup(picture_formats,
3292 sizeof(picture_formats) / sizeof(str_map), str);
3293 if(value != NOT_FOUND){
3294 if (isZSLMode() && !strcmp(str, "raw")) {
3295 mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT, "jpeg");
3296 } else {
3297 mParameters.set(QCameraParameters::KEY_PICTURE_FORMAT, str);
3298 }
3299 } else {
3300 ALOGE("Invalid Picture Format value: %s", str);
3301 return BAD_VALUE;
3302 }
3303 }
3304 return NO_ERROR;
3305 }
3306
setRecordingHintValue(const int32_t value)3307 status_t QCameraHardwareInterface::setRecordingHintValue(const int32_t value)
3308 {
3309 native_set_parms(MM_CAMERA_PARM_RECORDING_HINT, sizeof(value),
3310 (void *)&value);
3311 if (value == TRUE){
3312 native_set_parms(MM_CAMERA_PARM_CAF_ENABLE, sizeof(value),
3313 (void *)&value);
3314 }
3315 setDISMode();
3316 setFullLiveshot();
3317 return NO_ERROR;
3318 }
3319
setRecordingHint(const QCameraParameters & params)3320 status_t QCameraHardwareInterface::setRecordingHint(const QCameraParameters& params)
3321 {
3322
3323 const char * str = params.get(QCameraParameters::KEY_RECORDING_HINT);
3324
3325 if(str != NULL){
3326 int32_t value = attr_lookup(recording_Hints,
3327 sizeof(recording_Hints) / sizeof(str_map), str);
3328 if(value != NOT_FOUND){
3329 mRecordingHint = value;
3330 setRecordingHintValue(mRecordingHint);
3331 mParameters.set(QCameraParameters::KEY_RECORDING_HINT, str);
3332 return NO_ERROR;
3333 } else {
3334 ALOGE("Invalid Picture Format value: %s", str);
3335 setDISMode();
3336 setFullLiveshot();
3337 return BAD_VALUE;
3338 }
3339 }
3340 setDISMode();
3341 setFullLiveshot();
3342 return NO_ERROR;
3343 }
3344
setDISMode()3345 status_t QCameraHardwareInterface::setDISMode() {
3346 /* Enable DIS only if
3347 * - Camcorder mode AND
3348 * - DIS property is set AND
3349 * - Not in Low power mode. */
3350 uint32_t value = mRecordingHint && mDisEnabled
3351 && !isLowPowerCamcorder();
3352
3353 ALOGI("%s DIS is %s value = %d", __func__,
3354 value ? "Enabled" : "Disabled", value);
3355 native_set_parms(MM_CAMERA_PARM_DIS_ENABLE, sizeof(value),
3356 (void *)&value);
3357 return NO_ERROR;
3358 }
3359
setFullLiveshot()3360 status_t QCameraHardwareInterface::setFullLiveshot()
3361 {
3362 /* Enable full size liveshot only if
3363 * - Camcorder mode AND
3364 * - Full size liveshot is enabled. */
3365 uint32_t value = mRecordingHint && mFullLiveshotEnabled
3366 && !isLowPowerCamcorder();
3367
3368 if (((mDimension.picture_width == mDimension.video_width) &&
3369 (mDimension.picture_height == mDimension.video_height))) {
3370 /* If video size matches the live snapshot size
3371 * turn off full size liveshot to get higher fps. */
3372 value = 0;
3373 }
3374
3375 ALOGI("%s Full size liveshot %s value = %d", __func__,
3376 value ? "Enabled" : "Disabled", value);
3377 native_set_parms(MM_CAMERA_PARM_FULL_LIVESHOT, sizeof(value),
3378 (void *)&value);
3379 return NO_ERROR;
3380 }
3381
setMobiCat(const QCameraParameters & params)3382 status_t QCameraHardwareInterface::setMobiCat(const QCameraParameters& params)
3383 {
3384 mm_cam_mobicat_info_t mbc_info;
3385 char mbc_prop[PROPERTY_VALUE_MAX];
3386 int propval;
3387 memset(mbc_prop, 0, sizeof(mbc_prop));
3388 property_get("persist.camera.mobicat", mbc_prop, "0");
3389 propval = atoi(mbc_prop);
3390 mbc_info.enable = (mParameters.getInt("mobicat") == 1) ? 1 : 0;
3391 ALOGV("%s:%d] prop %d %d", __func__, __LINE__, mbc_info.enable, propval);
3392 mbc_info.enable |= propval;
3393
3394 if (mbc_info.enable != mMobiCatEnabled) {
3395 ALOGV("%s:%d] enable %d", __func__, __LINE__, mbc_info.enable);
3396 native_set_parms(MM_CAMERA_PARM_MOBICAT, sizeof(mm_cam_mobicat_info_t),
3397 (void *)&mbc_info);
3398 mMobiCatEnabled = mbc_info.enable;
3399 }
3400 return NO_ERROR;
3401 }
3402
3403
getAutoFocusMode(const QCameraParameters & params)3404 isp3a_af_mode_t QCameraHardwareInterface::getAutoFocusMode(
3405 const QCameraParameters& params)
3406 {
3407 isp3a_af_mode_t afMode = AF_MODE_MAX;
3408 afMode = (isp3a_af_mode_t)mFocusMode;
3409 return afMode;
3410 }
3411
getPictureSize(int * picture_width,int * picture_height) const3412 void QCameraHardwareInterface::getPictureSize(int *picture_width,
3413 int *picture_height) const
3414 {
3415 mParameters.getPictureSize(picture_width, picture_height);
3416 }
3417
getPreviewSize(int * preview_width,int * preview_height) const3418 void QCameraHardwareInterface::getPreviewSize(int *preview_width,
3419 int *preview_height) const
3420 {
3421 mParameters.getPreviewSize(preview_width, preview_height);
3422 }
3423
getVideoSize(int * video_width,int * video_height) const3424 void QCameraHardwareInterface::getVideoSize(int *video_width,
3425 int *video_height) const
3426 {
3427 mParameters.getVideoSize(video_width, video_height);
3428 }
3429
getThumbnailSize(int * thumb_width,int * thumb_height) const3430 void QCameraHardwareInterface::getThumbnailSize(int *thumb_width,
3431 int *thumb_height) const
3432 {
3433 *thumb_width = mParameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
3434 *thumb_height = mParameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
3435 }
3436
getPreviewFormat() const3437 cam_format_t QCameraHardwareInterface::getPreviewFormat() const
3438 {
3439 cam_format_t foramt = CAMERA_YUV_420_NV21;
3440 const char *str = mParameters.getPreviewFormat();
3441 int32_t value = attr_lookup(preview_formats,
3442 sizeof(preview_formats)/sizeof(str_map),
3443 str);
3444
3445 if(value != NOT_FOUND) {
3446 int num = sizeof(preview_format_info_list)/sizeof(preview_format_info_t);
3447 int i;
3448 for (i = 0; i < num; i++) {
3449 if (preview_format_info_list[i].Hal_format == value) {
3450 foramt = preview_format_info_list[i].mm_cam_format;
3451 break;
3452 }
3453 }
3454 }
3455
3456 return foramt;
3457 }
3458
getPreviewPadding() const3459 cam_pad_format_t QCameraHardwareInterface::getPreviewPadding() const
3460 {
3461 return mPreviewFormatInfo.padding;
3462 }
3463
getJpegQuality() const3464 int QCameraHardwareInterface::getJpegQuality() const
3465 {
3466 return mJpegQuality;
3467 }
3468
getNumOfSnapshots(void) const3469 int QCameraHardwareInterface::getNumOfSnapshots(void) const
3470 {
3471 char prop[PROPERTY_VALUE_MAX];
3472 memset(prop, 0, sizeof(prop));
3473 property_get("persist.camera.snapshot.number", prop, "0");
3474 ALOGI("%s: prop enable/disable = %d", __func__, atoi(prop));
3475 if (atoi(prop)) {
3476 ALOGE("%s: Reading maximum no of snapshots = %d"
3477 "from properties", __func__, atoi(prop));
3478 return atoi(prop);
3479 } else {
3480 return mParameters.getInt("num-snaps-per-shutter");
3481 }
3482 }
3483
getNumOfSnapshots(const QCameraParameters & params)3484 int QCameraHardwareInterface::getNumOfSnapshots(const QCameraParameters& params)
3485 {
3486 char prop[PROPERTY_VALUE_MAX];
3487 memset(prop, 0, sizeof(prop));
3488 property_get("persist.camera.snapshot.number", prop, "0");
3489 ALOGI("%s: prop enable/disable = %d", __func__, atoi(prop));
3490 if (atoi(prop)) {
3491 ALOGI("%s: Reading maximum no of snapshots = %d"
3492 "from properties", __func__, atoi(prop));
3493 return atoi(prop);
3494 } else {
3495 return params.getInt("num-snaps-per-shutter");
3496 }
3497
3498 }
3499
3500 int QCameraHardwareInterface::
getThumbSizesFromAspectRatio(uint32_t aspect_ratio,int * picture_width,int * picture_height)3501 getThumbSizesFromAspectRatio(uint32_t aspect_ratio,
3502 int *picture_width,
3503 int *picture_height)
3504 {
3505 for(unsigned int i = 0; i < THUMBNAIL_SIZE_COUNT; i++ ){
3506 if(thumbnail_sizes[i].aspect_ratio == aspect_ratio)
3507 {
3508 *picture_width = thumbnail_sizes[i].width;
3509 *picture_height = thumbnail_sizes[i].height;
3510 return NO_ERROR;
3511 }
3512 }
3513
3514 return BAD_VALUE;
3515 }
3516
isRawSnapshot()3517 bool QCameraHardwareInterface::isRawSnapshot()
3518 {
3519 const char *format = mParameters.getPictureFormat();
3520 if( format!= NULL &&
3521 !strcmp(format, QCameraParameters::PIXEL_FORMAT_RAW)){
3522 return true;
3523 }
3524 else{
3525 return false;
3526 }
3527 }
3528
setPreviewSizeTable(void)3529 status_t QCameraHardwareInterface::setPreviewSizeTable(void)
3530 {
3531 status_t ret = NO_ERROR;
3532 mm_camera_dimension_t dim;
3533 struct camera_size_type* preview_size_table;
3534 int preview_table_size;
3535 int i = 0;
3536 char str[10] = {0};
3537
3538 /* Initialize table with default values */
3539 preview_size_table = default_preview_sizes;
3540 preview_table_size = preview_sizes_count;
3541
3542
3543 /* Get maximum preview size supported by sensor*/
3544 memset(&dim, 0, sizeof(mm_camera_dimension_t));
3545 ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
3546 MM_CAMERA_PARM_MAX_PREVIEW_SIZE, &dim);
3547 if (ret != NO_ERROR) {
3548 ALOGE("%s: Failure getting Max Preview Size supported by camera",
3549 __func__);
3550 goto end;
3551 }
3552
3553 ALOGD("%s: Max Preview Sizes Supported: %d X %d", __func__,
3554 dim.width, dim.height);
3555
3556 for (i = 0; i < preview_table_size; i++) {
3557 if ((preview_size_table->width <= dim.width) &&
3558 (preview_size_table->height <= dim.height)) {
3559 ALOGD("%s: Camera Preview Size Table "
3560 "Max width: %d height %d table_size: %d",
3561 __func__, preview_size_table->width,
3562 preview_size_table->height, preview_table_size - i);
3563 break;
3564 }
3565 preview_size_table++;
3566 }
3567 //set preferred preview size to maximum preview size
3568 sprintf(str, "%dx%d", preview_size_table->width, preview_size_table->height);
3569 mParameters.set(QCameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, str);
3570 ALOGD("KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO = %s", str);
3571
3572 end:
3573 /* Save the table in global member*/
3574 mPreviewSizes = preview_size_table;
3575 mPreviewSizeCount = preview_table_size - i;
3576
3577 return ret;
3578 }
3579
setPictureSizeTable(void)3580 status_t QCameraHardwareInterface::setPictureSizeTable(void)
3581 {
3582 status_t ret = NO_ERROR;
3583 mm_camera_dimension_t dim;
3584 struct camera_size_type* picture_size_table;
3585 int picture_table_size;
3586 int i = 0, count = 0;
3587
3588 /* Initialize table with default values */
3589 picture_table_size = sizeof(default_picture_sizes)/
3590 sizeof(default_picture_sizes[0]);
3591 picture_size_table = default_picture_sizes;
3592 mPictureSizes =
3593 ( struct camera_size_type *)malloc(picture_table_size *
3594 sizeof(struct camera_size_type));
3595 if (mPictureSizes == NULL) {
3596 ALOGE("%s: Failre allocating memory to store picture size table",__func__);
3597 goto end;
3598 }
3599
3600 /* Get maximum picture size supported by sensor*/
3601 memset(&dim, 0, sizeof(mm_camera_dimension_t));
3602 ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
3603 MM_CAMERA_PARM_MAX_PICTURE_SIZE, &dim);
3604 if (ret != NO_ERROR) {
3605 ALOGE("%s: Failure getting Max Picture Size supported by camera",
3606 __func__);
3607 ret = NO_MEMORY;
3608 free(mPictureSizes);
3609 mPictureSizes = NULL;
3610 goto end;
3611 }
3612
3613 ALOGD("%s: Max Picture Sizes Supported: %d X %d", __func__,
3614 dim.width, dim.height);
3615
3616 for (i = 0; i < picture_table_size; i++) {
3617 /* We'll store those dimensions whose width AND height
3618 are less than or equal to maximum supported */
3619 if ((picture_size_table->width <= dim.width) &&
3620 (picture_size_table->height <= dim.height)) {
3621 ALOGD("%s: Camera Picture Size Table "
3622 "Max width: %d height %d table_size: %d",
3623 __func__, picture_size_table->width,
3624 picture_size_table->height, count+1);
3625 mPictureSizes[count].height = picture_size_table->height;
3626 mPictureSizes[count].width = picture_size_table->width;
3627 count++;
3628 }
3629 picture_size_table++;
3630 }
3631 mPictureSizeCount = count;
3632
3633 end:
3634 /* In case of error, we use default picture sizes */
3635 if (ret != NO_ERROR) {
3636 mPictureSizes = default_picture_sizes;
3637 mPictureSizeCount = picture_table_size;
3638 }
3639 return ret;
3640 }
3641
setVideoSizeTable(void)3642 status_t QCameraHardwareInterface::setVideoSizeTable(void)
3643 {
3644 status_t ret = NO_ERROR;
3645 mm_camera_dimension_t dim;
3646 struct camera_size_type* video_size_table;
3647 int video_table_size;
3648 int i = 0, count = 0;
3649 ALOGE("%s: E", __func__);
3650
3651 /* Initialize table with default values */
3652 video_table_size = video_sizes_count;
3653 video_size_table = default_video_sizes;
3654 mVideoSizes =
3655 (struct camera_size_type *)malloc(video_table_size *
3656 sizeof(struct camera_size_type));
3657 if(mVideoSizes == NULL) {
3658 ALOGE("%s: error allocating memory to store video size table",__func__);
3659 ret = BAD_VALUE;
3660 goto end;
3661 }
3662
3663 /* Get maximum video size supported by sensor*/
3664 memset(&dim, 0, sizeof(mm_camera_dimension_t));
3665 ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle,
3666 MM_CAMERA_PARM_MAX_VIDEO_SIZE, &dim);
3667 if(ret != NO_ERROR) {
3668 ALOGE("%s: error getting Max Video Size supported by camera",
3669 __func__);
3670 ret = NO_MEMORY;
3671 free(mVideoSizes);
3672 mVideoSizes = NULL;
3673 ret = BAD_VALUE;
3674 goto end;
3675 }
3676
3677 ALOGD("%s: Max Video Size Supported: %d X %d", __func__,
3678 dim.width, dim.height);
3679
3680 for(i=0; i < video_table_size; i++) {
3681 /* We'll store those dimensions whose width AND height
3682 are less than or equal to maximum supported */
3683 if((video_size_table->width <= dim.width) &&
3684 (video_size_table->height <= dim.height)) {
3685 ALOGD("%s: Supported Video Size [%d] = %dx%d", __func__, count, video_size_table->width,
3686 video_size_table->height);
3687 mVideoSizes[count].height = video_size_table->height;
3688 mVideoSizes[count].width = video_size_table->width;
3689 count++;
3690 }
3691 video_size_table++;
3692 }
3693 mVideoSizeCount = count;
3694
3695 end:
3696 ALOGE("%s: X", __func__);
3697 return ret;
3698 }
3699
freeVideoSizeTable(void)3700 void QCameraHardwareInterface::freeVideoSizeTable(void)
3701 {
3702 if(mVideoSizes != NULL)
3703 {
3704 free(mVideoSizes);
3705 }
3706 mVideoSizeCount = 0;
3707 }
3708
3709
freePictureTable(void)3710 void QCameraHardwareInterface::freePictureTable(void)
3711 {
3712 /* If we couldn't allocate memory to store picture table
3713 we use the picture table pointer to point to default
3714 picture table array. In that case we cannot free it.*/
3715 if ((mPictureSizes != default_picture_sizes) && mPictureSizes) {
3716 free(mPictureSizes);
3717 }
3718 }
3719
setHistogram(int histogram_en)3720 status_t QCameraHardwareInterface::setHistogram(int histogram_en)
3721 {
3722 status_t ret = NO_ERROR;
3723
3724 ALOGV("setHistogram: E");
3725 if(mStatsOn == histogram_en) {
3726 return ret;
3727 }
3728
3729 status_t rc = NO_ERROR;
3730 mCameraHandle->ops->is_parm_supported(mCameraHandle->camera_handle,
3731 MM_CAMERA_PARM_HISTOGRAM,
3732 (uint8_t*)&rc,(uint8_t*)&rc);
3733 if(!rc) {
3734 ALOGE(" Histogram is not supported for this");
3735 return NO_ERROR;
3736 }
3737 mSendData = histogram_en;
3738 mStatsOn = histogram_en;
3739
3740 if (histogram_en == QCAMERA_PARM_ENABLE) {
3741 ret = initHistogramBuffers();
3742 if (ret != NO_ERROR) {
3743 ALOGE("%s Error initializing Histogram buffers ", __func__);
3744 return ret;
3745 }
3746 }
3747 ALOGI(" Histogram -> %s", histogram_en ? "Enabled" : "Disabled");
3748 native_set_parms(MM_CAMERA_PARM_HISTOGRAM, sizeof(int), &histogram_en);
3749 if(histogram_en == QCAMERA_PARM_DISABLE) {
3750 ret = deInitHistogramBuffers();
3751 if (ret != NO_ERROR) {
3752 ALOGE("%s Error deInitializing Histogram buffers ", __func__);
3753 return ret;
3754 }
3755 }
3756 ALOGV("setHistogram: X");
3757 return ret;
3758 }
3759
setZSLBurstLookBack(const QCameraParameters & params)3760 status_t QCameraHardwareInterface::setZSLBurstLookBack(const QCameraParameters& params)
3761 {
3762 const char *v = params.get("capture-burst-retroactive");
3763 if (v) {
3764 int look_back = atoi(v);
3765 ALOGI("%s: look_back =%d", __func__, look_back);
3766 mParameters.set("capture-burst-retroactive", look_back);
3767 }
3768 return NO_ERROR;
3769 }
3770
setZSLBurstInterval(const QCameraParameters & params)3771 status_t QCameraHardwareInterface::setZSLBurstInterval(const QCameraParameters& params)
3772 {
3773 mZslInterval = BURST_INTREVAL_DEFAULT;
3774 const char *v = params.get("capture-burst-interval");
3775 if (v) {
3776 int interval = atoi(v);
3777 ALOGI("%s: Interval =%d", __func__, interval);
3778 if(interval < BURST_INTREVAL_MIN ||interval > BURST_INTREVAL_MAX ) {
3779 return BAD_VALUE;
3780 }
3781 mZslInterval = interval;
3782 }
3783 return NO_ERROR;
3784 }
3785
getZSLBurstInterval(void)3786 int QCameraHardwareInterface::getZSLBurstInterval( void )
3787 {
3788 int val;
3789
3790 if (mZslInterval == BURST_INTREVAL_DEFAULT) {
3791 char prop[PROPERTY_VALUE_MAX];
3792 memset(prop, 0, sizeof(prop));
3793 property_get("persist.camera.zsl.interval", prop, "1");
3794 val = atoi(prop);
3795 ALOGD("%s: prop interval = %d", __func__, val);
3796 } else {
3797 val = mZslInterval;
3798 }
3799 return val;
3800 }
3801
3802
getZSLQueueDepth(void) const3803 int QCameraHardwareInterface::getZSLQueueDepth(void) const
3804 {
3805 char prop[PROPERTY_VALUE_MAX];
3806 memset(prop, 0, sizeof(prop));
3807 property_get("persist.camera.zsl.queuedepth", prop, "2");
3808 ALOGI("%s: prop = %d", __func__, atoi(prop));
3809 return atoi(prop);
3810 }
3811
getZSLBackLookCount(void) const3812 int QCameraHardwareInterface::getZSLBackLookCount(void) const
3813 {
3814 int look_back;
3815 char prop[PROPERTY_VALUE_MAX];
3816 memset(prop, 0, sizeof(prop));
3817 property_get("persist.camera.zsl.backlookcnt", prop, "0");
3818 ALOGI("%s: prop = %d", __func__, atoi(prop));
3819 look_back = atoi(prop);
3820 if (look_back == 0 ) {
3821 look_back = mParameters.getInt("capture-burst-retroactive");
3822 ALOGE("%s: look_back = %d", __func__, look_back);
3823 }
3824 return look_back;
3825 }
3826
3827 //EXIF functions
deinitExifData()3828 void QCameraHardwareInterface::deinitExifData()
3829 {
3830 ALOGD("Clearing EXIF data");
3831 memset(mExifData, 0, sizeof(exif_tags_info_t) * MAX_EXIF_TABLE_ENTRIES);
3832 mExifTableNumEntries = 0;
3833 }
3834
addExifTag(exif_tag_id_t tagid,exif_tag_type_t type,uint32_t count,uint8_t copy,void * data)3835 void QCameraHardwareInterface::addExifTag(exif_tag_id_t tagid, exif_tag_type_t type,
3836 uint32_t count, uint8_t copy, void *data) {
3837
3838 if(mExifTableNumEntries >= MAX_EXIF_TABLE_ENTRIES) {
3839 ALOGE("%s: Number of entries exceeded limit", __func__);
3840 return;
3841 }
3842 int index = mExifTableNumEntries;
3843 mExifData[index].tag_id = tagid;
3844 mExifData[index].tag_entry.type = type;
3845 mExifData[index].tag_entry.count = count;
3846 mExifData[index].tag_entry.copy = copy;
3847 if((type == EXIF_RATIONAL) && (count > 1))
3848 mExifData[index].tag_entry.data._rats = (rat_t *)data;
3849 if((type == EXIF_RATIONAL) && (count == 1))
3850 mExifData[index].tag_entry.data._rat = *(rat_t *)data;
3851 else if(type == EXIF_ASCII)
3852 mExifData[index].tag_entry.data._ascii = (char *)data;
3853 else if(type == EXIF_BYTE)
3854 mExifData[index].tag_entry.data._byte = *(uint8_t *)data;
3855 else if((type == EXIF_SHORT) && (count > 1))
3856 mExifData[index].tag_entry.data._shorts = (uint16_t *)data;
3857 else if((type == EXIF_SHORT) && (count == 1))
3858 mExifData[index].tag_entry.data._short = *(uint16_t *)data;
3859 // Increase number of entries
3860 mExifTableNumEntries++;
3861 }
3862
getRational(int num,int denom)3863 rat_t getRational(int num, int denom)
3864 {
3865 rat_t temp = {num, denom};
3866 return temp;
3867 }
3868
initExifData()3869 void QCameraHardwareInterface::initExifData(){
3870 if(mExifValues.dateTime) {
3871 addExifTag(EXIFTAGID_EXIF_DATE_TIME_ORIGINAL, EXIF_ASCII,
3872 20, 1, (void *)mExifValues.dateTime);
3873 }
3874 addExifTag(EXIFTAGID_FOCAL_LENGTH, EXIF_RATIONAL, 1, 1, (void *)&(mExifValues.focalLength));
3875 addExifTag(EXIFTAGID_ISO_SPEED_RATING,EXIF_SHORT,1,1,(void *)&(mExifValues.isoSpeed));
3876
3877 if(mExifValues.mGpsProcess) {
3878 addExifTag(EXIFTAGID_GPS_PROCESSINGMETHOD, EXIF_ASCII,
3879 EXIF_ASCII_PREFIX_SIZE + strlen(mExifValues.gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE) + 1,
3880 1, (void *)mExifValues.gpsProcessingMethod);
3881 }
3882
3883 if(mExifValues.mLatitude) {
3884 addExifTag(EXIFTAGID_GPS_LATITUDE, EXIF_RATIONAL, 3, 1, (void *)mExifValues.latitude);
3885
3886 if(mExifValues.latRef) {
3887 addExifTag(EXIFTAGID_GPS_LATITUDE_REF, EXIF_ASCII, 2,
3888 1, (void *)mExifValues.latRef);
3889 }
3890 }
3891
3892 if(mExifValues.mLongitude) {
3893 addExifTag(EXIFTAGID_GPS_LONGITUDE, EXIF_RATIONAL, 3, 1, (void *)mExifValues.longitude);
3894
3895 if(mExifValues.lonRef) {
3896 addExifTag(EXIFTAGID_GPS_LONGITUDE_REF, EXIF_ASCII, 2,
3897 1, (void *)mExifValues.lonRef);
3898 }
3899 }
3900
3901 if(mExifValues.mAltitude) {
3902 addExifTag(EXIFTAGID_GPS_ALTITUDE, EXIF_RATIONAL, 1,
3903 1, (void *)&(mExifValues.altitude));
3904
3905 addExifTag(EXIFTAGID_GPS_ALTITUDE_REF, EXIF_BYTE, 1, 1, (void *)&mExifValues.mAltitude_ref);
3906 }
3907
3908 if(mExifValues.mTimeStamp) {
3909 time_t unixTime;
3910 struct tm *UTCTimestamp;
3911
3912 unixTime = (time_t)mExifValues.mGPSTimestamp;
3913 UTCTimestamp = gmtime(&unixTime);
3914
3915 strftime(mExifValues.gpsDateStamp, sizeof(mExifValues.gpsDateStamp), "%Y:%m:%d", UTCTimestamp);
3916 addExifTag(EXIFTAGID_GPS_DATESTAMP, EXIF_ASCII,
3917 strlen(mExifValues.gpsDateStamp)+1 , 1, (void *)mExifValues.gpsDateStamp);
3918
3919 mExifValues.gpsTimeStamp[0] = getRational(UTCTimestamp->tm_hour, 1);
3920 mExifValues.gpsTimeStamp[1] = getRational(UTCTimestamp->tm_min, 1);
3921 mExifValues.gpsTimeStamp[2] = getRational(UTCTimestamp->tm_sec, 1);
3922
3923 addExifTag(EXIFTAGID_GPS_TIMESTAMP, EXIF_RATIONAL,
3924 3, 1, (void *)mExifValues.gpsTimeStamp);
3925 ALOGE("EXIFTAGID_GPS_TIMESTAMP set");
3926 }
3927
3928 }
3929
3930 //Add all exif tags in this function
setExifTags()3931 void QCameraHardwareInterface::setExifTags()
3932 {
3933 const char *str;
3934
3935 //set TimeStamp
3936 str = mParameters.get(QCameraParameters::KEY_QC_EXIF_DATETIME);
3937 if(str != NULL) {
3938 strncpy(mExifValues.dateTime, str, 19);
3939 mExifValues.dateTime[19] = '\0';
3940 }
3941
3942 //Set focal length
3943 int focalLengthValue = (int) (mParameters.getFloat(
3944 QCameraParameters::KEY_FOCAL_LENGTH) * FOCAL_LENGTH_DECIMAL_PRECISION);
3945
3946 mExifValues.focalLength = getRational(focalLengthValue, FOCAL_LENGTH_DECIMAL_PRECISION);
3947
3948 //Set ISO Speed
3949 mExifValues.isoSpeed = getISOSpeedValue();
3950
3951 //get time and date from system
3952 time_t rawtime;
3953 struct tm * timeinfo;
3954 time(&rawtime);
3955 timeinfo = localtime (&rawtime);
3956 //Write datetime according to EXIF Spec
3957 //"YYYY:MM:DD HH:MM:SS" (20 chars including \0)
3958 snprintf(mExifValues.dateTime, 20, "%04d:%02d:%02d %02d:%02d:%02d",
3959 timeinfo->tm_year + 1900, timeinfo->tm_mon + 1,
3960 timeinfo->tm_mday, timeinfo->tm_hour,
3961 timeinfo->tm_min, timeinfo->tm_sec);
3962
3963 //set gps tags
3964 setExifTagsGPS();
3965 }
3966
setExifTagsGPS()3967 void QCameraHardwareInterface::setExifTagsGPS()
3968 {
3969 const char *str = NULL;
3970
3971 //Set GPS processing method
3972 str = mParameters.get(QCameraParameters::KEY_GPS_PROCESSING_METHOD);
3973 if(str != NULL) {
3974 memcpy(mExifValues.gpsProcessingMethod, ExifAsciiPrefix, EXIF_ASCII_PREFIX_SIZE);
3975 strncpy(mExifValues.gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE, str,
3976 GPS_PROCESSING_METHOD_SIZE - 1);
3977 mExifValues.gpsProcessingMethod[EXIF_ASCII_PREFIX_SIZE + GPS_PROCESSING_METHOD_SIZE-1] = '\0';
3978 ALOGE("EXIFTAGID_GPS_PROCESSINGMETHOD = %s %s", mExifValues.gpsProcessingMethod,
3979 mExifValues.gpsProcessingMethod+8);
3980 mExifValues.mGpsProcess = true;
3981 }else{
3982 mExifValues.mGpsProcess = false;
3983 }
3984 str = NULL;
3985
3986 //Set Latitude
3987 str = mParameters.get(QCameraParameters::KEY_GPS_LATITUDE);
3988 if(str != NULL) {
3989 parseGPSCoordinate(str, mExifValues.latitude);
3990 ALOGE("EXIFTAGID_GPS_LATITUDE = %s", str);
3991
3992 //set Latitude Ref
3993 float latitudeValue = mParameters.getFloat(QCameraParameters::KEY_GPS_LATITUDE);
3994 if(latitudeValue < 0.0f) {
3995 mExifValues.latRef[0] = 'S';
3996 } else {
3997 mExifValues.latRef[0] = 'N';
3998 }
3999 mExifValues.latRef[1] = '\0';
4000 mExifValues.mLatitude = true;
4001 mParameters.set(QCameraParameters::KEY_QC_GPS_LATITUDE_REF,mExifValues.latRef);
4002 ALOGE("EXIFTAGID_GPS_LATITUDE_REF = %s", mExifValues.latRef);
4003 }else{
4004 mExifValues.mLatitude = false;
4005 }
4006
4007 //set Longitude
4008 str = NULL;
4009 str = mParameters.get(QCameraParameters::KEY_GPS_LONGITUDE);
4010 if(str != NULL) {
4011 parseGPSCoordinate(str, mExifValues.longitude);
4012 ALOGE("EXIFTAGID_GPS_LONGITUDE = %s", str);
4013
4014 //set Longitude Ref
4015 float longitudeValue = mParameters.getFloat(QCameraParameters::KEY_GPS_LONGITUDE);
4016 if(longitudeValue < 0.0f) {
4017 mExifValues.lonRef[0] = 'W';
4018 } else {
4019 mExifValues.lonRef[0] = 'E';
4020 }
4021 mExifValues.lonRef[1] = '\0';
4022 mExifValues.mLongitude = true;
4023 ALOGE("EXIFTAGID_GPS_LONGITUDE_REF = %s", mExifValues.lonRef);
4024 mParameters.set(QCameraParameters::KEY_QC_GPS_LONGITUDE_REF, mExifValues.lonRef);
4025 }else{
4026 mExifValues.mLongitude = false;
4027 }
4028
4029 //set Altitude
4030 str = mParameters.get(QCameraParameters::KEY_GPS_ALTITUDE);
4031 if(str != NULL) {
4032 double value = atof(str);
4033 mExifValues.mAltitude_ref = 0;
4034 if(value < 0){
4035 mExifValues.mAltitude_ref = 1;
4036 value = -value;
4037 }
4038 mExifValues.altitude = getRational(value*1000, 1000);
4039 mExifValues.mAltitude = true;
4040 //set AltitudeRef
4041 mParameters.set(QCameraParameters::KEY_QC_GPS_ALTITUDE_REF, mExifValues.mAltitude_ref);
4042 ALOGE("EXIFTAGID_GPS_ALTITUDE = %f", value);
4043 }else{
4044 mExifValues.mAltitude = false;
4045 }
4046
4047 //set Gps TimeStamp
4048 str = NULL;
4049 str = mParameters.get(QCameraParameters::KEY_GPS_TIMESTAMP);
4050 if(str != NULL) {
4051 mExifValues.mTimeStamp = true;
4052 mExifValues.mGPSTimestamp = atol(str);
4053 }else{
4054 mExifValues.mTimeStamp = false;
4055 }
4056 }
4057
4058 //latlonString is string formatted coordinate
4059 //coord is rat_t[3]
parseGPSCoordinate(const char * latlonString,rat_t * coord)4060 void QCameraHardwareInterface::parseGPSCoordinate(const char *latlonString, rat_t* coord)
4061 {
4062 if(coord == NULL) {
4063 ALOGE("%s: error, invalid argument coord == NULL", __func__);
4064 return;
4065 }
4066 float degF = fabs(atof(latlonString));
4067 float minF = (degF- (int) degF) * 60;
4068 float secF = (minF - (int) minF) * 60;
4069
4070 coord[0] = getRational((int) degF, 1);
4071 coord[1] = getRational((int) minF, 1);
4072 coord[2] = getRational((int) (secF * 10000), 10000);
4073 }
4074
isLowPowerCamcorder()4075 bool QCameraHardwareInterface::isLowPowerCamcorder() {
4076
4077 if (mPowerMode == LOW_POWER)
4078 return true;
4079
4080 if(mHFRLevel > 1) /* hard code the value now. Need to move tgtcommon to camear.h */
4081 return true;
4082
4083 return false;
4084 }
4085
setNoDisplayMode(const QCameraParameters & params)4086 status_t QCameraHardwareInterface::setNoDisplayMode(const QCameraParameters& params)
4087 {
4088 char prop[PROPERTY_VALUE_MAX];
4089 memset(prop, 0, sizeof(prop));
4090 property_get("persist.camera.nodisplay", prop, "0");
4091 int prop_val = atoi(prop);
4092
4093 if (prop_val == 0) {
4094 const char *str_val = params.get("no-display-mode");
4095 if(str_val && strlen(str_val) > 0) {
4096 mNoDisplayMode = atoi(str_val);
4097 } else {
4098 mNoDisplayMode = 0;
4099 }
4100 ALOGD("Param mNoDisplayMode =%d", mNoDisplayMode);
4101 } else {
4102 mNoDisplayMode = prop_val;
4103 ALOGD("prop mNoDisplayMode =%d", mNoDisplayMode);
4104 }
4105 return NO_ERROR;
4106 }
4107
setRDIMode(const QCameraParameters & params)4108 status_t QCameraHardwareInterface::setRDIMode(const QCameraParameters& params)
4109 {
4110 char prop[PROPERTY_VALUE_MAX];
4111 memset(prop, 0, sizeof(prop));
4112 property_get("persist.camera.rdi.mode", prop, "0");
4113 int prop_val = atoi(prop);
4114 rdiMode = prop_val;
4115 ALOGE("RDI Mode = %d",rdiMode);
4116 return NO_ERROR;
4117 }
4118
setDimension()4119 status_t QCameraHardwareInterface::setDimension()
4120 {
4121 ALOGV("%s: E", __func__);
4122 cam_ctrl_dimension_t dim;
4123 int ret = MM_CAMERA_OK;
4124 int postviewWidth,postviewHeight;
4125
4126 memset(&dim, 0, sizeof(cam_ctrl_dimension_t));
4127 ret = mCameraHandle->ops->get_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DIMENSION,&dim);
4128
4129 if (MM_CAMERA_OK != ret) {
4130 ALOGE("%s: error - can't get preview dimension!", __func__);
4131 ALOGE("%s: X", __func__);
4132 return BAD_VALUE;
4133 }
4134
4135 getPreviewSize(&mPreviewWidth, &mPreviewHeight);
4136 dim.display_width = mPreviewWidth;
4137 dim.display_height = mPreviewHeight;
4138
4139 cam_format_t value = getPreviewFormat();
4140 if(value != NOT_FOUND && value != dim.prev_format ) {
4141 //Setting to Parameter requested by the Upper layer
4142 dim.prev_format = value;
4143 }else{
4144 //Setting to default Format.
4145 dim.prev_format = CAMERA_YUV_420_NV21;
4146 }
4147 dim.prev_padding_format = getPreviewPadding( );
4148
4149 getVideoSize(&videoWidth, &videoHeight);
4150 dim.enc_format = CAMERA_YUV_420_NV12;
4151 dim.orig_video_width = videoWidth;
4152 dim.orig_video_height = videoHeight;
4153 dim.video_width = videoWidth;
4154 dim.video_height = videoHeight;
4155 dim.video_chroma_width = videoWidth;
4156 dim.video_chroma_height = videoHeight;
4157
4158 getPictureSize(&mPictureWidth, &mPictureHeight);
4159 dim.picture_width = mPictureWidth;
4160 dim.picture_height = mPictureHeight;
4161
4162 getThumbnailSize(&thumbnailWidth,&thumbnailHeight);
4163 dim.ui_thumbnail_width = thumbnailWidth;
4164 dim.ui_thumbnail_height = thumbnailHeight;
4165
4166 /* Reset the Main image and thumbnail formats here,
4167 * since they might have been changed when video size
4168 * livesnapshot was taken. */
4169 if (mSnapshotFormat == 1)
4170 dim.main_img_format = CAMERA_YUV_422_NV61;
4171 else
4172 dim.main_img_format = CAMERA_YUV_420_NV21;
4173 dim.thumb_format = CAMERA_YUV_420_NV21;
4174
4175 //RDI Format
4176 dim.rdi0_format = CAMERA_BAYER_SBGGR10;
4177
4178 /*Code to handle different limitations*/
4179 if (mRecordingHint && mFullLiveshotEnabled){
4180 dim.ui_thumbnail_height = dim.display_height;
4181 dim.ui_thumbnail_width = dim.display_width;
4182 }
4183 if (isZSLMode()){
4184 postviewWidth = mPreviewWidth;
4185 postviewHeight = mPreviewHeight;
4186 } else {
4187 postviewWidth = thumbnailWidth;
4188 postviewHeight = thumbnailHeight;
4189 }
4190 if (mPictureWidth < postviewWidth || mPictureHeight < postviewHeight)
4191 {
4192 //Changes to handle VFE limitation when primary o/p is main image
4193 dim.picture_width = postviewWidth;
4194 dim.picture_height = postviewHeight;
4195 }
4196
4197 //VFE output1 shouldn't be greater than VFE output2.
4198 if( (dim.display_width > dim.video_width) ||
4199 (dim.display_height > dim.video_height)) {
4200 //Set preview sizes as record sizes.
4201 dim.display_width = dim.video_width;
4202 dim.display_height = dim.video_height;
4203 }
4204 if (mRecordingHint && mFullLiveshotEnabled){
4205 if( (dim.picture_width < dim.video_width) ||
4206 (dim.picture_height < dim.video_height)) {
4207 dim.picture_width = dim.video_width;
4208 dim.picture_height = dim.video_height;
4209 }
4210 }
4211
4212 if(mIs3DModeOn == true) {
4213 /* As preview and video frames are same in 3D mode,
4214 * preview size should be same as video size. This
4215 * cahnge is needed to take of video resolutions
4216 * like 720P and 1080p where the application can
4217 * request different preview sizes like 768x432
4218 */
4219 ALOGE("3D mod is on");
4220 dim.display_width = dim.video_width;
4221 dim.display_height = dim.video_height;
4222 }
4223
4224 /*End of limitation code*/
4225
4226 ret = mCameraHandle->ops->set_parm(mCameraHandle->camera_handle, MM_CAMERA_PARM_DIMENSION,&dim);
4227 if (MM_CAMERA_OK != ret) {
4228 ALOGE("%s X: error - can't config preview parms!", __func__);
4229 return BAD_VALUE;
4230 }
4231 if(mStreams[MM_CAMERA_PREVIEW]) {
4232 mStreams[MM_CAMERA_PREVIEW]->mFormat = dim.prev_format;
4233 mStreams[MM_CAMERA_PREVIEW]->mWidth = dim.display_width;
4234 mStreams[MM_CAMERA_PREVIEW]->mHeight = dim.display_height;
4235 }
4236 if(mStreams[MM_CAMERA_VIDEO]) {
4237 mStreams[MM_CAMERA_VIDEO]->mFormat = dim.enc_format;
4238 mStreams[MM_CAMERA_VIDEO]->mWidth = dim.video_width;
4239 mStreams[MM_CAMERA_VIDEO]->mHeight = dim.video_height;
4240 }
4241 if(mStreams[MM_CAMERA_SNAPSHOT_MAIN]) {
4242 mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mFormat = dim.main_img_format;
4243 if (!isRawSnapshot()) {
4244 mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mWidth = dim.picture_width;
4245 mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mHeight = dim.picture_height;
4246 } else {
4247 cam_frame_resolution_t raw_res;
4248
4249 /* the raw_picture_width in dimension is for RDI dump.
4250 * here, raw snapshot size is from camif. */
4251 memset(&raw_res, 0, sizeof(raw_res));
4252 raw_res.image_mode = MSM_V4L2_EXT_CAPTURE_MODE_RAW;
4253 raw_res.padding_format = CAMERA_PAD_TO_WORD;
4254 ret = mCameraHandle->ops->get_parm(
4255 mCameraHandle->camera_handle,
4256 MM_CAMERA_PARM_FRAME_RESOLUTION,&raw_res);
4257 if (MM_CAMERA_OK != ret) {
4258 ALOGE("%s error - config raw snapshot parms, rc = %d",
4259 __func__, ret);
4260 return BAD_VALUE;
4261 }
4262 mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mWidth = raw_res.width;
4263 mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mHeight = raw_res.height;
4264 mStreams[MM_CAMERA_SNAPSHOT_MAIN]->mFormat = raw_res.format;
4265 }
4266 }
4267 if(mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]) {
4268 mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mFormat = dim.thumb_format;
4269 mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mWidth = dim.ui_thumbnail_width;
4270 mStreams[MM_CAMERA_SNAPSHOT_THUMBNAIL]->mHeight = dim.ui_thumbnail_height;
4271 }
4272
4273 memcpy(&mDimension, &dim, sizeof(mDimension));
4274 ALOGV("%s: X", __func__);
4275 return NO_ERROR;
4276 }
4277 }; /*namespace android */
4278