Home | History | Annotate | Download | only in HAL
      1 /*
      2 ** Copyright 2008, The Android Open Source Project
      3 ** Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
      4 ** Not a Contribution. Apache license notifications and license are
      5 ** retained 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 #ifndef ANDROID_HARDWARE_QCAMERA_PARAMETERS_H
     20 #define ANDROID_HARDWARE_QCAMERA_PARAMETERS_H
     21 
     22 #include <camera/CameraParameters.h>
     23 #include <cutils/properties.h>
     24 #include <hardware/camera.h>
     25 #include <stdlib.h>
     26 #include <utils/Errors.h>
     27 #include "cam_intf.h"
     28 #include "QCameraMem.h"
     29 #include "QCameraThermalAdapter.h"
     30 
     31 extern "C" {
     32 #include <mm_jpeg_interface.h>
     33 }
     34 
     35 using namespace android;
     36 
     37 namespace qcamera {
     38 
     39 //EXIF globals
     40 static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };          // "ASCII\0\0\0"
     41 static const char ExifUndefinedPrefix[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };   // "\0\0\0\0\0\0\0\0"
     42 
     43 #define EXIF_ASCII_PREFIX_SIZE           8   //(sizeof(ExifAsciiPrefix))
     44 #define FOCAL_LENGTH_DECIMAL_PRECISION   100
     45 
     46 class QCameraTorchInterface
     47 {
     48 public:
     49     virtual int prepareTorchCamera() = 0;
     50     virtual int releaseTorchCamera() = 0;
     51     virtual ~QCameraTorchInterface() {}
     52 };
     53 
     54 class QCameraAdjustFPS
     55 {
     56 public:
     57     virtual int recalcFPSRange(int &minFPS, int &maxFPS,
     58             int &vidMinFps, int &vidMaxFps) = 0;
     59     virtual ~QCameraAdjustFPS() {}
     60 };
     61 
     62 class QCameraParameters;
     63 class QCameraReprocScaleParam{
     64 public:
     65     QCameraReprocScaleParam(QCameraParameters *parent);
     66     virtual ~QCameraReprocScaleParam();
     67 
     68     virtual void setScaleEnable(bool enabled);
     69     virtual int32_t setScaleSizeTbl(uint8_t scale_cnt, cam_dimension_t *scale_tbl, uint8_t org_cnt, cam_dimension_t *org_tbl);
     70     virtual int32_t setValidatePicSize(int &width, int &height);
     71 
     72     virtual bool isScaleEnabled();
     73     virtual bool isUnderScaling();
     74 
     75 
     76     virtual uint8_t getScaleSizeTblCnt();
     77     virtual cam_dimension_t *getScaledSizeTbl();
     78     virtual uint8_t getTotalSizeTblCnt();
     79     virtual cam_dimension_t *getTotalSizeTbl();
     80     virtual int32_t getPicSizeFromAPK(int &width, int &height);
     81     virtual int32_t getPicSizeSetted(int &width, int &height);
     82 
     83 private:
     84     bool isScalePicSize(int width, int height);
     85     bool isValidatePicSize(int width, int height);
     86     int32_t setSensorSupportedPicSize();
     87     uint8_t checkScaleSizeTable(uint8_t scale_cnt, cam_dimension_t *scale_tbl, uint8_t org_cnt, cam_dimension_t *org_tbl);
     88 
     89     QCameraParameters *mParent;
     90     bool mScaleEnabled;
     91     bool mIsUnderScaling;   //if in scale status
     92     bool mScaleDirection;   // 0: Upscaling; 1: Downscaling
     93 
     94     // picture size cnt that need scale operation
     95     uint8_t mNeedScaleCnt;
     96     cam_dimension_t mNeedScaledSizeTbl[MAX_SCALE_SIZES_CNT];
     97 
     98     // sensor supported size cnt and table
     99     uint8_t mSensorSizeTblCnt;
    100     cam_dimension_t *mSensorSizeTbl;
    101 
    102     // Total size cnt (sensor supported + need scale cnt)
    103     uint8_t mTotalSizeTblCnt;
    104     cam_dimension_t mTotalSizeTbl[MAX_SIZES_CNT];
    105 
    106     cam_dimension_t mPicSizeFromAPK;   // dimension that APK is expected
    107     cam_dimension_t mPicSizeSetted;    // dimension that config vfe
    108 };
    109 
    110 class QCameraParameters: public CameraParameters
    111 {
    112 public:
    113     QCameraParameters();
    114     QCameraParameters(const String8 &params);
    115     ~QCameraParameters();
    116 
    117     // Supported PREVIEW/RECORDING SIZES IN HIGH FRAME RATE recording, sizes in pixels.
    118     // Example value: "800x480,432x320". Read only.
    119     static const char KEY_QC_SUPPORTED_HFR_SIZES[];
    120     // The mode of preview frame rate.
    121     // Example value: "frame-rate-auto, frame-rate-fixed".
    122     static const char KEY_QC_PREVIEW_FRAME_RATE_MODE[];
    123     static const char KEY_QC_SUPPORTED_PREVIEW_FRAME_RATE_MODES[];
    124     static const char KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE[];
    125     static const char KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE[];
    126     static const char KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] ;
    127 
    128     // Supported live snapshot sizes
    129     static const char KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES[];
    130 
    131     // Supported Raw formats
    132     static const char KEY_QC_SUPPORTED_RAW_FORMATS[];
    133     static const char KEY_QC_RAW_FORMAT[];
    134 
    135     //Touch Af/AEC settings.
    136     static const char KEY_QC_TOUCH_AF_AEC[];
    137     static const char KEY_QC_SUPPORTED_TOUCH_AF_AEC[];
    138     //Touch Index for AEC.
    139     static const char KEY_QC_TOUCH_INDEX_AEC[];
    140     //Touch Index for AF.
    141     static const char KEY_QC_TOUCH_INDEX_AF[];
    142     // Current auto scene detection mode.
    143     // Example value: "off" or "on" constants. Read/write.
    144     static const char KEY_QC_SCENE_DETECT[];
    145     // Supported auto scene detection settings.
    146     // Example value: "off,on". Read only.
    147     static const char KEY_QC_SUPPORTED_SCENE_DETECT[];
    148     static const char KEY_QC_SELECTABLE_ZONE_AF[];
    149 
    150     static const char KEY_QC_ISO_MODE[];
    151     static const char KEY_QC_SUPPORTED_ISO_MODES[];
    152     static const char KEY_QC_LENSSHADE[] ;
    153     static const char KEY_QC_SUPPORTED_LENSSHADE_MODES[] ;
    154     static const char KEY_QC_AUTO_EXPOSURE[];
    155     static const char KEY_QC_SUPPORTED_AUTO_EXPOSURE[];
    156 
    157     static const char KEY_QC_GPS_LATITUDE_REF[];
    158     static const char KEY_QC_GPS_LONGITUDE_REF[];
    159     static const char KEY_QC_GPS_ALTITUDE_REF[];
    160     static const char KEY_QC_GPS_STATUS[];
    161     static const char KEY_QC_MEMORY_COLOR_ENHANCEMENT[];
    162     static const char KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES[];
    163     static const char KEY_QC_DIS[];
    164     static const char KEY_QC_SUPPORTED_DIS_MODES[];
    165 
    166     static const char KEY_QC_ZSL[];
    167     static const char KEY_QC_SUPPORTED_ZSL_MODES[];
    168     static const char KEY_QC_ZSL_BURST_INTERVAL[];
    169     static const char KEY_QC_ZSL_BURST_LOOKBACK[];
    170     static const char KEY_QC_ZSL_QUEUE_DEPTH[];
    171 
    172     static const char KEY_QC_CAMERA_MODE[];
    173     static const char KEY_QC_ORIENTATION[];
    174 
    175     static const char KEY_QC_VIDEO_HIGH_FRAME_RATE[];
    176     static const char KEY_QC_VIDEO_HIGH_SPEED_RECORDING[];
    177     static const char KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[];
    178     static const char KEY_QC_HIGH_DYNAMIC_RANGE_IMAGING[];
    179     static const char KEY_QC_SUPPORTED_HDR_IMAGING_MODES[];
    180     static const char KEY_QC_AE_BRACKET_HDR[];
    181     static const char KEY_QC_SUPPORTED_AE_BRACKET_MODES[];
    182     static const char KEY_QC_CAPTURE_BURST_EXPOSURE[];
    183     static const char KEY_QC_NUM_SNAPSHOT_PER_SHUTTER[];
    184     static const char KEY_QC_NUM_RETRO_BURST_PER_SHUTTER[];
    185     static const char KEY_QC_SNAPSHOT_BURST_LED_ON_PERIOD[];
    186     static const char KEY_QC_SNAPSHOT_BURST_NUM[];
    187     static const char KEY_QC_NO_DISPLAY_MODE[];
    188     static const char KEY_QC_RAW_PICUTRE_SIZE[];
    189     static const char KEY_QC_TINTLESS_ENABLE[];
    190     static const char KEY_QC_SCENE_SELECTION[];
    191     static const char KEY_QC_CDS_MODE[];
    192 
    193     static const char KEY_INTERNAL_PERVIEW_RESTART[];
    194 
    195     // DENOISE
    196     static const char KEY_QC_DENOISE[];
    197     static const char KEY_QC_SUPPORTED_DENOISE[];
    198 
    199     //Selectable zone AF.
    200     static const char KEY_QC_FOCUS_ALGO[];
    201     static const char KEY_QC_SUPPORTED_FOCUS_ALGOS[];
    202 
    203     //Face Detection
    204     static const char KEY_QC_FACE_DETECTION[];
    205     static const char KEY_QC_SUPPORTED_FACE_DETECTION[];
    206 
    207     //Face Recognition
    208     static const char KEY_QC_FACE_RECOGNITION[];
    209     static const char KEY_QC_SUPPORTED_FACE_RECOGNITION[];
    210 
    211     // supported camera features to be queried by Snapdragon SDK
    212     //Read only
    213     static const char KEY_QC_SUPPORTED_CAMERA_FEATURES[];
    214 
    215     //Indicates number of faces requested by the application.
    216     //This value will be rejected if the requested faces
    217     //greater than supported by hardware.
    218     //Write only.
    219     static const char KEY_QC_MAX_NUM_REQUESTED_FACES[];
    220 
    221     //preview flip
    222     static const char KEY_QC_PREVIEW_FLIP[];
    223     //video flip
    224     static const char KEY_QC_VIDEO_FLIP[];
    225     //snapshot picture flip
    226     static const char KEY_QC_SNAPSHOT_PICTURE_FLIP[];
    227 
    228     static const char KEY_QC_SUPPORTED_FLIP_MODES[];
    229 
    230     //Face Detection, Facial processing requirement
    231     static const char KEY_QC_SNAPSHOT_FD_DATA[];
    232 
    233     //Auto HDR enable
    234     static const char KEY_QC_AUTO_HDR_ENABLE[];
    235     // video rotation
    236     static const char KEY_QC_VIDEO_ROTATION[];
    237 
    238     //Redeye Reduction
    239     static const char KEY_QC_REDEYE_REDUCTION[];
    240     static const char KEY_QC_SUPPORTED_REDEYE_REDUCTION[];
    241     static const char EFFECT_EMBOSS[];
    242     static const char EFFECT_SKETCH[];
    243     static const char EFFECT_NEON[];
    244 
    245     //AF Bracketing
    246     static const char KEY_QC_AF_BRACKET[];
    247     static const char KEY_QC_SUPPORTED_AF_BRACKET_MODES[];
    248 
    249     //Refocus
    250     static const char KEY_QC_RE_FOCUS[];
    251     static const char KEY_QC_SUPPORTED_RE_FOCUS_MODES[];
    252 
    253     //Chroma Flash
    254     static const char KEY_QC_CHROMA_FLASH[];
    255     static const char KEY_QC_SUPPORTED_CHROMA_FLASH_MODES[];
    256 
    257     //Opti Zoom
    258     static const char KEY_QC_OPTI_ZOOM[];
    259     static const char KEY_QC_SUPPORTED_OPTI_ZOOM_MODES[];
    260 
    261     // Auto HDR supported
    262     static const char KEY_QC_AUTO_HDR_SUPPORTED[];
    263 
    264     // Values for Touch AF/AEC
    265     static const char TOUCH_AF_AEC_OFF[];
    266     static const char TOUCH_AF_AEC_ON[];
    267 
    268     // Values for Scene mode
    269     static const char SCENE_MODE_ASD[];
    270     static const char SCENE_MODE_BACKLIGHT[];
    271     static const char SCENE_MODE_FLOWERS[];
    272     static const char SCENE_MODE_AR[];
    273     static const char SCENE_MODE_HDR[];
    274     static const char PIXEL_FORMAT_YUV420SP_ADRENO[]; // ADRENO
    275     static const char PIXEL_FORMAT_YV12[]; // NV12
    276     static const char PIXEL_FORMAT_NV12[]; //NV12
    277     static const char QC_PIXEL_FORMAT_NV12_VENUS[]; //NV12 VENUS
    278 
    279     // Values for raw picture format
    280     static const char QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV[];
    281     static const char QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU[];
    282     static const char QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY[];
    283     static const char QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY[];
    284     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG[];
    285     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG[];
    286     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB[];
    287     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR[];
    288     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG[];
    289     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG[];
    290     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB[];
    291     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR[];
    292     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG[];
    293     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG[];
    294     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB[];
    295     static const char QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR[];
    296     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG[];
    297     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG[];
    298     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB[];
    299     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR[];
    300     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG[];
    301     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG[];
    302     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB[];
    303     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR[];
    304     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG[];
    305     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG[];
    306     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB[];
    307     static const char QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR[];
    308     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG[];
    309     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG[];
    310     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB[];
    311     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR[];
    312     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG[];
    313     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG[];
    314     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB[];
    315     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR[];
    316     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG[];
    317     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG[];
    318     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB[];
    319     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR[];
    320     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG[];
    321     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG[];
    322     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB[];
    323     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR[];
    324     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG[];
    325     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG[];
    326     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB[];
    327     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR[];
    328     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG[];
    329     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG[];
    330     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB[];
    331     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR[];
    332     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG[];
    333     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG[];
    334     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB[];
    335     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR[];
    336     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG[];
    337     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG[];
    338     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB[];
    339     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR[];
    340     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG[];
    341     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG[];
    342     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB[];
    343     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR[];
    344     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG[];
    345     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG[];
    346     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB[];
    347     static const char QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR[];
    348 
    349     // ISO values
    350     static const char ISO_AUTO[];
    351     static const char ISO_HJR[];
    352     static const char ISO_100[];
    353     static const char ISO_200[];
    354     static const char ISO_400[];
    355     static const char ISO_800[];
    356     static const char ISO_1600[];
    357 
    358     // Values for auto exposure settings.
    359     static const char AUTO_EXPOSURE_FRAME_AVG[];
    360     static const char AUTO_EXPOSURE_CENTER_WEIGHTED[];
    361     static const char AUTO_EXPOSURE_SPOT_METERING[];
    362     static const char AUTO_EXPOSURE_SMART_METERING[];
    363     static const char AUTO_EXPOSURE_USER_METERING[];
    364     static const char AUTO_EXPOSURE_SPOT_METERING_ADV[];
    365     static const char AUTO_EXPOSURE_CENTER_WEIGHTED_ADV[];
    366 
    367     static const char KEY_QC_SHARPNESS[];
    368     static const char KEY_QC_MIN_SHARPNESS[];
    369     static const char KEY_QC_MAX_SHARPNESS[];
    370     static const char KEY_QC_SHARPNESS_STEP[];
    371     static const char KEY_QC_CONTRAST[];
    372     static const char KEY_QC_MIN_CONTRAST[];
    373     static const char KEY_QC_MAX_CONTRAST[];
    374     static const char KEY_QC_CONTRAST_STEP[];
    375     static const char KEY_QC_SATURATION[];
    376     static const char KEY_QC_MIN_SATURATION[];
    377     static const char KEY_QC_MAX_SATURATION[];
    378     static const char KEY_QC_SATURATION_STEP[];
    379     static const char KEY_QC_BRIGHTNESS[];
    380     static const char KEY_QC_MIN_BRIGHTNESS[];
    381     static const char KEY_QC_MAX_BRIGHTNESS[];
    382     static const char KEY_QC_BRIGHTNESS_STEP[];
    383     static const char KEY_QC_SCE_FACTOR[];
    384     static const char KEY_QC_MIN_SCE_FACTOR[];
    385     static const char KEY_QC_MAX_SCE_FACTOR[];
    386     static const char KEY_QC_SCE_FACTOR_STEP[];
    387 
    388     static const char KEY_QC_HISTOGRAM[] ;
    389     static const char KEY_QC_SUPPORTED_HISTOGRAM_MODES[] ;
    390     static const char KEY_QC_HDR_NEED_1X[];
    391     static const char KEY_QC_VIDEO_HDR[];
    392     static const char KEY_QC_VT_ENABLE[];
    393     static const char KEY_QC_SUPPORTED_VIDEO_HDR_MODES[];
    394     static const char KEY_QC_SENSOR_HDR[];
    395     static const char KEY_QC_SUPPORTED_SENSOR_HDR_MODES[];
    396     static const char KEY_QC_RDI_MODE[];
    397     static const char KEY_QC_SUPPORTED_RDI_MODES[];
    398     static const char KEY_QC_SECURE_MODE[];
    399     static const char KEY_QC_SUPPORTED_SECURE_MODES[];
    400 
    401     // Values for SKIN TONE ENHANCEMENT
    402     static const char SKIN_TONE_ENHANCEMENT_ENABLE[] ;
    403     static const char SKIN_TONE_ENHANCEMENT_DISABLE[] ;
    404 
    405     // Values for Denoise
    406     static const char DENOISE_OFF[] ;
    407     static const char DENOISE_ON[] ;
    408 
    409     // Values for auto exposure settings.
    410     static const char FOCUS_ALGO_AUTO[];
    411     static const char FOCUS_ALGO_SPOT_METERING[];
    412     static const char FOCUS_ALGO_CENTER_WEIGHTED[];
    413     static const char FOCUS_ALGO_FRAME_AVERAGE[];
    414 
    415     // Values for AE Bracketing settings.
    416     static const char AE_BRACKET_OFF[];
    417     static const char AE_BRACKET[];
    418 
    419     // Values for AF Bracketing settings.
    420     static const char AF_BRACKET_OFF[];
    421     static const char AF_BRACKET_ON[];
    422 
    423     // Values for Refocus settings.
    424     static const char RE_FOCUS_OFF[];
    425     static const char RE_FOCUS_ON[];
    426 
    427     // Values for Chroma Flash settings.
    428     static const char CHROMA_FLASH_OFF[];
    429     static const char CHROMA_FLASH_ON[];
    430 
    431     // Values for Opti Zoom settings.
    432     static const char OPTI_ZOOM_OFF[];
    433     static const char OPTI_ZOOM_ON[];
    434 
    435     // Values for HFR settings.
    436     static const char VIDEO_HFR_OFF[];
    437     static const char VIDEO_HFR_2X[];
    438     static const char VIDEO_HFR_3X[];
    439     static const char VIDEO_HFR_4X[];
    440     static const char VIDEO_HFR_5X[];
    441 
    442     // Values for feature on/off settings.
    443     static const char VALUE_OFF[];
    444     static const char VALUE_ON[];
    445 
    446     // Values for feature enable/disable settings.
    447     static const char VALUE_ENABLE[];
    448     static const char VALUE_DISABLE[];
    449 
    450     // Values for feature true/false settings.
    451     static const char VALUE_FALSE[];
    452     static const char VALUE_TRUE[];
    453 
    454     //Values for flip settings
    455     static const char FLIP_MODE_OFF[];
    456     static const char FLIP_MODE_V[];
    457     static const char FLIP_MODE_H[];
    458     static const char FLIP_MODE_VH[];
    459 
    460     //Values for CDS Mode
    461     static const char CDS_MODE_OFF[];
    462     static const char CDS_MODE_ON[];
    463     static const char CDS_MODE_AUTO[];
    464 
    465     static const char KEY_SELECTED_AUTO_SCENE[];
    466 
    467     enum {
    468         CAMERA_ORIENTATION_UNKNOWN = 0,
    469         CAMERA_ORIENTATION_PORTRAIT = 1,
    470         CAMERA_ORIENTATION_LANDSCAPE = 2,
    471     };
    472     typedef struct {
    473         const char *const desc;
    474         int val;
    475     } QCameraMap;
    476 
    477     friend class QCameraReprocScaleParam;
    478     QCameraReprocScaleParam m_reprocScaleParam;
    479     static const QCameraMap EFFECT_MODES_MAP[];
    480 
    481     void getSupportedHfrSizes(Vector<Size> &sizes);
    482     void setPreviewFrameRateMode(const char *mode);
    483     const char *getPreviewFrameRateMode() const;
    484     void setTouchIndexAec(int x, int y);
    485     void getTouchIndexAec(int *x, int *y);
    486     void setTouchIndexAf(int x, int y);
    487     void getTouchIndexAf(int *x, int *y);
    488 
    489     int32_t init(cam_capability_t *,
    490                  mm_camera_vtbl_t *,
    491                  QCameraAdjustFPS *,
    492                  QCameraTorchInterface *);
    493     void deinit();
    494     int32_t assign(QCameraParameters& params);
    495     int32_t initDefaultParameters();
    496     int32_t updateParameters(QCameraParameters&, bool &needRestart);
    497     int32_t commitParameters();
    498     int getPreviewHalPixelFormat() const;
    499     int32_t getStreamRotation(cam_stream_type_t streamType,
    500                                cam_pp_feature_config_t &featureConfig,
    501                                cam_dimension_t &dim);
    502     int32_t getStreamFormat(cam_stream_type_t streamType,
    503                              cam_format_t &format);
    504     int32_t getStreamDimension(cam_stream_type_t streamType,
    505                                 cam_dimension_t &dim);
    506     void getThumbnailSize(int *width, int *height) const;
    507 
    508     int getZSLBurstInterval();
    509     int getZSLQueueDepth();
    510     int getZSLBackLookCount();
    511     int getMaxUnmatchedFramesInQueue();
    512     bool isZSLMode() {return m_bZslMode;};
    513     bool isRdiMode() {return m_bRdiMode;};
    514     bool isSecureMode() {return m_bSecureMode;};
    515     bool isNoDisplayMode() {return m_bNoDisplayMode;};
    516     bool isWNREnabled() {return m_bWNROn;};
    517     bool isHfrMode() {return m_bHfrMode;};
    518     void getHfrFps(cam_fps_range_t &pFpsRange) { pFpsRange = m_hfrFpsRange;};
    519     uint8_t getNumOfSnapshots();
    520     uint8_t getNumOfRetroSnapshots();
    521     uint8_t getNumOfExtraHDRInBufsIfNeeded();
    522     uint8_t getNumOfExtraHDROutBufsIfNeeded();
    523     int getBurstNum();
    524     int getBurstLEDOnPeriod();
    525     int getRetroActiveBurstNum();
    526     bool getRecordingHintValue() {return m_bRecordingHint;}; // return local copy of video hint
    527     int setRecordingHintValue(int32_t value); // set local copy of video hint and send to server
    528                                               // no change in parameters value
    529     int getJpegQuality();
    530     int getJpegRotation();
    531 
    532     int32_t getExifDateTime(char *dateTime, uint32_t &count);
    533     int32_t getExifFocalLength(rat_t *focalLenght);
    534     uint16_t getExifIsoSpeed();
    535     int32_t getExifGpsProcessingMethod(char *gpsProcessingMethod, uint32_t &count);
    536     int32_t getExifLatitude(rat_t *latitude, char *latRef);
    537     int32_t getExifLongitude(rat_t *longitude, char *lonRef);
    538     int32_t getExifAltitude(rat_t *altitude, char *altRef);
    539     int32_t getExifGpsDateTimeStamp(char *gpsDateStamp, uint32_t bufLen, rat_t *gpsTimeStamp);
    540     int32_t updateFocusDistances(cam_focus_distances_info_t *focusDistances);
    541 
    542     bool isAEBracketEnabled();
    543     int32_t setAEBracketing();
    544     bool isFpsDebugEnabled() {return m_bDebugFps;};
    545     bool isHistogramEnabled() {return m_bHistogramEnabled;};
    546     bool isSceneSelectionEnabled() {return m_bSceneSelection;};
    547     int32_t setSelectedScene(cam_scene_mode_type scene);
    548     cam_scene_mode_type getSelectedScene();
    549     bool isFaceDetectionEnabled() {return ((m_nFaceProcMask & CAM_FACE_PROCESS_MASK_DETECTION) != 0);};
    550     bool getFaceDetectionOption() { return  m_bFaceDetectionOn;}
    551     int32_t setFaceDetectionOption(bool enabled);
    552     int32_t setHistogram(bool enabled);
    553     int32_t setFaceDetection(bool enabled, bool initCommit);
    554     int32_t setFrameSkip(enum msm_vfe_frame_skip_pattern pattern);
    555     qcamera_thermal_mode getThermalMode() {return m_ThermalMode;};
    556     int32_t updateRecordingHintValue(int32_t value);
    557     int32_t setHDRAEBracket(cam_exp_bracketing_t hdrBracket);
    558     bool isHDREnabled();
    559     bool isAutoHDREnabled();
    560     int32_t stopAEBracket();
    561     int32_t updateFlash(bool commitSettings);
    562     int32_t updateRAW(cam_dimension_t max_dim);
    563     bool isAVTimerEnabled();
    564     bool isDISEnabled();
    565 
    566     cam_focus_mode_type getFocusMode() const {return mFocusMode;};
    567     int32_t setNumOfSnapshot();
    568     int32_t adjustPreviewFpsRange(cam_fps_range_t *fpsRange);
    569     bool isJpegPictureFormat() {return (mPictureFormat == CAM_FORMAT_JPEG);};
    570     bool isNV16PictureFormat() {return (mPictureFormat == CAM_FORMAT_YUV_422_NV16);};
    571     bool isNV21PictureFormat() {return (mPictureFormat == CAM_FORMAT_YUV_420_NV21);};
    572     cam_denoise_process_type_t getWaveletDenoiseProcessPlate();
    573     int32_t getLiveSnapshotSize(cam_dimension_t &dim) {dim = m_LiveSnapshotSize; return NO_ERROR;};
    574     int32_t getRawSize(cam_dimension_t &dim) {dim = m_rawSize; return NO_ERROR;};
    575     int32_t setRawSize(cam_dimension_t &dim);
    576     int getFlipMode(cam_stream_type_t streamType);
    577     bool isSnapshotFDNeeded();
    578 
    579     bool isHDR1xFrameEnabled() {return m_bHDR1xFrameEnabled;}
    580     bool isYUVFrameInfoNeeded();
    581     const char*getFrameFmtString(cam_format_t fmt);
    582     bool isHDR1xExtraBufferNeeded() {return m_bHDR1xExtraBufferNeeded;}
    583     bool isHDROutputCropEnabled() {return m_bHDROutputCropEnabled;}
    584 
    585     bool isPreviewFlipChanged() { return m_bPreviewFlipChanged; };
    586     bool isVideoFlipChanged() { return m_bVideoFlipChanged; };
    587     bool isSnapshotFlipChanged() { return m_bSnapshotFlipChanged; };
    588     void setHDRSceneEnable(bool bflag);
    589 
    590     const char *getASDStateString(cam_auto_scene_t scene);
    591     bool isHDRThumbnailProcessNeeded() { return m_bHDRThumbnailProcessNeeded; };
    592     int getAutoFlickerMode();
    593 
    594     bool setStreamConfigure(bool isCapture, bool previewAsPostview);
    595     uint8_t getNumOfExtraBuffersForImageProc();
    596     bool needThumbnailReprocess(uint32_t *pFeatureMask);
    597     inline bool isUbiFocusEnabled() {return m_bAFBracketingOn;};
    598     inline bool isChromaFlashEnabled() {return m_bChromaFlashOn;};
    599     bool isOptiZoomEnabled();
    600     int32_t commitAFBracket(cam_af_bracketing_t afBracket);
    601     int32_t commitFlashBracket(cam_flash_bracketing_t flashBracket);
    602     int32_t set3ALock(const char *lockStr);
    603     int32_t setAndCommitZoom(int zoom_level);
    604     uint8_t getBurstCountForAdvancedCapture();
    605     int32_t setLongshotEnable(bool enable);
    606     String8 dump();
    607     inline bool isUbiRefocus() {return isUbiFocusEnabled() &&
    608         (m_pCapability->ubifocus_af_bracketing_need.output_count > 1);};
    609     inline uint32_t UfOutputCount() {
    610         return m_pCapability->ubifocus_af_bracketing_need.output_count;};
    611     inline bool generateThumbFromMain() {return isUbiFocusEnabled() ||
    612         isChromaFlashEnabled() || isOptiZoomEnabled(); }
    613     bool isDisplayFrameNeeded() { return m_bDisplayFrame; };
    614     int32_t setDisplayFrame(bool enabled) {m_bDisplayFrame=enabled; return 0;};
    615     bool isAdvCamFeaturesEnabled() {return isUbiFocusEnabled() ||
    616         isChromaFlashEnabled() || m_bOptiZoomOn || isHDREnabled();}
    617     int32_t setAecLock(const char *aecStr);
    618     bool is4k2kVideoResolution();
    619 
    620 private:
    621     int32_t setPreviewSize(const QCameraParameters& );
    622     int32_t setVideoSize(const QCameraParameters& );
    623     int32_t setPictureSize(const QCameraParameters& );
    624     int32_t setLiveSnapshotSize(const QCameraParameters& );
    625     int32_t setPreviewFormat(const QCameraParameters& );
    626     int32_t setPictureFormat(const QCameraParameters& );
    627     int32_t setOrientation(const QCameraParameters& );
    628     int32_t setJpegThumbnailSize(const QCameraParameters& );
    629     int32_t setJpegQuality(const QCameraParameters& );
    630     int32_t setPreviewFpsRange(const QCameraParameters& );
    631     int32_t setPreviewFrameRate(const QCameraParameters& );
    632     int32_t setAutoExposure(const QCameraParameters& );
    633     int32_t setEffect(const QCameraParameters& );
    634     int32_t setBrightness(const QCameraParameters& );
    635     int32_t setFocusMode(const QCameraParameters& );
    636     int32_t setSharpness(const QCameraParameters& );
    637     int32_t setSaturation(const QCameraParameters& );
    638     int32_t setContrast(const QCameraParameters& );
    639     int32_t setSkinToneEnhancement(const QCameraParameters& );
    640     int32_t setSceneDetect(const QCameraParameters& );
    641     int32_t setVideoHDR(const QCameraParameters& );
    642     int32_t setVtEnable(const QCameraParameters& );
    643     int32_t setZoom(const QCameraParameters& );
    644     int32_t setISOValue(const QCameraParameters& );
    645     int32_t setRotation(const QCameraParameters& );
    646     int32_t setVideoRotation(const QCameraParameters& );
    647     int32_t setFlash(const QCameraParameters& );
    648     int32_t setAecLock(const QCameraParameters& );
    649     int32_t setAwbLock(const QCameraParameters& );
    650     int32_t setMCEValue(const QCameraParameters& );
    651     int32_t setDISValue(const QCameraParameters& params);
    652     int32_t setHighFrameRate(const QCameraParameters& );
    653     int32_t setHighSpeedRecording(const QCameraParameters& );
    654     int32_t setLensShadeValue(const QCameraParameters& );
    655     int32_t setExposureCompensation(const QCameraParameters& );
    656     int32_t setWhiteBalance(const QCameraParameters& );
    657     int32_t setAntibanding(const QCameraParameters& );
    658     int32_t setFocusAreas(const QCameraParameters& );
    659     int32_t setMeteringAreas(const QCameraParameters& );
    660     int32_t setSceneMode(const QCameraParameters& );
    661     int32_t setSelectableZoneAf(const QCameraParameters& );
    662     int32_t setAEBracket(const QCameraParameters& );
    663     int32_t setAFBracket(const QCameraParameters& );
    664     int32_t setChromaFlash(const QCameraParameters& );
    665     int32_t setOptiZoom(const QCameraParameters& );
    666     int32_t setRedeyeReduction(const QCameraParameters& );
    667     int32_t setGpsLocation(const QCameraParameters& );
    668     int32_t setRecordingHint(const QCameraParameters& );
    669     int32_t setNoDisplayMode(const QCameraParameters& );
    670     int32_t setWaveletDenoise(const QCameraParameters& );
    671     int32_t setZslMode(const QCameraParameters& );
    672     int32_t setZslAttributes(const QCameraParameters& );
    673     int32_t setAutoHDR(const QCameraParameters& params);
    674     int32_t setCameraMode(const QCameraParameters& );
    675     int32_t setSceneSelectionMode(const QCameraParameters& params);
    676     int32_t setFaceRecognition(const QCameraParameters& );
    677     int32_t setFlip(const QCameraParameters& );
    678     int32_t setBurstNum(const QCameraParameters& params);
    679     int32_t setRetroActiveBurstNum(const QCameraParameters& params);
    680     int32_t setBurstLEDOnPeriod(const QCameraParameters& params);
    681     int32_t setSnapshotFDReq(const QCameraParameters& );
    682     int32_t setStatsDebugMask();
    683     int32_t setPAAF();
    684     int32_t setTintlessValue(const QCameraParameters& params);
    685     int32_t setCDSMode(const QCameraParameters& params);
    686     int32_t setMobicat(const QCameraParameters& params);
    687     int32_t setRdiMode(const QCameraParameters& );
    688     int32_t setSecureMode(const QCameraParameters& );
    689     int32_t setAutoExposure(const char *autoExp);
    690     int32_t setPreviewFpsRange(int min_fps,int max_fps,
    691             int vid_min_fps,int vid_max_fps);
    692     int32_t setEffect(const char *effect);
    693     int32_t setBrightness(int brightness);
    694     int32_t setFocusMode(const char *focusMode);
    695     int32_t setSharpness(int sharpness);
    696     int32_t setSaturation(int saturation);
    697     int32_t setContrast(int contrast);
    698     int32_t setSkinToneEnhancement(int sceFactor);
    699     int32_t setSceneDetect(const char *scendDetect);
    700     int32_t setVideoHDR(const char *videoHDR);
    701     int32_t setSensorSnapshotHDR(const char *snapshotHDR);
    702     int32_t setVtEnable(const char *vtEnable);
    703     int32_t setZoom(int zoom_level);
    704     int32_t setISOValue(const char *isoValue);
    705     int32_t setFlash(const char *flashStr);
    706     int32_t setAwbLock(const char *awbStr);
    707     int32_t setMCEValue(const char *mceStr);
    708     int32_t setDISValue(const char *disStr);
    709     int32_t setHighFrameRate(const char *hfrStr);
    710     int32_t setLensShadeValue(const char *lensShadeStr);
    711     int32_t setExposureCompensation(int expComp);
    712     int32_t setWhiteBalance(const char *wbStr);
    713     int32_t setAntibanding(const char *antiBandingStr);
    714     int32_t setFocusAreas(const char *focusAreasStr);
    715     int32_t setMeteringAreas(const char *meteringAreasStr);
    716     int32_t setSceneMode(const char *sceneModeStr);
    717     int32_t setSelectableZoneAf(const char *selZoneAFStr);
    718     int32_t setAEBracket(const char *aecBracketStr);
    719     int32_t setAFBracket(const char *afBracketStr);
    720     int32_t setChromaFlash(const char *chromaFlashStr);
    721     int32_t setOptiZoom(const char *optiZoomStr);
    722     int32_t setRedeyeReduction(const char *redeyeStr);
    723     int32_t setWaveletDenoise(const char *wnrStr);
    724     int32_t setFaceRecognition(const char *faceRecog, int maxFaces);
    725     int32_t setTintlessValue(const char *tintStr);
    726     bool UpdateHFRFrameRate(const QCameraParameters& params);
    727     int32_t setRdiMode(const char *str);
    728     int32_t setSecureMode(const char *str);
    729 
    730     int32_t parse_pair(const char *str, int *first, int *second,
    731                        char delim, char **endptr);
    732     void parseSizesList(const char *sizesStr, Vector<Size> &sizes);
    733     int32_t parseNDimVector(const char *str, int *num, int N, char delim);
    734     int32_t parseCameraAreaString(const char *str, int max_num_areas,
    735                                   cam_area_t *pAreas, int& num_areas_found);
    736     bool validateCameraAreas(cam_area_t *areas, int num_areas);
    737     int parseGPSCoordinate(const char *coord_str, rat_t *coord);
    738     int32_t getRational(rat_t *rat, int num, int denom);
    739     String8 createSizesString(const cam_dimension_t *sizes, int len);
    740     String8 createValuesString(const int *values, int len,
    741                                const QCameraMap *map, int map_len);
    742     String8 createValuesStringFromMap(const QCameraMap *map,
    743                                       int map_len);
    744     String8 createHfrValuesString(const cam_hfr_info_t *values, int len,
    745                                   const QCameraMap *map, int map_len);
    746     String8 createHfrSizesString(const cam_hfr_info_t *values, int len);
    747     String8 createFpsRangeString(const cam_fps_range_t *fps,
    748                                  int len,
    749                                  int &default_fps_index);
    750     String8 createFpsString(cam_fps_range_t &fps);
    751     String8 createZoomRatioValuesString(int *zoomRatios, int length);
    752     int lookupAttr(const QCameraMap arr[], int len, const char *name);
    753     const char *lookupNameByValue(const QCameraMap arr[], int len, int value);
    754 
    755     // ops for batch set/get params with server
    756     int32_t initBatchUpdate(parm_buffer_t *p_table);
    757     int32_t AddSetParmEntryToBatch(parm_buffer_t *p_table,
    758                                    cam_intf_parm_type_t paramType,
    759                                    uint32_t paramLength,
    760                                    void *paramValue);
    761     int32_t commitSetBatch();
    762     int32_t AddGetParmEntryToBatch(parm_buffer_t *p_table,
    763                                    cam_intf_parm_type_t paramType);
    764     int32_t commitGetBatch();
    765 
    766     // ops to tempororily update parameter entries and commit
    767     int32_t updateParamEntry(const char *key, const char *value);
    768     int32_t commitParamChanges();
    769 
    770     // Map from strings to values
    771     static const cam_dimension_t THUMBNAIL_SIZES_MAP[];
    772     static const QCameraMap AUTO_EXPOSURE_MAP[];
    773     static const QCameraMap PREVIEW_FORMATS_MAP[];
    774     static const QCameraMap PICTURE_TYPES_MAP[];
    775     static const QCameraMap RAW_FORMATS_MAP[];
    776     static const QCameraMap FOCUS_MODES_MAP[];
    777     static const QCameraMap SCENE_MODES_MAP[];
    778     static const QCameraMap FLASH_MODES_MAP[];
    779     static const QCameraMap FOCUS_ALGO_MAP[];
    780     static const QCameraMap WHITE_BALANCE_MODES_MAP[];
    781     static const QCameraMap ANTIBANDING_MODES_MAP[];
    782     static const QCameraMap ISO_MODES_MAP[];
    783     static const QCameraMap HFR_MODES_MAP[];
    784     static const QCameraMap BRACKETING_MODES_MAP[];
    785     static const QCameraMap ON_OFF_MODES_MAP[];
    786     static const QCameraMap ENABLE_DISABLE_MODES_MAP[];
    787     static const QCameraMap DENOISE_ON_OFF_MODES_MAP[];
    788     static const QCameraMap TRUE_FALSE_MODES_MAP[];
    789     static const QCameraMap TOUCH_AF_AEC_MODES_MAP[];
    790     static const QCameraMap FLIP_MODES_MAP[];
    791     static const QCameraMap AF_BRACKETING_MODES_MAP[];
    792     static const QCameraMap RE_FOCUS_MODES_MAP[];
    793     static const QCameraMap CHROMA_FLASH_MODES_MAP[];
    794     static const QCameraMap OPTI_ZOOM_MODES_MAP[];
    795     static const QCameraMap RDI_MODES_MAP[];
    796     static const QCameraMap CDS_MODES_MAP[];
    797 
    798     cam_capability_t *m_pCapability;
    799     mm_camera_vtbl_t *m_pCamOpsTbl;
    800     QCameraHeapMemory *m_pParamHeap;
    801     parm_buffer_t     *m_pParamBuf;  // ptr to param buf in m_pParamHeap
    802 
    803     bool m_bZslMode;                // if ZSL is enabled
    804     bool m_bZslMode_new;
    805     bool m_bRecordingHint;          // local copy of recording hint
    806     bool m_bRecordingHint_new;
    807     bool m_bHistogramEnabled;       // if histogram is enabled
    808     int  m_nFaceProcMask;           // face process mask
    809     bool m_bFaceDetectionOn;        //  if face Detection turned on by user
    810     bool m_bDebugFps;               // if FPS need to be logged
    811     cam_focus_mode_type mFocusMode;
    812     cam_format_t mPreviewFormat;
    813     int32_t mPictureFormat;         // could be CAMERA_PICTURE_TYPE_JPEG or cam_format_t
    814     bool m_bNeedRestart;            // if preview needs restart after parameters updated
    815     bool m_bNoDisplayMode;
    816     bool m_bWNROn;
    817     bool m_bInited;
    818     int m_nBurstNum;
    819     int m_nRetroBurstNum;
    820     int m_nBurstLEDOnPeriod;
    821     cam_exp_bracketing_t m_AEBracketingClient;
    822     bool m_bUpdateEffects;          // Cause reapplying of effects
    823     bool m_bSceneTransitionAuto;    // Indicate that scene has changed to Auto
    824     bool m_bPreviewFlipChanged;        // if flip setting for preview changed
    825     bool m_bVideoFlipChanged;          // if flip setting for video changed
    826     bool m_bSnapshotFlipChanged;       // if flip setting for snapshot changed
    827     bool m_bFixedFrameRateSet;      // Indicates that a fixed frame rate is set
    828     qcamera_thermal_mode m_ThermalMode; // adjust fps vs adjust frameskip
    829     cam_dimension_t m_LiveSnapshotSize; // live snapshot size
    830     cam_dimension_t m_rawSize; // live snapshot size
    831     bool m_bHDREnabled;             // if HDR is enabled
    832     bool m_bAVTimerEnabled;    //if AVTimer is enabled
    833     bool m_bDISEnabled;
    834 
    835     QCameraAdjustFPS *m_AdjustFPS;
    836     bool m_bHDR1xFrameEnabled;          // if frame with exposure compensation 0 during HDR is enabled
    837     bool m_HDRSceneEnabled; // Auto HDR indication
    838     bool m_bHDRThumbnailProcessNeeded;        // if thumbnail need to be processed for HDR
    839     bool m_bHDR1xExtraBufferNeeded;     // if extra frame with exposure compensation 0 during HDR is needed
    840     bool m_bHDROutputCropEnabled;     // if HDR output frame need to be scaled to user resolution
    841     QCameraTorchInterface *m_pTorch; // Interface for enabling torch
    842     bool m_bReleaseTorchCamera; // Release camera resources after torch gets disabled
    843 
    844     DefaultKeyedVector<String8,String8> m_tempMap; // map for temororily store parameters to be set
    845     cam_fps_range_t m_default_fps_range;
    846     bool m_bAFBracketingOn;
    847     bool m_bChromaFlashOn;
    848     bool m_bOptiZoomOn;
    849     bool m_bSceneSelection;
    850     Mutex m_SceneSelectLock;
    851     cam_scene_mode_type m_SelectedScene;
    852     cam_fps_range_t m_hfrFpsRange;
    853     bool m_bHfrMode;
    854     bool m_bSensorHDREnabled;             // if HDR is enabled
    855     bool m_bRdiMode;                // if RDI mode
    856     bool m_bUbiRefocus;
    857     bool m_bDisplayFrame;
    858     bool m_bSecureMode;
    859     bool m_bAeBracketingEnabled;
    860     int32_t mFlashValue;
    861     int32_t mFlashDaemonValue;
    862 
    863 };
    864 
    865 }; // namespace qcamera
    866 
    867 #endif
    868