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