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