1 /* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved. 2 * 3 * Redistribution and use in source and binary forms, with or without 4 * modification, are permitted provided that the following conditions are 5 * met: 6 * * Redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer. 8 * * Redistributions in binary form must reproduce the above 9 * copyright notice, this list of conditions and the following 10 * disclaimer in the documentation and/or other materials provided 11 * with the distribution. 12 * * Neither the name of The Linux Foundation nor the names of its 13 * contributors may be used to endorse or promote products derived 14 * from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 */ 29 30 #define LOG_TAG "QCameraParameters" 31 32 #include <cutils/properties.h> 33 #include <math.h> 34 #include <utils/Errors.h> 35 #include <string.h> 36 #include <stdlib.h> 37 #include <gralloc_priv.h> 38 #include "QCamera2HWI.h" 39 #include "QCameraParameters.h" 40 41 #define ASPECT_TOLERANCE 0.001 42 #define FLIP_V_H (FLIP_H | FLIP_V) 43 44 namespace qcamera { 45 // Parameter keys to communicate between camera application and driver. 46 const char QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES[] = "hfr-size-values"; 47 const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_MODE[] = "preview-frame-rate-mode"; 48 const char QCameraParameters::KEY_QC_SUPPORTED_PREVIEW_FRAME_RATE_MODES[] = "preview-frame-rate-modes"; 49 const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE[] = "frame-rate-auto"; 50 const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE[] = "frame-rate-fixed"; 51 const char QCameraParameters::KEY_QC_TOUCH_AF_AEC[] = "touch-af-aec"; 52 const char QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC[] = "touch-af-aec-values"; 53 const char QCameraParameters::KEY_QC_TOUCH_INDEX_AEC[] = "touch-index-aec"; 54 const char QCameraParameters::KEY_QC_TOUCH_INDEX_AF[] = "touch-index-af"; 55 const char QCameraParameters::KEY_QC_SCENE_DETECT[] = "scene-detect"; 56 const char QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT[] = "scene-detect-values"; 57 const char QCameraParameters::KEY_QC_ISO_MODE[] = "iso"; 58 const char QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES[] = "iso-values"; 59 const char QCameraParameters::KEY_QC_LENSSHADE[] = "lensshade"; 60 const char QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES[] = "lensshade-values"; 61 const char QCameraParameters::KEY_QC_AUTO_EXPOSURE[] = "auto-exposure"; 62 const char QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE[] = "auto-exposure-values"; 63 const char QCameraParameters::KEY_QC_DENOISE[] = "denoise"; 64 const char QCameraParameters::KEY_QC_SUPPORTED_DENOISE[] = "denoise-values"; 65 const char QCameraParameters::KEY_QC_FOCUS_ALGO[] = "selectable-zone-af"; 66 const char QCameraParameters::KEY_QC_SUPPORTED_FOCUS_ALGOS[] = "selectable-zone-af-values"; 67 const char QCameraParameters::KEY_QC_FACE_DETECTION[] = "face-detection"; 68 const char QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION[] = "face-detection-values"; 69 const char QCameraParameters::KEY_QC_FACE_RECOGNITION[] = "face-recognition"; 70 const char QCameraParameters::KEY_QC_SUPPORTED_FACE_RECOGNITION[] = "face-recognition-values"; 71 const char QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT[] = "mce"; 72 const char QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES[] = "mce-values"; 73 const char QCameraParameters::KEY_QC_DIS[] = "dis"; 74 const char QCameraParameters::KEY_QC_SUPPORTED_DIS_MODES[] = "dis-values"; 75 const char QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE[] = "video-hfr"; 76 const char QCameraParameters::KEY_QC_VIDEO_HIGH_SPEED_RECORDING[] = "video-hsr"; 77 const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[] = "video-hfr-values"; 78 const char QCameraParameters::KEY_QC_REDEYE_REDUCTION[] = "redeye-reduction"; 79 const char QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION[] = "redeye-reduction-values"; 80 const char QCameraParameters::KEY_QC_HIGH_DYNAMIC_RANGE_IMAGING[] = "hdr"; 81 const char QCameraParameters::KEY_QC_SUPPORTED_HDR_IMAGING_MODES[] = "hdr-values"; 82 const char QCameraParameters::KEY_QC_ZSL[] = "zsl"; 83 const char QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES[] = "zsl-values"; 84 const char QCameraParameters::KEY_QC_ZSL_BURST_INTERVAL[] = "capture-burst-interval"; 85 const char QCameraParameters::KEY_QC_ZSL_BURST_LOOKBACK[] = "capture-burst-retroactive"; 86 const char QCameraParameters::KEY_QC_ZSL_QUEUE_DEPTH[] = "capture-burst-queue-depth"; 87 const char QCameraParameters::KEY_QC_CAMERA_MODE[] = "camera-mode"; 88 const char QCameraParameters::KEY_QC_AE_BRACKET_HDR[] = "ae-bracket-hdr"; 89 const char QCameraParameters::KEY_QC_SUPPORTED_AE_BRACKET_MODES[] = "ae-bracket-hdr-values"; 90 const char QCameraParameters::KEY_QC_SUPPORTED_RAW_FORMATS[] = "raw-format-values"; 91 const char QCameraParameters::KEY_QC_RAW_FORMAT[] = "raw-format"; 92 const char QCameraParameters::KEY_QC_ORIENTATION[] = "orientation"; 93 const char QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF[] = "selectable-zone-af"; 94 const char QCameraParameters::KEY_QC_CAPTURE_BURST_EXPOSURE[] = "capture-burst-exposures"; 95 const char QCameraParameters::KEY_QC_NUM_SNAPSHOT_PER_SHUTTER[] = "num-snaps-per-shutter"; 96 const char QCameraParameters::KEY_QC_NUM_RETRO_BURST_PER_SHUTTER[] = "num-retro-burst-per-shutter"; 97 const char QCameraParameters::KEY_QC_SNAPSHOT_BURST_LED_ON_PERIOD[] = "zsl-burst-led-on-period"; 98 const char QCameraParameters::KEY_QC_NO_DISPLAY_MODE[] = "no-display-mode"; 99 const char QCameraParameters::KEY_QC_RAW_PICUTRE_SIZE[] = "raw-size"; 100 const char QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] = "skinToneEnhancement-values"; 101 const char QCameraParameters::KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES[] = "supported-live-snapshot-sizes"; 102 const char QCameraParameters::KEY_QC_HDR_NEED_1X[] = "hdr-need-1x"; 103 const char QCameraParameters::KEY_QC_PREVIEW_FLIP[] = "preview-flip"; 104 const char QCameraParameters::KEY_QC_VIDEO_FLIP[] = "video-flip"; 105 const char QCameraParameters::KEY_QC_SNAPSHOT_PICTURE_FLIP[] = "snapshot-picture-flip"; 106 const char QCameraParameters::KEY_QC_SUPPORTED_FLIP_MODES[] = "flip-mode-values"; 107 const char QCameraParameters::KEY_QC_VIDEO_HDR[] = "video-hdr"; 108 const char QCameraParameters::KEY_QC_SENSOR_HDR[] = "sensor-hdr"; 109 const char QCameraParameters::KEY_QC_VT_ENABLE[] = "avtimer"; 110 const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HDR_MODES[] = "video-hdr-values"; 111 const char QCameraParameters::KEY_QC_SUPPORTED_SENSOR_HDR_MODES[] = "sensor-hdr-values"; 112 const char QCameraParameters::KEY_QC_AUTO_HDR_ENABLE [] = "auto-hdr-enable"; 113 const char QCameraParameters::KEY_QC_SNAPSHOT_BURST_NUM[] = "snapshot-burst-num"; 114 const char QCameraParameters::KEY_QC_SNAPSHOT_FD_DATA[] = "snapshot-fd-data-enable"; 115 const char QCameraParameters::KEY_QC_TINTLESS_ENABLE[] = "tintless"; 116 const char QCameraParameters::KEY_QC_SCENE_SELECTION[] = "scene-selection"; 117 const char QCameraParameters::KEY_QC_CDS_MODE[] = "cds-mode"; 118 const char QCameraParameters::KEY_QC_VIDEO_ROTATION[] = "video-rotation"; 119 const char QCameraParameters::KEY_QC_AF_BRACKET[] = "af-bracket"; 120 const char QCameraParameters::KEY_QC_SUPPORTED_AF_BRACKET_MODES[] = "af-bracket-values"; 121 const char QCameraParameters::KEY_QC_RE_FOCUS[] = "re-focus"; 122 const char QCameraParameters::KEY_QC_SUPPORTED_RE_FOCUS_MODES[] = "re-focus-values"; 123 const char QCameraParameters::KEY_QC_CHROMA_FLASH[] = "chroma-flash"; 124 const char QCameraParameters::KEY_QC_SUPPORTED_CHROMA_FLASH_MODES[] = "chroma-flash-values"; 125 const char QCameraParameters::KEY_QC_OPTI_ZOOM[] = "opti-zoom"; 126 const char QCameraParameters::KEY_QC_SUPPORTED_OPTI_ZOOM_MODES[] = "opti-zoom-values"; 127 const char QCameraParameters::KEY_INTERNAL_PERVIEW_RESTART[] = "internal-restart"; 128 const char QCameraParameters::KEY_QC_RDI_MODE[] = "rdi-mode"; 129 const char QCameraParameters::KEY_QC_SUPPORTED_RDI_MODES[] = "rdi-mode-values"; 130 const char QCameraParameters::KEY_QC_SECURE_MODE[] = "secure-mode"; 131 const char QCameraParameters::KEY_QC_SUPPORTED_SECURE_MODES[] = "secure-mode-values"; 132 const char QCameraParameters::KEY_QC_AUTO_HDR_SUPPORTED[] = "auto-hdr-supported"; 133 134 // Values for effect settings. 135 const char QCameraParameters::EFFECT_EMBOSS[] = "emboss"; 136 const char QCameraParameters::EFFECT_SKETCH[] = "sketch"; 137 const char QCameraParameters::EFFECT_NEON[] = "neon"; 138 139 // Values for auto exposure settings. 140 const char QCameraParameters::TOUCH_AF_AEC_OFF[] = "touch-off"; 141 const char QCameraParameters::TOUCH_AF_AEC_ON[] = "touch-on"; 142 143 // Values for scene mode settings. 144 const char QCameraParameters::SCENE_MODE_ASD[] = "asd"; // corresponds to CAMERA_BESTSHOT_AUTO in HAL 145 const char QCameraParameters::SCENE_MODE_BACKLIGHT[] = "backlight"; 146 const char QCameraParameters::SCENE_MODE_FLOWERS[] = "flowers"; 147 const char QCameraParameters::SCENE_MODE_AR[] = "AR"; 148 const char QCameraParameters::SCENE_MODE_HDR[] = "hdr"; 149 150 // Formats for setPreviewFormat and setPictureFormat. 151 const char QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO[] = "yuv420sp-adreno"; 152 const char QCameraParameters::PIXEL_FORMAT_YV12[] = "yuv420p"; 153 const char QCameraParameters::PIXEL_FORMAT_NV12[] = "nv12"; 154 const char QCameraParameters::QC_PIXEL_FORMAT_NV12_VENUS[] = "nv12-venus"; 155 156 // Values for raw image formats 157 const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV[] = "yuv-raw8-yuyv"; 158 const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU[] = "yuv-raw8-yvyu"; 159 const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY[] = "yuv-raw8-uyvy"; 160 const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY[] = "yuv-raw8-vyuy"; 161 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG[] = "bayer-qcom-8gbrg"; 162 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG[] = "bayer-qcom-8grbg"; 163 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB[] = "bayer-qcom-8rggb"; 164 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR[] = "bayer-qcom-8bggr"; 165 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG[] = "bayer-qcom-10gbrg"; 166 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG[] = "bayer-qcom-10grbg"; 167 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB[] = "bayer-qcom-10rggb"; 168 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR[] = "bayer-qcom-10bggr"; 169 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG[] = "bayer-qcom-12gbrg"; 170 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG[] = "bayer-qcom-12grbg"; 171 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB[] = "bayer-qcom-12rggb"; 172 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR[] = "bayer-qcom-12bggr"; 173 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG[] = "bayer-mipi-8gbrg"; 174 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG[] = "bayer-mipi-8grbg"; 175 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB[] = "bayer-mipi-8rggb"; 176 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR[] = "bayer-mipi-8bggr"; 177 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG[] = "bayer-mipi-10gbrg"; 178 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG[] = "bayer-mipi-10grbg"; 179 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB[] = "bayer-mipi-10rggb"; 180 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR[] = "bayer-mipi-10bggr"; 181 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG[] = "bayer-mipi-12gbrg"; 182 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG[] = "bayer-mipi-12grbg"; 183 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB[] = "bayer-mipi-12rggb"; 184 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR[] = "bayer-mipi-12bggr"; 185 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG[] = "bayer-ideal-qcom-8gbrg"; 186 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG[] = "bayer-ideal-qcom-8grbg"; 187 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB[] = "bayer-ideal-qcom-8rggb"; 188 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR[] = "bayer-ideal-qcom-8bggr"; 189 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG[] = "bayer-ideal-qcom-10gbrg"; 190 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG[] = "bayer-ideal-qcom-10grbg"; 191 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB[] = "bayer-ideal-qcom-10rggb"; 192 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR[] = "bayer-ideal-qcom-10bggr"; 193 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG[] = "bayer-ideal-qcom-12gbrg"; 194 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG[] = "bayer-ideal-qcom-12grbg"; 195 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB[] = "bayer-ideal-qcom-12rggb"; 196 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR[] = "bayer-ideal-qcom-12bggr"; 197 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG[] = "bayer-ideal-mipi-8gbrg"; 198 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG[] = "bayer-ideal-mipi-8grbg"; 199 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB[] = "bayer-ideal-mipi-8rggb"; 200 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR[] = "bayer-ideal-mipi-8bggr"; 201 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG[] = "bayer-ideal-mipi-10gbrg"; 202 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG[] = "bayer-ideal-mipi-10grbg"; 203 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB[] = "bayer-ideal-mipi-10rggb"; 204 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR[] = "bayer-ideal-mipi-10bggr"; 205 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG[] = "bayer-ideal-mipi-12gbrg"; 206 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG[] = "bayer-ideal-mipi-12grbg"; 207 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB[] = "bayer-ideal-mipi-12rggb"; 208 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR[] = "bayer-ideal-mipi-12bggr"; 209 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG[] = "bayer-ideal-plain8-8gbrg"; 210 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG[] = "bayer-ideal-plain8-8grbg"; 211 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB[] = "bayer-ideal-plain8-8rggb"; 212 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR[] = "bayer-ideal-plain8-8bggr"; 213 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG[] = "bayer-ideal-plain16-8gbrg"; 214 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG[] = "bayer-ideal-plain16-8grbg"; 215 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB[] = "bayer-ideal-plain16-8rggb"; 216 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR[] = "bayer-ideal-plain16-8bggr"; 217 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG[] = "bayer-ideal-plain16-10gbrg"; 218 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG[] = "bayer-ideal-plain16-10grbg"; 219 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB[] = "bayer-ideal-plain16-10rggb"; 220 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR[] = "bayer-ideal-plain16-10bggr"; 221 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG[] = "bayer-ideal-plain16-12gbrg"; 222 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG[] = "bayer-ideal-plain16-12grbg"; 223 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB[] = "bayer-ideal-plain16-12rggb"; 224 const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR[] = "bayer-ideal-plain16-12bggr"; 225 226 // Values for ISO Settings 227 const char QCameraParameters::ISO_AUTO[] = "auto"; 228 const char QCameraParameters::ISO_HJR[] = "ISO_HJR"; 229 const char QCameraParameters::ISO_100[] = "ISO100"; 230 const char QCameraParameters::ISO_200[] = "ISO200"; 231 const char QCameraParameters::ISO_400[] = "ISO400"; 232 const char QCameraParameters::ISO_800[] = "ISO800"; 233 const char QCameraParameters::ISO_1600[] = "ISO1600"; 234 235 // Values for auto exposure settings. 236 const char QCameraParameters::AUTO_EXPOSURE_FRAME_AVG[] = "frame-average"; 237 const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED[] = "center-weighted"; 238 const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING[] = "spot-metering"; 239 const char QCameraParameters::AUTO_EXPOSURE_SMART_METERING[] = "smart-metering"; 240 const char QCameraParameters::AUTO_EXPOSURE_USER_METERING[] = "user-metering"; 241 const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING_ADV[] = "spot-metering-adv"; 242 const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED_ADV[] = "center-weighted-adv"; 243 244 const char QCameraParameters::KEY_QC_GPS_LATITUDE_REF[] = "gps-latitude-ref"; 245 const char QCameraParameters::KEY_QC_GPS_LONGITUDE_REF[] = "gps-longitude-ref"; 246 const char QCameraParameters::KEY_QC_GPS_ALTITUDE_REF[] = "gps-altitude-ref"; 247 const char QCameraParameters::KEY_QC_GPS_STATUS[] = "gps-status"; 248 249 const char QCameraParameters::KEY_QC_HISTOGRAM[] = "histogram"; 250 const char QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES[] = "histogram-values"; 251 252 const char QCameraParameters::VALUE_ENABLE[] = "enable"; 253 const char QCameraParameters::VALUE_DISABLE[] = "disable"; 254 const char QCameraParameters::VALUE_OFF[] = "off"; 255 const char QCameraParameters::VALUE_ON[] = "on"; 256 const char QCameraParameters::VALUE_TRUE[] = "true"; 257 const char QCameraParameters::VALUE_FALSE[] = "false"; 258 259 const char QCameraParameters::KEY_QC_SHARPNESS[] = "sharpness"; 260 const char QCameraParameters::KEY_QC_MIN_SHARPNESS[] = "min-sharpness"; 261 const char QCameraParameters::KEY_QC_MAX_SHARPNESS[] = "max-sharpness"; 262 const char QCameraParameters::KEY_QC_SHARPNESS_STEP[] = "sharpness-step"; 263 const char QCameraParameters::KEY_QC_CONTRAST[] = "contrast"; 264 const char QCameraParameters::KEY_QC_MIN_CONTRAST[] = "min-contrast"; 265 const char QCameraParameters::KEY_QC_MAX_CONTRAST[] = "max-contrast"; 266 const char QCameraParameters::KEY_QC_CONTRAST_STEP[] = "contrast-step"; 267 const char QCameraParameters::KEY_QC_SATURATION[] = "saturation"; 268 const char QCameraParameters::KEY_QC_MIN_SATURATION[] = "min-saturation"; 269 const char QCameraParameters::KEY_QC_MAX_SATURATION[] = "max-saturation"; 270 const char QCameraParameters::KEY_QC_SATURATION_STEP[] = "saturation-step"; 271 const char QCameraParameters::KEY_QC_BRIGHTNESS[] = "luma-adaptation"; 272 const char QCameraParameters::KEY_QC_MIN_BRIGHTNESS[] = "min-brightness"; 273 const char QCameraParameters::KEY_QC_MAX_BRIGHTNESS[] = "max-brightness"; 274 const char QCameraParameters::KEY_QC_BRIGHTNESS_STEP[] = "brightness-step"; 275 const char QCameraParameters::KEY_QC_SCE_FACTOR[] = "skinToneEnhancement"; 276 const char QCameraParameters::KEY_QC_MIN_SCE_FACTOR[] = "min-sce-factor"; 277 const char QCameraParameters::KEY_QC_MAX_SCE_FACTOR[] = "max-sce-factor"; 278 const char QCameraParameters::KEY_QC_SCE_FACTOR_STEP[] = "sce-factor-step"; 279 280 const char QCameraParameters::KEY_QC_SUPPORTED_CAMERA_FEATURES[] = "qc-camera-features"; 281 const char QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES[] = "qc-max-num-requested-faces"; 282 283 //Values for DENOISE 284 const char QCameraParameters::DENOISE_OFF[] = "denoise-off"; 285 const char QCameraParameters::DENOISE_ON[] = "denoise-on"; 286 287 // Values for selectable zone af Settings 288 const char QCameraParameters::FOCUS_ALGO_AUTO[] = "auto"; 289 const char QCameraParameters::FOCUS_ALGO_SPOT_METERING[] = "spot-metering"; 290 const char QCameraParameters::FOCUS_ALGO_CENTER_WEIGHTED[] = "center-weighted"; 291 const char QCameraParameters::FOCUS_ALGO_FRAME_AVERAGE[] = "frame-average"; 292 293 // Values for HFR settings. 294 const char QCameraParameters::VIDEO_HFR_OFF[] = "off"; 295 const char QCameraParameters::VIDEO_HFR_2X[] = "60"; 296 const char QCameraParameters::VIDEO_HFR_3X[] = "90"; 297 const char QCameraParameters::VIDEO_HFR_4X[] = "120"; 298 const char QCameraParameters::VIDEO_HFR_5X[] = "150"; 299 300 // Values for HDR Bracketing settings. 301 const char QCameraParameters::AE_BRACKET_OFF[] = "Off"; 302 const char QCameraParameters::AE_BRACKET[] = "AE-Bracket"; 303 304 // Values for AF Bracketing setting. 305 const char QCameraParameters::AF_BRACKET_OFF[] = "af-bracket-off"; 306 const char QCameraParameters::AF_BRACKET_ON[] = "af-bracket-on"; 307 308 // Values for Refocus setting. 309 const char QCameraParameters::RE_FOCUS_OFF[] = "re-focus-off"; 310 const char QCameraParameters::RE_FOCUS_ON[] = "re-focus-on"; 311 312 // Values for Chroma Flash setting. 313 const char QCameraParameters::CHROMA_FLASH_OFF[] = "chroma-flash-off"; 314 const char QCameraParameters::CHROMA_FLASH_ON[] = "chroma-flash-on"; 315 316 // Values for Opti Zoom setting. 317 const char QCameraParameters::OPTI_ZOOM_OFF[] = "opti-zoom-off"; 318 const char QCameraParameters::OPTI_ZOOM_ON[] = "opti-zoom-on"; 319 320 // Values for FLIP settings. 321 const char QCameraParameters::FLIP_MODE_OFF[] = "off"; 322 const char QCameraParameters::FLIP_MODE_V[] = "flip-v"; 323 const char QCameraParameters::FLIP_MODE_H[] = "flip-h"; 324 const char QCameraParameters::FLIP_MODE_VH[] = "flip-vh"; 325 326 const char QCameraParameters::CDS_MODE_OFF[] = "off"; 327 const char QCameraParameters::CDS_MODE_ON[] = "on"; 328 const char QCameraParameters::CDS_MODE_AUTO[] = "auto"; 329 330 const char QCameraParameters::KEY_SELECTED_AUTO_SCENE[] = "selected-auto-scene"; 331 332 static const char* portrait = "portrait"; 333 static const char* landscape = "landscape"; 334 335 const cam_dimension_t QCameraParameters::THUMBNAIL_SIZES_MAP[] = { 336 { 512, 288 }, //1.777778 337 { 480, 288 }, //1.666667 338 { 256, 154 }, //1.66233 339 { 432, 288 }, //1.5 340 { 320, 240 }, //1.33333 341 { 176, 144 }, //1.222222 342 { 0, 0 } // required by Android SDK 343 }; 344 345 const QCameraParameters::QCameraMap QCameraParameters::AUTO_EXPOSURE_MAP[] = { 346 { AUTO_EXPOSURE_FRAME_AVG, CAM_AEC_MODE_FRAME_AVERAGE }, 347 { AUTO_EXPOSURE_CENTER_WEIGHTED, CAM_AEC_MODE_CENTER_WEIGHTED }, 348 { AUTO_EXPOSURE_SPOT_METERING, CAM_AEC_MODE_SPOT_METERING }, 349 { AUTO_EXPOSURE_SMART_METERING, CAM_AEC_MODE_SMART_METERING }, 350 { AUTO_EXPOSURE_USER_METERING, CAM_AEC_MODE_USER_METERING }, 351 { AUTO_EXPOSURE_SPOT_METERING_ADV, CAM_AEC_MODE_SPOT_METERING_ADV }, 352 { AUTO_EXPOSURE_CENTER_WEIGHTED_ADV, CAM_AEC_MODE_CENTER_WEIGHTED_ADV }, 353 }; 354 355 const QCameraParameters::QCameraMap QCameraParameters::PREVIEW_FORMATS_MAP[] = { 356 {PIXEL_FORMAT_YUV420SP, CAM_FORMAT_YUV_420_NV21}, 357 {PIXEL_FORMAT_YUV420P, CAM_FORMAT_YUV_420_YV12}, 358 {PIXEL_FORMAT_YUV420SP_ADRENO, CAM_FORMAT_YUV_420_NV21_ADRENO}, 359 {PIXEL_FORMAT_YV12, CAM_FORMAT_YUV_420_YV12}, 360 {PIXEL_FORMAT_NV12, CAM_FORMAT_YUV_420_NV12}, 361 {QC_PIXEL_FORMAT_NV12_VENUS, CAM_FORMAT_YUV_420_NV12_VENUS} 362 }; 363 364 const QCameraParameters::QCameraMap QCameraParameters::PICTURE_TYPES_MAP[] = { 365 {PIXEL_FORMAT_JPEG, CAM_FORMAT_JPEG}, 366 {PIXEL_FORMAT_YUV420SP, CAM_FORMAT_YUV_420_NV21}, 367 {PIXEL_FORMAT_YUV422SP, CAM_FORMAT_YUV_422_NV16}, 368 {QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV, CAM_FORMAT_YUV_RAW_8BIT_YUYV}, 369 {QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU, CAM_FORMAT_YUV_RAW_8BIT_YVYU}, 370 {QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY, CAM_FORMAT_YUV_RAW_8BIT_UYVY}, 371 {QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY, CAM_FORMAT_YUV_RAW_8BIT_VYUY}, 372 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GBRG}, 373 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GRBG}, 374 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_RGGB}, 375 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_BGGR}, 376 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GBRG}, 377 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GRBG}, 378 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_RGGB}, 379 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_BGGR}, 380 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GBRG}, 381 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GRBG}, 382 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_RGGB}, 383 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_BGGR}, 384 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GBRG}, 385 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GRBG}, 386 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_RGGB}, 387 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_BGGR}, 388 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG}, 389 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GRBG}, 390 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_RGGB}, 391 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_BGGR}, 392 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GBRG}, 393 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GRBG}, 394 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_RGGB}, 395 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_BGGR}, 396 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GBRG}, 397 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GRBG}, 398 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_RGGB}, 399 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_BGGR}, 400 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GBRG}, 401 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GRBG}, 402 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_RGGB}, 403 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_BGGR}, 404 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GBRG}, 405 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GRBG}, 406 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_RGGB}, 407 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_BGGR}, 408 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GBRG}, 409 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GRBG}, 410 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_RGGB}, 411 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_BGGR}, 412 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GBRG}, 413 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GRBG}, 414 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_RGGB}, 415 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_BGGR}, 416 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GBRG}, 417 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GRBG}, 418 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_RGGB}, 419 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_BGGR}, 420 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GBRG}, 421 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GRBG}, 422 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_RGGB}, 423 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_BGGR}, 424 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GBRG}, 425 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GRBG}, 426 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_RGGB}, 427 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_BGGR}, 428 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GBRG}, 429 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GRBG}, 430 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_RGGB}, 431 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_BGGR}, 432 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GBRG}, 433 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GRBG}, 434 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_RGGB}, 435 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_BGGR} 436 }; 437 438 const QCameraParameters::QCameraMap QCameraParameters::RAW_FORMATS_MAP[] = { 439 }; 440 441 const QCameraParameters::QCameraMap QCameraParameters::FOCUS_MODES_MAP[] = { 442 { FOCUS_MODE_AUTO, CAM_FOCUS_MODE_AUTO }, 443 { FOCUS_MODE_INFINITY, CAM_FOCUS_MODE_INFINITY }, 444 { FOCUS_MODE_MACRO, CAM_FOCUS_MODE_MACRO }, 445 { FOCUS_MODE_FIXED, CAM_FOCUS_MODE_FIXED }, 446 { FOCUS_MODE_EDOF, CAM_FOCUS_MODE_EDOF }, 447 { FOCUS_MODE_CONTINUOUS_PICTURE, CAM_FOCUS_MODE_CONTINOUS_PICTURE }, 448 { FOCUS_MODE_CONTINUOUS_VIDEO, CAM_FOCUS_MODE_CONTINOUS_VIDEO } 449 }; 450 451 const QCameraParameters::QCameraMap QCameraParameters::EFFECT_MODES_MAP[] = { 452 { EFFECT_NONE, CAM_EFFECT_MODE_OFF }, 453 { EFFECT_MONO, CAM_EFFECT_MODE_MONO }, 454 { EFFECT_NEGATIVE, CAM_EFFECT_MODE_NEGATIVE }, 455 { EFFECT_SOLARIZE, CAM_EFFECT_MODE_SOLARIZE }, 456 { EFFECT_SEPIA, CAM_EFFECT_MODE_SEPIA }, 457 { EFFECT_POSTERIZE, CAM_EFFECT_MODE_POSTERIZE }, 458 { EFFECT_WHITEBOARD, CAM_EFFECT_MODE_WHITEBOARD }, 459 { EFFECT_BLACKBOARD, CAM_EFFECT_MODE_BLACKBOARD }, 460 { EFFECT_AQUA, CAM_EFFECT_MODE_AQUA }, 461 { EFFECT_EMBOSS, CAM_EFFECT_MODE_EMBOSS }, 462 { EFFECT_SKETCH, CAM_EFFECT_MODE_SKETCH }, 463 { EFFECT_NEON, CAM_EFFECT_MODE_NEON } 464 }; 465 466 const QCameraParameters::QCameraMap QCameraParameters::SCENE_MODES_MAP[] = { 467 { SCENE_MODE_AUTO, CAM_SCENE_MODE_OFF }, 468 { SCENE_MODE_ACTION, CAM_SCENE_MODE_ACTION }, 469 { SCENE_MODE_PORTRAIT, CAM_SCENE_MODE_PORTRAIT }, 470 { SCENE_MODE_LANDSCAPE, CAM_SCENE_MODE_LANDSCAPE }, 471 { SCENE_MODE_NIGHT, CAM_SCENE_MODE_NIGHT }, 472 { SCENE_MODE_NIGHT_PORTRAIT, CAM_SCENE_MODE_NIGHT_PORTRAIT }, 473 { SCENE_MODE_THEATRE, CAM_SCENE_MODE_THEATRE }, 474 { SCENE_MODE_BEACH, CAM_SCENE_MODE_BEACH }, 475 { SCENE_MODE_SNOW, CAM_SCENE_MODE_SNOW }, 476 { SCENE_MODE_SUNSET, CAM_SCENE_MODE_SUNSET }, 477 { SCENE_MODE_STEADYPHOTO, CAM_SCENE_MODE_ANTISHAKE }, 478 { SCENE_MODE_FIREWORKS , CAM_SCENE_MODE_FIREWORKS }, 479 { SCENE_MODE_SPORTS , CAM_SCENE_MODE_SPORTS }, 480 { SCENE_MODE_PARTY, CAM_SCENE_MODE_PARTY }, 481 { SCENE_MODE_CANDLELIGHT, CAM_SCENE_MODE_CANDLELIGHT }, 482 { SCENE_MODE_ASD, CAM_SCENE_MODE_AUTO }, 483 { SCENE_MODE_BACKLIGHT, CAM_SCENE_MODE_BACKLIGHT }, 484 { SCENE_MODE_FLOWERS, CAM_SCENE_MODE_FLOWERS }, 485 { SCENE_MODE_AR, CAM_SCENE_MODE_AR }, 486 { SCENE_MODE_HDR, CAM_SCENE_MODE_HDR }, 487 }; 488 489 const QCameraParameters::QCameraMap QCameraParameters::FLASH_MODES_MAP[] = { 490 { FLASH_MODE_OFF, CAM_FLASH_MODE_OFF }, 491 { FLASH_MODE_AUTO, CAM_FLASH_MODE_AUTO }, 492 { FLASH_MODE_ON, CAM_FLASH_MODE_ON }, 493 { FLASH_MODE_TORCH, CAM_FLASH_MODE_TORCH } 494 }; 495 496 const QCameraParameters::QCameraMap QCameraParameters::FOCUS_ALGO_MAP[] = { 497 { FOCUS_ALGO_AUTO, CAM_FOCUS_ALGO_AUTO }, 498 { FOCUS_ALGO_SPOT_METERING, CAM_FOCUS_ALGO_SPOT }, 499 { FOCUS_ALGO_CENTER_WEIGHTED, CAM_FOCUS_ALGO_CENTER_WEIGHTED }, 500 { FOCUS_ALGO_FRAME_AVERAGE, CAM_FOCUS_ALGO_AVERAGE } 501 }; 502 503 const QCameraParameters::QCameraMap QCameraParameters::WHITE_BALANCE_MODES_MAP[] = { 504 { WHITE_BALANCE_AUTO, CAM_WB_MODE_AUTO }, 505 { WHITE_BALANCE_INCANDESCENT, CAM_WB_MODE_INCANDESCENT }, 506 { WHITE_BALANCE_FLUORESCENT, CAM_WB_MODE_FLUORESCENT }, 507 { WHITE_BALANCE_WARM_FLUORESCENT,CAM_WB_MODE_WARM_FLUORESCENT}, 508 { WHITE_BALANCE_DAYLIGHT, CAM_WB_MODE_DAYLIGHT }, 509 { WHITE_BALANCE_CLOUDY_DAYLIGHT, CAM_WB_MODE_CLOUDY_DAYLIGHT }, 510 { WHITE_BALANCE_TWILIGHT, CAM_WB_MODE_TWILIGHT }, 511 { WHITE_BALANCE_SHADE, CAM_WB_MODE_SHADE } 512 }; 513 514 const QCameraParameters::QCameraMap QCameraParameters::ANTIBANDING_MODES_MAP[] = { 515 { ANTIBANDING_OFF, CAM_ANTIBANDING_MODE_OFF }, 516 { ANTIBANDING_50HZ, CAM_ANTIBANDING_MODE_50HZ }, 517 { ANTIBANDING_60HZ, CAM_ANTIBANDING_MODE_60HZ }, 518 { ANTIBANDING_AUTO, CAM_ANTIBANDING_MODE_AUTO } 519 }; 520 521 const QCameraParameters::QCameraMap QCameraParameters::ISO_MODES_MAP[] = { 522 { ISO_AUTO, CAM_ISO_MODE_AUTO }, 523 { ISO_HJR, CAM_ISO_MODE_DEBLUR }, 524 { ISO_100, CAM_ISO_MODE_100 }, 525 { ISO_200, CAM_ISO_MODE_200 }, 526 { ISO_400, CAM_ISO_MODE_400 }, 527 { ISO_800, CAM_ISO_MODE_800 }, 528 { ISO_1600, CAM_ISO_MODE_1600 } 529 }; 530 531 const QCameraParameters::QCameraMap QCameraParameters::HFR_MODES_MAP[] = { 532 { VIDEO_HFR_OFF, CAM_HFR_MODE_OFF }, 533 { VIDEO_HFR_2X, CAM_HFR_MODE_60FPS }, 534 { VIDEO_HFR_3X, CAM_HFR_MODE_90FPS }, 535 { VIDEO_HFR_4X, CAM_HFR_MODE_120FPS }, 536 { VIDEO_HFR_5X, CAM_HFR_MODE_150FPS } 537 }; 538 539 const QCameraParameters::QCameraMap QCameraParameters::BRACKETING_MODES_MAP[] = { 540 { AE_BRACKET_OFF, CAM_EXP_BRACKETING_OFF }, 541 { AE_BRACKET, CAM_EXP_BRACKETING_ON } 542 }; 543 544 const QCameraParameters::QCameraMap QCameraParameters::ON_OFF_MODES_MAP[] = { 545 { VALUE_OFF, 0 }, 546 { VALUE_ON, 1 } 547 }; 548 549 const QCameraParameters::QCameraMap QCameraParameters::TOUCH_AF_AEC_MODES_MAP[] = { 550 { QCameraParameters::TOUCH_AF_AEC_OFF, 0 }, 551 { QCameraParameters::TOUCH_AF_AEC_ON, 1 } 552 }; 553 554 const QCameraParameters::QCameraMap QCameraParameters::ENABLE_DISABLE_MODES_MAP[] = { 555 { VALUE_ENABLE, 1 }, 556 { VALUE_DISABLE, 0 } 557 }; 558 559 const QCameraParameters::QCameraMap QCameraParameters::DENOISE_ON_OFF_MODES_MAP[] = { 560 { DENOISE_OFF, 0 }, 561 { DENOISE_ON, 1 } 562 }; 563 564 const QCameraParameters::QCameraMap QCameraParameters::TRUE_FALSE_MODES_MAP[] = { 565 { VALUE_FALSE, 0}, 566 { VALUE_TRUE, 1} 567 }; 568 569 const QCameraParameters::QCameraMap QCameraParameters::FLIP_MODES_MAP[] = { 570 {FLIP_MODE_OFF, 0}, 571 {FLIP_MODE_V, FLIP_V}, 572 {FLIP_MODE_H, FLIP_H}, 573 {FLIP_MODE_VH, FLIP_V_H} 574 }; 575 576 const QCameraParameters::QCameraMap QCameraParameters::AF_BRACKETING_MODES_MAP[] = { 577 { AF_BRACKET_OFF, 0 }, 578 { AF_BRACKET_ON, 1 } 579 }; 580 581 const QCameraParameters::QCameraMap QCameraParameters::RE_FOCUS_MODES_MAP[] = { 582 { RE_FOCUS_OFF, 0 }, 583 { RE_FOCUS_ON, 1 } 584 }; 585 586 const QCameraParameters::QCameraMap QCameraParameters::CHROMA_FLASH_MODES_MAP[] = { 587 { CHROMA_FLASH_OFF, 0 }, 588 { CHROMA_FLASH_ON, 1 } 589 }; 590 591 const QCameraParameters::QCameraMap QCameraParameters::OPTI_ZOOM_MODES_MAP[] = { 592 { OPTI_ZOOM_OFF, 0 }, 593 { OPTI_ZOOM_ON, 1 } 594 }; 595 596 const QCameraParameters::QCameraMap QCameraParameters::CDS_MODES_MAP[] = { 597 { CDS_MODE_OFF, CAM_CDS_MODE_OFF }, 598 { CDS_MODE_ON, CAM_CDS_MODE_ON }, 599 { CDS_MODE_AUTO, CAM_CDS_MODE_AUTO} 600 }; 601 602 #define DEFAULT_CAMERA_AREA "(0, 0, 0, 0, 0)" 603 #define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX ) 604 605 /*=========================================================================== 606 * FUNCTION : QCameraParameters 607 * 608 * DESCRIPTION: default constructor of QCameraParameters 609 * 610 * PARAMETERS : none 611 * 612 * RETURN : None 613 *==========================================================================*/ 614 QCameraParameters::QCameraParameters() 615 : CameraParameters(), 616 m_reprocScaleParam(this), 617 m_pCapability(NULL), 618 m_pCamOpsTbl(NULL), 619 m_pParamHeap(NULL), 620 m_pParamBuf(NULL), 621 m_bZslMode(false), 622 m_bZslMode_new(false), 623 m_bRecordingHint(false), 624 m_bRecordingHint_new(false), 625 m_bHistogramEnabled(false), 626 m_nFaceProcMask(0), 627 m_bFaceDetectionOn(0), 628 m_bDebugFps(false), 629 mFocusMode(CAM_FOCUS_MODE_MAX), 630 mPreviewFormat(CAM_FORMAT_YUV_420_NV21), 631 mPictureFormat(CAM_FORMAT_JPEG), 632 m_bNeedRestart(false), 633 m_bNoDisplayMode(false), 634 m_bWNROn(false), 635 m_bInited(false), 636 m_nBurstNum(1), 637 m_nRetroBurstNum(0), 638 m_nBurstLEDOnPeriod(100), 639 m_bUpdateEffects(false), 640 m_bSceneTransitionAuto(false), 641 m_bPreviewFlipChanged(false), 642 m_bVideoFlipChanged(false), 643 m_bSnapshotFlipChanged(false), 644 m_bFixedFrameRateSet(false), 645 m_bHDREnabled(false), 646 m_bAVTimerEnabled(false), 647 m_bDISEnabled(false), 648 m_AdjustFPS(NULL), 649 m_bHDR1xFrameEnabled(true), 650 m_HDRSceneEnabled(false), 651 m_bHDRThumbnailProcessNeeded(false), 652 m_bHDR1xExtraBufferNeeded(true), 653 m_bHDROutputCropEnabled(false), 654 m_tempMap(), 655 m_bAFBracketingOn(false), 656 m_bChromaFlashOn(false), 657 m_bOptiZoomOn(false), 658 m_bSceneSelection(false), 659 m_SelectedScene(CAM_SCENE_MODE_MAX), 660 m_bHfrMode(false), 661 m_bSensorHDREnabled(false), 662 m_bRdiMode(false), 663 m_bDisplayFrame(true), 664 m_bSecureMode(false), 665 m_bAeBracketingEnabled(false), 666 mFlashValue(CAM_FLASH_MODE_OFF), 667 mFlashDaemonValue(CAM_FLASH_MODE_OFF) 668 { 669 char value[PROPERTY_VALUE_MAX]; 670 // TODO: may move to parameter instead of sysprop 671 property_get("persist.debug.sf.showfps", value, "0"); 672 m_bDebugFps = atoi(value) > 0 ? true : false; 673 m_bReleaseTorchCamera = false; 674 m_pTorch = NULL; 675 676 // For thermal mode, it should be set as system property 677 // because system property applies to all applications, while 678 // parameters only apply to specific app. 679 property_get("persist.camera.thermal.mode", value, "fps"); 680 if (!strcmp(value, "frameskip")) { 681 m_ThermalMode = QCAMERA_THERMAL_ADJUST_FRAMESKIP; 682 } else { 683 if (strcmp(value, "fps")) 684 ALOGE("%s: Invalid camera thermal mode %s", __func__, value); 685 m_ThermalMode = QCAMERA_THERMAL_ADJUST_FPS; 686 } 687 688 memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize)); 689 memset(&m_default_fps_range, 0, sizeof(m_default_fps_range)); 690 memset(&m_hfrFpsRange, 0, sizeof(m_hfrFpsRange)); 691 } 692 693 /*=========================================================================== 694 * FUNCTION : QCameraParameters 695 * 696 * DESCRIPTION: constructor of QCameraParameters 697 * 698 * PARAMETERS : 699 * @params : parameters in string 700 * 701 * RETURN : None 702 *==========================================================================*/ 703 QCameraParameters::QCameraParameters(const String8 ¶ms) 704 : CameraParameters(params), 705 m_reprocScaleParam(this), 706 m_pCapability(NULL), 707 m_pCamOpsTbl(NULL), 708 m_pParamHeap(NULL), 709 m_pParamBuf(NULL), 710 m_bZslMode(false), 711 m_bZslMode_new(false), 712 m_bRecordingHint(false), 713 m_bRecordingHint_new(false), 714 m_bHistogramEnabled(false), 715 m_nFaceProcMask(0), 716 m_bDebugFps(false), 717 mFocusMode(CAM_FOCUS_MODE_MAX), 718 mPreviewFormat(CAM_FORMAT_YUV_420_NV21), 719 mPictureFormat(CAM_FORMAT_JPEG), 720 m_bNeedRestart(false), 721 m_bNoDisplayMode(false), 722 m_bWNROn(false), 723 m_bInited(false), 724 m_nBurstNum(1), 725 m_nRetroBurstNum(0), 726 m_nBurstLEDOnPeriod(100), 727 m_bPreviewFlipChanged(false), 728 m_bVideoFlipChanged(false), 729 m_bSnapshotFlipChanged(false), 730 m_bFixedFrameRateSet(false), 731 m_bHDREnabled(false), 732 m_bAVTimerEnabled(false), 733 m_AdjustFPS(NULL), 734 m_bHDR1xFrameEnabled(true), 735 m_HDRSceneEnabled(false), 736 m_bHDRThumbnailProcessNeeded(false), 737 m_bHDR1xExtraBufferNeeded(true), 738 m_bHDROutputCropEnabled(false), 739 m_tempMap(), 740 m_bAFBracketingOn(false), 741 m_bChromaFlashOn(false), 742 m_bOptiZoomOn(false), 743 m_bSceneSelection(false), 744 m_SelectedScene(CAM_SCENE_MODE_MAX), 745 m_bHfrMode(false), 746 m_bSensorHDREnabled(false), 747 m_bRdiMode(false), 748 m_bSecureMode(false), 749 m_bAeBracketingEnabled(false), 750 mFlashValue(CAM_FLASH_MODE_OFF), 751 mFlashDaemonValue(CAM_FLASH_MODE_OFF) 752 { 753 memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize)); 754 memset(&m_default_fps_range, 0, sizeof(m_default_fps_range)); 755 memset(&m_hfrFpsRange, 0, sizeof(m_hfrFpsRange)); 756 m_pTorch = NULL; 757 m_bReleaseTorchCamera = false; 758 } 759 760 /*=========================================================================== 761 * FUNCTION : ~QCameraParameters 762 * 763 * DESCRIPTION: deconstructor of QCameraParameters 764 * 765 * PARAMETERS : none 766 * 767 * RETURN : None 768 *==========================================================================*/ 769 QCameraParameters::~QCameraParameters() 770 { 771 deinit(); 772 } 773 774 /*=========================================================================== 775 * FUNCTION : createSizesString 776 * 777 * DESCRIPTION: create string obj contains array of dimensions 778 * 779 * PARAMETERS : 780 * @sizes : array of dimensions 781 * @len : size of dimension array 782 * 783 * RETURN : string obj 784 *==========================================================================*/ 785 String8 QCameraParameters::createSizesString(const cam_dimension_t *sizes, int len) 786 { 787 String8 str; 788 char buffer[32]; 789 790 if (len > 0) { 791 snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height); 792 str.append(buffer); 793 } 794 for (int i = 1; i < len; i++) { 795 snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height); 796 str.append(buffer); 797 } 798 return str; 799 } 800 801 /*=========================================================================== 802 * FUNCTION : createValuesString 803 * 804 * DESCRIPTION: create string obj contains array of values from map when matched 805 * from input values array 806 * 807 * PARAMETERS : 808 * @values : array of values 809 * @len : size of values array 810 * @map : map contains the mapping between values and enums 811 * @map_len : size of the map 812 * 813 * RETURN : string obj 814 *==========================================================================*/ 815 String8 QCameraParameters::createValuesString(const int *values, 816 int len, 817 const QCameraMap* map, 818 int map_len) 819 { 820 String8 str; 821 int count = 0; 822 823 for (int i = 0; i < len; i++ ) { 824 for (int j = 0; j < map_len; j ++) 825 if (map[j].val == values[i]) { 826 if (NULL != map[j].desc) { 827 if (count > 0) { 828 str.append(","); 829 } 830 str.append(map[j].desc); 831 count++; 832 break; //loop j 833 } 834 } 835 } 836 return str; 837 } 838 839 /*=========================================================================== 840 * FUNCTION : createValuesStringFromMap 841 * 842 * DESCRIPTION: create string obj contains array of values directly from map 843 * 844 * PARAMETERS : 845 * @map : map contains the mapping between values and enums 846 * @map_len : size of the map 847 * 848 * RETURN : string obj 849 *==========================================================================*/ 850 String8 QCameraParameters::createValuesStringFromMap(const QCameraMap* map, 851 int map_len) 852 { 853 String8 str; 854 855 for (int i = 0; i < map_len; i++) { 856 if (NULL != map[i].desc) { 857 if (i > 0) { 858 str.append(","); 859 } 860 str.append(map[i].desc); 861 } 862 } 863 return str; 864 } 865 866 /*=========================================================================== 867 * FUNCTION : createZoomRatioValuesString 868 * 869 * DESCRIPTION: create string obj contains array of zoom ratio values 870 * 871 * PARAMETERS : 872 * @zoomRaios : array of zoom ratios 873 * @length : size of the array 874 * 875 * RETURN : string obj 876 *==========================================================================*/ 877 String8 QCameraParameters::createZoomRatioValuesString(int *zoomRatios, int length) 878 { 879 String8 str; 880 char buffer[32] = {0}; 881 882 if(length > 0){ 883 snprintf(buffer, sizeof(buffer), "%d", zoomRatios[0]); 884 str.append(buffer); 885 } 886 887 for (int i =1;i<length;i++){ 888 memset(buffer, 0, sizeof(buffer)); 889 snprintf(buffer, sizeof(buffer), ",%d", zoomRatios[i]); 890 str.append(buffer); 891 } 892 return str; 893 } 894 895 /*=========================================================================== 896 * FUNCTION : createHfrValuesString 897 * 898 * DESCRIPTION: create string obj contains array of hfr values from map when 899 * matched from input hfr values 900 * 901 * PARAMETERS : 902 * @values : array of hfr info 903 * @len : size of the array 904 * @map : map of hfr string value and enum 905 * map_len : size of map 906 * 907 * RETURN : string obj 908 *==========================================================================*/ 909 String8 QCameraParameters::createHfrValuesString( 910 const cam_hfr_info_t *values, 911 int len, 912 const QCameraMap* map, 913 int map_len) 914 { 915 String8 str; 916 int count = 0; 917 918 for (int i = 0; i < len; i++ ) { 919 for (int j = 0; j < map_len; j ++) 920 if (map[j].val == (int)values[i].mode) { 921 if (NULL != map[j].desc) { 922 if (count > 0) { 923 str.append(","); 924 } 925 str.append(map[j].desc); 926 count++; 927 break; //loop j 928 } 929 } 930 } 931 if (count > 0) { 932 str.append(","); 933 } 934 str.append(VIDEO_HFR_OFF); 935 return str; 936 } 937 938 /*=========================================================================== 939 * FUNCTION : createHfrSizesString 940 * 941 * DESCRIPTION: create string obj contains array of hfr sizes 942 * 943 * PARAMETERS : 944 * @values : array of hfr info 945 * @len : size of the array 946 * 947 * RETURN : string obj 948 *==========================================================================*/ 949 String8 QCameraParameters::createHfrSizesString( 950 const cam_hfr_info_t *values, 951 int len) 952 { 953 String8 str; 954 char buffer[32]; 955 956 if (len > 0) { 957 snprintf(buffer, sizeof(buffer), "%dx%d", 958 values[0].dim.width, values[0].dim.height); 959 str.append(buffer); 960 } 961 for (int i = 1; i < len; i++) { 962 snprintf(buffer, sizeof(buffer), ",%dx%d", 963 values[i].dim.width, values[i].dim.height); 964 str.append(buffer); 965 } 966 return str; 967 } 968 969 /*=========================================================================== 970 * FUNCTION : createFpsString 971 * 972 * DESCRIPTION: create string obj contains array of FPS rates 973 * 974 * PARAMETERS : 975 * @fps : default fps range 976 * 977 * RETURN : string obj 978 *==========================================================================*/ 979 String8 QCameraParameters::createFpsString(cam_fps_range_t &fps) 980 { 981 char buffer[32]; 982 String8 fpsValues; 983 984 int min_fps = int(fps.min_fps); 985 int max_fps = int(fps.max_fps); 986 987 if (min_fps < fps.min_fps){ 988 min_fps++; 989 } 990 if (max_fps > fps.max_fps) { 991 max_fps--; 992 } 993 if (min_fps <= max_fps) { 994 snprintf(buffer, sizeof(buffer), "%d", min_fps); 995 fpsValues.append(buffer); 996 } 997 998 for (int i = min_fps+1; i <= max_fps; i++) { 999 snprintf(buffer, sizeof(buffer), ",%d", i); 1000 fpsValues.append(buffer); 1001 } 1002 1003 return fpsValues; 1004 } 1005 1006 /*=========================================================================== 1007 * FUNCTION : createFpsRangeString 1008 * 1009 * DESCRIPTION: create string obj contains array of FPS ranges 1010 * 1011 * PARAMETERS : 1012 * @fps : array of fps ranges 1013 * @len : size of the array 1014 * @default_fps_index : reference to index of default fps range 1015 * 1016 * RETURN : string obj 1017 *==========================================================================*/ 1018 String8 QCameraParameters::createFpsRangeString(const cam_fps_range_t* fps, 1019 int len, 1020 int &default_fps_index) 1021 { 1022 String8 str; 1023 char buffer[32]; 1024 int max_range = 0; 1025 int min_fps, max_fps; 1026 1027 if (len > 0) { 1028 min_fps = int(fps[0].min_fps * 1000); 1029 max_fps = int(fps[0].max_fps * 1000); 1030 max_range = max_fps - min_fps; 1031 default_fps_index = 0; 1032 snprintf(buffer, sizeof(buffer), "(%d,%d)", min_fps, max_fps); 1033 str.append(buffer); 1034 } 1035 for (int i = 1; i < len; i++) { 1036 min_fps = int(fps[i].min_fps * 1000); 1037 max_fps = int(fps[i].max_fps * 1000); 1038 if (max_range < (max_fps - min_fps)) { 1039 max_range = max_fps - min_fps; 1040 default_fps_index = i; 1041 } 1042 snprintf(buffer, sizeof(buffer), ",(%d,%d)", min_fps, max_fps); 1043 str.append(buffer); 1044 } 1045 return str; 1046 } 1047 1048 /*=========================================================================== 1049 * FUNCTION : lookupAttr 1050 * 1051 * DESCRIPTION: lookup a value by its name 1052 * 1053 * PARAMETERS : 1054 * @attr : map contains <name, value> 1055 * @len : size of the map 1056 * @name : name to be looked up 1057 * 1058 * RETURN : valid value if found 1059 * NAME_NOT_FOUND if not found 1060 *==========================================================================*/ 1061 int QCameraParameters::lookupAttr(const QCameraMap arr[], int len, const char *name) 1062 { 1063 if (name) { 1064 for (int i = 0; i < len; i++) { 1065 if (!strcmp(arr[i].desc, name)) 1066 return arr[i].val; 1067 } 1068 } 1069 return NAME_NOT_FOUND; 1070 } 1071 1072 /*=========================================================================== 1073 * FUNCTION : lookupNameByValue 1074 * 1075 * DESCRIPTION: lookup a name by its value 1076 * 1077 * PARAMETERS : 1078 * @attr : map contains <name, value> 1079 * @len : size of the map 1080 * @value : value to be looked up 1081 * 1082 * RETURN : name str or NULL if not found 1083 *==========================================================================*/ 1084 const char *QCameraParameters::lookupNameByValue(const QCameraMap arr[], int len, int value) 1085 { 1086 for (int i = 0; i < len; i++) { 1087 if (arr[i].val == value) { 1088 return arr[i].desc; 1089 } 1090 } 1091 return NULL; 1092 } 1093 1094 /*=========================================================================== 1095 * FUNCTION : setPreviewSize 1096 * 1097 * DESCRIPTION: set preview size from user setting 1098 * 1099 * PARAMETERS : 1100 * @params : user setting parameters 1101 * 1102 * RETURN : int32_t type of status 1103 * NO_ERROR -- success 1104 * none-zero failure code 1105 *==========================================================================*/ 1106 int32_t QCameraParameters::setPreviewSize(const QCameraParameters& params) 1107 { 1108 int width, height; 1109 params.getPreviewSize(&width, &height); 1110 CDBG("Requested preview size %d x %d", width, height); 1111 1112 // Validate the preview size 1113 for (size_t i = 0; i < m_pCapability->preview_sizes_tbl_cnt; ++i) { 1114 if (width == m_pCapability->preview_sizes_tbl[i].width 1115 && height == m_pCapability->preview_sizes_tbl[i].height) { 1116 // check if need to restart preview in case of preview size change 1117 int old_width, old_height; 1118 CameraParameters::getPreviewSize(&old_width, &old_height); 1119 if (width != old_width || height != old_height) { 1120 m_bNeedRestart = true; 1121 } 1122 1123 // set the new value 1124 CameraParameters::setPreviewSize(width, height); 1125 return NO_ERROR; 1126 } 1127 } 1128 ALOGE("Invalid preview size requested: %dx%d", width, height); 1129 return BAD_VALUE; 1130 } 1131 1132 /*=========================================================================== 1133 * FUNCTION : setPictureSize 1134 * 1135 * DESCRIPTION: set picture size from user setting 1136 * 1137 * PARAMETERS : 1138 * @params : user setting parameters 1139 * 1140 * RETURN : int32_t type of status 1141 * NO_ERROR -- success 1142 * none-zero failure code 1143 *==========================================================================*/ 1144 int32_t QCameraParameters::setPictureSize(const QCameraParameters& params) 1145 { 1146 int width, height; 1147 params.getPictureSize(&width, &height); 1148 CDBG("Requested picture size %d x %d", width, height); 1149 1150 // Validate the picture size 1151 if(!m_reprocScaleParam.isScaleEnabled()){ 1152 for (size_t i = 0; i < m_pCapability->picture_sizes_tbl_cnt; ++i) { 1153 if (width == m_pCapability->picture_sizes_tbl[i].width 1154 && height == m_pCapability->picture_sizes_tbl[i].height) { 1155 // check if need to restart preview in case of picture size change 1156 int old_width, old_height; 1157 CameraParameters::getPictureSize(&old_width, &old_height); 1158 if ((m_bZslMode || m_bRecordingHint) && 1159 (width != old_width || height != old_height)) { 1160 m_bNeedRestart = true; 1161 } 1162 1163 // set the new value 1164 CameraParameters::setPictureSize(width, height); 1165 return NO_ERROR; 1166 } 1167 } 1168 }else{ 1169 //should use scaled picture size table to validate 1170 if(m_reprocScaleParam.setValidatePicSize(width, height) == NO_ERROR){ 1171 // check if need to restart preview in case of picture size change 1172 int old_width, old_height; 1173 CameraParameters::getPictureSize(&old_width, &old_height); 1174 if ((m_bZslMode || m_bRecordingHint) && 1175 (width != old_width || height != old_height)) { 1176 m_bNeedRestart = true; 1177 } 1178 1179 // set the new value 1180 char val[32]; 1181 sprintf(val, "%dx%d", width, height); 1182 updateParamEntry(KEY_PICTURE_SIZE, val); 1183 CDBG("%s: %s", __func__, val); 1184 return NO_ERROR; 1185 } 1186 } 1187 ALOGE("Invalid picture size requested: %dx%d", width, height); 1188 return BAD_VALUE; 1189 } 1190 1191 /*=========================================================================== 1192 * FUNCTION : setVideoSize 1193 * 1194 * DESCRIPTION: set video size from user setting 1195 * 1196 * PARAMETERS : 1197 * @params : user setting parameters 1198 * 1199 * RETURN : int32_t type of status 1200 * NO_ERROR -- success 1201 * none-zero failure code 1202 *==========================================================================*/ 1203 int32_t QCameraParameters::setVideoSize(const QCameraParameters& params) 1204 { 1205 const char *str= NULL; 1206 int width, height; 1207 str = params.get(KEY_VIDEO_SIZE); 1208 if(!str) { 1209 //If application didn't set this parameter string, use the values from 1210 //getPreviewSize() as video dimensions. 1211 params.getPreviewSize(&width, &height); 1212 ALOGE("No Record Size requested, use the preview dimensions"); 1213 } else { 1214 params.getVideoSize(&width, &height); 1215 } 1216 1217 // Validate the video size 1218 for (size_t i = 0; i < m_pCapability->video_sizes_tbl_cnt; ++i) { 1219 if (width == m_pCapability->video_sizes_tbl[i].width 1220 && height == m_pCapability->video_sizes_tbl[i].height) { 1221 // check if need to restart preview in case of video size change 1222 int old_width, old_height; 1223 CameraParameters::getVideoSize(&old_width, &old_height); 1224 if (m_bRecordingHint && 1225 (width != old_width || height != old_height)) { 1226 m_bNeedRestart = true; 1227 } 1228 1229 // set the new value 1230 CameraParameters::setVideoSize(width, height); 1231 return NO_ERROR; 1232 } 1233 } 1234 1235 ALOGE("Invalid video size requested: %dx%d", width, height); 1236 return BAD_VALUE; 1237 } 1238 1239 /*=========================================================================== 1240 * FUNCTION : setLiveSnapshotSize 1241 * 1242 * DESCRIPTION: set live snapshot size 1243 * 1244 * PARAMETERS : 1245 * @params : user setting parameters 1246 * 1247 * RETURN : int32_t type of status 1248 * NO_ERROR -- success 1249 * none-zero failure code 1250 *==========================================================================*/ 1251 int32_t QCameraParameters::setLiveSnapshotSize(const QCameraParameters& params) 1252 { 1253 char value[PROPERTY_VALUE_MAX]; 1254 property_get("persist.camera.opt.livepic", value, "1"); 1255 bool useOptimal = atoi(value) > 0 ? true : false; 1256 1257 // use picture size from user setting 1258 params.getPictureSize(&m_LiveSnapshotSize.width, &m_LiveSnapshotSize.height); 1259 1260 uint8_t livesnapshot_sizes_tbl_cnt = m_pCapability->livesnapshot_sizes_tbl_cnt; 1261 cam_dimension_t *livesnapshot_sizes_tbl = &m_pCapability->livesnapshot_sizes_tbl[0]; 1262 1263 // check if HFR is enabled 1264 const char *hfrStr = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE); 1265 cam_hfr_mode_t hfrMode = CAM_HFR_MODE_OFF; 1266 const char *hsrStr = params.get(KEY_QC_VIDEO_HIGH_SPEED_RECORDING); 1267 1268 if (hsrStr != NULL && !strcmp(hsrStr, "on")) { 1269 for (int i = 0; i < m_pCapability->hfr_tbl_cnt; i++) { 1270 if (m_pCapability->hfr_tbl[i].mode == CAM_HFR_MODE_120FPS) { 1271 livesnapshot_sizes_tbl_cnt = 1272 m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl_cnt; 1273 livesnapshot_sizes_tbl = 1274 &m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl[0]; 1275 hfrMode = m_pCapability->hfr_tbl[i].mode; 1276 break; 1277 } 1278 } 1279 } 1280 else if (hfrStr != NULL) { 1281 int32_t value = lookupAttr(HFR_MODES_MAP, 1282 sizeof(HFR_MODES_MAP)/sizeof(QCameraMap), 1283 hfrStr); 1284 if (value != NAME_NOT_FOUND) { 1285 // if HFR is enabled, change live snapshot size 1286 if (value > CAM_HFR_MODE_OFF) { 1287 for (int i = 0; i < m_pCapability->hfr_tbl_cnt; i++) { 1288 if (m_pCapability->hfr_tbl[i].mode == value) { 1289 livesnapshot_sizes_tbl_cnt = 1290 m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl_cnt; 1291 livesnapshot_sizes_tbl = 1292 &m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl[0]; 1293 hfrMode = m_pCapability->hfr_tbl[i].mode; 1294 break; 1295 } 1296 } 1297 } 1298 } 1299 } 1300 1301 if (useOptimal || hfrMode != CAM_HFR_MODE_OFF) { 1302 bool found = false; 1303 1304 // first check if picture size is within the list of supported sizes 1305 for (int i = 0; i < livesnapshot_sizes_tbl_cnt; ++i) { 1306 if (m_LiveSnapshotSize.width == livesnapshot_sizes_tbl[i].width && 1307 m_LiveSnapshotSize.height == livesnapshot_sizes_tbl[i].height) { 1308 found = true; 1309 break; 1310 } 1311 } 1312 1313 if (!found) { 1314 // use optimal live snapshot size from supported list, 1315 // that has same preview aspect ratio 1316 int width = 0, height = 0; 1317 params.getPreviewSize(&width, &height); 1318 1319 double previewAspectRatio = (double)width / height; 1320 for (int i = 0; i < livesnapshot_sizes_tbl_cnt; ++i) { 1321 double ratio = (double)livesnapshot_sizes_tbl[i].width / 1322 livesnapshot_sizes_tbl[i].height; 1323 if (fabs(previewAspectRatio - ratio) <= ASPECT_TOLERANCE) { 1324 m_LiveSnapshotSize = livesnapshot_sizes_tbl[i]; 1325 found = true; 1326 break; 1327 } 1328 } 1329 1330 if (!found && hfrMode != CAM_HFR_MODE_OFF) { 1331 // Cannot find matching aspect ration from supported live snapshot list 1332 // choose the max dim from preview and video size 1333 CDBG("%s: Cannot find matching aspect ratio, choose max of preview or video size", __func__); 1334 params.getVideoSize(&m_LiveSnapshotSize.width, &m_LiveSnapshotSize.height); 1335 if (m_LiveSnapshotSize.width < width && m_LiveSnapshotSize.height < height) { 1336 m_LiveSnapshotSize.width = width; 1337 m_LiveSnapshotSize.height = height; 1338 } 1339 } 1340 } 1341 } 1342 CDBG("%s: live snapshot size %d x %d", __func__, 1343 m_LiveSnapshotSize.width, m_LiveSnapshotSize.height); 1344 1345 return NO_ERROR; 1346 } 1347 1348 1349 /*=========================================================================== 1350 * FUNCTION : setRawSize 1351 * 1352 * DESCRIPTION: set live snapshot size 1353 * 1354 * PARAMETERS : 1355 * @params : user setting parameters 1356 * 1357 * RETURN : int32_t type of status 1358 * NO_ERROR -- success 1359 * none-zero failure code 1360 *==========================================================================*/ 1361 int32_t QCameraParameters::setRawSize(cam_dimension_t &dim) 1362 { 1363 m_rawSize = dim; 1364 return NO_ERROR; 1365 } 1366 /*=========================================================================== 1367 * FUNCTION : setPreviewFormat 1368 * 1369 * DESCRIPTION: set preview format from user setting 1370 * 1371 * PARAMETERS : 1372 * @params : user setting parameters 1373 * 1374 * RETURN : int32_t type of status 1375 * NO_ERROR -- success 1376 * none-zero failure code 1377 *==========================================================================*/ 1378 int32_t QCameraParameters::setPreviewFormat(const QCameraParameters& params) 1379 { 1380 const char *str = params.getPreviewFormat(); 1381 int32_t previewFormat = 1382 lookupAttr(PREVIEW_FORMATS_MAP, 1383 sizeof(PREVIEW_FORMATS_MAP) / sizeof(QCameraMap), 1384 str); 1385 if (previewFormat != NAME_NOT_FOUND) { 1386 mPreviewFormat = (cam_format_t)previewFormat; 1387 1388 CameraParameters::setPreviewFormat(str); 1389 CDBG_HIGH("%s: format %d\n", __func__, mPreviewFormat); 1390 return NO_ERROR; 1391 } 1392 ALOGE("Invalid preview format value: %s", (str == NULL) ? "NULL" : str); 1393 return BAD_VALUE; 1394 } 1395 1396 /*=========================================================================== 1397 * FUNCTION : setPictureFormat 1398 * 1399 * DESCRIPTION: set picture format from user setting 1400 * 1401 * PARAMETERS : 1402 * @params : user setting parameters 1403 * 1404 * RETURN : int32_t type of status 1405 * NO_ERROR -- success 1406 * none-zero failure code 1407 *==========================================================================*/ 1408 int32_t QCameraParameters::setPictureFormat(const QCameraParameters& params) 1409 { 1410 const char *str = params.getPictureFormat(); 1411 int32_t pictureFormat = 1412 lookupAttr(PICTURE_TYPES_MAP, 1413 sizeof(PICTURE_TYPES_MAP) / sizeof(QCameraMap), 1414 str); 1415 if (pictureFormat != NAME_NOT_FOUND) { 1416 mPictureFormat = pictureFormat; 1417 1418 CameraParameters::setPictureFormat(str); 1419 CDBG_HIGH("%s: format %d\n", __func__, mPictureFormat); 1420 return NO_ERROR; 1421 } 1422 ALOGE("%s: Invalid picture format value: %s", __func__, (str == NULL) ? "NULL" : str); 1423 return BAD_VALUE; 1424 } 1425 1426 /*=========================================================================== 1427 * FUNCTION : setJpegThumbnailSize 1428 * 1429 * DESCRIPTION: set jpeg thumbnail size from user setting 1430 * 1431 * PARAMETERS : 1432 * @params : user setting parameters 1433 * 1434 * RETURN : int32_t type of status 1435 * NO_ERROR -- success 1436 * none-zero failure code 1437 *==========================================================================*/ 1438 int32_t QCameraParameters::setJpegThumbnailSize(const QCameraParameters& params) 1439 { 1440 int width = params.getInt(KEY_JPEG_THUMBNAIL_WIDTH); 1441 int height = params.getInt(KEY_JPEG_THUMBNAIL_HEIGHT); 1442 1443 CDBG("requested jpeg thumbnail size %d x %d", width, height); 1444 1445 int sizes_cnt = sizeof(THUMBNAIL_SIZES_MAP) / sizeof(cam_dimension_t); 1446 1447 cam_dimension_t dim; 1448 1449 // While taking livesnaphot match jpeg thumbnail size aspect 1450 // ratio to liveshot size. For normal snapshot match thumbnail 1451 // aspect ratio to picture size. 1452 if (m_bRecordingHint) { 1453 getLiveSnapshotSize(dim); 1454 } else { 1455 params.getPictureSize(&dim.width, &dim.height); 1456 } 1457 1458 if (0 == dim.height) { 1459 ALOGE("%s: picture size is invalid (%d x %d)", __func__, dim.width, dim.height); 1460 return BAD_VALUE; 1461 } 1462 double picAspectRatio = (double)dim.width / (double)dim.height; 1463 1464 int optimalWidth = 0, optimalHeight = 0; 1465 if (width != 0 || height != 0) { 1466 // If input jpeg thumnmail size is (0,0), meaning no thumbnail needed 1467 // hornor this setting. 1468 // Otherwise, search for optimal jpeg thumbnail size that has the same 1469 // aspect ratio as picture size. 1470 // If missign jpeg thumbnail size with appropriate aspect ratio, 1471 // just honor setting supplied by application. 1472 1473 // Try to find a size matches aspect ratio and has the largest width 1474 for (int i = 0; i < sizes_cnt; i++) { 1475 if (THUMBNAIL_SIZES_MAP[i].height == 0) { 1476 // No thumbnail case, just skip 1477 continue; 1478 } 1479 double ratio = 1480 (double)THUMBNAIL_SIZES_MAP[i].width / THUMBNAIL_SIZES_MAP[i].height; 1481 if (fabs(ratio - picAspectRatio) > ASPECT_TOLERANCE) { 1482 continue; 1483 } 1484 if (THUMBNAIL_SIZES_MAP[i].width > optimalWidth) { 1485 optimalWidth = THUMBNAIL_SIZES_MAP[i].width; 1486 optimalHeight = THUMBNAIL_SIZES_MAP[i].height; 1487 } 1488 } 1489 1490 if ((0 == optimalWidth) || (0 == optimalHeight)) { 1491 // Optimal size not found 1492 // Validate thumbnail size 1493 for (int i = 0; i < sizes_cnt; i++) { 1494 if (width == THUMBNAIL_SIZES_MAP[i].width && 1495 height == THUMBNAIL_SIZES_MAP[i].height) { 1496 optimalWidth = width; 1497 optimalHeight = height; 1498 break; 1499 } 1500 } 1501 } 1502 } 1503 1504 set(KEY_JPEG_THUMBNAIL_WIDTH, optimalWidth); 1505 set(KEY_JPEG_THUMBNAIL_HEIGHT, optimalHeight); 1506 return NO_ERROR; 1507 } 1508 1509 /*=========================================================================== 1510 1511 * FUNCTION : setBurstLEDOnPeriod 1512 * 1513 * DESCRIPTION: set burst LED on period 1514 * 1515 * PARAMETERS : 1516 * @params : user setting parameters 1517 * 1518 * RETURN : int32_t type of status 1519 * NO_ERROR -- success 1520 * none-zero failure code 1521 *==========================================================================*/ 1522 int32_t QCameraParameters::setBurstLEDOnPeriod(const QCameraParameters& params) 1523 { 1524 uint32_t nBurstLEDOnPeriod = 1525 params.getInt(KEY_QC_SNAPSHOT_BURST_LED_ON_PERIOD); 1526 //Check if the LED ON period is within limits 1527 if ((nBurstLEDOnPeriod <= 0) || (nBurstLEDOnPeriod > 800)) { 1528 // if burst led on period is not set in parameters, 1529 // read from sys prop 1530 char prop[PROPERTY_VALUE_MAX]; 1531 memset(prop, 0, sizeof(prop)); 1532 property_get("persist.camera.led.on.period", prop, "0"); 1533 nBurstLEDOnPeriod = atoi(prop); 1534 if (nBurstLEDOnPeriod <= 0) { 1535 nBurstLEDOnPeriod = 100; 1536 } 1537 } 1538 1539 set(KEY_QC_SNAPSHOT_BURST_LED_ON_PERIOD, nBurstLEDOnPeriod); 1540 m_nBurstLEDOnPeriod = nBurstLEDOnPeriod; 1541 CDBG_HIGH("%s: Burst LED on period %d", __func__, nBurstLEDOnPeriod); 1542 return AddSetParmEntryToBatch(m_pParamBuf, 1543 CAM_INTF_PARM_BURST_LED_ON_PERIOD, 1544 sizeof(nBurstLEDOnPeriod), 1545 &nBurstLEDOnPeriod); 1546 } 1547 1548 1549 1550 /*=========================================================================== 1551 * FUNCTION : setRetroActiveBurstNum 1552 * 1553 * DESCRIPTION: set retro active burst num 1554 * 1555 * PARAMETERS : 1556 * @params : user setting parameters 1557 * 1558 * RETURN : int32_t type of status 1559 * NO_ERROR -- success 1560 * none-zero failure code 1561 *==========================================================================*/ 1562 int32_t QCameraParameters::setRetroActiveBurstNum( 1563 const QCameraParameters& params) 1564 { 1565 int32_t nBurstNum = params.getInt(KEY_QC_NUM_RETRO_BURST_PER_SHUTTER); 1566 CDBG_HIGH("%s:[ZSL Retro] m_nRetroBurstNum = %d", __func__, m_nRetroBurstNum); 1567 if (nBurstNum <= 0) { 1568 // if burst number is not set in parameters, 1569 // read from sys prop 1570 char prop[PROPERTY_VALUE_MAX]; 1571 memset(prop, 0, sizeof(prop)); 1572 property_get("persist.camera.retro.number", prop, "0"); 1573 nBurstNum = atoi(prop); 1574 if (nBurstNum < 0) { 1575 nBurstNum = 0; 1576 } 1577 } 1578 1579 set(KEY_QC_NUM_RETRO_BURST_PER_SHUTTER, nBurstNum); 1580 1581 m_nRetroBurstNum = nBurstNum; 1582 CDBG_HIGH("%s: [ZSL Retro] m_nRetroBurstNum = %d", __func__, m_nRetroBurstNum); 1583 return NO_ERROR; 1584 } 1585 1586 /*=========================================================================== 1587 * FUNCTION : setJpegQuality 1588 * 1589 * DESCRIPTION: set jpeg encpding quality from user setting 1590 * 1591 * PARAMETERS : 1592 * @params : user setting parameters 1593 * 1594 * RETURN : int32_t type of status 1595 * NO_ERROR -- success 1596 * none-zero failure code 1597 *==========================================================================*/ 1598 int32_t QCameraParameters::setJpegQuality(const QCameraParameters& params) 1599 { 1600 int32_t rc = NO_ERROR; 1601 int quality = params.getInt(KEY_JPEG_QUALITY); 1602 if (quality >= 0 && quality <= 100) { 1603 set(KEY_JPEG_QUALITY, quality); 1604 } else { 1605 ALOGE("%s: Invalid jpeg quality=%d", __func__, quality); 1606 rc = BAD_VALUE; 1607 } 1608 1609 quality = params.getInt(KEY_JPEG_THUMBNAIL_QUALITY); 1610 if (quality >= 0 && quality <= 100) { 1611 set(KEY_JPEG_THUMBNAIL_QUALITY, quality); 1612 } else { 1613 ALOGE("%s: Invalid jpeg thumbnail quality=%d", __func__, quality); 1614 rc = BAD_VALUE; 1615 } 1616 return rc; 1617 } 1618 1619 /*=========================================================================== 1620 * FUNCTION : setOrientaion 1621 * 1622 * DESCRIPTION: set orientaion from user setting 1623 * 1624 * PARAMETERS : 1625 * @params : user setting parameters 1626 * 1627 * RETURN : int32_t type of status 1628 * NO_ERROR -- success 1629 * none-zero failure code 1630 *==========================================================================*/ 1631 int32_t QCameraParameters::setOrientation(const QCameraParameters& params) 1632 { 1633 const char *str = params.get(KEY_QC_ORIENTATION); 1634 1635 if (str != NULL) { 1636 if (strcmp(str, portrait) == 0 || strcmp(str, landscape) == 0) { 1637 // Camera service needs this to decide if the preview frames and raw 1638 // pictures should be rotated. 1639 set(KEY_QC_ORIENTATION, str); 1640 } else { 1641 ALOGE("%s: Invalid orientation value: %s", __func__, str); 1642 return BAD_VALUE; 1643 } 1644 } 1645 return NO_ERROR; 1646 } 1647 1648 /*=========================================================================== 1649 * FUNCTION : setAutoExposure 1650 * 1651 * DESCRIPTION: set auto exposure value from user setting 1652 * 1653 * PARAMETERS : 1654 * @params : user setting parameters 1655 * 1656 * RETURN : int32_t type of status 1657 * NO_ERROR -- success 1658 * none-zero failure code 1659 *==========================================================================*/ 1660 int32_t QCameraParameters::setAutoExposure(const QCameraParameters& params) 1661 { 1662 const char *str = params.get(KEY_QC_AUTO_EXPOSURE); 1663 const char *prev_str = get(KEY_QC_AUTO_EXPOSURE); 1664 if (str != NULL) { 1665 if (prev_str == NULL || 1666 strcmp(str, prev_str) != 0) { 1667 return setAutoExposure(str); 1668 } 1669 } 1670 return NO_ERROR; 1671 } 1672 1673 /*=========================================================================== 1674 * FUNCTION : setPreviewFpsRange 1675 * 1676 * DESCRIPTION: set preview FPS range from user setting 1677 * 1678 * PARAMETERS : 1679 * @params : user setting parameters 1680 * 1681 * RETURN : int32_t type of status 1682 * NO_ERROR -- success 1683 * none-zero failure code 1684 *==========================================================================*/ 1685 int32_t QCameraParameters::setPreviewFpsRange(const QCameraParameters& params) 1686 { 1687 int minFps,maxFps; 1688 int prevMinFps, prevMaxFps, vidMinFps, vidMaxFps; 1689 int rc = NO_ERROR; 1690 bool found = false, updateNeeded = false; 1691 1692 CameraParameters::getPreviewFpsRange(&prevMinFps, &prevMaxFps); 1693 params.getPreviewFpsRange(&minFps, &maxFps); 1694 1695 CDBG_HIGH("%s: FpsRange Values:(%d, %d)", __func__, prevMinFps, prevMaxFps); 1696 CDBG_HIGH("%s: Requested FpsRange Values:(%d, %d)", __func__, minFps, maxFps); 1697 1698 //first check if we need to change fps because of HFR mode change 1699 updateNeeded = UpdateHFRFrameRate(params); 1700 CDBG_HIGH("%s: UpdateHFRFrameRate %d", __func__, updateNeeded); 1701 1702 vidMinFps = m_hfrFpsRange.video_min_fps; 1703 vidMaxFps = m_hfrFpsRange.video_max_fps; 1704 1705 if(minFps == prevMinFps && maxFps == prevMaxFps) { 1706 if ( m_bFixedFrameRateSet ) { 1707 minFps = params.getPreviewFrameRate() * 1000; 1708 maxFps = params.getPreviewFrameRate() * 1000; 1709 m_bFixedFrameRateSet = false; 1710 } else if (!updateNeeded) { 1711 CDBG_HIGH("%s: No change in FpsRange", __func__); 1712 rc = NO_ERROR; 1713 goto end; 1714 } 1715 } 1716 for(int i = 0; i < m_pCapability->fps_ranges_tbl_cnt; i++) { 1717 // if the value is in the supported list 1718 if(minFps >= m_pCapability->fps_ranges_tbl[i].min_fps * 1000 && 1719 maxFps <= m_pCapability->fps_ranges_tbl[i].max_fps * 1000) { 1720 found = true; 1721 CDBG_HIGH("%s: FPS i=%d : minFps = %d, maxFps = %d" 1722 " vidMinFps = %d, vidMaxFps = %d", 1723 __func__, i, minFps, maxFps, 1724 (int)m_hfrFpsRange.video_min_fps, 1725 (int)m_hfrFpsRange.video_max_fps); 1726 if ((m_hfrFpsRange.video_min_fps == 0) || 1727 (m_hfrFpsRange.video_max_fps == 0)) { 1728 vidMinFps = minFps; 1729 vidMaxFps = maxFps; 1730 } 1731 else { 1732 vidMinFps = m_hfrFpsRange.video_min_fps; 1733 vidMaxFps = m_hfrFpsRange.video_max_fps; 1734 } 1735 1736 setPreviewFpsRange(minFps, maxFps, vidMinFps, vidMaxFps); 1737 break; 1738 } 1739 } 1740 if(found == false){ 1741 ALOGE("%s: error: FPS range value not supported", __func__); 1742 rc = BAD_VALUE; 1743 } 1744 end: 1745 return rc; 1746 } 1747 1748 /*=========================================================================== 1749 * FUNCTION : UpdateHFRFrameRate 1750 * 1751 * DESCRIPTION: set preview FPS range based on HFR setting 1752 * 1753 * PARAMETERS : 1754 * @params : user setting parameters 1755 * 1756 * RETURN : bool true/false 1757 * true -if HAL needs to overwrite FPS range set by app, false otherwise. 1758 *==========================================================================*/ 1759 1760 bool QCameraParameters::UpdateHFRFrameRate(const QCameraParameters& params) 1761 { 1762 bool updateNeeded = false; 1763 int min_fps, max_fps; 1764 int32_t hfrMode = CAM_HFR_MODE_OFF; 1765 1766 int parm_minfps,parm_maxfps; 1767 int prevMinFps, prevMaxFps; 1768 CameraParameters::getPreviewFpsRange(&prevMinFps, &prevMaxFps); 1769 params.getPreviewFpsRange(&parm_minfps, &parm_maxfps); 1770 CDBG_HIGH("%s: CameraParameters - : minFps = %d, maxFps = %d ", 1771 __func__, prevMinFps, prevMaxFps); 1772 CDBG_HIGH("%s: Requested params - : minFps = %d, maxFps = %d ", 1773 __func__, parm_minfps, parm_maxfps); 1774 1775 // check if HFR is enabled 1776 const char *hfrStr = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE); 1777 const char *prev_hfrStr = get(KEY_QC_VIDEO_HIGH_FRAME_RATE); 1778 CDBG_HIGH("%s: prevHfrStr - %s, hfrStr = %s ", 1779 __func__, prev_hfrStr, hfrStr); 1780 if(hfrStr != NULL){ 1781 hfrMode = lookupAttr(HFR_MODES_MAP, 1782 sizeof(HFR_MODES_MAP)/sizeof(QCameraMap), 1783 hfrStr); 1784 } 1785 // check if HSR is enabled 1786 const char *hsrStr = params.get(KEY_QC_VIDEO_HIGH_SPEED_RECORDING); 1787 const char *prev_hsrStr = get(KEY_QC_VIDEO_HIGH_SPEED_RECORDING); 1788 1789 if (hsrStr != NULL && !strcmp(hsrStr, "on")) { 1790 CDBG_HIGH("%s: HSR mode enabled ", __func__); 1791 hfrMode = CAM_HFR_MODE_120FPS; 1792 } 1793 1794 // if HSR is made ON just now 1795 if(hsrStr != NULL && (prev_hsrStr == NULL || (strcmp(hsrStr, prev_hsrStr))) && 1796 !strcmp(hsrStr, "on")) { 1797 min_fps = 120000; 1798 max_fps = 120000; 1799 m_hfrFpsRange.video_min_fps = min_fps; 1800 m_hfrFpsRange.video_max_fps = max_fps; 1801 1802 CDBG_HIGH("%s: HFR mode change - Set FPS : minFps = %d, maxFps = %d ", 1803 __func__,min_fps,max_fps); 1804 updateNeeded = true; 1805 } 1806 1807 // else if HSR is made OFF just now or HSR is OFF for some time 1808 // and HFR is changed just now 1809 else if (hfrStr != NULL && ((prev_hfrStr == NULL || strcmp(hfrStr,prev_hfrStr)) || 1810 (hsrStr != NULL && (prev_hsrStr == NULL || strcmp(hsrStr, prev_hsrStr)))) && 1811 ((hsrStr != NULL && strcmp(hsrStr, "on"))|| hsrStr == NULL)) { 1812 if (hfrMode != NAME_NOT_FOUND) { 1813 // if HFR is enabled, change fps range 1814 switch(hfrMode){ 1815 case CAM_HFR_MODE_60FPS: 1816 min_fps = 60000; 1817 max_fps = 60000; 1818 break; 1819 case CAM_HFR_MODE_90FPS: 1820 min_fps = 90000; 1821 max_fps = 90000; 1822 break; 1823 case CAM_HFR_MODE_120FPS: 1824 min_fps = 120000; 1825 max_fps = 120000; 1826 break; 1827 case CAM_HFR_MODE_150FPS: 1828 min_fps = 150000; 1829 max_fps = 150000; 1830 break; 1831 case CAM_HFR_MODE_OFF: 1832 default: 1833 // Set Video Fps to zero 1834 min_fps = 0; 1835 max_fps = 0; 1836 break; 1837 } 1838 m_hfrFpsRange.video_min_fps = min_fps; 1839 m_hfrFpsRange.video_max_fps = max_fps; 1840 1841 CDBG_HIGH("%s: HFR mode (%d) Set video FPS : minFps = %d, maxFps = %d ", 1842 __func__, hfrMode, min_fps, max_fps); 1843 // Signifies that there is a change in video FPS and need to set Fps 1844 updateNeeded = true; 1845 } 1846 } 1847 // Remember if HFR mode is ON 1848 if ((hfrMode > CAM_HFR_MODE_OFF) && (hfrMode < CAM_HFR_MODE_MAX)){ 1849 CDBG_HIGH("HFR mode is ON"); 1850 m_bHfrMode = true; 1851 } 1852 else { 1853 m_hfrFpsRange.video_min_fps = 0; 1854 m_hfrFpsRange.video_max_fps = 0; 1855 m_bHfrMode = false; 1856 CDBG_HIGH("HFR mode is OFF"); 1857 } 1858 return updateNeeded; 1859 } 1860 1861 /*=========================================================================== 1862 * FUNCTION : setPreviewFrameRate 1863 * 1864 * DESCRIPTION: set preview frame rate from user setting 1865 * 1866 * PARAMETERS : 1867 * @params : user setting parameters 1868 * 1869 * RETURN : int32_t type of status 1870 * NO_ERROR -- success 1871 * none-zero failure code 1872 *==========================================================================*/ 1873 int32_t QCameraParameters::setPreviewFrameRate(const QCameraParameters& params) 1874 { 1875 const char *str = params.get(KEY_PREVIEW_FRAME_RATE); 1876 const char *prev_str = get(KEY_PREVIEW_FRAME_RATE); 1877 1878 if ( str ) { 1879 if ( prev_str && 1880 strcmp(str, prev_str)) { 1881 CDBG("%s: Requested Fixed Frame Rate %s", __func__, str); 1882 updateParamEntry(KEY_PREVIEW_FRAME_RATE, str); 1883 m_bFixedFrameRateSet = true; 1884 } 1885 } 1886 return NO_ERROR; 1887 } 1888 1889 /*=========================================================================== 1890 * FUNCTION : setEffect 1891 * 1892 * DESCRIPTION: set effect value from user setting 1893 * 1894 * PARAMETERS : 1895 * @params : user setting parameters 1896 * 1897 * RETURN : int32_t type of status 1898 * NO_ERROR -- success 1899 * none-zero failure code 1900 *==========================================================================*/ 1901 int32_t QCameraParameters::setEffect(const QCameraParameters& params) 1902 { 1903 const char *str = params.get(KEY_EFFECT); 1904 const char *prev_str = get(KEY_EFFECT); 1905 if (str != NULL) { 1906 if (prev_str == NULL || 1907 strcmp(str, prev_str) != 0 || 1908 m_bUpdateEffects == true ) { 1909 m_bUpdateEffects = false; 1910 return setEffect(str); 1911 } 1912 } 1913 return NO_ERROR; 1914 } 1915 1916 /*=========================================================================== 1917 * FUNCTION : setFocusMode 1918 * 1919 * DESCRIPTION: set focus mode from user setting 1920 * 1921 * PARAMETERS : 1922 * @params : user setting parameters 1923 * 1924 * RETURN : int32_t type of status 1925 * NO_ERROR -- success 1926 * none-zero failure code 1927 *==========================================================================*/ 1928 int32_t QCameraParameters::setFocusMode(const QCameraParameters& params) 1929 { 1930 const char *str = params.get(KEY_FOCUS_MODE); 1931 const char *prev_str = get(KEY_FOCUS_MODE); 1932 if (str != NULL) { 1933 if (prev_str == NULL || 1934 strcmp(str, prev_str) != 0) { 1935 return setFocusMode(str); 1936 } 1937 } 1938 return NO_ERROR; 1939 } 1940 1941 /*=========================================================================== 1942 * FUNCTION : setBrightness 1943 * 1944 * DESCRIPTION: set brightness control value from user setting 1945 * 1946 * PARAMETERS : 1947 * @params : user setting parameters 1948 * 1949 * RETURN : int32_t type of status 1950 * NO_ERROR -- success 1951 * none-zero failure code 1952 *==========================================================================*/ 1953 int32_t QCameraParameters::setBrightness(const QCameraParameters& params) 1954 { 1955 int currentBrightness = getInt(KEY_QC_BRIGHTNESS); 1956 int brightness = params.getInt(KEY_QC_BRIGHTNESS); 1957 1958 if(params.get(KEY_QC_BRIGHTNESS) == NULL) { 1959 CDBG_HIGH("%s: Brigtness not set by App ",__func__); 1960 return NO_ERROR; 1961 } 1962 if (currentBrightness != brightness) { 1963 if (brightness >= m_pCapability->brightness_ctrl.min_value && 1964 brightness <= m_pCapability->brightness_ctrl.max_value) { 1965 CDBG(" new brightness value : %d ", brightness); 1966 return setBrightness(brightness); 1967 } else { 1968 ALOGE("%s: invalid value %d out of (%d, %d)", 1969 __func__, brightness, 1970 m_pCapability->brightness_ctrl.min_value, 1971 m_pCapability->brightness_ctrl.max_value); 1972 return BAD_VALUE; 1973 } 1974 } else { 1975 CDBG("%s: No brightness value changed.", __func__); 1976 return NO_ERROR; 1977 } 1978 } 1979 1980 /*=========================================================================== 1981 * FUNCTION : setSharpness 1982 * 1983 * DESCRIPTION: set sharpness control value from user setting 1984 * 1985 * PARAMETERS : 1986 * @params : user setting parameters 1987 * 1988 * RETURN : int32_t type of status 1989 * NO_ERROR -- success 1990 * none-zero failure code 1991 *==========================================================================*/ 1992 int32_t QCameraParameters::setSharpness(const QCameraParameters& params) 1993 { 1994 int shaprness = params.getInt(KEY_QC_SHARPNESS); 1995 int prev_sharp = getInt(KEY_QC_SHARPNESS); 1996 1997 if(params.get(KEY_QC_SHARPNESS) == NULL) { 1998 CDBG_HIGH("%s: Sharpness not set by App ",__func__); 1999 return NO_ERROR; 2000 } 2001 if (prev_sharp != shaprness) { 2002 if((shaprness >= m_pCapability->sharpness_ctrl.min_value) && 2003 (shaprness <= m_pCapability->sharpness_ctrl.max_value)) { 2004 CDBG(" new sharpness value : %d ", shaprness); 2005 return setSharpness(shaprness); 2006 } else { 2007 ALOGE("%s: invalid value %d out of (%d, %d)", 2008 __func__, shaprness, 2009 m_pCapability->sharpness_ctrl.min_value, 2010 m_pCapability->sharpness_ctrl.max_value); 2011 return BAD_VALUE; 2012 } 2013 } else { 2014 CDBG("%s: No value change in shaprness", __func__); 2015 return NO_ERROR; 2016 } 2017 } 2018 2019 /*=========================================================================== 2020 * FUNCTION : setSkintoneEnahancement 2021 * 2022 * DESCRIPTION: set skin tone enhancement factor from user setting 2023 * 2024 * PARAMETERS : 2025 * @params : user setting parameters 2026 * 2027 * RETURN : int32_t type of status 2028 * NO_ERROR -- success 2029 * none-zero failure code 2030 *==========================================================================*/ 2031 int32_t QCameraParameters::setSkinToneEnhancement(const QCameraParameters& params) 2032 { 2033 int sceFactor = params.getInt(KEY_QC_SCE_FACTOR); 2034 int prev_sceFactor = getInt(KEY_QC_SCE_FACTOR); 2035 2036 if(params.get(KEY_QC_SCE_FACTOR) == NULL) { 2037 CDBG_HIGH("%s: Skintone enhancement not set by App ",__func__); 2038 return NO_ERROR; 2039 } 2040 if (prev_sceFactor != sceFactor) { 2041 if((sceFactor >= m_pCapability->sce_ctrl.min_value) && 2042 (sceFactor <= m_pCapability->sce_ctrl.max_value)) { 2043 CDBG(" new Skintone Enhancement value : %d ", sceFactor); 2044 return setSkinToneEnhancement(sceFactor); 2045 } else { 2046 ALOGE("%s: invalid value %d out of (%d, %d)", 2047 __func__, sceFactor, 2048 m_pCapability->sce_ctrl.min_value, 2049 m_pCapability->sce_ctrl.max_value); 2050 return BAD_VALUE; 2051 } 2052 } else { 2053 CDBG("%s: No value change in skintone enhancement factor", __func__); 2054 return NO_ERROR; 2055 } 2056 } 2057 2058 /*=========================================================================== 2059 * FUNCTION : setSaturation 2060 * 2061 * DESCRIPTION: set saturation control value from user setting 2062 * 2063 * PARAMETERS : 2064 * @params : user setting parameters 2065 * 2066 * RETURN : int32_t type of status 2067 * NO_ERROR -- success 2068 * none-zero failure code 2069 *==========================================================================*/ 2070 int32_t QCameraParameters::setSaturation(const QCameraParameters& params) 2071 { 2072 int saturation = params.getInt(KEY_QC_SATURATION); 2073 int prev_sat = getInt(KEY_QC_SATURATION); 2074 2075 if(params.get(KEY_QC_SATURATION) == NULL) { 2076 CDBG_HIGH("%s: Saturation not set by App ",__func__); 2077 return NO_ERROR; 2078 } 2079 if (prev_sat != saturation) { 2080 if((saturation >= m_pCapability->saturation_ctrl.min_value) && 2081 (saturation <= m_pCapability->saturation_ctrl.max_value)) { 2082 CDBG(" new saturation value : %d ", saturation); 2083 return setSaturation(saturation); 2084 } else { 2085 ALOGE("%s: invalid value %d out of (%d, %d)", 2086 __func__, saturation, 2087 m_pCapability->saturation_ctrl.min_value, 2088 m_pCapability->saturation_ctrl.max_value); 2089 return BAD_VALUE; 2090 } 2091 } else { 2092 CDBG("%s: No value change in saturation factor", __func__); 2093 return NO_ERROR; 2094 } 2095 } 2096 2097 /*=========================================================================== 2098 * FUNCTION : setContrast 2099 * 2100 * DESCRIPTION: set contrast control value from user setting 2101 * 2102 * PARAMETERS : 2103 * @params : user setting parameters 2104 * 2105 * RETURN : int32_t type of status 2106 * NO_ERROR -- success 2107 * none-zero failure code 2108 *==========================================================================*/ 2109 int32_t QCameraParameters::setContrast(const QCameraParameters& params) 2110 { 2111 int contrast = params.getInt(KEY_QC_CONTRAST); 2112 int prev_contrast = getInt(KEY_QC_CONTRAST); 2113 2114 if(params.get(KEY_QC_CONTRAST) == NULL) { 2115 CDBG_HIGH("%s: Contrast not set by App ",__func__); 2116 return NO_ERROR; 2117 } 2118 if (prev_contrast != contrast) { 2119 if((contrast >= m_pCapability->contrast_ctrl.min_value) && 2120 (contrast <= m_pCapability->contrast_ctrl.max_value)) { 2121 CDBG(" new contrast value : %d ", contrast); 2122 int32_t rc = setContrast(contrast); 2123 return rc; 2124 } else { 2125 ALOGE("%s: invalid value %d out of (%d, %d)", 2126 __func__, contrast, 2127 m_pCapability->contrast_ctrl.min_value, 2128 m_pCapability->contrast_ctrl.max_value); 2129 return BAD_VALUE; 2130 } 2131 } else { 2132 CDBG("%s: No value change in contrast", __func__); 2133 return NO_ERROR; 2134 } 2135 } 2136 2137 /*=========================================================================== 2138 * FUNCTION : setExposureCompensation 2139 * 2140 * DESCRIPTION: set exposure compensation value from user setting 2141 * 2142 * PARAMETERS : 2143 * @params : user setting parameters 2144 * 2145 * RETURN : int32_t type of status 2146 * NO_ERROR -- success 2147 * none-zero failure code 2148 *==========================================================================*/ 2149 int32_t QCameraParameters::setExposureCompensation(const QCameraParameters & params) 2150 { 2151 int expComp = params.getInt(KEY_EXPOSURE_COMPENSATION); 2152 int prev_expComp = getInt(KEY_EXPOSURE_COMPENSATION); 2153 2154 if(params.get(KEY_EXPOSURE_COMPENSATION) == NULL) { 2155 CDBG_HIGH("%s: Exposure compensation not set by App ",__func__); 2156 return NO_ERROR; 2157 } 2158 if (prev_expComp != expComp) { 2159 if((expComp >= m_pCapability->exposure_compensation_min) && 2160 (expComp <= m_pCapability->exposure_compensation_max)) { 2161 CDBG(" new Exposure Compensation value : %d ", expComp); 2162 return setExposureCompensation(expComp); 2163 } else { 2164 ALOGE("%s: invalid value %d out of (%d, %d)", 2165 __func__, expComp, 2166 m_pCapability->exposure_compensation_min, 2167 m_pCapability->exposure_compensation_max); 2168 return BAD_VALUE; 2169 } 2170 } else { 2171 CDBG("%s: No value change in Exposure Compensation", __func__); 2172 return NO_ERROR; 2173 } 2174 } 2175 2176 /*=========================================================================== 2177 * FUNCTION : setWhiteBalance 2178 * 2179 * DESCRIPTION: set white balance value from user setting 2180 * 2181 * PARAMETERS : 2182 * @params : user setting parameters 2183 * 2184 * RETURN : int32_t type of status 2185 * NO_ERROR -- success 2186 * none-zero failure code 2187 *==========================================================================*/ 2188 int32_t QCameraParameters::setWhiteBalance(const QCameraParameters& params) 2189 { 2190 const char *str = params.get(KEY_WHITE_BALANCE); 2191 const char *prev_str = get(KEY_WHITE_BALANCE); 2192 if (str != NULL) { 2193 if (prev_str == NULL || 2194 strcmp(str, prev_str) != 0) { 2195 return setWhiteBalance(str); 2196 } 2197 } 2198 return NO_ERROR; 2199 } 2200 2201 /*=========================================================================== 2202 * FUNCTION : setAntibanding 2203 * 2204 * DESCRIPTION: set antibanding value from user setting 2205 * 2206 * PARAMETERS : 2207 * @params : user setting parameters 2208 * 2209 * RETURN : int32_t type of status 2210 * NO_ERROR -- success 2211 * none-zero failure code 2212 *==========================================================================*/ 2213 int32_t QCameraParameters::setAntibanding(const QCameraParameters& params) 2214 { 2215 const char *str = params.get(KEY_ANTIBANDING); 2216 const char *prev_str = get(KEY_ANTIBANDING); 2217 if (str != NULL) { 2218 if (prev_str == NULL || 2219 strcmp(str, prev_str) != 0) { 2220 return setAntibanding(str); 2221 } 2222 } 2223 return NO_ERROR; 2224 } 2225 2226 /*=========================================================================== 2227 * FUNCTION : setStatsDebugMask 2228 * 2229 * DESCRIPTION: get the value from persist file in Stats module that will 2230 * control funtionality in the module 2231 * 2232 * PARAMETERS : none 2233 * 2234 * RETURN : int32_t type of status 2235 * NO_ERROR -- success 2236 * none-zero failure code 2237 *==========================================================================*/ 2238 int32_t QCameraParameters::setStatsDebugMask() 2239 { 2240 uint32_t mask = 0; 2241 char value[PROPERTY_VALUE_MAX]; 2242 2243 property_get("persist.camera.stats.debug.mask", value, "0"); 2244 mask = (uint32_t)atoi(value); 2245 2246 CDBG_HIGH("%s: ctrl mask :%d", __func__, mask); 2247 2248 return AddSetParmEntryToBatch(m_pParamBuf, 2249 CAM_INTF_PARM_STATS_DEBUG_MASK, 2250 sizeof(mask), 2251 &mask); 2252 } 2253 2254 /*=========================================================================== 2255 * FUNCTION : setPAAF 2256 * 2257 * DESCRIPTION: get the value from persist file in Stats module that will 2258 * control the preview assisted AF in the module 2259 * 2260 * PARAMETERS : none 2261 * 2262 * RETURN : int32_t type of status 2263 * NO_ERROR -- success 2264 * none-zero failure code 2265 *==========================================================================*/ 2266 int32_t QCameraParameters::setPAAF() 2267 { 2268 uint32_t paaf = 0; 2269 char value[PROPERTY_VALUE_MAX]; 2270 2271 property_get("persist.camera.stats.af.paaf", value, "1"); 2272 paaf = (uint32_t)atoi(value); 2273 2274 ALOGE("%s: PAAF is: %s", __func__, paaf ? "ON": "OFF"); 2275 2276 return AddSetParmEntryToBatch(m_pParamBuf, 2277 CAM_INTF_PARM_STATS_AF_PAAF, 2278 sizeof(paaf), 2279 &paaf); 2280 } 2281 2282 /*=========================================================================== 2283 * FUNCTION : setSceneDetect 2284 * 2285 * DESCRIPTION: set scenen detect value from user setting 2286 * 2287 * PARAMETERS : 2288 * @params : user setting parameters 2289 * 2290 * RETURN : int32_t type of status 2291 * NO_ERROR -- success 2292 * none-zero failure code 2293 *==========================================================================*/ 2294 int32_t QCameraParameters::setSceneDetect(const QCameraParameters& params) 2295 { 2296 const char *str = params.get(KEY_QC_SCENE_DETECT); 2297 const char *prev_str = get(KEY_QC_SCENE_DETECT); 2298 if (str != NULL) { 2299 if (prev_str == NULL || 2300 strcmp(str, prev_str) != 0) { 2301 return setSceneDetect(str); 2302 } 2303 } 2304 return NO_ERROR; 2305 } 2306 2307 /*=========================================================================== 2308 * FUNCTION : setVideoHDR 2309 * 2310 * DESCRIPTION: set video HDR value from user setting 2311 * 2312 * PARAMETERS : 2313 * @params : user setting parameters 2314 * 2315 * RETURN : int32_t type of status 2316 * NO_ERROR -- success 2317 * none-zero failure code 2318 *==========================================================================*/ 2319 int32_t QCameraParameters::setVideoHDR(const QCameraParameters& params) 2320 { 2321 const char *str = params.get(KEY_QC_VIDEO_HDR); 2322 const char *prev_str = get(KEY_QC_VIDEO_HDR); 2323 if (str != NULL) { 2324 if (prev_str == NULL || 2325 strcmp(str, prev_str) != 0) { 2326 return setVideoHDR(str); 2327 } 2328 } 2329 return NO_ERROR; 2330 } 2331 2332 /*=========================================================================== 2333 * FUNCTION : setVtEnable 2334 * 2335 * DESCRIPTION: set vt Time Stamp enable from user setting 2336 * 2337 * PARAMETERS : 2338 * @params : user setting parameters 2339 * 2340 * RETURN : int32_t type of status 2341 * NO_ERROR -- success 2342 * none-zero failure code 2343 *==========================================================================*/ 2344 int32_t QCameraParameters::setVtEnable(const QCameraParameters& params) 2345 { 2346 const char *str = params.get(KEY_QC_VT_ENABLE); 2347 const char *prev_str = get(KEY_QC_VT_ENABLE); 2348 if (str != NULL) { 2349 if (prev_str == NULL || 2350 strcmp(str, prev_str) != 0) { 2351 return setVtEnable(str); 2352 } 2353 } 2354 return NO_ERROR; 2355 } 2356 2357 /*=========================================================================== 2358 * FUNCTION : setFaceRecognition 2359 * 2360 * DESCRIPTION: set face recognition mode from user setting 2361 * 2362 * PARAMETERS : 2363 * @params : user setting parameters 2364 * 2365 * RETURN : int32_t type of status 2366 * NO_ERROR -- success 2367 * none-zero failure code 2368 *==========================================================================*/ 2369 int32_t QCameraParameters::setFaceRecognition(const QCameraParameters& params) 2370 { 2371 const char *str = params.get(KEY_QC_FACE_RECOGNITION); 2372 const char *prev_str = get(KEY_QC_FACE_RECOGNITION); 2373 if (str != NULL) { 2374 if (prev_str == NULL || 2375 strcmp(str, prev_str) != 0) { 2376 int maxFaces = params.getInt(KEY_QC_MAX_NUM_REQUESTED_FACES); 2377 return setFaceRecognition(str, maxFaces); 2378 } 2379 } 2380 return NO_ERROR; 2381 } 2382 2383 /*=========================================================================== 2384 * FUNCTION : setZoom 2385 * 2386 * DESCRIPTION: set zoom value from user setting 2387 * 2388 * PARAMETERS : 2389 * @params : user setting parameters 2390 * 2391 * RETURN : int32_t type of status 2392 * NO_ERROR -- success 2393 * none-zero failure code 2394 *==========================================================================*/ 2395 int32_t QCameraParameters::setZoom(const QCameraParameters& params) 2396 { 2397 if ((m_pCapability->zoom_supported == 0 || 2398 m_pCapability->zoom_ratio_tbl_cnt == 0)) { 2399 CDBG_HIGH("%s: no zoom support", __func__); 2400 return NO_ERROR; 2401 } 2402 2403 int zoomLevel = params.getInt(KEY_ZOOM); 2404 if((zoomLevel < 0) || 2405 (zoomLevel >= m_pCapability->zoom_ratio_tbl_cnt)) { 2406 ALOGE("%s: invalid value %d out of (%d, %d)", 2407 __func__, zoomLevel, 2408 0, m_pCapability->zoom_ratio_tbl_cnt-1); 2409 return BAD_VALUE; 2410 } 2411 2412 int prevZoomLevel = getInt(KEY_ZOOM); 2413 if (prevZoomLevel == zoomLevel) { 2414 CDBG("%s: No value change in contrast", __func__); 2415 return NO_ERROR; 2416 } 2417 2418 return setZoom(zoomLevel); 2419 } 2420 2421 /*=========================================================================== 2422 * FUNCTION : setISOValue 2423 * 2424 * DESCRIPTION: set ISO value from user setting 2425 * 2426 * PARAMETERS : 2427 * @params : user setting parameters 2428 * 2429 * RETURN : int32_t type of status 2430 * NO_ERROR -- success 2431 * none-zero failure code 2432 *==========================================================================*/ 2433 int32_t QCameraParameters::setISOValue(const QCameraParameters& params) 2434 { 2435 const char *str = params.get(KEY_QC_ISO_MODE); 2436 const char *prev_str = get(KEY_QC_ISO_MODE); 2437 if (str != NULL) { 2438 if (prev_str == NULL || 2439 strcmp(str, prev_str) != 0) { 2440 return setISOValue(str); 2441 } 2442 } 2443 return NO_ERROR; 2444 } 2445 2446 /*=========================================================================== 2447 * FUNCTION : setVideoRotation 2448 * 2449 * DESCRIPTION: set rotation value from user setting 2450 * 2451 * PARAMETERS : 2452 * @params : user setting parameters 2453 * 2454 * RETURN : int32_t type of status 2455 * NO_ERROR -- success 2456 * none-zero failure code 2457 *==========================================================================*/ 2458 int32_t QCameraParameters::setVideoRotation(const QCameraParameters& params) 2459 { 2460 int rotation = params.getInt(KEY_QC_VIDEO_ROTATION); 2461 if (rotation != -1) { 2462 if (rotation == 0 || rotation == 90 || 2463 rotation == 180 || rotation == 270) { 2464 set(KEY_QC_VIDEO_ROTATION, rotation); 2465 } else { 2466 ALOGE("Invalid rotation value: %d", rotation); 2467 return BAD_VALUE; 2468 } 2469 } 2470 return NO_ERROR; 2471 } 2472 2473 /*=========================================================================== 2474 * FUNCTION : setRotation 2475 * 2476 * DESCRIPTION: set rotation value from user setting 2477 * 2478 * PARAMETERS : 2479 * @params : user setting parameters 2480 * 2481 * RETURN : int32_t type of status 2482 * NO_ERROR -- success 2483 * none-zero failure code 2484 *==========================================================================*/ 2485 int32_t QCameraParameters::setRotation(const QCameraParameters& params) 2486 { 2487 int rotation = params.getInt(KEY_ROTATION); 2488 if (rotation != -1) { 2489 if (rotation == 0 || rotation == 90 || 2490 rotation == 180 || rotation == 270) { 2491 set(KEY_ROTATION, rotation); 2492 } else { 2493 ALOGE("Invalid rotation value: %d", rotation); 2494 return BAD_VALUE; 2495 } 2496 } 2497 return NO_ERROR; 2498 } 2499 2500 /*=========================================================================== 2501 * FUNCTION : setFlash 2502 * 2503 * DESCRIPTION: set flash mode from user setting 2504 * 2505 * PARAMETERS : 2506 * @params : user setting parameters 2507 * 2508 * RETURN : int32_t type of status 2509 * NO_ERROR -- success 2510 * none-zero failure code 2511 *==========================================================================*/ 2512 int32_t QCameraParameters::setFlash(const QCameraParameters& params) 2513 { 2514 const char *str = params.get(KEY_FLASH_MODE); 2515 const char *prev_str = get(KEY_FLASH_MODE); 2516 if (str != NULL) { 2517 if (prev_str == NULL || 2518 strcmp(str, prev_str) != 0) { 2519 return setFlash(str); 2520 } 2521 } 2522 return NO_ERROR; 2523 } 2524 2525 /*=========================================================================== 2526 * FUNCTION : setAecLock 2527 * 2528 * DESCRIPTION: set AEC lock value from user setting 2529 * 2530 * PARAMETERS : 2531 * @params : user setting parameters 2532 * 2533 * RETURN : int32_t type of status 2534 * NO_ERROR -- success 2535 * none-zero failure code 2536 *==========================================================================*/ 2537 int32_t QCameraParameters::setAecLock(const QCameraParameters& params) 2538 { 2539 const char *str = params.get(KEY_AUTO_EXPOSURE_LOCK); 2540 const char *prev_str = get(KEY_AUTO_EXPOSURE_LOCK); 2541 if (str != NULL) { 2542 if (prev_str == NULL || 2543 strcmp(str, prev_str) != 0) { 2544 return setAecLock(str); 2545 } 2546 } 2547 return NO_ERROR; 2548 } 2549 2550 /*=========================================================================== 2551 * FUNCTION : setAwbLock 2552 * 2553 * DESCRIPTION: set AWB lock from user setting 2554 * 2555 * PARAMETERS : 2556 * @params : user setting parameters 2557 * 2558 * RETURN : int32_t type of status 2559 * NO_ERROR -- success 2560 * none-zero failure code 2561 *==========================================================================*/ 2562 int32_t QCameraParameters::setAwbLock(const QCameraParameters& params) 2563 { 2564 const char *str = params.get(KEY_AUTO_WHITEBALANCE_LOCK); 2565 const char *prev_str = get(KEY_AUTO_WHITEBALANCE_LOCK); 2566 if (str != NULL) { 2567 if (prev_str == NULL || 2568 strcmp(str, prev_str) != 0) { 2569 return setAwbLock(str); 2570 } 2571 } 2572 return NO_ERROR; 2573 } 2574 2575 /*=========================================================================== 2576 * FUNCTION : setAutoHDR 2577 * 2578 * DESCRIPTION: Enable/disable auto HDR 2579 * 2580 * PARAMETERS : 2581 * @params : user setting parameters 2582 * 2583 * RETURN : int32_t type of status 2584 * NO_ERROR -- success 2585 * none-zero failure code 2586 *==========================================================================*/ 2587 int32_t QCameraParameters::setAutoHDR(const QCameraParameters& params) 2588 { 2589 const char *str = params.get(KEY_QC_AUTO_HDR_ENABLE); 2590 const char *prev_str = get(KEY_QC_AUTO_HDR_ENABLE); 2591 char prop[PROPERTY_VALUE_MAX]; 2592 2593 memset(prop, 0, sizeof(prop)); 2594 property_get("persist.camera.auto.hdr.enable", prop, VALUE_DISABLE); 2595 if (str != NULL) { 2596 if (prev_str == NULL || 2597 strcmp(str, prev_str) != 0) { 2598 CDBG_HIGH("%s : Auto HDR set to: %s", __func__, str); 2599 return updateParamEntry(KEY_QC_AUTO_HDR_ENABLE, str); 2600 } 2601 } else { 2602 if (prev_str == NULL || 2603 strcmp(prev_str, prop) != 0 ) { 2604 CDBG_HIGH("%s : Auto HDR set to: %s", __func__, prop); 2605 updateParamEntry(KEY_QC_AUTO_HDR_ENABLE, prop); 2606 } 2607 } 2608 2609 return NO_ERROR; 2610 } 2611 2612 /*=========================================================================== 2613 * FUNCTION : isAutoHDREnabled 2614 * 2615 * DESCRIPTION: Query auto HDR status 2616 * 2617 * PARAMETERS : None 2618 * 2619 * RETURN : bool true/false 2620 *==========================================================================*/ 2621 bool QCameraParameters::isAutoHDREnabled() 2622 { 2623 const char *str = get(KEY_QC_AUTO_HDR_ENABLE); 2624 if (str != NULL) { 2625 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 2626 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 2627 str); 2628 if (value == NAME_NOT_FOUND) { 2629 ALOGE("%s: Invalid Auto HDR value %s", __func__, str); 2630 return false; 2631 } 2632 2633 CDBG_HIGH("%s : Auto HDR status is: %d", __func__, value); 2634 return value ? true : false; 2635 } 2636 2637 CDBG_HIGH("%s : Auto HDR status not set!", __func__); 2638 return false; 2639 } 2640 2641 /*=========================================================================== 2642 * FUNCTION : setMCEValue 2643 * 2644 * DESCRIPTION: set memory color enhancement value from user setting 2645 * 2646 * PARAMETERS : 2647 * @params : user setting parameters 2648 * 2649 * RETURN : int32_t type of status 2650 * NO_ERROR -- success 2651 * none-zero failure code 2652 *==========================================================================*/ 2653 int32_t QCameraParameters::setMCEValue(const QCameraParameters& params) 2654 { 2655 const char *str = params.get(KEY_QC_MEMORY_COLOR_ENHANCEMENT); 2656 const char *prev_str = get(KEY_QC_MEMORY_COLOR_ENHANCEMENT); 2657 if (str != NULL) { 2658 if (prev_str == NULL || 2659 strcmp(str, prev_str) != 0) { 2660 return setMCEValue(str); 2661 } 2662 } 2663 return NO_ERROR; 2664 } 2665 2666 /*=========================================================================== 2667 * FUNCTION : setDISValue 2668 * 2669 * DESCRIPTION: enable/disable DIS from user setting 2670 * 2671 * PARAMETERS : 2672 * @params : user setting parameters 2673 * 2674 * RETURN : int32_t type of status 2675 * NO_ERROR -- success 2676 * none-zero failure code 2677 *==========================================================================*/ 2678 int32_t QCameraParameters::setDISValue(const QCameraParameters& params) 2679 { 2680 const char *str = params.get(KEY_QC_DIS); 2681 const char *prev_str = get(KEY_QC_DIS); 2682 if (str != NULL) { 2683 if (prev_str == NULL || 2684 strcmp(str, prev_str) != 0) { 2685 return setDISValue(str); 2686 } 2687 } 2688 return NO_ERROR; 2689 } 2690 2691 /*=========================================================================== 2692 * FUNCTION : setHighFrameRate 2693 * 2694 * DESCRIPTION: set hight frame rate value from user setting 2695 * 2696 * PARAMETERS : 2697 * @params : user setting parameters 2698 * 2699 * RETURN : int32_t type of status 2700 * NO_ERROR -- success 2701 * none-zero failure code 2702 *==========================================================================*/ 2703 int32_t QCameraParameters::setHighFrameRate(const QCameraParameters& params) 2704 { 2705 const char *str = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE); 2706 const char *prev_str = get(KEY_QC_VIDEO_HIGH_FRAME_RATE); 2707 if (str != NULL) { 2708 if (prev_str == NULL || 2709 strcmp(str, prev_str) != 0) { 2710 return setHighFrameRate(str); 2711 } 2712 } 2713 return NO_ERROR; 2714 } 2715 2716 /*=========================================================================== 2717 * FUNCTION : setHighSpeedRecording 2718 * 2719 * DESCRIPTION: set high speed recording value from user setting 2720 * 2721 * PARAMETERS : 2722 * @params : user setting parameters 2723 * 2724 * RETURN : int32_t type of status 2725 * NO_ERROR -- success 2726 * none-zero failure code 2727 *==========================================================================*/ 2728 int32_t QCameraParameters::setHighSpeedRecording(const QCameraParameters& params) 2729 { 2730 const char *str = params.get(KEY_QC_VIDEO_HIGH_SPEED_RECORDING); 2731 const char *prev_str = get(KEY_QC_VIDEO_HIGH_SPEED_RECORDING); 2732 const char *hfr_str = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE); 2733 int32_t hfr_mode = CAM_HFR_MODE_OFF; 2734 if (hfr_str != NULL) { 2735 hfr_mode = lookupAttr(HFR_MODES_MAP, 2736 sizeof(HFR_MODES_MAP)/sizeof(QCameraMap), 2737 hfr_str); 2738 } 2739 if (str != NULL) { 2740 if (prev_str == NULL || 2741 strcmp(str, prev_str) != 0) { 2742 int32_t value; 2743 // if HSR is off, take HFR fps value 2744 if (!strcmp(str,"on")) value = CAM_HFR_MODE_120FPS; 2745 else value = hfr_mode; 2746 // HFR value changed, need to restart preview 2747 m_bNeedRestart = true; 2748 // Set HFR value 2749 updateParamEntry(KEY_QC_VIDEO_HIGH_SPEED_RECORDING, str); 2750 return AddSetParmEntryToBatch(m_pParamBuf, 2751 CAM_INTF_PARM_HFR, 2752 sizeof(value), 2753 &value); 2754 } 2755 } 2756 return NO_ERROR; 2757 } 2758 2759 /*=========================================================================== 2760 * FUNCTION : setLensShadeValue 2761 * 2762 * DESCRIPTION: set lens shade value from user setting 2763 * 2764 * PARAMETERS : 2765 * @params : user setting parameters 2766 * 2767 * RETURN : int32_t type of status 2768 * NO_ERROR -- success 2769 * none-zero failure code 2770 *==========================================================================*/ 2771 int32_t QCameraParameters::setLensShadeValue(const QCameraParameters& params) 2772 { 2773 const char *str = params.get(KEY_QC_LENSSHADE); 2774 const char *prev_str = get(KEY_QC_LENSSHADE); 2775 if (str != NULL) { 2776 if (prev_str == NULL || 2777 strcmp(str, prev_str) != 0) { 2778 return setLensShadeValue(str); 2779 } 2780 } 2781 return NO_ERROR; 2782 } 2783 2784 /*=========================================================================== 2785 * FUNCTION : setFocusAreas 2786 * 2787 * DESCRIPTION: set focus areas from user setting 2788 * 2789 * PARAMETERS : 2790 * @params : user setting parameters 2791 * 2792 * RETURN : int32_t type of status 2793 * NO_ERROR -- success 2794 * none-zero failure code 2795 *==========================================================================*/ 2796 int32_t QCameraParameters::setFocusAreas(const QCameraParameters& params) 2797 { 2798 const char *str = params.get(KEY_FOCUS_AREAS); 2799 if (str != NULL) { 2800 int max_num_af_areas = getInt(KEY_MAX_NUM_FOCUS_AREAS); 2801 if(max_num_af_areas == 0) { 2802 ALOGE("%s: max num of AF area is 0, cannot set focus areas", __func__); 2803 return BAD_VALUE; 2804 } 2805 2806 const char *prev_str = get(KEY_FOCUS_AREAS); 2807 if (prev_str == NULL || 2808 strcmp(str, prev_str) != 0) { 2809 return setFocusAreas(str); 2810 } 2811 } 2812 return NO_ERROR; 2813 } 2814 2815 /*=========================================================================== 2816 * FUNCTION : setMeteringAreas 2817 * 2818 * DESCRIPTION: set metering areas from user setting 2819 * 2820 * PARAMETERS : 2821 * @params : user setting parameters 2822 * 2823 * RETURN : int32_t type of status 2824 * NO_ERROR -- success 2825 * none-zero failure code 2826 *==========================================================================*/ 2827 int32_t QCameraParameters::setMeteringAreas(const QCameraParameters& params) 2828 { 2829 const char *str = params.get(KEY_METERING_AREAS); 2830 if (str != NULL) { 2831 int max_num_mtr_areas = getInt(KEY_MAX_NUM_METERING_AREAS); 2832 if(max_num_mtr_areas == 0) { 2833 ALOGE("%s: max num of metering areas is 0, cannot set focus areas", __func__); 2834 return BAD_VALUE; 2835 } 2836 2837 const char *prev_str = get(KEY_METERING_AREAS); 2838 if (prev_str == NULL || 2839 strcmp(str, prev_str) != 0) { 2840 return setMeteringAreas(str); 2841 } 2842 } 2843 return NO_ERROR; 2844 } 2845 2846 /*=========================================================================== 2847 * FUNCTION : setSceneMode 2848 * 2849 * DESCRIPTION: set scenen mode from user setting 2850 * 2851 * PARAMETERS : 2852 * @params : user setting parameters 2853 * 2854 * RETURN : int32_t type of status 2855 * NO_ERROR -- success 2856 * none-zero failure code 2857 *==========================================================================*/ 2858 int32_t QCameraParameters::setSceneMode(const QCameraParameters& params) 2859 { 2860 const char *str = params.get(KEY_SCENE_MODE); 2861 const char *prev_str = get(KEY_SCENE_MODE); 2862 CDBG_HIGH("%s: str - %s, prev_str - %s",__func__, str, prev_str); 2863 2864 if (str != NULL) { 2865 if (prev_str == NULL || 2866 strcmp(str, prev_str) != 0) { 2867 2868 if(strcmp(str, SCENE_MODE_AUTO) == 0) { 2869 m_bSceneTransitionAuto = true; 2870 } 2871 if (strcmp(str, SCENE_MODE_HDR) == 0) { 2872 // If HDR is set from client and the feature is not enabled in the backend, ignore it. 2873 if (m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_SENSOR_HDR) { 2874 m_bSensorHDREnabled = true; 2875 CDBG_HIGH("%s: Sensor HDR mode Enabled",__func__); 2876 2877 } 2878 else if (m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_HDR) { 2879 m_bHDREnabled = true; 2880 CDBG_HIGH("%s: S/W HDR Enabled",__func__); 2881 } 2882 else { 2883 return NO_ERROR; 2884 } 2885 } else { 2886 m_bHDREnabled = false; 2887 if (m_bSensorHDREnabled) { 2888 m_bSensorHDREnabled = false; 2889 m_bNeedRestart = true; 2890 setSensorSnapshotHDR("off"); 2891 } 2892 } 2893 2894 if (m_bSensorHDREnabled) { 2895 setSensorSnapshotHDR("on"); 2896 m_bNeedRestart = true; 2897 } else if ((m_bHDREnabled) || 2898 ((prev_str != NULL) && (strcmp(prev_str, SCENE_MODE_HDR) == 0))) { 2899 CDBG_HIGH("%s: scene mode changed between HDR and non-HDR, need restart", __func__); 2900 2901 m_bNeedRestart = true; 2902 // set if hdr 1x image is needed 2903 const char *need_hdr_1x = params.get(KEY_QC_HDR_NEED_1X); 2904 if (need_hdr_1x != NULL) { 2905 if (strcmp(need_hdr_1x, VALUE_TRUE) == 0) { 2906 m_bHDR1xFrameEnabled = true; 2907 } else { 2908 m_bHDR1xFrameEnabled = false; 2909 } 2910 2911 updateParamEntry(KEY_QC_HDR_NEED_1X, need_hdr_1x); 2912 } 2913 2914 AddSetParmEntryToBatch(m_pParamBuf, 2915 CAM_INTF_PARM_HDR_NEED_1X, 2916 sizeof(m_bHDR1xFrameEnabled), 2917 &m_bHDR1xFrameEnabled); 2918 } 2919 2920 return setSceneMode(str); 2921 } 2922 } 2923 return NO_ERROR; 2924 } 2925 2926 /*=========================================================================== 2927 * FUNCTION : setSelectableZoneAf 2928 * 2929 * DESCRIPTION: set selectable zone auto focus value from user setting 2930 * 2931 * PARAMETERS : 2932 * @params : user setting parameters 2933 * 2934 * RETURN : int32_t type of status 2935 * NO_ERROR -- success 2936 * none-zero failure code 2937 *==========================================================================*/ 2938 int32_t QCameraParameters::setSelectableZoneAf(const QCameraParameters& params) 2939 { 2940 const char *str = params.get(KEY_QC_SELECTABLE_ZONE_AF); 2941 const char *prev_str = get(KEY_QC_SELECTABLE_ZONE_AF); 2942 if (str != NULL) { 2943 if (prev_str == NULL || 2944 strcmp(str, prev_str) != 0) { 2945 return setSelectableZoneAf(str); 2946 } 2947 } 2948 return NO_ERROR; 2949 } 2950 2951 /*=========================================================================== 2952 * FUNCTION : setAEBracket 2953 * 2954 * DESCRIPTION: set AE bracket from user setting 2955 * 2956 * PARAMETERS : 2957 * @params : user setting parameters 2958 * 2959 * RETURN : int32_t type of status 2960 * NO_ERROR -- success 2961 * none-zero failure code 2962 *==========================================================================*/ 2963 int32_t QCameraParameters::setAEBracket(const QCameraParameters& params) 2964 { 2965 if (isHDREnabled()) { 2966 CDBG_HIGH("%s: scene mode is HDR, overwrite AE bracket setting to off", __func__); 2967 return setAEBracket(AE_BRACKET_OFF); 2968 } 2969 2970 const char *expStr = params.get(KEY_QC_CAPTURE_BURST_EXPOSURE); 2971 if (NULL != expStr && strlen(expStr) > 0) { 2972 set(KEY_QC_CAPTURE_BURST_EXPOSURE, expStr); 2973 } else { 2974 char prop[PROPERTY_VALUE_MAX]; 2975 memset(prop, 0, sizeof(prop)); 2976 property_get("persist.capture.burst.exposures", prop, ""); 2977 if (strlen(prop) > 0) { 2978 set(KEY_QC_CAPTURE_BURST_EXPOSURE, prop); 2979 } else { 2980 remove(KEY_QC_CAPTURE_BURST_EXPOSURE); 2981 } 2982 } 2983 2984 const char *str = params.get(KEY_QC_AE_BRACKET_HDR); 2985 const char *prev_str = get(KEY_QC_AE_BRACKET_HDR); 2986 if (str != NULL) { 2987 if (prev_str == NULL || 2988 strcmp(str, prev_str) != 0) { 2989 return setAEBracket(str); 2990 } 2991 } 2992 return NO_ERROR; 2993 } 2994 2995 /*=========================================================================== 2996 * FUNCTION : setAFBracket 2997 * 2998 * DESCRIPTION: set AF bracket from user setting 2999 * 3000 * PARAMETERS : 3001 * @params : user setting parameters 3002 * 3003 * RETURN : int32_t type of status 3004 * NO_ERROR -- success 3005 * none-zero failure code 3006 *==========================================================================*/ 3007 int32_t QCameraParameters::setAFBracket(const QCameraParameters& params) 3008 { 3009 if ((m_pCapability->qcom_supported_feature_mask & 3010 CAM_QCOM_FEATURE_UBIFOCUS) == 0){ 3011 CDBG_HIGH("%s: AF Bracketing is not supported",__func__); 3012 return NO_ERROR; 3013 } 3014 const char *str = params.get(KEY_QC_AF_BRACKET); 3015 const char *prev_str = get(KEY_QC_AF_BRACKET); 3016 CDBG_HIGH("%s: str =%s & prev_str =%s",__func__, str, prev_str); 3017 if (str != NULL) { 3018 if (prev_str == NULL || 3019 strcmp(str, prev_str) != 0) { 3020 m_bNeedRestart = true; 3021 return setAFBracket(str); 3022 } 3023 } 3024 return NO_ERROR; 3025 } 3026 3027 /*=========================================================================== 3028 * FUNCTION : setChromaFlash 3029 * 3030 * DESCRIPTION: set chroma flash from user setting 3031 * 3032 * PARAMETERS : 3033 * @params : user setting parameters 3034 * 3035 * RETURN : int32_t type of status 3036 * NO_ERROR -- success 3037 * none-zero failure code 3038 *==========================================================================*/ 3039 int32_t QCameraParameters::setChromaFlash(const QCameraParameters& params) 3040 { 3041 if ((m_pCapability->qcom_supported_feature_mask & 3042 CAM_QCOM_FEATURE_CHROMA_FLASH) == 0) { 3043 CDBG_HIGH("%s: Chroma Flash is not supported",__func__); 3044 return NO_ERROR; 3045 } 3046 const char *str = params.get(KEY_QC_CHROMA_FLASH); 3047 const char *prev_str = get(KEY_QC_CHROMA_FLASH); 3048 CDBG_HIGH("%s: str =%s & prev_str =%s",__func__, str, prev_str); 3049 if (str != NULL) { 3050 if (prev_str == NULL || 3051 strcmp(str, prev_str) != 0) { 3052 m_bNeedRestart = true; 3053 return setChromaFlash(str); 3054 } 3055 } 3056 return NO_ERROR; 3057 } 3058 3059 /*=========================================================================== 3060 * FUNCTION : setOptiZoom 3061 * 3062 * DESCRIPTION: set opti zoom from user setting 3063 * 3064 * PARAMETERS : 3065 * @params : user setting parameters 3066 * 3067 * RETURN : int32_t type of status 3068 * NO_ERROR -- success 3069 * none-zero failure code 3070 *==========================================================================*/ 3071 int32_t QCameraParameters::setOptiZoom(const QCameraParameters& params) 3072 { 3073 if ((m_pCapability->qcom_supported_feature_mask & 3074 CAM_QCOM_FEATURE_OPTIZOOM) == 0){ 3075 CDBG_HIGH("%s: Opti Zoom is not supported",__func__); 3076 return NO_ERROR; 3077 } 3078 const char *str = params.get(KEY_QC_OPTI_ZOOM); 3079 const char *prev_str = get(KEY_QC_OPTI_ZOOM); 3080 CDBG_HIGH("%s: str =%s & prev_str =%s",__func__, str, prev_str); 3081 if (str != NULL) { 3082 if (prev_str == NULL || 3083 strcmp(str, prev_str) != 0) { 3084 m_bNeedRestart = true; 3085 return setOptiZoom(str); 3086 } 3087 } 3088 return NO_ERROR; 3089 } 3090 3091 3092 /*=========================================================================== 3093 * FUNCTION : setRedeyeReduction 3094 * 3095 * DESCRIPTION: set red eye reduction setting from user setting 3096 * 3097 * PARAMETERS : 3098 * @params : user setting parameters 3099 * 3100 * RETURN : int32_t type of status 3101 * NO_ERROR -- success 3102 * none-zero failure code 3103 *==========================================================================*/ 3104 int32_t QCameraParameters::setRedeyeReduction(const QCameraParameters& params) 3105 { 3106 const char *str = params.get(KEY_QC_REDEYE_REDUCTION); 3107 const char *prev_str = get(KEY_QC_REDEYE_REDUCTION); 3108 if (str != NULL) { 3109 if (prev_str == NULL || 3110 strcmp(str, prev_str) != 0) { 3111 return setRedeyeReduction(str); 3112 } 3113 } 3114 return NO_ERROR; 3115 } 3116 3117 /*=========================================================================== 3118 * FUNCTION : setGpsLocation 3119 * 3120 * DESCRIPTION: set GPS location information from user setting 3121 * 3122 * PARAMETERS : 3123 * @params : user setting parameters 3124 * 3125 * RETURN : int32_t type of status 3126 * NO_ERROR -- success 3127 * none-zero failure code 3128 *==========================================================================*/ 3129 int32_t QCameraParameters::setGpsLocation(const QCameraParameters& params) 3130 { 3131 const char *method = params.get(KEY_GPS_PROCESSING_METHOD); 3132 if (method) { 3133 set(KEY_GPS_PROCESSING_METHOD, method); 3134 }else { 3135 remove(KEY_GPS_PROCESSING_METHOD); 3136 } 3137 3138 const char *latitude = params.get(KEY_GPS_LATITUDE); 3139 if (latitude) { 3140 set(KEY_GPS_LATITUDE, latitude); 3141 }else { 3142 remove(KEY_GPS_LATITUDE); 3143 } 3144 3145 const char *latitudeRef = params.get(KEY_QC_GPS_LATITUDE_REF); 3146 if (latitudeRef) { 3147 set(KEY_QC_GPS_LATITUDE_REF, latitudeRef); 3148 }else { 3149 remove(KEY_QC_GPS_LATITUDE_REF); 3150 } 3151 3152 const char *longitude = params.get(KEY_GPS_LONGITUDE); 3153 if (longitude) { 3154 set(KEY_GPS_LONGITUDE, longitude); 3155 }else { 3156 remove(KEY_GPS_LONGITUDE); 3157 } 3158 3159 const char *longitudeRef = params.get(KEY_QC_GPS_LONGITUDE_REF); 3160 if (longitudeRef) { 3161 set(KEY_QC_GPS_LONGITUDE_REF, longitudeRef); 3162 }else { 3163 remove(KEY_QC_GPS_LONGITUDE_REF); 3164 } 3165 3166 const char *altitudeRef = params.get(KEY_QC_GPS_ALTITUDE_REF); 3167 if (altitudeRef) { 3168 set(KEY_QC_GPS_ALTITUDE_REF, altitudeRef); 3169 }else { 3170 remove(KEY_QC_GPS_ALTITUDE_REF); 3171 } 3172 3173 const char *altitude = params.get(KEY_GPS_ALTITUDE); 3174 if (altitude) { 3175 set(KEY_GPS_ALTITUDE, altitude); 3176 }else { 3177 remove(KEY_GPS_ALTITUDE); 3178 } 3179 3180 const char *status = params.get(KEY_QC_GPS_STATUS); 3181 if (status) { 3182 set(KEY_QC_GPS_STATUS, status); 3183 } else { 3184 remove(KEY_QC_GPS_STATUS); 3185 } 3186 3187 const char *timestamp = params.get(KEY_GPS_TIMESTAMP); 3188 if (timestamp) { 3189 set(KEY_GPS_TIMESTAMP, timestamp); 3190 }else { 3191 remove(KEY_GPS_TIMESTAMP); 3192 } 3193 return NO_ERROR; 3194 } 3195 3196 /*=========================================================================== 3197 * FUNCTION : setNumOfSnapshot 3198 * 3199 * DESCRIPTION: set number of snapshot per shutter from user setting 3200 * 3201 * PARAMETERS : none 3202 * 3203 * RETURN : int32_t type of status 3204 * NO_ERROR -- success 3205 * none-zero failure code 3206 *==========================================================================*/ 3207 int32_t QCameraParameters::setNumOfSnapshot() 3208 { 3209 int nBurstNum = getBurstNum(); 3210 uint8_t nExpnum = 0; 3211 3212 const char *bracket_str = get(KEY_QC_AE_BRACKET_HDR); 3213 if (bracket_str != NULL && strlen(bracket_str) > 0) { 3214 int value = lookupAttr(BRACKETING_MODES_MAP, 3215 sizeof(BRACKETING_MODES_MAP)/sizeof(QCameraMap), 3216 bracket_str); 3217 switch (value) { 3218 case CAM_EXP_BRACKETING_ON: 3219 { 3220 nExpnum = 0; 3221 const char *str_val = get(KEY_QC_CAPTURE_BURST_EXPOSURE); 3222 if ((str_val != NULL) && (strlen(str_val) > 0)) { 3223 char prop[PROPERTY_VALUE_MAX]; 3224 memset(prop, 0, sizeof(prop)); 3225 strcpy(prop, str_val); 3226 char *saveptr = NULL; 3227 char *token = strtok_r(prop, ",", &saveptr); 3228 while (token != NULL) { 3229 token = strtok_r(NULL, ",", &saveptr); 3230 nExpnum++; 3231 } 3232 } 3233 if (nExpnum == 0) { 3234 nExpnum = 1; 3235 } 3236 } 3237 break; 3238 default: 3239 nExpnum = 1 + getNumOfExtraHDROutBufsIfNeeded(); 3240 break; 3241 } 3242 } 3243 3244 CDBG_HIGH("%s: nBurstNum = %d, nExpnum = %d", __func__, nBurstNum, nExpnum); 3245 set(KEY_QC_NUM_SNAPSHOT_PER_SHUTTER, nBurstNum * nExpnum); 3246 return NO_ERROR; 3247 } 3248 3249 /*=========================================================================== 3250 * FUNCTION : setRecordingHint 3251 * 3252 * DESCRIPTION: set recording hint value from user setting 3253 * 3254 * PARAMETERS : 3255 * @params : user setting parameters 3256 * 3257 * RETURN : int32_t type of status 3258 * NO_ERROR -- success 3259 * none-zero failure code 3260 *==========================================================================*/ 3261 int32_t QCameraParameters::setRecordingHint(const QCameraParameters& params) 3262 { 3263 const char * str = params.get(KEY_RECORDING_HINT); 3264 const char *prev_str = get(KEY_RECORDING_HINT); 3265 if (str != NULL) { 3266 if (prev_str == NULL || strcmp(str, prev_str) != 0) { 3267 int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP, 3268 sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap), 3269 str); 3270 if(value != NAME_NOT_FOUND){ 3271 updateParamEntry(KEY_RECORDING_HINT, str); 3272 setRecordingHintValue(value); 3273 if (getFaceDetectionOption() == true) { 3274 setFaceDetection(value > 0 ? false : true, false); 3275 } 3276 return NO_ERROR; 3277 } else { 3278 ALOGE("Invalid recording hint value: %s", str); 3279 return BAD_VALUE; 3280 } 3281 } 3282 } 3283 return NO_ERROR; 3284 } 3285 3286 /*=========================================================================== 3287 * FUNCTION : setNoDisplayMode 3288 * 3289 * DESCRIPTION: set no display mode from user setting 3290 * 3291 * PARAMETERS : 3292 * @params : user setting parameters 3293 * 3294 * RETURN : int32_t type of status 3295 * NO_ERROR -- success 3296 * none-zero failure code 3297 *==========================================================================*/ 3298 int32_t QCameraParameters::setNoDisplayMode(const QCameraParameters& params) 3299 { 3300 const char *str_val = params.get(KEY_QC_NO_DISPLAY_MODE); 3301 const char *prev_str = get(KEY_QC_NO_DISPLAY_MODE); 3302 if(str_val && strlen(str_val) > 0) { 3303 if (prev_str == NULL || strcmp(str_val, prev_str) != 0) { 3304 m_bNoDisplayMode = atoi(str_val); 3305 set(KEY_QC_NO_DISPLAY_MODE, str_val); 3306 m_bNeedRestart = true; 3307 } 3308 } else { 3309 m_bNoDisplayMode = false; 3310 } 3311 CDBG_HIGH("Param m_bNoDisplayMode = %d", m_bNoDisplayMode); 3312 return NO_ERROR; 3313 } 3314 3315 /*=========================================================================== 3316 * FUNCTION : setZslMode 3317 * 3318 * DESCRIPTION: set ZSL mode from user setting 3319 * 3320 * PARAMETERS : 3321 * @params : user setting parameters 3322 * 3323 * RETURN : int32_t type of status 3324 * NO_ERROR -- success 3325 * none-zero failure code 3326 *==========================================================================*/ 3327 int32_t QCameraParameters::setZslMode(const QCameraParameters& params) 3328 { 3329 const char *str_val = params.get(KEY_QC_ZSL); 3330 const char *prev_val = get(KEY_QC_ZSL); 3331 3332 if (str_val != NULL) { 3333 if (prev_val == NULL || strcmp(str_val, prev_val) != 0) { 3334 int32_t value = lookupAttr(ON_OFF_MODES_MAP, 3335 sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap), 3336 str_val); 3337 if (value != NAME_NOT_FOUND) { 3338 set(KEY_QC_ZSL, str_val); 3339 m_bZslMode_new = (value > 0)? true : false; 3340 3341 // ZSL mode changed, need restart preview 3342 m_bNeedRestart = true; 3343 3344 return AddSetParmEntryToBatch(m_pParamBuf, 3345 CAM_INTF_PARM_ZSL_MODE, 3346 sizeof(value), 3347 &value); 3348 } else { 3349 ALOGE("Invalid ZSL mode value: %s", str_val); 3350 return BAD_VALUE; 3351 } 3352 } 3353 } 3354 return NO_ERROR; 3355 } 3356 3357 /*=========================================================================== 3358 * FUNCTION : setWaveletDenoise 3359 * 3360 * DESCRIPTION: set wavelet denoise value from user setting 3361 * 3362 * PARAMETERS : 3363 * @params : user setting parameters 3364 * 3365 * RETURN : int32_t type of status 3366 * NO_ERROR -- success 3367 * none-zero failure code 3368 *==========================================================================*/ 3369 int32_t QCameraParameters::setWaveletDenoise(const QCameraParameters& params) 3370 { 3371 const char *str_pf = params.getPictureFormat(); 3372 int32_t pictureFormat = 3373 lookupAttr(PICTURE_TYPES_MAP, 3374 sizeof(PICTURE_TYPES_MAP) / sizeof(QCameraMap), 3375 str_pf); 3376 if (pictureFormat != NAME_NOT_FOUND) { 3377 if (CAM_FORMAT_YUV_422_NV16 == pictureFormat) { 3378 ALOGE("NV16 format isn't supported in denoise lib!"); 3379 return setWaveletDenoise(DENOISE_OFF); 3380 } 3381 } 3382 const char *str = params.get(KEY_QC_DENOISE); 3383 const char *prev_str = get(KEY_QC_DENOISE); 3384 if (str != NULL) { 3385 if (prev_str == NULL || 3386 strcmp(str, prev_str) != 0) { 3387 return setWaveletDenoise(str); 3388 } 3389 } 3390 return NO_ERROR; 3391 } 3392 3393 /*=========================================================================== 3394 * FUNCTION : setCameraMode 3395 * 3396 * DESCRIPTION: set camera mode from user setting 3397 * 3398 * PARAMETERS : 3399 * @params : user setting parameters 3400 * 3401 * RETURN : int32_t type of status 3402 * NO_ERROR -- success 3403 * none-zero failure code 3404 *==========================================================================*/ 3405 int32_t QCameraParameters::setCameraMode(const QCameraParameters& params) 3406 { 3407 const char *str = params.get(KEY_QC_CAMERA_MODE); 3408 if (str != NULL) { 3409 set(KEY_QC_CAMERA_MODE, str); 3410 } else { 3411 remove(KEY_QC_CAMERA_MODE); 3412 } 3413 return NO_ERROR; 3414 } 3415 3416 /*=========================================================================== 3417 * FUNCTION : setSceneSelectionMode 3418 * 3419 * DESCRIPTION: set scene selection mode from user setting 3420 * 3421 * PARAMETERS : 3422 * @params : user setting parameters 3423 * 3424 * RETURN : int32_t type of status 3425 * NO_ERROR -- success 3426 * none-zero failure code 3427 *==========================================================================*/ 3428 int32_t QCameraParameters::setSceneSelectionMode(const QCameraParameters& params) 3429 { 3430 const char *str = params.get(KEY_QC_SCENE_SELECTION); 3431 const char *prev_str = get(KEY_QC_SCENE_SELECTION); 3432 if (NULL != str) { 3433 if ((NULL == prev_str) || (strcmp(str, prev_str) != 0)) { 3434 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 3435 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 3436 str); 3437 if (value != NAME_NOT_FOUND) { 3438 ALOGD("%s: Setting selection value %s", __func__, str); 3439 if (value && m_bZslMode_new) { 3440 updateParamEntry(KEY_QC_SCENE_SELECTION, str); 3441 m_bNeedRestart = true; 3442 m_bSceneSelection = true; 3443 } else if (!value) { 3444 updateParamEntry(KEY_QC_SCENE_SELECTION, str); 3445 m_bNeedRestart = true; 3446 m_bSceneSelection = false; 3447 } else { 3448 ALOGE("%s: Trying to enable scene selection in non ZSL mode!!!", 3449 __func__); 3450 return BAD_VALUE; 3451 } 3452 } else { 3453 ALOGE("%s: Trying to configure invalid scene selection value: %s", 3454 __func__, 3455 str); 3456 return BAD_VALUE; 3457 } 3458 } 3459 } 3460 3461 return NO_ERROR; 3462 } 3463 3464 /*=========================================================================== 3465 * FUNCTION : setSelectedScene 3466 * 3467 * DESCRIPTION: select specific scene 3468 * 3469 * PARAMETERS : 3470 * @scene : scene mode 3471 * 3472 * RETURN : int32_t type of status 3473 * NO_ERROR -- success 3474 * none-zero failure code 3475 *==========================================================================*/ 3476 int32_t QCameraParameters::setSelectedScene(cam_scene_mode_type scene) 3477 { 3478 Mutex::Autolock l(m_SceneSelectLock); 3479 m_SelectedScene = scene; 3480 return NO_ERROR; 3481 } 3482 3483 /*=========================================================================== 3484 * FUNCTION : getSelectedScene 3485 * 3486 * DESCRIPTION: get selected scene 3487 * 3488 * PARAMETERS : 3489 * 3490 * RETURN : currently selected scene 3491 *==========================================================================*/ 3492 cam_scene_mode_type QCameraParameters::getSelectedScene() 3493 { 3494 Mutex::Autolock l(m_SceneSelectLock); 3495 return m_SelectedScene; 3496 } 3497 3498 /*========================================================== 3499 * FUNCTION : setRdiMode 3500 * 3501 * DESCRIPTION: set Rdi mode from user setting 3502 * 3503 * PARAMETERS : 3504 * @params : user setting parameters 3505 * 3506 * RETURN : int32_t type of status 3507 * NO_ERROR -- success 3508 * none-zero failure code 3509 *===========================================================*/ 3510 int32_t QCameraParameters::setRdiMode(const QCameraParameters& params) 3511 { 3512 const char *str = params.get(KEY_QC_RDI_MODE); 3513 const char *prev_str = get(KEY_QC_RDI_MODE); 3514 char prop[PROPERTY_VALUE_MAX]; 3515 memset(prop, 0, sizeof(prop)); 3516 3517 property_get("persist.camera.rdi.mode", prop, VALUE_DISABLE); 3518 if ((str != NULL) && (prev_str == NULL || strcmp(str, prev_str) != 0)) { 3519 ALOGD("%s:%d : RDI mode set to %s", __func__, __LINE__, str); 3520 setRdiMode(str); 3521 } else if (prev_str == NULL || strcmp(prev_str, prop) != 0 ) { 3522 ALOGD("%s:%d : RDI mode set to prop: %s", __func__, __LINE__, prop); 3523 setRdiMode(prop); 3524 } 3525 return NO_ERROR; 3526 } 3527 3528 /*========================================================== 3529 * FUNCTION : setSecureMode 3530 * 3531 * DESCRIPTION: set secure mode from user setting 3532 * 3533 * PARAMETERS : 3534 * @params : user setting parameters 3535 * 3536 * RETURN : int32_t type of status 3537 * NO_ERROR -- success 3538 * none-zero failure code 3539 *===========================================================*/ 3540 3541 int32_t QCameraParameters::setSecureMode( 3542 const QCameraParameters& params) 3543 { 3544 const char *str = params.get(KEY_QC_SECURE_MODE); 3545 const char *prev_str = get(KEY_QC_SECURE_MODE); 3546 char prop[PROPERTY_VALUE_MAX]; 3547 memset(prop, 0, sizeof(prop)); 3548 3549 property_get("persist.camera.secure.mode", prop, VALUE_DISABLE); 3550 if ((str != NULL) && (prev_str == NULL || strcmp(str, prev_str) != 0)) { 3551 ALOGD("%s : Secure mode set to KEY: %s", __func__, str); 3552 setSecureMode(str); 3553 } else if (prev_str == NULL || strcmp(prev_str, prop) != 0 ) { 3554 ALOGD("%s : Secure mode set to prop: %s", __func__, prop); 3555 setSecureMode(prop); 3556 } 3557 return NO_ERROR; 3558 } 3559 3560 /*=========================================================================== 3561 * FUNCTION : setZslAttributes 3562 * 3563 * DESCRIPTION: set ZSL related attributes from user setting 3564 * 3565 * PARAMETERS : 3566 * @params : user setting parameters 3567 * 3568 * RETURN : int32_t type of status 3569 * NO_ERROR -- success 3570 * none-zero failure code 3571 *==========================================================================*/ 3572 int32_t QCameraParameters::setZslAttributes(const QCameraParameters& params) 3573 { 3574 // TODO: may switch to pure param instead of sysprop 3575 char prop[PROPERTY_VALUE_MAX]; 3576 3577 const char *str = params.get(KEY_QC_ZSL_BURST_INTERVAL); 3578 if (str != NULL) { 3579 set(KEY_QC_ZSL_BURST_INTERVAL, str); 3580 } else { 3581 memset(prop, 0, sizeof(prop)); 3582 property_get("persist.camera.zsl.interval", prop, "1"); 3583 set(KEY_QC_ZSL_BURST_INTERVAL, prop); 3584 CDBG_HIGH("%s: [ZSL Retro] burst interval: %s", __func__, prop); 3585 } 3586 3587 str = params.get(KEY_QC_ZSL_BURST_LOOKBACK); 3588 if (str != NULL) { 3589 set(KEY_QC_ZSL_BURST_LOOKBACK, str); 3590 } else { 3591 memset(prop, 0, sizeof(prop)); 3592 property_get("persist.camera.zsl.backlookcnt", prop, "2"); 3593 set(KEY_QC_ZSL_BURST_LOOKBACK, prop); 3594 CDBG_HIGH("%s: [ZSL Retro] look back count: %s", __func__, prop); 3595 } 3596 3597 str = params.get(KEY_QC_ZSL_QUEUE_DEPTH); 3598 if (str != NULL) { 3599 set(KEY_QC_ZSL_QUEUE_DEPTH, str); 3600 } else { 3601 memset(prop, 0, sizeof(prop)); 3602 property_get("persist.camera.zsl.queuedepth", prop, "2"); 3603 set(KEY_QC_ZSL_QUEUE_DEPTH, prop); 3604 CDBG_HIGH("%s: [ZSL Retro] queue depth: %s", __func__, prop); 3605 } 3606 3607 return NO_ERROR; 3608 } 3609 3610 /*=========================================================================== 3611 * FUNCTION : setFlip 3612 * 3613 * DESCRIPTION: set preview/ video/ picture flip mode from user setting 3614 * 3615 * PARAMETERS : 3616 * @params : user setting parameters 3617 * 3618 * RETURN : int32_t type of status 3619 * NO_ERROR -- success 3620 * none-zero failure code 3621 *==========================================================================*/ 3622 int32_t QCameraParameters::setFlip(const QCameraParameters& params) 3623 { 3624 if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_FLIP) == 0) { 3625 CDBG_HIGH("%s: flip is not supported.", __func__); 3626 return NO_ERROR; 3627 } 3628 3629 //check preview flip setting 3630 const char *str = params.get(KEY_QC_PREVIEW_FLIP); 3631 const char *prev_val = get(KEY_QC_PREVIEW_FLIP); 3632 if(str != NULL){ 3633 if (prev_val == NULL || strcmp(str, prev_val) != 0) { 3634 int32_t value = lookupAttr(FLIP_MODES_MAP, 3635 sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap), 3636 str); 3637 if(value != NAME_NOT_FOUND){ 3638 set(KEY_QC_PREVIEW_FLIP, str); 3639 m_bPreviewFlipChanged = true; 3640 } 3641 } 3642 } 3643 3644 // check video filp setting 3645 str = params.get(KEY_QC_VIDEO_FLIP); 3646 prev_val = get(KEY_QC_VIDEO_FLIP); 3647 if(str != NULL){ 3648 if (prev_val == NULL || strcmp(str, prev_val) != 0) { 3649 int32_t value = lookupAttr(FLIP_MODES_MAP, 3650 sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap), 3651 str); 3652 if(value != NAME_NOT_FOUND){ 3653 set(KEY_QC_VIDEO_FLIP, str); 3654 m_bVideoFlipChanged = true; 3655 } 3656 } 3657 } 3658 3659 // check picture filp setting 3660 str = params.get(KEY_QC_SNAPSHOT_PICTURE_FLIP); 3661 prev_val = get(KEY_QC_SNAPSHOT_PICTURE_FLIP); 3662 if(str != NULL){ 3663 if (prev_val == NULL || strcmp(str, prev_val) != 0) { 3664 int32_t value = lookupAttr(FLIP_MODES_MAP, 3665 sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap), 3666 str); 3667 if(value != NAME_NOT_FOUND){ 3668 set(KEY_QC_SNAPSHOT_PICTURE_FLIP, str); 3669 m_bSnapshotFlipChanged = true; 3670 } 3671 } 3672 } 3673 3674 return NO_ERROR; 3675 } 3676 3677 /*=========================================================================== 3678 * FUNCTION : setBurstNum 3679 * 3680 * DESCRIPTION: set burst number of snapshot 3681 * 3682 * PARAMETERS : 3683 * @params : user setting parameters 3684 * 3685 * RETURN : int32_t type of status 3686 * NO_ERROR -- success 3687 * none-zero failure code 3688 *==========================================================================*/ 3689 int32_t QCameraParameters::setBurstNum(const QCameraParameters& params) 3690 { 3691 int nBurstNum = params.getInt(KEY_QC_SNAPSHOT_BURST_NUM); 3692 if (isAdvCamFeaturesEnabled()) { 3693 nBurstNum = 1; 3694 } 3695 if (nBurstNum <= 0) { 3696 // if burst number is not set in parameters, 3697 // read from sys prop 3698 char prop[PROPERTY_VALUE_MAX]; 3699 memset(prop, 0, sizeof(prop)); 3700 property_get("persist.camera.snapshot.number", prop, "0"); 3701 nBurstNum = atoi(prop); 3702 if (nBurstNum <= 0) { 3703 nBurstNum = 1; 3704 } 3705 } 3706 set(KEY_QC_SNAPSHOT_BURST_NUM, nBurstNum); 3707 m_nBurstNum = nBurstNum; 3708 CDBG_HIGH("%s: [ZSL Retro] m_nBurstNum = %d", __func__, m_nBurstNum); 3709 return AddSetParmEntryToBatch(m_pParamBuf, 3710 CAM_INTF_PARM_BURST_NUM, 3711 sizeof(nBurstNum), 3712 &nBurstNum); 3713 } 3714 3715 /*=========================================================================== 3716 * FUNCTION : setSnapshotFDReq 3717 * 3718 * DESCRIPTION: set requirement of Face Detection Metadata in Snapshot mode. 3719 * 3720 * PARAMETERS : 3721 * @params : user setting parameters 3722 * 3723 * RETURN : int32_t type of status 3724 * NO_ERROR -- success 3725 * none-zero failure code 3726 *==========================================================================*/ 3727 int32_t QCameraParameters::setSnapshotFDReq(const QCameraParameters& params) 3728 { 3729 char prop[PROPERTY_VALUE_MAX]; 3730 const char *str = params.get(KEY_QC_SNAPSHOT_FD_DATA); 3731 3732 if(str != NULL){ 3733 set(KEY_QC_SNAPSHOT_FD_DATA, str); 3734 }else{ 3735 memset(prop, 0, sizeof(prop)); 3736 property_get("persist.camera.snapshot.fd", prop, "0"); 3737 set(KEY_QC_SNAPSHOT_FD_DATA, prop); 3738 } 3739 return NO_ERROR; 3740 } 3741 3742 /*=========================================================================== 3743 * FUNCTION : setMobicat 3744 * 3745 * DESCRIPTION: set Mobicat on/off. 3746 * 3747 * PARAMETERS : 3748 * @params : user setting parameters 3749 * 3750 * RETURN : int32_t type of status 3751 * NO_ERROR -- success 3752 * none-zero failure code 3753 *==========================================================================*/ 3754 int32_t QCameraParameters::setMobicat(const QCameraParameters& ) 3755 { 3756 char value [PROPERTY_VALUE_MAX]; 3757 property_get("persist.camera.mobicat", value, "0"); 3758 bool enableMobi = atoi(value) > 0 ? true : false; 3759 int32_t ret = NO_ERROR;; 3760 3761 if (enableMobi) { 3762 tune_cmd_t tune_cmd; 3763 tune_cmd.type = 2; 3764 tune_cmd.module = 0; 3765 tune_cmd.value = 1; 3766 3767 ret = AddSetParmEntryToBatch(m_pParamBuf, 3768 CAM_INTF_PARM_SET_VFE_COMMAND, 3769 sizeof(tune_cmd_t), 3770 &tune_cmd); 3771 if (NO_ERROR != ret) { 3772 return ret; 3773 } 3774 tune_cmd.module = 0; 3775 3776 ret = AddSetParmEntryToBatch(m_pParamBuf, 3777 CAM_INTF_PARM_SET_PP_COMMAND, 3778 sizeof(tune_cmd_t), 3779 &tune_cmd); 3780 } 3781 3782 return ret; 3783 } 3784 3785 /*=========================================================================== 3786 * FUNCTION : updateParameters 3787 * 3788 * DESCRIPTION: update parameters from user setting 3789 * 3790 * PARAMETERS : 3791 * @params : user setting parameters 3792 * @needRestart : [output] if preview need restart upon setting changes 3793 * 3794 * RETURN : int32_t type of status 3795 * NO_ERROR -- success 3796 * none-zero failure code 3797 *==========================================================================*/ 3798 int32_t QCameraParameters::updateParameters(QCameraParameters& params, 3799 bool &needRestart) 3800 { 3801 int32_t final_rc = NO_ERROR; 3802 int32_t rc; 3803 m_bNeedRestart = false; 3804 3805 if(initBatchUpdate(m_pParamBuf) < 0 ) { 3806 ALOGE("%s:Failed to initialize group update table",__func__); 3807 rc = BAD_TYPE; 3808 goto UPDATE_PARAM_DONE; 3809 } 3810 3811 if ((rc = setPreviewSize(params))) final_rc = rc; 3812 if ((rc = setVideoSize(params))) final_rc = rc; 3813 if ((rc = setPictureSize(params))) final_rc = rc; 3814 if ((rc = setPreviewFormat(params))) final_rc = rc; 3815 if ((rc = setPictureFormat(params))) final_rc = rc; 3816 if ((rc = setJpegQuality(params))) final_rc = rc; 3817 if ((rc = setOrientation(params))) final_rc = rc; 3818 if ((rc = setRotation(params))) final_rc = rc; 3819 if ((rc = setVideoRotation(params))) final_rc = rc; 3820 if ((rc = setNoDisplayMode(params))) final_rc = rc; 3821 if ((rc = setZslMode(params))) final_rc = rc; 3822 if ((rc = setZslAttributes(params))) final_rc = rc; 3823 if ((rc = setCameraMode(params))) final_rc = rc; 3824 if ((rc = setSceneSelectionMode(params))) final_rc = rc; 3825 if ((rc = setRecordingHint(params))) final_rc = rc; 3826 if ((rc = setRdiMode(params))) final_rc = rc; 3827 if ((rc = setSecureMode(params))) final_rc = rc; 3828 if ((rc = setPreviewFrameRate(params))) final_rc = rc; 3829 if ((rc = setPreviewFpsRange(params))) final_rc = rc; 3830 if ((rc = setAutoExposure(params))) final_rc = rc; 3831 if ((rc = setEffect(params))) final_rc = rc; 3832 if ((rc = setBrightness(params))) final_rc = rc; 3833 if ((rc = setZoom(params))) final_rc = rc; 3834 if ((rc = setSharpness(params))) final_rc = rc; 3835 if ((rc = setSaturation(params))) final_rc = rc; 3836 if ((rc = setContrast(params))) final_rc = rc; 3837 if ((rc = setFocusMode(params))) final_rc = rc; 3838 if ((rc = setISOValue(params))) final_rc = rc; 3839 if ((rc = setSkinToneEnhancement(params))) final_rc = rc; 3840 if ((rc = setFlash(params))) final_rc = rc; 3841 if ((rc = setAecLock(params))) final_rc = rc; 3842 if ((rc = setAwbLock(params))) final_rc = rc; 3843 if ((rc = setLensShadeValue(params))) final_rc = rc; 3844 if ((rc = setMCEValue(params))) final_rc = rc; 3845 if ((rc = setDISValue(params))) final_rc = rc; 3846 if ((rc = setHighFrameRate(params))) final_rc = rc; 3847 if ((rc = setHighSpeedRecording(params))) final_rc = rc; 3848 if ((rc = setAntibanding(params))) final_rc = rc; 3849 if ((rc = setExposureCompensation(params))) final_rc = rc; 3850 if ((rc = setWhiteBalance(params))) final_rc = rc; 3851 if ((rc = setSceneMode(params))) final_rc = rc; 3852 if ((rc = setFocusAreas(params))) final_rc = rc; 3853 if ((rc = setMeteringAreas(params))) final_rc = rc; 3854 if ((rc = setSelectableZoneAf(params))) final_rc = rc; 3855 if ((rc = setRedeyeReduction(params))) final_rc = rc; 3856 if ((rc = setAEBracket(params))) final_rc = rc; 3857 if ((rc = setAutoHDR(params))) final_rc = rc; 3858 if ((rc = setGpsLocation(params))) final_rc = rc; 3859 if ((rc = setWaveletDenoise(params))) final_rc = rc; 3860 if ((rc = setFaceRecognition(params))) final_rc = rc; 3861 if ((rc = setFlip(params))) final_rc = rc; 3862 if ((rc = setVideoHDR(params))) final_rc = rc; 3863 if ((rc = setVtEnable(params))) final_rc = rc; 3864 if ((rc = setAFBracket(params))) final_rc = rc; 3865 if ((rc = setChromaFlash(params))) final_rc = rc; 3866 if ((rc = setOptiZoom(params))) final_rc = rc; 3867 if ((rc = setBurstNum(params))) final_rc = rc; 3868 if ((rc = setBurstLEDOnPeriod(params))) final_rc = rc; 3869 if ((rc = setRetroActiveBurstNum(params))) final_rc = rc; 3870 if ((rc = setSnapshotFDReq(params))) final_rc = rc; 3871 if ((rc = setTintlessValue(params))) final_rc = rc; 3872 if ((rc = setCDSMode(params))) final_rc = rc; 3873 3874 // update live snapshot size after all other parameters are set 3875 if ((rc = setLiveSnapshotSize(params))) final_rc = rc; 3876 if ((rc = setJpegThumbnailSize(params))) final_rc = rc; 3877 if ((rc = setStatsDebugMask())) final_rc = rc; 3878 if ((rc = setPAAF())) final_rc = rc; 3879 if ((rc = setMobicat(params))) final_rc = rc; 3880 3881 if ((rc = updateFlash(false))) final_rc = rc; 3882 3883 UPDATE_PARAM_DONE: 3884 needRestart = m_bNeedRestart; 3885 return final_rc; 3886 } 3887 3888 /*=========================================================================== 3889 * FUNCTION : commitParameters 3890 * 3891 * DESCRIPTION: commit parameter changes to backend 3892 * 3893 * PARAMETERS : none 3894 * 3895 * RETURN : int32_t type of status 3896 * NO_ERROR -- success 3897 * none-zero failure code 3898 *==========================================================================*/ 3899 int32_t QCameraParameters::commitParameters() 3900 { 3901 return commitSetBatch(); 3902 } 3903 3904 /*=========================================================================== 3905 * FUNCTION : initDefaultParameters 3906 * 3907 * DESCRIPTION: initialize default parameters for the first time 3908 * 3909 * PARAMETERS : none 3910 * 3911 * RETURN : int32_t type of status 3912 * NO_ERROR -- success 3913 * none-zero failure code 3914 *==========================================================================*/ 3915 int32_t QCameraParameters::initDefaultParameters() 3916 { 3917 if(initBatchUpdate(m_pParamBuf) < 0 ) { 3918 ALOGE("%s:Failed to initialize group update table", __func__); 3919 return BAD_TYPE; 3920 } 3921 int32_t hal_version = CAM_HAL_V1; 3922 AddSetParmEntryToBatch(m_pParamBuf, 3923 CAM_INTF_PARM_HAL_VERSION, 3924 sizeof(hal_version), 3925 &hal_version); 3926 3927 /*************************Initialize Values******************************/ 3928 // Set read only parameters from camera capability 3929 set(KEY_SMOOTH_ZOOM_SUPPORTED, 3930 m_pCapability->smooth_zoom_supported? VALUE_TRUE : VALUE_FALSE); 3931 set(KEY_ZOOM_SUPPORTED, 3932 m_pCapability->zoom_supported? VALUE_TRUE : VALUE_FALSE); 3933 set(KEY_VIDEO_SNAPSHOT_SUPPORTED, 3934 m_pCapability->video_snapshot_supported? VALUE_TRUE : VALUE_FALSE); 3935 set(KEY_VIDEO_STABILIZATION_SUPPORTED, 3936 m_pCapability->video_stablization_supported? VALUE_TRUE : VALUE_FALSE); 3937 set(KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 3938 m_pCapability->auto_exposure_lock_supported? VALUE_TRUE : VALUE_FALSE); 3939 set(KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 3940 m_pCapability->auto_wb_lock_supported? VALUE_TRUE : VALUE_FALSE); 3941 set(KEY_QC_SUPPORTED_CAMERA_FEATURES, 3942 m_pCapability->qcom_supported_feature_mask); 3943 set(KEY_MAX_NUM_DETECTED_FACES_HW, m_pCapability->max_num_roi); 3944 set(KEY_MAX_NUM_DETECTED_FACES_SW, m_pCapability->max_num_roi); 3945 set(KEY_QC_MAX_NUM_REQUESTED_FACES, m_pCapability->max_num_roi); 3946 // Set focal length, horizontal view angle, and vertical view angle 3947 setFloat(KEY_FOCAL_LENGTH, m_pCapability->focal_length); 3948 setFloat(KEY_HORIZONTAL_VIEW_ANGLE, m_pCapability->hor_view_angle); 3949 setFloat(KEY_VERTICAL_VIEW_ANGLE, m_pCapability->ver_view_angle); 3950 set(QCameraParameters::KEY_FOCUS_DISTANCES, "Infinity,Infinity,Infinity"); 3951 set(KEY_QC_AUTO_HDR_SUPPORTED, 3952 (m_pCapability->auto_hdr_supported)? VALUE_TRUE : VALUE_FALSE); 3953 // Set supported preview sizes 3954 if (m_pCapability->preview_sizes_tbl_cnt > 0 && 3955 m_pCapability->preview_sizes_tbl_cnt <= MAX_SIZES_CNT) { 3956 String8 previewSizeValues = createSizesString( 3957 m_pCapability->preview_sizes_tbl, m_pCapability->preview_sizes_tbl_cnt); 3958 set(KEY_SUPPORTED_PREVIEW_SIZES, previewSizeValues.string()); 3959 CDBG_HIGH("%s: supported preview sizes: %s", __func__, previewSizeValues.string()); 3960 // Set default preview size 3961 CameraParameters::setPreviewSize(m_pCapability->preview_sizes_tbl[0].width, 3962 m_pCapability->preview_sizes_tbl[0].height); 3963 } else { 3964 ALOGE("%s: supported preview sizes cnt is 0 or exceeds max!!!", __func__); 3965 } 3966 3967 // Set supported video sizes 3968 if (m_pCapability->video_sizes_tbl_cnt > 0 && 3969 m_pCapability->video_sizes_tbl_cnt <= MAX_SIZES_CNT) { 3970 String8 videoSizeValues = createSizesString( 3971 m_pCapability->video_sizes_tbl, m_pCapability->video_sizes_tbl_cnt); 3972 set(KEY_SUPPORTED_VIDEO_SIZES, videoSizeValues.string()); 3973 CDBG_HIGH("%s: supported video sizes: %s", __func__, videoSizeValues.string()); 3974 // Set default video size 3975 CameraParameters::setVideoSize(m_pCapability->video_sizes_tbl[0].width, 3976 m_pCapability->video_sizes_tbl[0].height); 3977 3978 //Set preferred Preview size for video 3979 String8 vSize = createSizesString(&m_pCapability->preview_sizes_tbl[0], 1); 3980 set(KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, vSize.string()); 3981 } else { 3982 ALOGE("%s: supported video sizes cnt is 0 or exceeds max!!!", __func__); 3983 } 3984 3985 // Set supported picture sizes 3986 if (m_pCapability->picture_sizes_tbl_cnt > 0 && 3987 m_pCapability->picture_sizes_tbl_cnt <= MAX_SIZES_CNT) { 3988 String8 pictureSizeValues = createSizesString( 3989 m_pCapability->picture_sizes_tbl, m_pCapability->picture_sizes_tbl_cnt); 3990 set(KEY_SUPPORTED_PICTURE_SIZES, pictureSizeValues.string()); 3991 CDBG_HIGH("%s: supported pic sizes: %s", __func__, pictureSizeValues.string()); 3992 // Set default picture size to the smallest resolution 3993 CameraParameters::setPictureSize( 3994 m_pCapability->picture_sizes_tbl[m_pCapability->picture_sizes_tbl_cnt-1].width, 3995 m_pCapability->picture_sizes_tbl[m_pCapability->picture_sizes_tbl_cnt-1].height); 3996 } else { 3997 ALOGE("%s: supported picture sizes cnt is 0 or exceeds max!!!", __func__); 3998 } 3999 4000 // Need check if scale should be enabled 4001 if (m_pCapability->scale_picture_sizes_cnt > 0 && 4002 m_pCapability->scale_picture_sizes_cnt <= MAX_SCALE_SIZES_CNT){ 4003 //get scale size, enable scaling. And re-set picture size table with scale sizes 4004 m_reprocScaleParam.setScaleEnable(true); 4005 int rc_s = m_reprocScaleParam.setScaleSizeTbl( 4006 m_pCapability->scale_picture_sizes_cnt, m_pCapability->scale_picture_sizes, 4007 m_pCapability->picture_sizes_tbl_cnt, m_pCapability->picture_sizes_tbl); 4008 if(rc_s == NO_ERROR){ 4009 cam_dimension_t *totalSizeTbl = m_reprocScaleParam.getTotalSizeTbl(); 4010 uint8_t totalSizeCnt = m_reprocScaleParam.getTotalSizeTblCnt(); 4011 String8 pictureSizeValues = createSizesString(totalSizeTbl, totalSizeCnt); 4012 set(KEY_SUPPORTED_PICTURE_SIZES, pictureSizeValues.string()); 4013 CDBG_HIGH("%s: scaled supported pic sizes: %s", __func__, pictureSizeValues.string()); 4014 }else{ 4015 m_reprocScaleParam.setScaleEnable(false); 4016 ALOGE("%s: reset scaled picture size table failed.", __func__); 4017 } 4018 }else{ 4019 m_reprocScaleParam.setScaleEnable(false); 4020 } 4021 4022 // Set supported thumbnail sizes 4023 String8 thumbnailSizeValues = createSizesString( 4024 THUMBNAIL_SIZES_MAP, 4025 sizeof(THUMBNAIL_SIZES_MAP)/sizeof(cam_dimension_t)); 4026 set(KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, thumbnailSizeValues.string()); 4027 // Set default thumnail size 4028 set(KEY_JPEG_THUMBNAIL_WIDTH, THUMBNAIL_SIZES_MAP[0].width); 4029 set(KEY_JPEG_THUMBNAIL_HEIGHT, THUMBNAIL_SIZES_MAP[0].height); 4030 4031 // Set supported livesnapshot sizes 4032 if (m_pCapability->livesnapshot_sizes_tbl_cnt > 0 && 4033 m_pCapability->livesnapshot_sizes_tbl_cnt <= MAX_SIZES_CNT) { 4034 String8 liveSnpashotSizeValues = createSizesString( 4035 m_pCapability->livesnapshot_sizes_tbl, 4036 m_pCapability->livesnapshot_sizes_tbl_cnt); 4037 set(KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES, liveSnpashotSizeValues.string()); 4038 CDBG("%s: supported live snapshot sizes: %s", __func__, liveSnpashotSizeValues.string()); 4039 m_LiveSnapshotSize = 4040 m_pCapability->livesnapshot_sizes_tbl[m_pCapability->livesnapshot_sizes_tbl_cnt-1]; 4041 } 4042 4043 // Set supported preview formats 4044 String8 previewFormatValues = createValuesString( 4045 (int *)m_pCapability->supported_preview_fmts, 4046 m_pCapability->supported_preview_fmt_cnt, 4047 PREVIEW_FORMATS_MAP, 4048 sizeof(PREVIEW_FORMATS_MAP)/sizeof(QCameraMap)); 4049 set(KEY_SUPPORTED_PREVIEW_FORMATS, previewFormatValues.string()); 4050 // Set default preview format 4051 CameraParameters::setPreviewFormat(PIXEL_FORMAT_YUV420SP); 4052 4053 // Set default Video Format 4054 set(KEY_VIDEO_FRAME_FORMAT, PIXEL_FORMAT_YUV420SP); 4055 4056 // Set supported picture formats 4057 String8 pictureTypeValues(PIXEL_FORMAT_JPEG); 4058 String8 str = createValuesString( 4059 (int *)m_pCapability->supported_raw_fmts, 4060 m_pCapability->supported_raw_fmt_cnt, 4061 PICTURE_TYPES_MAP, 4062 sizeof(PICTURE_TYPES_MAP)/sizeof(QCameraMap)); 4063 if (str.string() != NULL) { 4064 pictureTypeValues.append(","); 4065 pictureTypeValues.append(str); 4066 } 4067 4068 set(KEY_SUPPORTED_PICTURE_FORMATS, pictureTypeValues.string()); 4069 // Set default picture Format 4070 CameraParameters::setPictureFormat(PIXEL_FORMAT_JPEG); 4071 // Set raw image size 4072 char raw_size_str[32]; 4073 snprintf(raw_size_str, sizeof(raw_size_str), "%dx%d", 4074 m_pCapability->raw_dim[0].width, m_pCapability->raw_dim[0].height); 4075 set(KEY_QC_RAW_PICUTRE_SIZE, raw_size_str); 4076 CDBG("%s: KEY_QC_RAW_PICUTRE_SIZE: w: %d, h: %d ", __func__, 4077 m_pCapability->raw_dim[0].width, m_pCapability->raw_dim[0].height); 4078 4079 //set default jpeg quality and thumbnail quality 4080 set(KEY_JPEG_QUALITY, 85); 4081 set(KEY_JPEG_THUMBNAIL_QUALITY, 85); 4082 4083 // Set FPS ranges 4084 if (m_pCapability->fps_ranges_tbl_cnt > 0 && 4085 m_pCapability->fps_ranges_tbl_cnt <= MAX_SIZES_CNT) { 4086 int default_fps_index = 0; 4087 String8 fpsRangeValues = createFpsRangeString(m_pCapability->fps_ranges_tbl, 4088 m_pCapability->fps_ranges_tbl_cnt, 4089 default_fps_index); 4090 set(KEY_SUPPORTED_PREVIEW_FPS_RANGE, fpsRangeValues.string()); 4091 4092 int min_fps = 4093 int(m_pCapability->fps_ranges_tbl[default_fps_index].min_fps * 1000); 4094 int max_fps = 4095 int(m_pCapability->fps_ranges_tbl[default_fps_index].max_fps * 1000); 4096 m_default_fps_range = m_pCapability->fps_ranges_tbl[default_fps_index]; 4097 //Set video fps same as preview fps 4098 setPreviewFpsRange(min_fps, max_fps, min_fps, max_fps); 4099 4100 // Set legacy preview fps 4101 String8 fpsValues = createFpsString(m_pCapability->fps_ranges_tbl[default_fps_index]); 4102 set(KEY_SUPPORTED_PREVIEW_FRAME_RATES, fpsValues.string()); 4103 CDBG_HIGH("%s: supported fps rates: %s", __func__, fpsValues.string()); 4104 CameraParameters::setPreviewFrameRate(int(m_pCapability->fps_ranges_tbl[default_fps_index].max_fps)); 4105 } else { 4106 ALOGE("%s: supported fps ranges cnt is 0 or exceeds max!!!", __func__); 4107 } 4108 4109 // Set supported focus modes 4110 if (m_pCapability->supported_focus_modes_cnt > 0) { 4111 String8 focusModeValues = createValuesString( 4112 (int *)m_pCapability->supported_focus_modes, 4113 m_pCapability->supported_focus_modes_cnt, 4114 FOCUS_MODES_MAP, 4115 sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap)); 4116 set(KEY_SUPPORTED_FOCUS_MODES, focusModeValues); 4117 4118 // Set default focus mode and update corresponding parameter buf 4119 const char *focusMode = lookupNameByValue(FOCUS_MODES_MAP, 4120 sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap), 4121 m_pCapability->supported_focus_modes[0]); 4122 if (focusMode != NULL) { 4123 setFocusMode(focusMode); 4124 } else { 4125 setFocusMode(FOCUS_MODE_FIXED); 4126 } 4127 } else { 4128 ALOGE("%s: supported focus modes cnt is 0!!!", __func__); 4129 } 4130 4131 // Set focus areas 4132 if (m_pCapability->max_num_focus_areas > MAX_ROI) { 4133 m_pCapability->max_num_focus_areas = MAX_ROI; 4134 } 4135 set(KEY_MAX_NUM_FOCUS_AREAS, m_pCapability->max_num_focus_areas); 4136 if (m_pCapability->max_num_focus_areas > 0) { 4137 setFocusAreas(DEFAULT_CAMERA_AREA); 4138 } 4139 4140 // Set metering areas 4141 if (m_pCapability->max_num_metering_areas > MAX_ROI) { 4142 m_pCapability->max_num_metering_areas = MAX_ROI; 4143 } 4144 set(KEY_MAX_NUM_METERING_AREAS, m_pCapability->max_num_metering_areas); 4145 if (m_pCapability->max_num_metering_areas > 0) { 4146 setMeteringAreas(DEFAULT_CAMERA_AREA); 4147 } 4148 4149 // Set Saturation 4150 set(KEY_QC_MIN_SATURATION, m_pCapability->saturation_ctrl.min_value); 4151 set(KEY_QC_MAX_SATURATION, m_pCapability->saturation_ctrl.max_value); 4152 set(KEY_QC_SATURATION_STEP, m_pCapability->saturation_ctrl.step); 4153 setSaturation(m_pCapability->saturation_ctrl.def_value); 4154 4155 // Set Sharpness 4156 set(KEY_QC_MIN_SHARPNESS, m_pCapability->sharpness_ctrl.min_value); 4157 set(KEY_QC_MAX_SHARPNESS, m_pCapability->sharpness_ctrl.max_value); 4158 set(KEY_QC_SHARPNESS_STEP, m_pCapability->sharpness_ctrl.step); 4159 setSharpness(m_pCapability->sharpness_ctrl.def_value); 4160 4161 // Set Contrast 4162 set(KEY_QC_MIN_CONTRAST, m_pCapability->contrast_ctrl.min_value); 4163 set(KEY_QC_MAX_CONTRAST, m_pCapability->contrast_ctrl.max_value); 4164 set(KEY_QC_CONTRAST_STEP, m_pCapability->contrast_ctrl.step); 4165 setContrast(m_pCapability->contrast_ctrl.def_value); 4166 4167 // Set SCE factor 4168 set(KEY_QC_MIN_SCE_FACTOR, m_pCapability->sce_ctrl.min_value); // -100 4169 set(KEY_QC_MAX_SCE_FACTOR, m_pCapability->sce_ctrl.max_value); // 100 4170 set(KEY_QC_SCE_FACTOR_STEP, m_pCapability->sce_ctrl.step); // 10 4171 setSkinToneEnhancement(m_pCapability->sce_ctrl.def_value); // 0 4172 4173 // Set Brightness 4174 set(KEY_QC_MIN_BRIGHTNESS, m_pCapability->brightness_ctrl.min_value); // 0 4175 set(KEY_QC_MAX_BRIGHTNESS, m_pCapability->brightness_ctrl.max_value); // 6 4176 set(KEY_QC_BRIGHTNESS_STEP, m_pCapability->brightness_ctrl.step); // 1 4177 setBrightness(m_pCapability->brightness_ctrl.def_value); 4178 4179 // Set Auto exposure 4180 String8 autoExposureValues = createValuesString( 4181 (int *)m_pCapability->supported_aec_modes, 4182 m_pCapability->supported_aec_modes_cnt, 4183 AUTO_EXPOSURE_MAP, 4184 sizeof(AUTO_EXPOSURE_MAP) / sizeof(QCameraMap)); 4185 set(KEY_QC_SUPPORTED_AUTO_EXPOSURE, autoExposureValues.string()); 4186 setAutoExposure(AUTO_EXPOSURE_FRAME_AVG); 4187 4188 // Set Exposure Compensation 4189 set(KEY_MAX_EXPOSURE_COMPENSATION, m_pCapability->exposure_compensation_max); // 12 4190 set(KEY_MIN_EXPOSURE_COMPENSATION, m_pCapability->exposure_compensation_min); // -12 4191 setFloat(KEY_EXPOSURE_COMPENSATION_STEP, m_pCapability->exposure_compensation_step); // 1/6 4192 setExposureCompensation(m_pCapability->exposure_compensation_default); // 0 4193 4194 // Set Antibanding 4195 String8 antibandingValues = createValuesString( 4196 (int *)m_pCapability->supported_antibandings, 4197 m_pCapability->supported_antibandings_cnt, 4198 ANTIBANDING_MODES_MAP, 4199 sizeof(ANTIBANDING_MODES_MAP) / sizeof(QCameraMap)); 4200 set(KEY_SUPPORTED_ANTIBANDING, antibandingValues); 4201 setAntibanding(ANTIBANDING_OFF); 4202 4203 // Set Effect 4204 String8 effectValues = createValuesString( 4205 (int *)m_pCapability->supported_effects, 4206 m_pCapability->supported_effects_cnt, 4207 EFFECT_MODES_MAP, 4208 sizeof(EFFECT_MODES_MAP) / sizeof(QCameraMap)); 4209 set(KEY_SUPPORTED_EFFECTS, effectValues); 4210 setEffect(EFFECT_NONE); 4211 4212 // Set WhiteBalance 4213 String8 whitebalanceValues = createValuesString( 4214 (int *)m_pCapability->supported_white_balances, 4215 m_pCapability->supported_white_balances_cnt, 4216 WHITE_BALANCE_MODES_MAP, 4217 sizeof(WHITE_BALANCE_MODES_MAP) / sizeof(QCameraMap)); 4218 set(KEY_SUPPORTED_WHITE_BALANCE, whitebalanceValues); 4219 setWhiteBalance(WHITE_BALANCE_AUTO); 4220 4221 // Set Flash mode 4222 if(m_pCapability->supported_flash_modes_cnt > 0) { 4223 String8 flashValues = createValuesString( 4224 (int *)m_pCapability->supported_flash_modes, 4225 m_pCapability->supported_flash_modes_cnt, 4226 FLASH_MODES_MAP, 4227 sizeof(FLASH_MODES_MAP) / sizeof(QCameraMap)); 4228 set(KEY_SUPPORTED_FLASH_MODES, flashValues); 4229 setFlash(FLASH_MODE_OFF); 4230 } else { 4231 ALOGE("%s: supported flash modes cnt is 0!!!", __func__); 4232 } 4233 4234 // Set Scene Mode 4235 String8 sceneModeValues = createValuesString( 4236 (int *)m_pCapability->supported_scene_modes, 4237 m_pCapability->supported_scene_modes_cnt, 4238 SCENE_MODES_MAP, 4239 sizeof(SCENE_MODES_MAP) / sizeof(QCameraMap)); 4240 set(KEY_SUPPORTED_SCENE_MODES, sceneModeValues); 4241 setSceneMode(SCENE_MODE_AUTO); 4242 4243 // Set ISO Mode 4244 String8 isoValues = createValuesString( 4245 (int *)m_pCapability->supported_iso_modes, 4246 m_pCapability->supported_iso_modes_cnt, 4247 ISO_MODES_MAP, 4248 sizeof(ISO_MODES_MAP) / sizeof(QCameraMap)); 4249 set(KEY_QC_SUPPORTED_ISO_MODES, isoValues); 4250 setISOValue(ISO_AUTO); 4251 4252 // Set HFR 4253 String8 hfrValues = createHfrValuesString( 4254 m_pCapability->hfr_tbl, 4255 m_pCapability->hfr_tbl_cnt, 4256 HFR_MODES_MAP, 4257 sizeof(HFR_MODES_MAP) / sizeof(QCameraMap)); 4258 set(KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES, hfrValues.string()); 4259 set(KEY_QC_VIDEO_HIGH_SPEED_RECORDING, "off"); 4260 String8 hfrSizeValues = createHfrSizesString( 4261 m_pCapability->hfr_tbl, 4262 m_pCapability->hfr_tbl_cnt); 4263 set(KEY_QC_SUPPORTED_HFR_SIZES, hfrSizeValues.string()); 4264 setHighFrameRate(VIDEO_HFR_OFF); 4265 4266 // Set Focus algorithms 4267 String8 focusAlgoValues = createValuesString( 4268 (int *)m_pCapability->supported_focus_algos, 4269 m_pCapability->supported_focus_algos_cnt, 4270 FOCUS_ALGO_MAP, 4271 sizeof(FOCUS_ALGO_MAP) / sizeof(QCameraMap)); 4272 set(KEY_QC_SUPPORTED_FOCUS_ALGOS, focusAlgoValues); 4273 setSelectableZoneAf(FOCUS_ALGO_AUTO); 4274 4275 // Set Zoom Ratios 4276 if (m_pCapability->zoom_supported > 0) { 4277 String8 zoomRatioValues = createZoomRatioValuesString( 4278 m_pCapability->zoom_ratio_tbl, 4279 m_pCapability->zoom_ratio_tbl_cnt); 4280 set(KEY_ZOOM_RATIOS, zoomRatioValues); 4281 set(KEY_MAX_ZOOM, m_pCapability->zoom_ratio_tbl_cnt - 1); 4282 setZoom(0); 4283 } 4284 4285 // Set Bracketing/HDR 4286 char prop[PROPERTY_VALUE_MAX]; 4287 memset(prop, 0, sizeof(prop)); 4288 property_get("persist.capture.burst.exposures", prop, ""); 4289 if (strlen(prop) > 0) { 4290 set(KEY_QC_CAPTURE_BURST_EXPOSURE, prop); 4291 } 4292 String8 bracketingValues = createValuesStringFromMap( 4293 BRACKETING_MODES_MAP, 4294 sizeof(BRACKETING_MODES_MAP) / sizeof(QCameraMap)); 4295 set(KEY_QC_SUPPORTED_AE_BRACKET_MODES, bracketingValues); 4296 setAEBracket(AE_BRACKET_OFF); 4297 4298 //Set AF Bracketing. 4299 for(int i = 0; i < m_pCapability->supported_focus_modes_cnt; i++) { 4300 if ((CAM_FOCUS_MODE_AUTO == m_pCapability->supported_focus_modes[i]) && 4301 ((m_pCapability->qcom_supported_feature_mask & 4302 CAM_QCOM_FEATURE_UBIFOCUS) > 0)) { 4303 String8 afBracketingValues = createValuesStringFromMap( 4304 AF_BRACKETING_MODES_MAP, 4305 sizeof(AF_BRACKETING_MODES_MAP) / sizeof(QCameraMap)); 4306 set(KEY_QC_SUPPORTED_AF_BRACKET_MODES, afBracketingValues); 4307 setAFBracket(AF_BRACKET_OFF); 4308 break; 4309 } 4310 } 4311 4312 //Set Refocus. 4313 //Re-use ubifocus flag for now. 4314 if ((m_pCapability->qcom_supported_feature_mask & 4315 CAM_QCOM_FEATURE_UBIFOCUS) > 0){ 4316 String8 reFocusValues = createValuesStringFromMap( 4317 RE_FOCUS_MODES_MAP, 4318 sizeof(RE_FOCUS_MODES_MAP) / sizeof(QCameraMap)); 4319 set(KEY_QC_SUPPORTED_RE_FOCUS_MODES, reFocusValues); 4320 } 4321 4322 //Set Chroma Flash. 4323 if ((m_pCapability->supported_flash_modes_cnt > 0) && 4324 (m_pCapability->qcom_supported_feature_mask & 4325 CAM_QCOM_FEATURE_CHROMA_FLASH) > 0) { 4326 String8 chromaFlashValues = createValuesStringFromMap( 4327 CHROMA_FLASH_MODES_MAP, 4328 sizeof(CHROMA_FLASH_MODES_MAP) / sizeof(QCameraMap)); 4329 set(KEY_QC_SUPPORTED_CHROMA_FLASH_MODES, chromaFlashValues); 4330 setChromaFlash(CHROMA_FLASH_OFF); 4331 } 4332 4333 //Set Opti Zoom. 4334 if (m_pCapability->zoom_supported && 4335 (m_pCapability->qcom_supported_feature_mask & 4336 CAM_QCOM_FEATURE_OPTIZOOM) > 0){ 4337 String8 optiZoomValues = createValuesStringFromMap( 4338 OPTI_ZOOM_MODES_MAP, 4339 sizeof(OPTI_ZOOM_MODES_MAP) / sizeof(QCameraMap)); 4340 set(KEY_QC_SUPPORTED_OPTI_ZOOM_MODES, optiZoomValues); 4341 setOptiZoom(OPTI_ZOOM_OFF); 4342 } 4343 4344 // Set Denoise 4345 if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_DENOISE2D) > 0){ 4346 String8 denoiseValues = createValuesStringFromMap( 4347 DENOISE_ON_OFF_MODES_MAP, sizeof(DENOISE_ON_OFF_MODES_MAP) / sizeof(QCameraMap)); 4348 set(KEY_QC_SUPPORTED_DENOISE, denoiseValues.string()); 4349 #ifdef DEFAULT_DENOISE_MODE_ON 4350 setWaveletDenoise(DENOISE_ON); 4351 #else 4352 setWaveletDenoise(DENOISE_OFF); 4353 #endif 4354 } 4355 4356 // Set feature enable/disable 4357 String8 enableDisableValues = createValuesStringFromMap( 4358 ENABLE_DISABLE_MODES_MAP, sizeof(ENABLE_DISABLE_MODES_MAP) / sizeof(QCameraMap)); 4359 4360 // Set Lens Shading 4361 set(KEY_QC_SUPPORTED_LENSSHADE_MODES, enableDisableValues); 4362 setLensShadeValue(VALUE_ENABLE); 4363 4364 // Set MCE 4365 set(KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES, enableDisableValues); 4366 setMCEValue(VALUE_ENABLE); 4367 4368 // Set DIS 4369 set(KEY_QC_SUPPORTED_DIS_MODES, enableDisableValues); 4370 setDISValue(VALUE_DISABLE); 4371 4372 // Set Histogram 4373 set(KEY_QC_SUPPORTED_HISTOGRAM_MODES, 4374 m_pCapability->histogram_supported ? enableDisableValues : ""); 4375 set(KEY_QC_HISTOGRAM, VALUE_DISABLE); 4376 4377 //Set Red Eye Reduction 4378 set(KEY_QC_SUPPORTED_REDEYE_REDUCTION, enableDisableValues); 4379 setRedeyeReduction(VALUE_DISABLE); 4380 4381 //Set SkinTone Enhancement 4382 set(KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES, enableDisableValues); 4383 4384 // Set feature on/off 4385 String8 onOffValues = createValuesStringFromMap( 4386 ON_OFF_MODES_MAP, sizeof(ON_OFF_MODES_MAP) / sizeof(QCameraMap)); 4387 4388 //Set Scene Detection 4389 set(KEY_QC_SUPPORTED_SCENE_DETECT, onOffValues); 4390 setSceneDetect(VALUE_OFF); 4391 m_bHDREnabled = false; 4392 m_bHDR1xFrameEnabled = true; 4393 4394 m_bHDRThumbnailProcessNeeded = false; 4395 m_bHDR1xExtraBufferNeeded = true; 4396 for (uint32_t i=0; i<m_pCapability->hdr_bracketing_setting.num_frames; i++) { 4397 if (0 == m_pCapability->hdr_bracketing_setting.exp_val.values[i]) { 4398 m_bHDR1xExtraBufferNeeded = false; 4399 break; 4400 } 4401 } 4402 4403 // Set HDR output scaling 4404 char value[PROPERTY_VALUE_MAX]; 4405 4406 property_get("persist.camera.hdr.outcrop", value, VALUE_DISABLE); 4407 if (strncmp(VALUE_ENABLE, value, sizeof(VALUE_ENABLE))) { 4408 m_bHDROutputCropEnabled = false; 4409 } else { 4410 m_bHDROutputCropEnabled = true; 4411 } 4412 4413 //Set Face Detection 4414 set(KEY_QC_SUPPORTED_FACE_DETECTION, onOffValues); 4415 set(KEY_QC_FACE_DETECTION, VALUE_OFF); 4416 4417 //Set Face Recognition 4418 //set(KEY_QC_SUPPORTED_FACE_RECOGNITION, onOffValues); 4419 //set(KEY_QC_FACE_RECOGNITION, VALUE_OFF); 4420 4421 //Set ZSL 4422 set(KEY_QC_SUPPORTED_ZSL_MODES, onOffValues); 4423 #ifdef DEFAULT_ZSL_MODE_ON 4424 set(KEY_QC_ZSL, VALUE_ON); 4425 m_bZslMode = true; 4426 #else 4427 set(KEY_QC_ZSL, VALUE_OFF); 4428 m_bZslMode = false; 4429 #endif 4430 m_bZslMode_new = m_bZslMode; 4431 4432 set(KEY_QC_SCENE_SELECTION, VALUE_DISABLE); 4433 4434 // Rdi mode 4435 set(KEY_QC_SUPPORTED_RDI_MODES, enableDisableValues); 4436 setRdiMode(VALUE_DISABLE); 4437 4438 // Secure mode 4439 set(KEY_QC_SUPPORTED_SECURE_MODES, enableDisableValues); 4440 setSecureMode(VALUE_DISABLE); 4441 4442 //Set video HDR 4443 if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_VIDEO_HDR) > 0) { 4444 set(KEY_QC_SUPPORTED_VIDEO_HDR_MODES, onOffValues); 4445 set(KEY_QC_VIDEO_HDR, VALUE_OFF); 4446 } 4447 4448 //Set HW Sensor Snapshot HDR 4449 if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_SENSOR_HDR)> 0) { 4450 set(KEY_QC_SUPPORTED_SENSOR_HDR_MODES, onOffValues); 4451 set(KEY_QC_SENSOR_HDR, VALUE_OFF); 4452 m_bSensorHDREnabled = false; 4453 } 4454 4455 // Set VT TimeStamp 4456 set(KEY_QC_VT_ENABLE, VALUE_DISABLE); 4457 //Set Touch AF/AEC 4458 String8 touchValues = createValuesStringFromMap( 4459 TOUCH_AF_AEC_MODES_MAP, sizeof(TOUCH_AF_AEC_MODES_MAP) / sizeof(QCameraMap)); 4460 4461 set(KEY_QC_SUPPORTED_TOUCH_AF_AEC, touchValues); 4462 set(KEY_QC_TOUCH_AF_AEC, TOUCH_AF_AEC_OFF); 4463 4464 //set flip mode 4465 if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_FLIP) > 0) { 4466 String8 flipModes = createValuesStringFromMap( 4467 FLIP_MODES_MAP, sizeof(FLIP_MODES_MAP) / sizeof(QCameraMap)); 4468 set(KEY_QC_SUPPORTED_FLIP_MODES, flipModes); 4469 set(KEY_QC_PREVIEW_FLIP, FLIP_MODE_OFF); 4470 set(KEY_QC_VIDEO_FLIP, FLIP_MODE_OFF); 4471 set(KEY_QC_SNAPSHOT_PICTURE_FLIP, FLIP_MODE_OFF); 4472 } 4473 4474 // Set default Auto Exposure lock value 4475 setAecLock(VALUE_FALSE); 4476 4477 // Set default AWB_LOCK lock value 4478 setAwbLock(VALUE_FALSE); 4479 4480 // Set default Camera mode 4481 set(KEY_QC_CAMERA_MODE, 0); 4482 4483 // Add support for internal preview restart 4484 set(KEY_INTERNAL_PERVIEW_RESTART, VALUE_TRUE); 4485 // Set default burst number 4486 set(KEY_QC_SNAPSHOT_BURST_NUM, 0); 4487 set(KEY_QC_NUM_RETRO_BURST_PER_SHUTTER, 0); 4488 4489 int32_t rc = commitParameters(); 4490 if (rc == NO_ERROR) { 4491 rc = setNumOfSnapshot(); 4492 } 4493 return rc; 4494 } 4495 4496 /*=========================================================================== 4497 * FUNCTION : init 4498 * 4499 * DESCRIPTION: initialize parameter obj 4500 * 4501 * PARAMETERS : 4502 * @capabilities : ptr to camera capabilities 4503 * @mmops : ptr to memory ops table for mapping/unmapping 4504 * 4505 * RETURN : int32_t type of status 4506 * NO_ERROR -- success 4507 * none-zero failure code 4508 *==========================================================================*/ 4509 int32_t QCameraParameters::init(cam_capability_t *capabilities, 4510 mm_camera_vtbl_t *mmOps, 4511 QCameraAdjustFPS *adjustFPS, 4512 QCameraTorchInterface *torch) 4513 { 4514 int32_t rc = NO_ERROR; 4515 4516 m_pCapability = capabilities; 4517 m_pCamOpsTbl = mmOps; 4518 m_AdjustFPS = adjustFPS; 4519 m_pTorch = torch; 4520 4521 //Allocate Set Param Buffer 4522 m_pParamHeap = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE); 4523 rc = m_pParamHeap->allocate(1, sizeof(parm_buffer_t), NON_SECURE); 4524 if(rc != OK) { 4525 rc = NO_MEMORY; 4526 ALOGE("Failed to allocate SETPARM Heap memory"); 4527 goto TRANS_INIT_ERROR1; 4528 } 4529 4530 //Map memory for parameters buffer 4531 rc = m_pCamOpsTbl->ops->map_buf(m_pCamOpsTbl->camera_handle, 4532 CAM_MAPPING_BUF_TYPE_PARM_BUF, 4533 m_pParamHeap->getFd(0), 4534 sizeof(parm_buffer_t)); 4535 if(rc < 0) { 4536 ALOGE("%s:failed to map SETPARM buffer",__func__); 4537 rc = FAILED_TRANSACTION; 4538 goto TRANS_INIT_ERROR2; 4539 } 4540 m_pParamBuf = (parm_buffer_t*) DATA_PTR(m_pParamHeap,0); 4541 4542 initDefaultParameters(); 4543 4544 m_bInited = true; 4545 4546 goto TRANS_INIT_DONE; 4547 4548 TRANS_INIT_ERROR2: 4549 m_pParamHeap->deallocate(); 4550 4551 TRANS_INIT_ERROR1: 4552 delete m_pParamHeap; 4553 m_pParamHeap = NULL; 4554 4555 TRANS_INIT_DONE: 4556 return rc; 4557 } 4558 4559 /*=========================================================================== 4560 * FUNCTION : deinit 4561 * 4562 * DESCRIPTION: deinitialize 4563 * 4564 * PARAMETERS : none 4565 * 4566 * RETURN : none 4567 *==========================================================================*/ 4568 void QCameraParameters::deinit() 4569 { 4570 if (!m_bInited) { 4571 return; 4572 } 4573 4574 //clear all entries in the map 4575 String8 emptyStr; 4576 QCameraParameters::unflatten(emptyStr); 4577 4578 if (NULL != m_pCamOpsTbl) { 4579 m_pCamOpsTbl->ops->unmap_buf( 4580 m_pCamOpsTbl->camera_handle, 4581 CAM_MAPPING_BUF_TYPE_PARM_BUF); 4582 m_pCamOpsTbl = NULL; 4583 } 4584 m_pCapability = NULL; 4585 if (NULL != m_pParamHeap) { 4586 m_pParamHeap->deallocate(); 4587 delete m_pParamHeap; 4588 m_pParamHeap = NULL; 4589 m_pParamBuf = NULL; 4590 } 4591 4592 m_AdjustFPS = NULL; 4593 4594 m_tempMap.clear(); 4595 4596 m_bInited = false; 4597 } 4598 4599 /*=========================================================================== 4600 * FUNCTION : parse_pair 4601 * 4602 * DESCRIPTION: helper function to parse string like "640x480" or "10000,20000" 4603 * 4604 * PARAMETERS : 4605 * @str : input string to be parse 4606 * @first : [output] first value of the pair 4607 * @second : [output] second value of the pair 4608 * @delim : [input] delimeter to seperate the pair 4609 * @endptr : [output] ptr to the end of the pair string 4610 * 4611 * RETURN : int32_t type of status 4612 * NO_ERROR -- success 4613 * none-zero failure code 4614 *==========================================================================*/ 4615 int32_t QCameraParameters::parse_pair(const char *str, 4616 int *first, 4617 int *second, 4618 char delim, 4619 char **endptr = NULL) 4620 { 4621 // Find the first integer. 4622 char *end; 4623 int w = (int)strtol(str, &end, 10); 4624 // If a delimeter does not immediately follow, give up. 4625 if (*end != delim) { 4626 ALOGE("Cannot find delimeter (%c) in str=%s", delim, str); 4627 return BAD_VALUE; 4628 } 4629 4630 // Find the second integer, immediately after the delimeter. 4631 int h = (int)strtol(end+1, &end, 10); 4632 4633 *first = w; 4634 *second = h; 4635 4636 if (endptr) { 4637 *endptr = end; 4638 } 4639 4640 return NO_ERROR; 4641 } 4642 4643 /*=========================================================================== 4644 * FUNCTION : parseSizesList 4645 * 4646 * DESCRIPTION: helper function to parse string containing sizes 4647 * 4648 * PARAMETERS : 4649 * @sizesStr: [input] input string to be parse 4650 * @sizes : [output] reference to store parsed sizes 4651 * 4652 * RETURN : none 4653 *==========================================================================*/ 4654 void QCameraParameters::parseSizesList(const char *sizesStr, Vector<Size> &sizes) 4655 { 4656 if (sizesStr == 0) { 4657 return; 4658 } 4659 4660 char *sizeStartPtr = (char *)sizesStr; 4661 4662 while (true) { 4663 int width, height; 4664 int success = parse_pair(sizeStartPtr, &width, &height, 'x', 4665 &sizeStartPtr); 4666 if (success == -1 || (*sizeStartPtr != ',' && *sizeStartPtr != '\0')) { 4667 ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr); 4668 return; 4669 } 4670 sizes.push(Size(width, height)); 4671 4672 if (*sizeStartPtr == '\0') { 4673 return; 4674 } 4675 sizeStartPtr++; 4676 } 4677 } 4678 4679 /*=========================================================================== 4680 * FUNCTION : getSupportedHfrSizes 4681 * 4682 * DESCRIPTION: return supported HFR sizes 4683 * 4684 * PARAMETERS : 4685 * @sizes : [output] reference to a vector storing supported HFR sizes 4686 * 4687 * RETURN : none 4688 *==========================================================================*/ 4689 void QCameraParameters::getSupportedHfrSizes(Vector<Size> &sizes) 4690 { 4691 const char *hfrSizesStr = get(KEY_QC_SUPPORTED_HFR_SIZES); 4692 parseSizesList(hfrSizesStr, sizes); 4693 } 4694 4695 /*=========================================================================== 4696 * FUNCTION : adjustPreviewFpsRanges 4697 * 4698 * DESCRIPTION: adjust preview FPS ranges 4699 * according to external events 4700 * 4701 * PARAMETERS : 4702 * @minFPS : min FPS value 4703 * @maxFPS : max FPS value 4704 * 4705 * RETURN : int32_t type of status 4706 * NO_ERROR -- success 4707 * none-zero failure code 4708 *==========================================================================*/ 4709 int32_t QCameraParameters::adjustPreviewFpsRange(cam_fps_range_t *fpsRange) 4710 { 4711 if ( fpsRange == NULL ) { 4712 return BAD_VALUE; 4713 } 4714 4715 if ( m_pParamBuf == NULL ) { 4716 return NO_INIT; 4717 } 4718 4719 int32_t rc = initBatchUpdate(m_pParamBuf); 4720 if ( rc != NO_ERROR ) { 4721 ALOGE("%s:Failed to initialize group update table", __func__); 4722 return rc; 4723 } 4724 4725 rc = AddSetParmEntryToBatch(m_pParamBuf, 4726 CAM_INTF_PARM_FPS_RANGE, 4727 sizeof(cam_fps_range_t), 4728 fpsRange); 4729 if ( rc != NO_ERROR ) { 4730 ALOGE("%s: Parameters batch failed",__func__); 4731 return rc; 4732 } 4733 4734 rc = commitSetBatch(); 4735 if ( rc != NO_ERROR ) { 4736 ALOGE("%s:Failed to commit batch parameters", __func__); 4737 return rc; 4738 } 4739 4740 return rc; 4741 } 4742 4743 /*=========================================================================== 4744 * FUNCTION : setPreviewFpsRanges 4745 * 4746 * DESCRIPTION: set preview FPS ranges 4747 * 4748 * PARAMETERS : 4749 * @minFPS : min FPS value 4750 * @maxFPS : max FPS value 4751 * 4752 * RETURN : int32_t type of status 4753 * NO_ERROR -- success 4754 * none-zero failure code 4755 *==========================================================================*/ 4756 int32_t QCameraParameters::setPreviewFpsRange(int min_fps, 4757 int max_fps, int vid_min_fps,int vid_max_fps) 4758 { 4759 char str[32]; 4760 char value[PROPERTY_VALUE_MAX]; 4761 int fixedFpsValue; 4762 /*This property get value should be the fps that user needs*/ 4763 property_get("persist.debug.set.fixedfps", value, "0"); 4764 fixedFpsValue = atoi(value); 4765 4766 CDBG_HIGH("%s: E minFps = %d, maxFps = %d , vid minFps = %d, vid maxFps = %d", 4767 __func__, min_fps, max_fps, vid_min_fps, vid_max_fps); 4768 4769 if(fixedFpsValue != 0) { 4770 min_fps = (int)fixedFpsValue*1000; 4771 max_fps = (int)fixedFpsValue*1000; 4772 } 4773 snprintf(str, sizeof(str), "%d,%d", min_fps, max_fps); 4774 CDBG_HIGH("%s: Setting preview fps range %s", __func__, str); 4775 updateParamEntry(KEY_PREVIEW_FPS_RANGE, str); 4776 cam_fps_range_t fps_range; 4777 memset(&fps_range, 0x00, sizeof(cam_fps_range_t)); 4778 fps_range.min_fps = min_fps / float (1000.0); 4779 fps_range.max_fps = max_fps / float (1000.0); 4780 fps_range.video_min_fps = vid_min_fps / float (1000.0); 4781 fps_range.video_max_fps = vid_max_fps / float (1000.0); 4782 4783 4784 CDBG_HIGH("%s: Updated: minFps = %d, maxFps = %d ," 4785 " vid minFps = %d, vid maxFps = %d", 4786 __func__, min_fps, max_fps, vid_min_fps, vid_max_fps); 4787 4788 if ( NULL != m_AdjustFPS ) { 4789 m_AdjustFPS->recalcFPSRange(min_fps, max_fps, vid_min_fps, vid_max_fps); 4790 CDBG_HIGH("%s: Thermal adjusted preview fps range %d,%d, %d, %d", 4791 __func__, 4792 min_fps, 4793 max_fps, vid_min_fps, vid_max_fps); 4794 fps_range.min_fps = min_fps; 4795 fps_range.max_fps = max_fps; 4796 fps_range.video_min_fps = vid_min_fps; 4797 fps_range.video_max_fps = vid_max_fps; 4798 4799 } 4800 4801 return AddSetParmEntryToBatch(m_pParamBuf, 4802 CAM_INTF_PARM_FPS_RANGE, 4803 sizeof(cam_fps_range_t), 4804 &fps_range); 4805 } 4806 4807 4808 4809 /*=========================================================================== 4810 * FUNCTION : setAutoExposure 4811 * 4812 * DESCRIPTION: set auto exposure 4813 * 4814 * PARAMETERS : 4815 * @autoExp : auto exposure value string 4816 * 4817 * RETURN : int32_t type of status 4818 * NO_ERROR -- success 4819 * none-zero failure code 4820 *==========================================================================*/ 4821 int32_t QCameraParameters::setAutoExposure(const char *autoExp) 4822 { 4823 if (autoExp != NULL) { 4824 int32_t value = lookupAttr(AUTO_EXPOSURE_MAP, 4825 sizeof(AUTO_EXPOSURE_MAP)/sizeof(AUTO_EXPOSURE_MAP[0]), 4826 autoExp); 4827 if (value != NAME_NOT_FOUND) { 4828 CDBG_HIGH("%s: Setting auto exposure %s", __func__, autoExp); 4829 updateParamEntry(KEY_QC_AUTO_EXPOSURE, autoExp); 4830 return AddSetParmEntryToBatch(m_pParamBuf, 4831 CAM_INTF_PARM_AEC_ALGO_TYPE, 4832 sizeof(value), 4833 &value); 4834 } 4835 } 4836 ALOGE("Invalid auto exposure value: %s", (autoExp == NULL) ? "NULL" : autoExp); 4837 return BAD_VALUE; 4838 } 4839 4840 /*=========================================================================== 4841 * FUNCTION : setEffect 4842 * 4843 * DESCRIPTION: set effect 4844 * 4845 * PARAMETERS : 4846 * @effect : effect value string 4847 * 4848 * RETURN : int32_t type of status 4849 * NO_ERROR -- success 4850 * none-zero failure code 4851 *==========================================================================*/ 4852 int32_t QCameraParameters::setEffect(const char *effect) 4853 { 4854 if (effect != NULL) { 4855 int32_t value = lookupAttr(EFFECT_MODES_MAP, 4856 sizeof(EFFECT_MODES_MAP)/sizeof(QCameraMap), 4857 effect); 4858 if (value != NAME_NOT_FOUND) { 4859 CDBG_HIGH("%s: Setting effect %s", __func__, effect); 4860 updateParamEntry(KEY_EFFECT, effect); 4861 uint8_t prmEffect = static_cast<uint8_t>(value); 4862 return AddSetParmEntryToBatch(m_pParamBuf, 4863 CAM_INTF_PARM_EFFECT, 4864 sizeof(prmEffect), 4865 &prmEffect); 4866 } 4867 } 4868 ALOGE("Invalid effect value: %s", (effect == NULL) ? "NULL" : effect); 4869 return BAD_VALUE; 4870 } 4871 4872 /*=========================================================================== 4873 * FUNCTION : setBrightness 4874 * 4875 * DESCRIPTION: set brightness control value 4876 * 4877 * PARAMETERS : 4878 * @brightness : brightness control value 4879 * 4880 * RETURN : int32_t type of status 4881 * NO_ERROR -- success 4882 * none-zero failure code 4883 *==========================================================================*/ 4884 int32_t QCameraParameters::setBrightness(int brightness) 4885 { 4886 char val[16]; 4887 sprintf(val, "%d", brightness); 4888 updateParamEntry(KEY_QC_BRIGHTNESS, val); 4889 4890 int32_t value = brightness; 4891 CDBG_HIGH("%s: Setting brightness %s", __func__, val); 4892 return AddSetParmEntryToBatch(m_pParamBuf, 4893 CAM_INTF_PARM_BRIGHTNESS, 4894 sizeof(value), 4895 &value); 4896 } 4897 4898 /*=========================================================================== 4899 * FUNCTION : setFocusMode 4900 * 4901 * DESCRIPTION: set focus mode 4902 * 4903 * PARAMETERS : 4904 * @focusMode : focus mode value string 4905 * 4906 * RETURN : int32_t type of status 4907 * NO_ERROR -- success 4908 * none-zero failure code 4909 *==========================================================================*/ 4910 int32_t QCameraParameters::setFocusMode(const char *focusMode) 4911 { 4912 int32_t rc; 4913 if (focusMode != NULL) { 4914 int32_t value = lookupAttr(FOCUS_MODES_MAP, 4915 sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap), 4916 focusMode); 4917 if (value != NAME_NOT_FOUND) { 4918 CDBG_HIGH("%s: Setting focus mode %s", __func__, focusMode); 4919 uint8_t fm = (uint8_t)value; 4920 mFocusMode = (cam_focus_mode_type)value; 4921 4922 updateParamEntry(KEY_FOCUS_MODE, focusMode); 4923 rc = AddSetParmEntryToBatch(m_pParamBuf, 4924 CAM_INTF_PARM_FOCUS_MODE, 4925 sizeof(fm), 4926 &fm); 4927 if (strcmp(focusMode,"infinity")==0){ 4928 set(QCameraParameters::KEY_FOCUS_DISTANCES, "Infinity,Infinity,Infinity"); 4929 } 4930 return rc; 4931 } 4932 } 4933 ALOGE("Invalid focus mode value: %s", (focusMode == NULL) ? "NULL" : focusMode); 4934 return BAD_VALUE; 4935 } 4936 4937 /*=========================================================================== 4938 * FUNCTION : setSharpness 4939 * 4940 * DESCRIPTION: set sharpness control value 4941 * 4942 * PARAMETERS : 4943 * @sharpness : sharpness control value 4944 * 4945 * RETURN : int32_t type of status 4946 * NO_ERROR -- success 4947 * none-zero failure code 4948 *==========================================================================*/ 4949 int32_t QCameraParameters::setSharpness(int sharpness) 4950 { 4951 char val[16]; 4952 sprintf(val, "%d", sharpness); 4953 updateParamEntry(KEY_QC_SHARPNESS, val); 4954 CDBG_HIGH("%s: Setting sharpness %s", __func__, val); 4955 4956 int32_t value = sharpness; 4957 return AddSetParmEntryToBatch(m_pParamBuf, 4958 CAM_INTF_PARM_SHARPNESS, 4959 sizeof(value), 4960 &value); 4961 } 4962 4963 /*=========================================================================== 4964 * FUNCTION : setSkinToneEnhancement 4965 * 4966 * DESCRIPTION: set skin tone enhancement value 4967 * 4968 * PARAMETERS : 4969 * @sceFactore : skin tone enhancement factor value 4970 * 4971 * RETURN : int32_t type of status 4972 * NO_ERROR -- success 4973 * none-zero failure code 4974 *==========================================================================*/ 4975 int32_t QCameraParameters::setSkinToneEnhancement(int sceFactor) 4976 { 4977 char val[16]; 4978 sprintf(val, "%d", sceFactor); 4979 updateParamEntry(KEY_QC_SCE_FACTOR, val); 4980 CDBG_HIGH("%s: Setting skintone enhancement %s", __func__, val); 4981 4982 int32_t value = sceFactor; 4983 return AddSetParmEntryToBatch(m_pParamBuf, 4984 CAM_INTF_PARM_SCE_FACTOR, 4985 sizeof(value), 4986 &value); 4987 } 4988 4989 /*=========================================================================== 4990 * FUNCTION : setSaturation 4991 * 4992 * DESCRIPTION: set saturation control value 4993 * 4994 * PARAMETERS : 4995 * @saturation : saturation control value 4996 * 4997 * RETURN : int32_t type of status 4998 * NO_ERROR -- success 4999 * none-zero failure code 5000 *==========================================================================*/ 5001 int32_t QCameraParameters::setSaturation(int saturation) 5002 { 5003 char val[16]; 5004 sprintf(val, "%d", saturation); 5005 updateParamEntry(KEY_QC_SATURATION, val); 5006 CDBG_HIGH("%s: Setting saturation %s", __func__, val); 5007 5008 int32_t value = saturation; 5009 return AddSetParmEntryToBatch(m_pParamBuf, 5010 CAM_INTF_PARM_SATURATION, 5011 sizeof(value), 5012 &value); 5013 } 5014 5015 /*=========================================================================== 5016 * FUNCTION : setContrast 5017 * 5018 * DESCRIPTION: set contrast control value 5019 * 5020 * PARAMETERS : 5021 * @contrast : contrast control value 5022 * 5023 * RETURN : int32_t type of status 5024 * NO_ERROR -- success 5025 * none-zero failure code 5026 *==========================================================================*/ 5027 int32_t QCameraParameters::setContrast(int contrast) 5028 { 5029 char val[16]; 5030 sprintf(val, "%d", contrast); 5031 updateParamEntry(KEY_QC_CONTRAST, val); 5032 CDBG_HIGH("%s: Setting contrast %s", __func__, val); 5033 5034 int32_t value = contrast; 5035 return AddSetParmEntryToBatch(m_pParamBuf, 5036 CAM_INTF_PARM_CONTRAST, 5037 sizeof(value), 5038 &value); 5039 } 5040 5041 /*=========================================================================== 5042 * FUNCTION : setSceneDetect 5043 * 5044 * DESCRIPTION: set scenen detect value 5045 * 5046 * PARAMETERS : 5047 * @sceneDetect : scene detect value string 5048 * 5049 * RETURN : int32_t type of status 5050 * NO_ERROR -- success 5051 * none-zero failure code 5052 *==========================================================================*/ 5053 int32_t QCameraParameters::setSceneDetect(const char *sceneDetect) 5054 { 5055 if (sceneDetect != NULL) { 5056 int32_t value = lookupAttr(ON_OFF_MODES_MAP, 5057 sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap), 5058 sceneDetect); 5059 if (value != NAME_NOT_FOUND) { 5060 CDBG_HIGH("%s: Setting Scene Detect %s", __func__, sceneDetect); 5061 updateParamEntry(KEY_QC_SCENE_DETECT, sceneDetect); 5062 return AddSetParmEntryToBatch(m_pParamBuf, 5063 CAM_INTF_PARM_ASD_ENABLE, 5064 sizeof(value), 5065 &value); 5066 } 5067 } 5068 ALOGE("Invalid Scene Detect value: %s", 5069 (sceneDetect == NULL) ? "NULL" : sceneDetect); 5070 return BAD_VALUE; 5071 } 5072 5073 /*=========================================================================== 5074 * FUNCTION : setSensorSnapshotHDR 5075 * 5076 * DESCRIPTION: set snapshot HDR value 5077 * 5078 * PARAMETERS : 5079 * @snapshotHDR : snapshot HDR value string 5080 * 5081 * RETURN : int32_t type of status 5082 * NO_ERROR -- success 5083 * none-zero failure code 5084 *==========================================================================*/ 5085 int32_t QCameraParameters::setSensorSnapshotHDR(const char *snapshotHDR) 5086 { 5087 if (snapshotHDR != NULL) { 5088 int32_t value = lookupAttr(ON_OFF_MODES_MAP, 5089 sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap), 5090 snapshotHDR); 5091 if (value != NAME_NOT_FOUND) { 5092 CDBG_HIGH("%s: Setting Sensor Snapshot HDR %s", __func__, snapshotHDR); 5093 updateParamEntry(KEY_QC_SENSOR_HDR, snapshotHDR); 5094 return AddSetParmEntryToBatch(m_pParamBuf, 5095 CAM_INTF_PARM_SENSOR_HDR, 5096 sizeof(value), 5097 &value); 5098 } 5099 } 5100 ALOGE("Invalid Snapshot HDR value: %s", 5101 (snapshotHDR == NULL) ? "NULL" : snapshotHDR); 5102 return BAD_VALUE; 5103 5104 } 5105 5106 5107 /*=========================================================================== 5108 * FUNCTION : setVideoHDR 5109 * 5110 * DESCRIPTION: set video HDR value 5111 * 5112 * PARAMETERS : 5113 * @videoHDR : svideo HDR value string 5114 * 5115 * RETURN : int32_t type of status 5116 * NO_ERROR -- success 5117 * none-zero failure code 5118 *==========================================================================*/ 5119 int32_t QCameraParameters::setVideoHDR(const char *videoHDR) 5120 { 5121 if (videoHDR != NULL) { 5122 int32_t value = lookupAttr(ON_OFF_MODES_MAP, 5123 sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap), 5124 videoHDR); 5125 if (value != NAME_NOT_FOUND) { 5126 CDBG_HIGH("%s: Setting Video HDR %s", __func__, videoHDR); 5127 updateParamEntry(KEY_QC_VIDEO_HDR, videoHDR); 5128 return AddSetParmEntryToBatch(m_pParamBuf, 5129 CAM_INTF_PARM_VIDEO_HDR, 5130 sizeof(value), 5131 &value); 5132 } 5133 } 5134 ALOGE("Invalid Video HDR value: %s", 5135 (videoHDR == NULL) ? "NULL" : videoHDR); 5136 return BAD_VALUE; 5137 } 5138 5139 5140 5141 /*=========================================================================== 5142 * FUNCTION : setVtEnable 5143 * 5144 * DESCRIPTION: set vt Enable value 5145 * 5146 * PARAMETERS : 5147 * @videoHDR : svtEnable value string 5148 * 5149 * RETURN : int32_t type of status 5150 * NO_ERROR -- success 5151 * none-zero failure code 5152 *==========================================================================*/ 5153 int32_t QCameraParameters::setVtEnable(const char *vtEnable) 5154 { 5155 if (vtEnable != NULL) { 5156 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 5157 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 5158 vtEnable); 5159 if (value != NAME_NOT_FOUND) { 5160 CDBG_HIGH("%s: Setting Vt Enable %s", __func__, vtEnable); 5161 m_bAVTimerEnabled = true; 5162 updateParamEntry(KEY_QC_VT_ENABLE, vtEnable); 5163 return AddSetParmEntryToBatch(m_pParamBuf, 5164 CAM_INTF_PARM_VT, 5165 sizeof(value), 5166 &value); 5167 } 5168 } 5169 ALOGE("Invalid Vt Enable value: %s", 5170 (vtEnable == NULL) ? "NULL" : vtEnable); 5171 m_bAVTimerEnabled = false; 5172 return BAD_VALUE; 5173 } 5174 5175 /*=========================================================================== 5176 * FUNCTION : setFaceRecognition 5177 * 5178 * DESCRIPTION: set face recognition value 5179 * 5180 * PARAMETERS : 5181 * @faceRecog : face recognition value string 5182 * @maxFaces : number of max faces to be detected/recognized 5183 * 5184 * RETURN : int32_t type of status 5185 * NO_ERROR -- success 5186 * none-zero failure code 5187 *==========================================================================*/ 5188 int32_t QCameraParameters::setFaceRecognition(const char *faceRecog, int maxFaces) 5189 { 5190 if (faceRecog != NULL) { 5191 int32_t value = lookupAttr(ON_OFF_MODES_MAP, 5192 sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap), 5193 faceRecog); 5194 if (value != NAME_NOT_FOUND) { 5195 CDBG_HIGH("%s: Setting face recognition %s", __func__, faceRecog); 5196 updateParamEntry(KEY_QC_FACE_RECOGNITION, faceRecog); 5197 5198 int faceProcMask = m_nFaceProcMask; 5199 if (value > 0) { 5200 faceProcMask |= CAM_FACE_PROCESS_MASK_RECOGNITION; 5201 } else { 5202 faceProcMask &= ~CAM_FACE_PROCESS_MASK_RECOGNITION; 5203 } 5204 5205 if(m_nFaceProcMask == faceProcMask) { 5206 CDBG_HIGH("%s: face process mask not changed, no ops here", __func__); 5207 return NO_ERROR; 5208 } 5209 m_nFaceProcMask = faceProcMask; 5210 CDBG_HIGH("%s: FaceProcMask -> %d", __func__, m_nFaceProcMask); 5211 5212 // set parm for face process 5213 cam_fd_set_parm_t fd_set_parm; 5214 memset(&fd_set_parm, 0, sizeof(cam_fd_set_parm_t)); 5215 fd_set_parm.fd_mode = m_nFaceProcMask; 5216 fd_set_parm.num_fd = maxFaces; 5217 5218 return AddSetParmEntryToBatch(m_pParamBuf, 5219 CAM_INTF_PARM_FD, 5220 sizeof(fd_set_parm), 5221 &fd_set_parm); 5222 } 5223 } 5224 ALOGE("Invalid face recognition value: %s", (faceRecog == NULL) ? "NULL" : faceRecog); 5225 return BAD_VALUE; 5226 } 5227 5228 /*=========================================================================== 5229 * FUNCTION : setZoom 5230 * 5231 * DESCRIPTION: set zoom level 5232 * 5233 * PARAMETERS : 5234 * @zoom_level : zoom level 5235 * 5236 * RETURN : int32_t type of status 5237 * NO_ERROR -- success 5238 * none-zero failure code 5239 *==========================================================================*/ 5240 int32_t QCameraParameters::setZoom(int zoom_level) 5241 { 5242 char val[16]; 5243 sprintf(val, "%d", zoom_level); 5244 updateParamEntry(KEY_ZOOM, val); 5245 5246 return AddSetParmEntryToBatch(m_pParamBuf, 5247 CAM_INTF_PARM_ZOOM, 5248 sizeof(zoom_level), 5249 &zoom_level); 5250 } 5251 5252 /*=========================================================================== 5253 * FUNCTION : setISOValue 5254 * 5255 * DESCRIPTION: set ISO value 5256 * 5257 * PARAMETERS : 5258 * @isoValue : ISO value string 5259 * 5260 * RETURN : int32_t type of status 5261 * NO_ERROR -- success 5262 * none-zero failure code 5263 *==========================================================================*/ 5264 int32_t QCameraParameters::setISOValue(const char *isoValue) 5265 { 5266 if (isoValue != NULL) { 5267 int32_t value = lookupAttr(ISO_MODES_MAP, 5268 sizeof(ISO_MODES_MAP)/sizeof(QCameraMap), 5269 isoValue); 5270 if (value != NAME_NOT_FOUND) { 5271 CDBG_HIGH("%s: Setting ISO value %s", __func__, isoValue); 5272 updateParamEntry(KEY_QC_ISO_MODE, isoValue); 5273 return AddSetParmEntryToBatch(m_pParamBuf, 5274 CAM_INTF_PARM_ISO, 5275 sizeof(value), 5276 &value); 5277 } 5278 } 5279 ALOGE("Invalid ISO value: %s", 5280 (isoValue == NULL) ? "NULL" : isoValue); 5281 return BAD_VALUE; 5282 } 5283 5284 /*=========================================================================== 5285 * FUNCTION : setLongshotEnable 5286 * 5287 * DESCRIPTION: set a flag indicating longshot mode 5288 * 5289 * PARAMETERS : 5290 * @enable : true - Longshot enabled 5291 * false - Longshot disabled 5292 * 5293 * RETURN : int32_t type of status 5294 * NO_ERROR -- success 5295 * none-zero failure code 5296 *==========================================================================*/ 5297 int32_t QCameraParameters::setLongshotEnable(bool enable) 5298 { 5299 int32_t rc = NO_ERROR; 5300 int8_t value = enable; 5301 5302 if(initBatchUpdate(m_pParamBuf) < 0 ) { 5303 ALOGE("%s:Failed to initialize group update table", __func__); 5304 return BAD_TYPE; 5305 } 5306 5307 rc = AddSetParmEntryToBatch(m_pParamBuf, 5308 CAM_INTF_PARM_LONGSHOT_ENABLE, 5309 sizeof(value), 5310 &value); 5311 if (rc != NO_ERROR) { 5312 ALOGE("%s:Failed to update table", __func__); 5313 return rc; 5314 } 5315 5316 rc = commitSetBatch(); 5317 if (rc != NO_ERROR) { 5318 ALOGE("%s:Failed to parameter changes", __func__); 5319 return rc; 5320 } 5321 5322 return rc; 5323 } 5324 5325 /*=========================================================================== 5326 * FUNCTION : setFlash 5327 * 5328 * DESCRIPTION: set flash mode 5329 * 5330 * PARAMETERS : 5331 * @flashStr : LED flash mode value string 5332 * 5333 * RETURN : int32_t type of status 5334 * NO_ERROR -- success 5335 * none-zero failure code 5336 *==========================================================================*/ 5337 int32_t QCameraParameters::setFlash(const char *flashStr) 5338 { 5339 if (flashStr != NULL) { 5340 int32_t value = lookupAttr(FLASH_MODES_MAP, 5341 sizeof(FLASH_MODES_MAP)/sizeof(QCameraMap), 5342 flashStr); 5343 if (value != NAME_NOT_FOUND) { 5344 CDBG_HIGH("%s: Setting Flash value %s", __func__, flashStr); 5345 5346 if (NULL != m_pTorch && !m_bRecordingHint_new) { 5347 if ( value == CAM_FLASH_MODE_TORCH ) { 5348 m_pTorch->prepareTorchCamera(); 5349 } else { 5350 m_bReleaseTorchCamera = true; 5351 } 5352 } 5353 5354 updateParamEntry(KEY_FLASH_MODE, flashStr); 5355 mFlashValue = value; 5356 return NO_ERROR; 5357 } 5358 } 5359 ALOGE("Invalid flash value: %s", (flashStr == NULL) ? "NULL" : flashStr); 5360 return BAD_VALUE; 5361 } 5362 5363 /*=========================================================================== 5364 * FUNCTION : setAecLock 5365 * 5366 * DESCRIPTION: set AEC lock value 5367 * 5368 * PARAMETERS : 5369 * @aecLockStr : AEC lock value string 5370 * 5371 * RETURN : int32_t type of status 5372 * NO_ERROR -- success 5373 * none-zero failure code 5374 *==========================================================================*/ 5375 int32_t QCameraParameters::setAecLock(const char *aecLockStr) 5376 { 5377 if (aecLockStr != NULL) { 5378 int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP, 5379 sizeof(TRUE_FALSE_MODES_MAP)/ 5380 sizeof(QCameraMap), 5381 aecLockStr); 5382 if (value != NAME_NOT_FOUND) { 5383 CDBG_HIGH("%s: Setting AECLock value %s", __func__, aecLockStr); 5384 updateParamEntry(KEY_AUTO_EXPOSURE_LOCK, aecLockStr); 5385 return AddSetParmEntryToBatch(m_pParamBuf, 5386 CAM_INTF_PARM_AEC_LOCK, 5387 sizeof(value), 5388 &value); 5389 } 5390 } 5391 ALOGE("Invalid AECLock value: %s", 5392 (aecLockStr == NULL) ? "NULL" : aecLockStr); 5393 return BAD_VALUE; 5394 } 5395 5396 /*=========================================================================== 5397 * FUNCTION : setAwbLock 5398 * 5399 * DESCRIPTION: set AWB lock value 5400 * 5401 * PARAMETERS : 5402 * @awbLockStr : AWB lock value string 5403 * 5404 * RETURN : int32_t type of status 5405 * NO_ERROR -- success 5406 * none-zero failure code 5407 *==========================================================================*/ 5408 int32_t QCameraParameters::setAwbLock(const char *awbLockStr) 5409 { 5410 if (awbLockStr != NULL) { 5411 int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP, 5412 sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap), 5413 awbLockStr); 5414 if (value != NAME_NOT_FOUND) { 5415 CDBG_HIGH("%s: Setting AWBLock value %s", __func__, awbLockStr); 5416 updateParamEntry(KEY_AUTO_WHITEBALANCE_LOCK, awbLockStr); 5417 return AddSetParmEntryToBatch(m_pParamBuf, 5418 CAM_INTF_PARM_AWB_LOCK, 5419 sizeof(value), 5420 &value); 5421 } 5422 } 5423 ALOGE("Invalid AWBLock value: %s", (awbLockStr == NULL) ? "NULL" : awbLockStr); 5424 return BAD_VALUE; 5425 } 5426 5427 /*=========================================================================== 5428 * FUNCTION : setMCEValue 5429 * 5430 * DESCRIPTION: set memory color enhancement value 5431 * 5432 * PARAMETERS : 5433 * @mceStr : MCE value string 5434 * 5435 * RETURN : int32_t type of status 5436 * NO_ERROR -- success 5437 * none-zero failure code 5438 *==========================================================================*/ 5439 int32_t QCameraParameters::setMCEValue(const char *mceStr) 5440 { 5441 if (mceStr != NULL) { 5442 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 5443 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 5444 mceStr); 5445 if (value != NAME_NOT_FOUND) { 5446 CDBG_HIGH("%s: Setting AWBLock value %s", __func__, mceStr); 5447 updateParamEntry(KEY_QC_MEMORY_COLOR_ENHANCEMENT, mceStr); 5448 return AddSetParmEntryToBatch(m_pParamBuf, 5449 CAM_INTF_PARM_MCE, 5450 sizeof(value), 5451 &value); 5452 } 5453 } 5454 ALOGE("Invalid MCE value: %s", (mceStr == NULL) ? "NULL" : mceStr); 5455 return BAD_VALUE; 5456 } 5457 5458 /*=========================================================================== 5459 * FUNCTION : setTintlessValue 5460 * 5461 * DESCRIPTION: enable/disable tintless from user setting 5462 * 5463 * PARAMETERS : 5464 * @params : user setting parameters 5465 * 5466 * RETURN : int32_t type of status 5467 * NO_ERROR -- success 5468 * none-zero failure code 5469 *==========================================================================*/ 5470 int32_t QCameraParameters::setTintlessValue(const QCameraParameters& params) 5471 { 5472 const char *str = params.get(KEY_QC_TINTLESS_ENABLE); 5473 const char *prev_str = get(KEY_QC_TINTLESS_ENABLE); 5474 char prop[PROPERTY_VALUE_MAX]; 5475 5476 memset(prop, 0, sizeof(prop)); 5477 property_get("persist.camera.tintless", prop, VALUE_DISABLE); 5478 if (str != NULL) { 5479 if (prev_str == NULL || 5480 strcmp(str, prev_str) != 0) { 5481 return setTintlessValue(str); 5482 } 5483 } else { 5484 if (prev_str == NULL || 5485 strcmp(prev_str, prop) != 0 ) { 5486 setTintlessValue(prop); 5487 } 5488 } 5489 5490 return NO_ERROR; 5491 } 5492 5493 /*=========================================================================== 5494 * FUNCTION : setTintlessValue 5495 * 5496 * DESCRIPTION: set tintless value 5497 * 5498 * PARAMETERS : 5499 * @tintStr : Tintless value string 5500 * 5501 * RETURN : int32_t type of status 5502 * NO_ERROR -- success 5503 * none-zero failure code 5504 *==========================================================================*/ 5505 int32_t QCameraParameters::setTintlessValue(const char *tintStr) 5506 { 5507 if (tintStr != NULL) { 5508 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 5509 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 5510 tintStr); 5511 if (value != NAME_NOT_FOUND) { 5512 CDBG_HIGH("%s: Setting Tintless value %s", __func__, tintStr); 5513 updateParamEntry(KEY_QC_TINTLESS_ENABLE, tintStr); 5514 return AddSetParmEntryToBatch(m_pParamBuf, 5515 CAM_INTF_PARM_TINTLESS, 5516 sizeof(value), 5517 &value); 5518 } 5519 } 5520 ALOGE("Invalid Tintless value: %s", (tintStr == NULL) ? "NULL" : tintStr); 5521 return BAD_VALUE; 5522 } 5523 5524 /*=========================================================================== 5525 * FUNCTION : setCDSMode 5526 * 5527 * DESCRIPTION: Set CDS mode 5528 * 5529 * PARAMETERS : 5530 * @params : user setting parameters 5531 * 5532 * RETURN : int32_t type of status 5533 * NO_ERROR -- success 5534 * none-zero failure code 5535 *==========================================================================*/ 5536 int32_t QCameraParameters::setCDSMode(const QCameraParameters& params) 5537 { 5538 const char *str = params.get(KEY_QC_CDS_MODE); 5539 const char *prev_str = get(KEY_QC_CDS_MODE); 5540 char *cds_mode_str = NULL; 5541 int32_t rc = NO_ERROR; 5542 5543 if (str) { 5544 if (!prev_str || !strcmp(str, prev_str)) { 5545 cds_mode_str = (char *)str; 5546 } 5547 } else { 5548 char prop[PROPERTY_VALUE_MAX]; 5549 memset(prop, 0, sizeof(prop)); 5550 property_get("persist.camera.CDS", prop, CDS_MODE_AUTO); 5551 cds_mode_str = prop; 5552 } 5553 5554 if (cds_mode_str) { 5555 ALOGV("%s: Set CDS mode = %s", __func__, cds_mode_str); 5556 5557 int32_t cds_mode = lookupAttr(CDS_MODES_MAP, 5558 sizeof(CDS_MODES_MAP) / sizeof(QCameraMap), 5559 cds_mode_str); 5560 5561 rc = AddSetParmEntryToBatch(m_pParamBuf, 5562 CAM_INTF_PARM_CDS_MODE, 5563 sizeof(cds_mode), 5564 &cds_mode); 5565 if (rc != NO_ERROR) { 5566 ALOGE("%s:Failed CDS MODE to update table", __func__); 5567 } 5568 } 5569 return rc; 5570 } 5571 5572 /*=========================================================================== 5573 * FUNCTION : setDISValue 5574 * 5575 * DESCRIPTION: set DIS value 5576 * 5577 * PARAMETERS : 5578 * @disStr : DIS value string 5579 * 5580 * RETURN : int32_t type of status 5581 * NO_ERROR -- success 5582 * none-zero failure code 5583 *==========================================================================*/ 5584 int32_t QCameraParameters::setDISValue(const char *disStr) 5585 { 5586 if (disStr != NULL) { 5587 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 5588 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 5589 disStr); 5590 if (value != NAME_NOT_FOUND) { 5591 //For some IS types (like EIS 2.0), when DIS value is changed, we need to restart 5592 //preview because of topology change in backend. But, for now, restart preview 5593 //for all IS types. 5594 m_bNeedRestart = true; 5595 CDBG("%s: Setting DIS value %s", __func__, disStr); 5596 updateParamEntry(KEY_QC_DIS, disStr); 5597 if (!(strcmp(disStr,"enable"))) { 5598 m_bDISEnabled = true; 5599 } else { 5600 m_bDISEnabled = false; 5601 } 5602 return AddSetParmEntryToBatch(m_pParamBuf, 5603 CAM_INTF_PARM_DIS_ENABLE, 5604 sizeof(value), 5605 &value); 5606 } 5607 } 5608 ALOGE("Invalid DIS value: %s", (disStr == NULL) ? "NULL" : disStr); 5609 m_bDISEnabled = false; 5610 return BAD_VALUE; 5611 } 5612 5613 /*=========================================================================== 5614 * FUNCTION : setHighFrameRate 5615 * 5616 * DESCRIPTION: set high frame rate 5617 * 5618 * PARAMETERS : 5619 * @hfrStr : HFR value string 5620 * 5621 * RETURN : int32_t type of status 5622 * NO_ERROR -- success 5623 * none-zero failure code 5624 *==========================================================================*/ 5625 int32_t QCameraParameters::setHighFrameRate(const char *hfrStr) 5626 { 5627 if (hfrStr != NULL) { 5628 int32_t value = lookupAttr(HFR_MODES_MAP, 5629 sizeof(HFR_MODES_MAP)/sizeof(QCameraMap), 5630 hfrStr); 5631 if (value != NAME_NOT_FOUND) { 5632 // HFR value changed, need to restart preview 5633 m_bNeedRestart = true; 5634 // Set HFR value 5635 CDBG_HIGH("%s: Setting HFR value %s", __func__, hfrStr); 5636 updateParamEntry(KEY_QC_VIDEO_HIGH_FRAME_RATE, hfrStr); 5637 return AddSetParmEntryToBatch(m_pParamBuf, 5638 CAM_INTF_PARM_HFR, 5639 sizeof(value), 5640 &value); 5641 } 5642 } 5643 ALOGE("Invalid HFR value: %s", (hfrStr == NULL) ? "NULL" : hfrStr); 5644 return BAD_VALUE; 5645 } 5646 5647 /*=========================================================================== 5648 * FUNCTION : setLensShadeValue 5649 * 5650 * DESCRIPTION: set lens shade value 5651 * 5652 * PARAMETERS : 5653 * @lensSahdeStr : lens shade value string 5654 * 5655 * RETURN : int32_t type of status 5656 * NO_ERROR -- success 5657 * none-zero failure code 5658 *==========================================================================*/ 5659 int32_t QCameraParameters::setLensShadeValue(const char *lensShadeStr) 5660 { 5661 if (lensShadeStr != NULL) { 5662 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 5663 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 5664 lensShadeStr); 5665 if (value != NAME_NOT_FOUND) { 5666 CDBG_HIGH("%s: Setting LensShade value %s", __func__, lensShadeStr); 5667 updateParamEntry(KEY_QC_LENSSHADE, lensShadeStr); 5668 return AddSetParmEntryToBatch(m_pParamBuf, 5669 CAM_INTF_PARM_ROLLOFF, 5670 sizeof(value), 5671 &value); 5672 } 5673 } 5674 ALOGE("Invalid LensShade value: %s", 5675 (lensShadeStr == NULL) ? "NULL" : lensShadeStr); 5676 return BAD_VALUE; 5677 } 5678 5679 /*=========================================================================== 5680 * FUNCTION : setExposureCompensation 5681 * 5682 * DESCRIPTION: set exposure compensation value 5683 * 5684 * PARAMETERS : 5685 * @expComp : exposure compensation value 5686 * 5687 * RETURN : int32_t type of status 5688 * NO_ERROR -- success 5689 * none-zero failure code 5690 *==========================================================================*/ 5691 int32_t QCameraParameters::setExposureCompensation(int expComp) 5692 { 5693 char val[16]; 5694 sprintf(val, "%d", expComp); 5695 updateParamEntry(KEY_EXPOSURE_COMPENSATION, val); 5696 5697 // Don't need to pass step as part of setParameter because 5698 // camera daemon is already aware of it. 5699 return AddSetParmEntryToBatch(m_pParamBuf, 5700 CAM_INTF_PARM_EXPOSURE_COMPENSATION, 5701 sizeof(expComp), 5702 &expComp); 5703 } 5704 5705 /*=========================================================================== 5706 * FUNCTION : setWhiteBalance 5707 * 5708 * DESCRIPTION: set white balance mode 5709 * 5710 * PARAMETERS : 5711 * @wbStr : white balance mode value string 5712 * 5713 * RETURN : int32_t type of status 5714 * NO_ERROR -- success 5715 * none-zero failure code 5716 *==========================================================================*/ 5717 int32_t QCameraParameters::setWhiteBalance(const char *wbStr) 5718 { 5719 if (wbStr != NULL) { 5720 int32_t value = lookupAttr(WHITE_BALANCE_MODES_MAP, 5721 sizeof(WHITE_BALANCE_MODES_MAP)/sizeof(QCameraMap), 5722 wbStr); 5723 if (value != NAME_NOT_FOUND) { 5724 CDBG_HIGH("%s: Setting WhiteBalance value %s", __func__, wbStr); 5725 updateParamEntry(KEY_WHITE_BALANCE, wbStr); 5726 return AddSetParmEntryToBatch(m_pParamBuf, 5727 CAM_INTF_PARM_WHITE_BALANCE, 5728 sizeof(value), 5729 &value); 5730 } 5731 } 5732 ALOGE("Invalid WhiteBalance value: %s", (wbStr == NULL) ? "NULL" : wbStr); 5733 return BAD_VALUE; 5734 } 5735 int QCameraParameters::getAutoFlickerMode() 5736 { 5737 /* Enable Advanced Auto Antibanding where we can set 5738 any of the following option 5739 ie. CAM_ANTIBANDING_MODE_AUTO 5740 CAM_ANTIBANDING_MODE_AUTO_50HZ 5741 CAM_ANTIBANDING_MODE_AUTO_60HZ 5742 Currently setting it to default */ 5743 char prop[PROPERTY_VALUE_MAX]; 5744 memset(prop, 0, sizeof(prop)); 5745 property_get("persist.camera.set.afd", prop, "3"); 5746 return atoi(prop); 5747 } 5748 5749 /*=========================================================================== 5750 * FUNCTION : setAntibanding 5751 * 5752 * DESCRIPTION: set antibanding value 5753 * 5754 * PARAMETERS : 5755 * @antiBandingStr : antibanding value string 5756 * 5757 * RETURN : int32_t type of status 5758 * NO_ERROR -- success 5759 * none-zero failure code 5760 *==========================================================================*/ 5761 int32_t QCameraParameters::setAntibanding(const char *antiBandingStr) 5762 { 5763 if (antiBandingStr != NULL) { 5764 int32_t value = lookupAttr(ANTIBANDING_MODES_MAP, 5765 sizeof(ANTIBANDING_MODES_MAP)/sizeof(QCameraMap), 5766 antiBandingStr); 5767 if (value != NAME_NOT_FOUND) { 5768 CDBG_HIGH("%s: Setting AntiBanding value %s", __func__, antiBandingStr); 5769 updateParamEntry(KEY_ANTIBANDING, antiBandingStr); 5770 if(value == CAM_ANTIBANDING_MODE_AUTO) { 5771 value = getAutoFlickerMode(); 5772 } 5773 return AddSetParmEntryToBatch(m_pParamBuf, 5774 CAM_INTF_PARM_ANTIBANDING, 5775 sizeof(value), 5776 &value); 5777 } 5778 } 5779 ALOGE("Invalid AntiBanding value: %s", 5780 (antiBandingStr == NULL) ? "NULL" : antiBandingStr); 5781 return BAD_VALUE; 5782 } 5783 5784 /*=========================================================================== 5785 * FUNCTION : setFocusAreas 5786 * 5787 * DESCRIPTION: set focus areas 5788 * 5789 * PARAMETERS : 5790 * @focusAreasStr : focus areas value string 5791 * 5792 * RETURN : int32_t type of status 5793 * NO_ERROR -- success 5794 * none-zero failure code 5795 *==========================================================================*/ 5796 int32_t QCameraParameters::setFocusAreas(const char *focusAreasStr) 5797 { 5798 if (m_pCapability->max_num_focus_areas == 0 || 5799 focusAreasStr == NULL) { 5800 CDBG("%s: Parameter string is null", __func__); 5801 return NO_ERROR; 5802 } 5803 5804 cam_area_t *areas = (cam_area_t *)malloc(sizeof(cam_area_t) * m_pCapability->max_num_focus_areas); 5805 if (NULL == areas) { 5806 ALOGE("%s: No memory for areas", __func__); 5807 return NO_MEMORY; 5808 } 5809 memset(areas, 0, sizeof(cam_area_t) * m_pCapability->max_num_focus_areas); 5810 int num_areas_found = 0; 5811 if (parseCameraAreaString(focusAreasStr, 5812 m_pCapability->max_num_focus_areas, 5813 areas, 5814 num_areas_found) != NO_ERROR) { 5815 ALOGE("%s: Failed to parse the string: %s", __func__, focusAreasStr); 5816 free(areas); 5817 return BAD_VALUE; 5818 } 5819 5820 if (validateCameraAreas(areas, num_areas_found) == false) { 5821 ALOGE("%s: invalid areas specified : %s", __func__, focusAreasStr); 5822 free(areas); 5823 return BAD_VALUE; 5824 } 5825 5826 updateParamEntry(KEY_FOCUS_AREAS, focusAreasStr); 5827 5828 //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0, 5829 //so no action is takenby the lower layer 5830 if (num_areas_found == 1 && 5831 areas[0].rect.left == 0 && 5832 areas[0].rect.top == 0 && 5833 areas[0].rect.width == 0 && 5834 areas[0].rect.height == 0 && 5835 areas[0].weight == 0) { 5836 num_areas_found = 0; 5837 } 5838 5839 int previewWidth, previewHeight; 5840 getPreviewSize(&previewWidth, &previewHeight); 5841 cam_roi_info_t af_roi_value; 5842 memset(&af_roi_value, 0, sizeof(cam_roi_info_t)); 5843 af_roi_value.num_roi = num_areas_found; 5844 for (int i = 0; i < num_areas_found; i++) { 5845 CDBG_HIGH("%s: FocusArea[%d] = (%d, %d, %d, %d)", 5846 __func__, i, (areas[i].rect.top), (areas[i].rect.left), 5847 (areas[i].rect.width), (areas[i].rect.height)); 5848 5849 //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) 5850 af_roi_value.roi[i].left = (int32_t)((areas[i].rect.left + 1000.0f) * (previewWidth / 2000.0f)); 5851 af_roi_value.roi[i].top = (int32_t)((areas[i].rect.top + 1000.0f) * (previewHeight / 2000.0f)); 5852 af_roi_value.roi[i].width = (int32_t)(areas[i].rect.width * previewWidth / 2000.0f); 5853 af_roi_value.roi[i].height = (int32_t)(areas[i].rect.height * previewHeight / 2000.0f); 5854 af_roi_value.weight[i] = areas[i].weight; 5855 } 5856 free(areas); 5857 return AddSetParmEntryToBatch(m_pParamBuf, 5858 CAM_INTF_PARM_AF_ROI, 5859 sizeof(af_roi_value), 5860 &af_roi_value); 5861 } 5862 5863 /*=========================================================================== 5864 * FUNCTION : setMeteringAreas 5865 * 5866 * DESCRIPTION: set metering areas value 5867 * 5868 * PARAMETERS : 5869 * @meteringAreasStr : metering areas value string 5870 * 5871 * RETURN : int32_t type of status 5872 * NO_ERROR -- success 5873 * none-zero failure code 5874 *==========================================================================*/ 5875 int32_t QCameraParameters::setMeteringAreas(const char *meteringAreasStr) 5876 { 5877 if (m_pCapability->max_num_metering_areas == 0 || 5878 meteringAreasStr == NULL) { 5879 CDBG("%s: Parameter string is null", __func__); 5880 return NO_ERROR; 5881 } 5882 5883 cam_area_t *areas = (cam_area_t *)malloc(sizeof(cam_area_t) * m_pCapability->max_num_metering_areas); 5884 if (NULL == areas) { 5885 ALOGE("%s: No memory for areas", __func__); 5886 return NO_MEMORY; 5887 } 5888 memset(areas, 0, sizeof(cam_area_t) * m_pCapability->max_num_metering_areas); 5889 int num_areas_found = 0; 5890 if (parseCameraAreaString(meteringAreasStr, 5891 m_pCapability->max_num_metering_areas, 5892 areas, 5893 num_areas_found) < 0) { 5894 ALOGE("%s: Failed to parse the string: %s", __func__, meteringAreasStr); 5895 free(areas); 5896 return BAD_VALUE; 5897 } 5898 5899 if (validateCameraAreas(areas, num_areas_found) == false) { 5900 ALOGE("%s: invalid areas specified : %s", __func__, meteringAreasStr); 5901 free(areas); 5902 return BAD_VALUE; 5903 } 5904 5905 updateParamEntry(KEY_METERING_AREAS, meteringAreasStr); 5906 5907 //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0, 5908 //so no action is takenby the lower layer 5909 if (num_areas_found == 1 && 5910 areas[0].rect.left == 0 && 5911 areas[0].rect.top == 0 && 5912 areas[0].rect.width == 0 && 5913 areas[0].rect.height == 0 && 5914 areas[0].weight == 0) { 5915 num_areas_found = 0; 5916 } 5917 cam_set_aec_roi_t aec_roi_value; 5918 int previewWidth, previewHeight; 5919 getPreviewSize(&previewWidth, &previewHeight); 5920 5921 memset(&aec_roi_value, 0, sizeof(cam_set_aec_roi_t)); 5922 if (num_areas_found > 0) { 5923 aec_roi_value.aec_roi_enable = CAM_AEC_ROI_ON; 5924 aec_roi_value.aec_roi_type = CAM_AEC_ROI_BY_COORDINATE; 5925 5926 for (int i = 0; i < num_areas_found; i++) { 5927 CDBG_HIGH("%s: MeteringArea[%d] = (%d, %d, %d, %d)", 5928 __func__, i, (areas[i].rect.top), (areas[i].rect.left), 5929 (areas[i].rect.width), (areas[i].rect.height)); 5930 5931 //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) 5932 aec_roi_value.cam_aec_roi_position.coordinate[i].x = 5933 (uint32_t)(((areas[i].rect.left + areas[i].rect.width / 2) + 1000.0f) * previewWidth / 2000.0f) ; 5934 aec_roi_value.cam_aec_roi_position.coordinate[i].y = 5935 (uint32_t)(((areas[i].rect.top + areas[i].rect.height / 2) + 1000.0f) * previewHeight / 2000.0f) ; 5936 } 5937 } else { 5938 aec_roi_value.aec_roi_enable = CAM_AEC_ROI_OFF; 5939 } 5940 free(areas); 5941 return AddSetParmEntryToBatch(m_pParamBuf, 5942 CAM_INTF_PARM_AEC_ROI, 5943 sizeof(aec_roi_value), 5944 &aec_roi_value); 5945 } 5946 5947 /*=========================================================================== 5948 * FUNCTION : setSceneMode 5949 * 5950 * DESCRIPTION: set scene mode 5951 * 5952 * PARAMETERS : 5953 * @sceneModeStr : scene mode value string 5954 * 5955 * RETURN : int32_t type of status 5956 * NO_ERROR -- success 5957 * none-zero failure code 5958 *==========================================================================*/ 5959 int32_t QCameraParameters::setSceneMode(const char *sceneModeStr) 5960 { 5961 if (sceneModeStr != NULL) { 5962 int32_t value = lookupAttr(SCENE_MODES_MAP, 5963 sizeof(SCENE_MODES_MAP)/sizeof(QCameraMap), 5964 sceneModeStr); 5965 if (value != NAME_NOT_FOUND) { 5966 CDBG("%s: Setting SceneMode %s", __func__, sceneModeStr); 5967 updateParamEntry(KEY_SCENE_MODE, sceneModeStr); 5968 if (m_bSensorHDREnabled) { 5969 // Incase of HW HDR mode, we do not update the same as Best shot mode. 5970 CDBG_HIGH("%s: H/W HDR mode enabled. Do not set Best Shot Mode", __func__); 5971 return NO_ERROR; 5972 } 5973 if (m_bSceneSelection) { 5974 setSelectedScene((cam_scene_mode_type) value); 5975 } 5976 int32_t rc = AddSetParmEntryToBatch(m_pParamBuf, 5977 CAM_INTF_PARM_BESTSHOT_MODE, 5978 sizeof(value), 5979 &value); 5980 return rc; 5981 } 5982 } 5983 ALOGE("%s: Invalid Secene Mode: %s", 5984 __func__, (sceneModeStr == NULL) ? "NULL" : sceneModeStr); 5985 return BAD_VALUE; 5986 } 5987 5988 /*=========================================================================== 5989 * FUNCTION : setSelectableZoneAf 5990 * 5991 * DESCRIPTION: set selectable zone AF algorithm 5992 * 5993 * PARAMETERS : 5994 * @selZoneAFStr : selectable zone AF algorithm value string 5995 * 5996 * RETURN : int32_t type of status 5997 * NO_ERROR -- success 5998 * none-zero failure code 5999 *==========================================================================*/ 6000 int32_t QCameraParameters::setSelectableZoneAf(const char *selZoneAFStr) 6001 { 6002 if (selZoneAFStr != NULL) { 6003 int32_t value = lookupAttr(FOCUS_ALGO_MAP, 6004 sizeof(FOCUS_ALGO_MAP)/sizeof(QCameraMap), 6005 selZoneAFStr); 6006 if (value != NAME_NOT_FOUND) { 6007 CDBG("%s: Setting Selectable Zone AF value %s", __func__, selZoneAFStr); 6008 updateParamEntry(KEY_QC_SELECTABLE_ZONE_AF, selZoneAFStr); 6009 return AddSetParmEntryToBatch(m_pParamBuf, 6010 CAM_INTF_PARM_FOCUS_ALGO_TYPE, 6011 sizeof(value), 6012 &value); 6013 } 6014 } 6015 ALOGE("%s: Invalid selectable zone af value: %s", 6016 __func__, (selZoneAFStr == NULL) ? "NULL" : selZoneAFStr); 6017 return BAD_VALUE; 6018 } 6019 6020 /*=========================================================================== 6021 * FUNCTION : isAEBracketEnabled 6022 * 6023 * DESCRIPTION: checks if AE bracketing is enabled 6024 * 6025 * PARAMETERS : 6026 * 6027 * RETURN : TRUE/FALSE 6028 *==========================================================================*/ 6029 bool QCameraParameters::isAEBracketEnabled() 6030 { 6031 const char *str = get(KEY_QC_AE_BRACKET_HDR); 6032 if (str != NULL) { 6033 if (strcmp(str, AE_BRACKET_OFF) != 0) { 6034 return true; 6035 } 6036 } 6037 return false; 6038 } 6039 6040 /*=========================================================================== 6041 * FUNCTION : setAEBracket 6042 * 6043 * DESCRIPTION: set AE bracket value 6044 * 6045 * PARAMETERS : 6046 * @aecBracketStr : AE bracket value string 6047 * 6048 * RETURN : int32_t type of status 6049 * NO_ERROR -- success 6050 * none-zero failure code 6051 *==========================================================================*/ 6052 int32_t QCameraParameters::setAEBracket(const char *aecBracketStr) 6053 { 6054 if (aecBracketStr == NULL) { 6055 CDBG("%s: setAEBracket with NULL value", __func__); 6056 return NO_ERROR; 6057 } 6058 6059 cam_exp_bracketing_t expBracket; 6060 memset(&expBracket, 0, sizeof(expBracket)); 6061 6062 int value = lookupAttr(BRACKETING_MODES_MAP, 6063 sizeof(BRACKETING_MODES_MAP)/sizeof(QCameraMap), 6064 aecBracketStr); 6065 switch (value) { 6066 case CAM_EXP_BRACKETING_ON: 6067 { 6068 CDBG("%s, EXP_BRACKETING_ON", __func__); 6069 const char *str_val = get(KEY_QC_CAPTURE_BURST_EXPOSURE); 6070 if ((str_val != NULL) && (strlen(str_val)>0)) { 6071 expBracket.mode = CAM_EXP_BRACKETING_ON; 6072 m_bAeBracketingEnabled = true; 6073 strlcpy(expBracket.values, str_val, MAX_EXP_BRACKETING_LENGTH); 6074 CDBG("%s: setting Exposure Bracketing value of %s", 6075 __func__, expBracket.values); 6076 } 6077 else { 6078 /* Apps not set capture-burst-exposures, error case fall into bracketing off mode */ 6079 CDBG("%s: capture-burst-exposures not set, back to HDR OFF mode", __func__); 6080 m_bAeBracketingEnabled = false; 6081 expBracket.mode = CAM_EXP_BRACKETING_OFF; 6082 } 6083 } 6084 break; 6085 default: 6086 { 6087 m_bAeBracketingEnabled = false; 6088 CDBG_HIGH("%s, EXP_BRACKETING_OFF", __func__); 6089 expBracket.mode = CAM_EXP_BRACKETING_OFF; 6090 } 6091 break; 6092 } 6093 6094 // Cache client AE bracketing configuration 6095 memcpy(&m_AEBracketingClient, &expBracket, sizeof(cam_exp_bracketing_t)); 6096 6097 /* save the value*/ 6098 updateParamEntry(KEY_QC_AE_BRACKET_HDR, aecBracketStr); 6099 return NO_ERROR; 6100 } 6101 6102 /*=========================================================================== 6103 * FUNCTION : set3ALock 6104 * 6105 * DESCRIPTION: enable/disable 3A lock. 6106 * 6107 * PARAMETERS : 6108 * @lockStr : lock value string. 6109 * 6110 * RETURN : int32_t type of status 6111 * NO_ERROR -- success 6112 * none-zero failure code 6113 *==========================================================================*/ 6114 int32_t QCameraParameters::set3ALock(const char *lockStr) 6115 { 6116 int32_t rc = NO_ERROR; 6117 if (lockStr != NULL) { 6118 int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP, 6119 sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap), 6120 lockStr); 6121 if (value != NAME_NOT_FOUND) { 6122 CDBG_HIGH("%s: Setting Lock lockStr =%s", __func__, lockStr); 6123 if(initBatchUpdate(m_pParamBuf) < 0 ) { 6124 ALOGE("%s:Failed to initialize group update table", __func__); 6125 return BAD_TYPE; 6126 } 6127 int32_t focus_mode; 6128 if (value == 1) { 6129 if (isUbiFocusEnabled()) { 6130 //For Ubi focus move focus to infinity. 6131 focus_mode = CAM_FOCUS_MODE_INFINITY; 6132 } else if (isOptiZoomEnabled()){ 6133 //For optizoom set focus as fixed. 6134 focus_mode = CAM_FOCUS_MODE_FIXED; 6135 } 6136 } else { 6137 // retrieve previous focus value. 6138 const char *focus = get(KEY_FOCUS_MODE); 6139 focus_mode = lookupAttr(FOCUS_MODES_MAP, 6140 sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap), 6141 focus); 6142 CDBG("%s: focus mode %s", __func__, focus); 6143 } 6144 //Lock AWB 6145 rc = AddSetParmEntryToBatch(m_pParamBuf, 6146 CAM_INTF_PARM_AWB_LOCK, 6147 sizeof(value), 6148 &value); 6149 if (NO_ERROR != rc) { 6150 return rc; 6151 } 6152 //Lock AEC 6153 rc = AddSetParmEntryToBatch(m_pParamBuf, 6154 CAM_INTF_PARM_AEC_LOCK, 6155 sizeof(value), 6156 &value); 6157 if (NO_ERROR != rc) { 6158 return rc; 6159 } 6160 rc = AddSetParmEntryToBatch(m_pParamBuf, 6161 CAM_INTF_PARM_FOCUS_MODE, 6162 sizeof(focus_mode), 6163 &focus_mode); 6164 if (NO_ERROR != rc) { 6165 return rc; 6166 } 6167 6168 rc = commitSetBatch(); 6169 if (rc != NO_ERROR) { 6170 ALOGE("%s:Failed to commit batch", __func__); 6171 } 6172 } 6173 } 6174 return rc; 6175 } 6176 6177 /*=========================================================================== 6178 * FUNCTION : setAndCommitZoom 6179 * 6180 * DESCRIPTION: set zoom. 6181 * 6182 * PARAMETERS : 6183 * @zoom_level : zoom level to set. 6184 * 6185 * RETURN : int32_t type of status 6186 * NO_ERROR -- success 6187 * none-zero failure code 6188 *==========================================================================*/ 6189 int32_t QCameraParameters::setAndCommitZoom(int zoom_level) 6190 { 6191 CDBG_HIGH("%s: E",__func__); 6192 int32_t rc = NO_ERROR; 6193 if(initBatchUpdate(m_pParamBuf) < 0 ) { 6194 ALOGE("%s:Failed to initialize group update table", __func__); 6195 return BAD_TYPE; 6196 } 6197 rc = AddSetParmEntryToBatch(m_pParamBuf, 6198 CAM_INTF_PARM_ZOOM, 6199 sizeof(zoom_level), 6200 &zoom_level); 6201 6202 if (rc != NO_ERROR) { 6203 ALOGE("%s:Failed to update table", __func__); 6204 return rc; 6205 } 6206 rc = commitSetBatch(); 6207 if (rc != NO_ERROR) { 6208 ALOGE("%s:Failed to set Flash value", __func__); 6209 } 6210 CDBG_HIGH("%s: X",__func__); 6211 return rc; 6212 } 6213 6214 /*=========================================================================== 6215 * FUNCTION : isOptiZoomEnabled 6216 * 6217 * DESCRIPTION: checks whether optizoom is enabled 6218 * 6219 * PARAMETERS : 6220 * 6221 * RETURN : true - enabled, false - disabled 6222 * 6223 *==========================================================================*/ 6224 bool QCameraParameters::isOptiZoomEnabled() 6225 { 6226 if (m_bOptiZoomOn) { 6227 uint8_t zoom_level = (uint8_t) getInt(CameraParameters::KEY_ZOOM); 6228 cam_opti_zoom_t *opti_zoom_settings_need = 6229 &(m_pCapability->opti_zoom_settings_need); 6230 uint8_t zoom_threshold = opti_zoom_settings_need->zoom_threshold; 6231 CDBG_HIGH("%s: current zoom level =%d & zoom_threshold =%d", 6232 __func__, zoom_level, zoom_threshold); 6233 6234 if (zoom_level >= zoom_threshold) { 6235 return true; 6236 } 6237 } 6238 6239 return false; 6240 } 6241 6242 /*=========================================================================== 6243 * FUNCTION : commitAFBracket 6244 * 6245 * DESCRIPTION: commit AF Bracket. 6246 * 6247 * PARAMETERS : 6248 * @AFBracket : AF bracketing configuration 6249 * 6250 * RETURN : int32_t type of status 6251 * NO_ERROR -- success 6252 * none-zero failure code 6253 *==========================================================================*/ 6254 int32_t QCameraParameters::commitAFBracket(cam_af_bracketing_t afBracket) 6255 { 6256 6257 int32_t rc = NO_ERROR; 6258 if(initBatchUpdate(m_pParamBuf) < 0 ) { 6259 ALOGE("%s:Failed to initialize group update table", __func__); 6260 return BAD_TYPE; 6261 } 6262 6263 rc = AddSetParmEntryToBatch(m_pParamBuf, 6264 CAM_INTF_PARM_FOCUS_BRACKETING, 6265 sizeof(afBracket), 6266 &afBracket); 6267 if (rc != NO_ERROR) { 6268 ALOGE("%s:Failed to update table", __func__); 6269 return rc; 6270 } 6271 6272 rc = commitSetBatch(); 6273 if (rc != NO_ERROR) { 6274 ALOGE("%s:Failed to commit batch", __func__); 6275 } 6276 6277 return rc; 6278 } 6279 6280 /*=========================================================================== 6281 * FUNCTION : commitFlashBracket 6282 * 6283 * DESCRIPTION: commit Flash Bracket. 6284 * 6285 * PARAMETERS : 6286 * @AFBracket : Flash bracketing configuration 6287 * 6288 * RETURN : int32_t type of status 6289 * NO_ERROR -- success 6290 * none-zero failure code 6291 *==========================================================================*/ 6292 int32_t QCameraParameters::commitFlashBracket( 6293 cam_flash_bracketing_t flashBracket) 6294 { 6295 CDBG_HIGH("%s: E",__func__); 6296 int32_t rc = NO_ERROR; 6297 if(initBatchUpdate(m_pParamBuf) < 0 ) { 6298 ALOGE("%s:Failed to initialize group update table", __func__); 6299 return BAD_TYPE; 6300 } 6301 6302 rc = AddSetParmEntryToBatch(m_pParamBuf, 6303 CAM_INTF_PARM_FLASH_BRACKETING, 6304 sizeof(flashBracket), 6305 &flashBracket); 6306 if (rc != NO_ERROR) { 6307 ALOGE("%s:Failed to update table", __func__); 6308 return rc; 6309 } 6310 6311 rc = commitSetBatch(); 6312 if (rc != NO_ERROR) { 6313 ALOGE("%s:Failed to commit batch", __func__); 6314 } 6315 6316 CDBG_HIGH("%s: X",__func__); 6317 return rc; 6318 } 6319 6320 /*=========================================================================== 6321 * FUNCTION : setAFBracket 6322 * 6323 * DESCRIPTION: set AF bracket value 6324 * 6325 * PARAMETERS : 6326 * @afBracketStr : AF bracket value string 6327 * 6328 * RETURN : int32_t type of status 6329 * NO_ERROR -- success 6330 * none-zero failure code 6331 *==========================================================================*/ 6332 int32_t QCameraParameters::setAFBracket(const char *afBracketStr) 6333 { 6334 CDBG_HIGH("%s: afBracketStr =%s",__func__,afBracketStr); 6335 6336 if(afBracketStr != NULL) { 6337 int value = lookupAttr(AF_BRACKETING_MODES_MAP, 6338 sizeof(AF_BRACKETING_MODES_MAP)/ 6339 sizeof(QCameraMap), 6340 afBracketStr); 6341 if (value != NAME_NOT_FOUND) { 6342 m_bAFBracketingOn = (value != 0); 6343 updateParamEntry(KEY_QC_AF_BRACKET, afBracketStr); 6344 6345 return NO_ERROR; 6346 } 6347 } 6348 6349 ALOGE("Invalid af bracket value: %s", 6350 (afBracketStr == NULL) ? "NULL" : afBracketStr); 6351 return BAD_VALUE; 6352 } 6353 6354 /*=========================================================================== 6355 * FUNCTION : setChromaFlash 6356 * 6357 * DESCRIPTION: set chroma flash value 6358 * 6359 * PARAMETERS : 6360 * @aecBracketStr : chroma flash value string 6361 * 6362 * RETURN : int32_t type of status 6363 * NO_ERROR -- success 6364 * none-zero failure code 6365 *==========================================================================*/ 6366 int32_t QCameraParameters::setChromaFlash(const char *chromaFlashStr) 6367 { 6368 CDBG_HIGH("%s: chromaFlashStr =%s",__func__,chromaFlashStr); 6369 if(chromaFlashStr != NULL) { 6370 int value = lookupAttr(CHROMA_FLASH_MODES_MAP, 6371 sizeof(CHROMA_FLASH_MODES_MAP)/sizeof(QCameraMap), 6372 chromaFlashStr); 6373 if(value != NAME_NOT_FOUND) { 6374 m_bChromaFlashOn = (value != 0); 6375 updateParamEntry(KEY_QC_CHROMA_FLASH, chromaFlashStr); 6376 6377 return NO_ERROR; 6378 } 6379 } 6380 6381 ALOGE("Invalid chroma flash value: %s", 6382 (chromaFlashStr == NULL) ? "NULL" : chromaFlashStr); 6383 return BAD_VALUE; 6384 } 6385 6386 /*=========================================================================== 6387 * FUNCTION : setOptiZoom 6388 * 6389 * DESCRIPTION: set opti zoom value 6390 * 6391 * PARAMETERS : 6392 * @aecBracketStr : opti zoom value string 6393 * 6394 * RETURN : int32_t type of status 6395 * NO_ERROR -- success 6396 * none-zero failure code 6397 *==========================================================================*/ 6398 int32_t QCameraParameters::setOptiZoom(const char *optiZoomStr) 6399 { 6400 CDBG_HIGH("%s: optiZoomStr =%s",__func__,optiZoomStr); 6401 if(optiZoomStr != NULL) { 6402 int value = lookupAttr(OPTI_ZOOM_MODES_MAP, 6403 sizeof(OPTI_ZOOM_MODES_MAP)/sizeof(QCameraMap), 6404 optiZoomStr); 6405 if(value != NAME_NOT_FOUND) { 6406 m_bOptiZoomOn = (value != 0); 6407 updateParamEntry(KEY_QC_OPTI_ZOOM, optiZoomStr); 6408 6409 return NO_ERROR; 6410 } 6411 } 6412 ALOGE("Invalid opti zoom value: %s", 6413 (optiZoomStr == NULL) ? "NULL" : optiZoomStr); 6414 return BAD_VALUE; 6415 } 6416 6417 /*=========================================================================== 6418 * FUNCTION : setAEBracketing 6419 * 6420 * DESCRIPTION: enables AE bracketing 6421 * 6422 * PARAMETERS : 6423 * 6424 * RETURN : int32_t type of status 6425 * NO_ERROR -- success 6426 * none-zero failure code 6427 *==========================================================================*/ 6428 int32_t QCameraParameters::setAEBracketing() 6429 { 6430 int32_t rc = NO_ERROR; 6431 if(initBatchUpdate(m_pParamBuf) < 0 ) { 6432 ALOGE("%s:Failed to initialize group update table", __func__); 6433 return BAD_TYPE; 6434 } 6435 6436 rc = AddSetParmEntryToBatch(m_pParamBuf, 6437 CAM_INTF_PARM_HDR, 6438 sizeof(m_AEBracketingClient), 6439 &m_AEBracketingClient); 6440 if (rc != NO_ERROR) { 6441 ALOGE("%s:Failed to update AE bracketing", __func__); 6442 return rc; 6443 } 6444 6445 rc = commitSetBatch(); 6446 if (rc != NO_ERROR) { 6447 ALOGE("%s:Failed to configure AE bracketing", __func__); 6448 return rc; 6449 } 6450 6451 return rc; 6452 } 6453 6454 /*=========================================================================== 6455 * FUNCTION : setHDRAEBracket 6456 * 6457 * DESCRIPTION: enables AE bracketing for HDR 6458 * 6459 * PARAMETERS : 6460 * @hdrBracket : HDR bracketing configuration 6461 * 6462 * RETURN : int32_t type of status 6463 * NO_ERROR -- success 6464 * none-zero failure code 6465 *==========================================================================*/ 6466 int32_t QCameraParameters::setHDRAEBracket(cam_exp_bracketing_t hdrBracket) 6467 { 6468 int32_t rc = NO_ERROR; 6469 if(initBatchUpdate(m_pParamBuf) < 0 ) { 6470 ALOGE("%s:Failed to initialize group update table", __func__); 6471 return BAD_TYPE; 6472 } 6473 6474 rc = AddSetParmEntryToBatch(m_pParamBuf, 6475 CAM_INTF_PARM_HDR, 6476 sizeof(hdrBracket), 6477 &hdrBracket); 6478 if (rc != NO_ERROR) { 6479 ALOGE("%s:Failed to update table", __func__); 6480 return rc; 6481 } 6482 6483 rc = commitSetBatch(); 6484 if (rc != NO_ERROR) { 6485 ALOGE("%s:Failed to configure HDR bracketing", __func__); 6486 return rc; 6487 } 6488 6489 return rc; 6490 } 6491 6492 /*=========================================================================== 6493 * FUNCTION : restoreAEBracket 6494 * 6495 * DESCRIPTION: restores client AE bracketing configuration after HDR is done 6496 * 6497 * PARAMETERS : 6498 * 6499 * RETURN : int32_t type of status 6500 * NO_ERROR -- success 6501 * none-zero failure code 6502 *==========================================================================*/ 6503 int32_t QCameraParameters::stopAEBracket() 6504 { 6505 cam_exp_bracketing_t bracketing; 6506 6507 bracketing.mode = CAM_EXP_BRACKETING_OFF; 6508 6509 return setHDRAEBracket(bracketing); 6510 } 6511 6512 /*=========================================================================== 6513 * FUNCTION : updateFlash 6514 * 6515 * DESCRIPTION: restores client flash configuration or disables flash 6516 * 6517 * PARAMETERS : 6518 * @commitSettings : flag indicating whether settings need to be commited 6519 * 6520 * RETURN : int32_t type of status 6521 * NO_ERROR -- success 6522 * none-zero failure code 6523 *==========================================================================*/ 6524 int32_t QCameraParameters::updateFlash(bool commitSettings) 6525 { 6526 int32_t rc = NO_ERROR; 6527 int32_t value; 6528 6529 if (commitSettings) { 6530 if(initBatchUpdate(m_pParamBuf) < 0 ) { 6531 ALOGE("%s:Failed to initialize group update table", __func__); 6532 return BAD_TYPE; 6533 } 6534 } 6535 6536 if (isHDREnabled() || m_bAeBracketingEnabled || m_bAFBracketingOn || 6537 m_bOptiZoomOn) { 6538 value = CAM_FLASH_MODE_OFF; 6539 } else if (m_bChromaFlashOn) { 6540 value = CAM_FLASH_MODE_ON; 6541 } else { 6542 value = mFlashValue; 6543 } 6544 6545 if (value != mFlashDaemonValue) { 6546 CDBG("%s: Setting Flash value %d", __func__, value); 6547 rc = AddSetParmEntryToBatch(m_pParamBuf, 6548 CAM_INTF_PARM_LED_MODE, 6549 sizeof(value), 6550 &value); 6551 if (rc != NO_ERROR) { 6552 rc = BAD_VALUE; 6553 ALOGE("%s:Failed to set led mode", __func__); 6554 return rc; 6555 } 6556 6557 mFlashDaemonValue = value; 6558 } else { 6559 rc = NO_ERROR; 6560 } 6561 6562 if (commitSettings) { 6563 rc = commitSetBatch(); 6564 if (rc != NO_ERROR) { 6565 ALOGE("%s:Failed to configure HDR bracketing", __func__); 6566 return rc; 6567 } 6568 } 6569 6570 return rc; 6571 } 6572 6573 /*=========================================================================== 6574 * FUNCTION : setRedeyeReduction 6575 * 6576 * DESCRIPTION: set red eye reduction value 6577 * 6578 * PARAMETERS : 6579 * @redeyeStr : red eye reduction value string 6580 * 6581 * RETURN : int32_t type of status 6582 * NO_ERROR -- success 6583 * none-zero failure code 6584 *==========================================================================*/ 6585 int32_t QCameraParameters::setRedeyeReduction(const char *redeyeStr) 6586 { 6587 if (redeyeStr != NULL) { 6588 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 6589 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 6590 redeyeStr); 6591 if (value != NAME_NOT_FOUND) { 6592 CDBG("%s: Setting RedEye Reduce value %s", __func__, redeyeStr); 6593 updateParamEntry(KEY_QC_REDEYE_REDUCTION, redeyeStr); 6594 return AddSetParmEntryToBatch(m_pParamBuf, 6595 CAM_INTF_PARM_REDEYE_REDUCTION, 6596 sizeof(value), 6597 &value); 6598 } 6599 } 6600 ALOGE("%s: Invalid RedEye Reduce value: %s", 6601 __func__, (redeyeStr == NULL) ? "NULL" : redeyeStr); 6602 return BAD_VALUE; 6603 } 6604 6605 /*=========================================================================== 6606 * FUNCTION : getWaveletDenoiseProcessPlate 6607 * 6608 * DESCRIPTION: query wavelet denoise process plate 6609 * 6610 * PARAMETERS : None 6611 * 6612 * RETURN : WNR prcocess plate vlaue 6613 *==========================================================================*/ 6614 cam_denoise_process_type_t QCameraParameters::getWaveletDenoiseProcessPlate() 6615 { 6616 char prop[PROPERTY_VALUE_MAX]; 6617 memset(prop, 0, sizeof(prop)); 6618 cam_denoise_process_type_t processPlate = CAM_WAVELET_DENOISE_CBCR_ONLY; 6619 property_get("persist.denoise.process.plates", prop, ""); 6620 if (strlen(prop) > 0) { 6621 switch(atoi(prop)) { 6622 case 0: 6623 processPlate = CAM_WAVELET_DENOISE_YCBCR_PLANE; 6624 break; 6625 case 1: 6626 processPlate = CAM_WAVELET_DENOISE_CBCR_ONLY; 6627 break; 6628 case 2: 6629 processPlate = CAM_WAVELET_DENOISE_STREAMLINE_YCBCR; 6630 break; 6631 case 3: 6632 processPlate = CAM_WAVELET_DENOISE_STREAMLINED_CBCR; 6633 break; 6634 default: 6635 processPlate = CAM_WAVELET_DENOISE_CBCR_ONLY; 6636 break; 6637 } 6638 } 6639 return processPlate; 6640 } 6641 6642 /*=========================================================================== 6643 * FUNCTION : setWaveletDenoise 6644 * 6645 * DESCRIPTION: set wavelet denoise value 6646 * 6647 * PARAMETERS : 6648 * @wnrStr : wavelet denoise value string 6649 * 6650 * RETURN : int32_t type of status 6651 * NO_ERROR -- success 6652 * none-zero failure code 6653 *==========================================================================*/ 6654 int32_t QCameraParameters::setWaveletDenoise(const char *wnrStr) 6655 { 6656 if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_DENOISE2D) == 0){ 6657 CDBG_HIGH("%s: WNR is not supported",__func__); 6658 return NO_ERROR; 6659 } 6660 6661 if (wnrStr != NULL) { 6662 int value = lookupAttr(DENOISE_ON_OFF_MODES_MAP, 6663 sizeof(DENOISE_ON_OFF_MODES_MAP)/sizeof(QCameraMap), 6664 wnrStr); 6665 if (value != NAME_NOT_FOUND) { 6666 updateParamEntry(KEY_QC_DENOISE, wnrStr); 6667 6668 cam_denoise_param_t temp; 6669 memset(&temp, 0, sizeof(temp)); 6670 temp.denoise_enable = value; 6671 m_bWNROn = (value != 0); 6672 if (m_bWNROn) { 6673 temp.process_plates = getWaveletDenoiseProcessPlate(); 6674 } 6675 CDBG("%s: Denoise enable=%d, plates=%d", 6676 __func__, temp.denoise_enable, temp.process_plates); 6677 return AddSetParmEntryToBatch(m_pParamBuf, 6678 CAM_INTF_PARM_WAVELET_DENOISE, 6679 sizeof(temp), 6680 &temp); 6681 } 6682 } 6683 ALOGE("%s: Invalid Denoise value: %s", __func__, (wnrStr == NULL) ? "NULL" : wnrStr); 6684 return BAD_VALUE; 6685 } 6686 6687 /*=========================================================================== 6688 * FUNCTION : setRdiMode 6689 * 6690 * DESCRIPTION: set rdi mode value 6691 * 6692 * PARAMETERS : 6693 * @str : rdi mode value string 6694 * 6695 * RETURN : int32_t type of status 6696 * NO_ERROR -- success 6697 * none-zero failure code 6698 *==========================================================================*/ 6699 int32_t QCameraParameters::setRdiMode(const char *str) 6700 { 6701 CDBG("RDI_DEBUG %s: rdi mode value: %s", __func__, str); 6702 6703 if (str != NULL) { 6704 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 6705 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 6706 str); 6707 if (value != NAME_NOT_FOUND) { 6708 updateParamEntry(KEY_QC_RDI_MODE, str); 6709 m_bRdiMode = (value == 0)? false : true; 6710 return AddSetParmEntryToBatch(m_pParamBuf, 6711 CAM_INTF_PARM_RDI_MODE, 6712 sizeof(value), 6713 &value); 6714 } 6715 } 6716 ALOGE("%s: Invalid rdi mode value: %s", 6717 __func__, (str == NULL) ? "NULL" : str); 6718 return BAD_VALUE; 6719 } 6720 6721 6722 /*=========================================================================== 6723 * FUNCTION : setSecureMode 6724 * 6725 * DESCRIPTION: set secure mode value 6726 * 6727 * PARAMETERS : 6728 * @str : secure mode value string 6729 * 6730 * RETURN : int32_t type of status 6731 * NO_ERROR -- success 6732 * none-zero failure code 6733 *==========================================================================*/ 6734 int32_t QCameraParameters::setSecureMode(const char *str) 6735 { 6736 ALOGD("%s: Secure mode value: %s", __func__, str); 6737 6738 if (str != NULL) { 6739 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 6740 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 6741 str); 6742 if (value != NAME_NOT_FOUND) { 6743 updateParamEntry(KEY_QC_SECURE_MODE, str); 6744 m_bSecureMode = (value == 0)? false : true; 6745 return NO_ERROR; 6746 } 6747 } 6748 ALOGE("%s: Invalid Secure mode value: %s", 6749 __func__, (str == NULL) ? "NULL" : str); 6750 return BAD_VALUE; 6751 } 6752 6753 /*=========================================================================== 6754 * FUNCTION : setPreviewFrameRateMode 6755 * 6756 * DESCRIPTION: set preview frame rate mode 6757 * 6758 * PARAMETERS : 6759 * @mode : preview frame rate mode 6760 * 6761 * RETURN : none 6762 *==========================================================================*/ 6763 void QCameraParameters::setPreviewFrameRateMode(const char *mode) 6764 { 6765 set(KEY_QC_PREVIEW_FRAME_RATE_MODE, mode); 6766 } 6767 6768 /*=========================================================================== 6769 * FUNCTION : getPreviewFrameRateMode 6770 * 6771 * DESCRIPTION: get preview frame rate mode 6772 * 6773 * PARAMETERS : none 6774 * 6775 * RETURN : preview frame rate mode string 6776 *==========================================================================*/ 6777 const char *QCameraParameters::getPreviewFrameRateMode() const 6778 { 6779 return get(KEY_QC_PREVIEW_FRAME_RATE_MODE); 6780 } 6781 6782 /*=========================================================================== 6783 * FUNCTION : setTouchIndexAec 6784 * 6785 * DESCRIPTION: set touch index AEC 6786 * 6787 * PARAMETERS : 6788 * @x,y : 6789 * 6790 * RETURN : none 6791 *==========================================================================*/ 6792 void QCameraParameters::setTouchIndexAec(int x, int y) 6793 { 6794 char str[32]; 6795 snprintf(str, sizeof(str), "%dx%d", x, y); 6796 set(KEY_QC_TOUCH_INDEX_AEC, str); 6797 } 6798 6799 /*=========================================================================== 6800 * FUNCTION : getTouchIndexAec 6801 * 6802 * DESCRIPTION: get touch index AEC 6803 * 6804 * PARAMETERS : 6805 * @x,y : 6806 * 6807 * RETURN : none 6808 *==========================================================================*/ 6809 void QCameraParameters::getTouchIndexAec(int *x, int *y) 6810 { 6811 *x = -1; 6812 *y = -1; 6813 6814 // Get the current string, if it doesn't exist, leave the -1x-1 6815 const char *p = get(KEY_QC_TOUCH_INDEX_AEC); 6816 if (p == 0) 6817 return; 6818 6819 int tempX, tempY; 6820 if (parse_pair(p, &tempX, &tempY, 'x') == 0) { 6821 *x = tempX; 6822 *y = tempY; 6823 } 6824 } 6825 6826 /*=========================================================================== 6827 * FUNCTION : setTouchIndexAf 6828 * 6829 * DESCRIPTION: set touch index AF 6830 * 6831 * PARAMETERS : 6832 * @x,y : 6833 * 6834 * RETURN : none 6835 *==========================================================================*/ 6836 void QCameraParameters::setTouchIndexAf(int x, int y) 6837 { 6838 char str[32]; 6839 snprintf(str, sizeof(str), "%dx%d", x, y); 6840 set(KEY_QC_TOUCH_INDEX_AF, str); 6841 } 6842 6843 /*=========================================================================== 6844 * FUNCTION : getTouchIndexAf 6845 * 6846 * DESCRIPTION: get touch index AF 6847 * 6848 * PARAMETERS : 6849 * @x,y : 6850 * 6851 * RETURN : none 6852 *==========================================================================*/ 6853 void QCameraParameters::getTouchIndexAf(int *x, int *y) 6854 { 6855 *x = -1; 6856 *y = -1; 6857 6858 // Get the current string, if it doesn't exist, leave the -1x-1 6859 const char *p = get(KEY_QC_TOUCH_INDEX_AF); 6860 if (p == 0) 6861 return; 6862 6863 int tempX, tempY; 6864 if (parse_pair(p, &tempX, &tempY, 'x') == 0) { 6865 *x = tempX; 6866 *y = tempY; 6867 } 6868 } 6869 6870 /*=========================================================================== 6871 * FUNCTION : getStreamFormat 6872 * 6873 * DESCRIPTION: get stream format by its type 6874 * 6875 * PARAMETERS : 6876 * @streamType : [input] stream type 6877 * @format : [output] stream format 6878 * 6879 * RETURN : int32_t type of status 6880 * NO_ERROR -- success 6881 * none-zero failure code 6882 *==========================================================================*/ 6883 int32_t QCameraParameters::getStreamRotation(cam_stream_type_t streamType, 6884 cam_pp_feature_config_t &featureConfig, 6885 cam_dimension_t &dim) 6886 { 6887 int32_t ret = NO_ERROR; 6888 int rotationParam = getInt(KEY_QC_VIDEO_ROTATION); 6889 featureConfig.rotation = ROTATE_0; 6890 int swapDim = 0; 6891 switch (streamType) { 6892 case CAM_STREAM_TYPE_VIDEO: 6893 switch(rotationParam) { 6894 case 90: 6895 featureConfig.feature_mask |= CAM_QCOM_FEATURE_ROTATION; 6896 featureConfig.rotation = ROTATE_90; 6897 swapDim = 1; 6898 break; 6899 case 180: 6900 featureConfig.feature_mask |= CAM_QCOM_FEATURE_ROTATION; 6901 featureConfig.rotation = ROTATE_180; 6902 break; 6903 case 270: 6904 featureConfig.feature_mask |= CAM_QCOM_FEATURE_ROTATION; 6905 featureConfig.rotation = ROTATE_270; 6906 swapDim = 1; 6907 break; 6908 default: 6909 featureConfig.rotation = ROTATE_0; 6910 } 6911 break; 6912 case CAM_STREAM_TYPE_PREVIEW: 6913 case CAM_STREAM_TYPE_POSTVIEW: 6914 case CAM_STREAM_TYPE_SNAPSHOT: 6915 case CAM_STREAM_TYPE_RAW: 6916 case CAM_STREAM_TYPE_METADATA: 6917 case CAM_STREAM_TYPE_OFFLINE_PROC: 6918 case CAM_STREAM_TYPE_DEFAULT: 6919 default: 6920 break; 6921 } 6922 6923 if (swapDim > 0) { 6924 int w = 0; 6925 w = dim.width; 6926 dim.width = dim.height; 6927 dim.height = w; 6928 } 6929 return ret; 6930 } 6931 6932 /*=========================================================================== 6933 * FUNCTION : getStreamFormat 6934 * 6935 * DESCRIPTION: get stream format by its type 6936 * 6937 * PARAMETERS : 6938 * @streamType : [input] stream type 6939 * @format : [output] stream format 6940 * 6941 * RETURN : int32_t type of status 6942 * NO_ERROR -- success 6943 * none-zero failure code 6944 *==========================================================================*/ 6945 int32_t QCameraParameters::getStreamFormat(cam_stream_type_t streamType, 6946 cam_format_t &format) 6947 { 6948 int32_t ret = NO_ERROR; 6949 6950 format = CAM_FORMAT_MAX; 6951 switch (streamType) { 6952 case CAM_STREAM_TYPE_PREVIEW: 6953 case CAM_STREAM_TYPE_POSTVIEW: 6954 format = mPreviewFormat; 6955 break; 6956 case CAM_STREAM_TYPE_SNAPSHOT: 6957 if ( mPictureFormat == CAM_FORMAT_YUV_422_NV16 ) { 6958 format = CAM_FORMAT_YUV_422_NV16; 6959 } else { 6960 char prop[PROPERTY_VALUE_MAX]; 6961 int snapshotFormat; 6962 memset(prop, 0, sizeof(prop)); 6963 property_get("persist.camera.snap.format", prop, "0"); 6964 snapshotFormat = atoi(prop); 6965 if(snapshotFormat == 1) { 6966 format = CAM_FORMAT_YUV_422_NV61; 6967 } else { 6968 format = CAM_FORMAT_YUV_420_NV21; 6969 } 6970 } 6971 break; 6972 case CAM_STREAM_TYPE_VIDEO: 6973 format = CAM_FORMAT_YUV_420_NV12; 6974 break; 6975 case CAM_STREAM_TYPE_RAW: 6976 if (isRdiMode()) { 6977 format = m_pCapability->rdi_mode_stream_fmt; 6978 } else if (mPictureFormat >= CAM_FORMAT_YUV_RAW_8BIT_YUYV) { 6979 format = (cam_format_t)mPictureFormat; 6980 } else { 6981 char raw_format[PROPERTY_VALUE_MAX]; 6982 int rawFormat; 6983 memset(raw_format, 0, sizeof(raw_format)); 6984 /*Default value is CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GBRG*/ 6985 property_get("persist.camera.raw.format", raw_format, "16"); 6986 rawFormat = atoi(raw_format); 6987 format = (cam_format_t)rawFormat; 6988 CDBG_HIGH("%s: Raw stream format %d bundled with snapshot", 6989 __func__, format); 6990 } 6991 break; 6992 case CAM_STREAM_TYPE_METADATA: 6993 case CAM_STREAM_TYPE_OFFLINE_PROC: 6994 case CAM_STREAM_TYPE_DEFAULT: 6995 default: 6996 break; 6997 } 6998 6999 return ret; 7000 } 7001 7002 /*=========================================================================== 7003 * FUNCTION : getFlipMode 7004 * 7005 * DESCRIPTION: get flip mode 7006 * 7007 * PARAMETERS : 7008 * @cam_intf_parm_type_t : [input] stream type 7009 * 7010 * RETURN : int type of flip mode 7011 * 0 - no filp 7012 * 1 - FLIP_H 7013 * 2 - FLIP_V 7014 * 3 - FLIP_H | FLIP_V 7015 *==========================================================================*/ 7016 int QCameraParameters::getFlipMode(cam_stream_type_t type) 7017 { 7018 const char *str = NULL; 7019 int flipMode = 0; // no flip 7020 7021 switch(type){ 7022 case CAM_STREAM_TYPE_PREVIEW: 7023 if (!isRdiMode()) { 7024 str = get(KEY_QC_PREVIEW_FLIP); 7025 } 7026 break; 7027 case CAM_STREAM_TYPE_VIDEO: 7028 str = get(KEY_QC_VIDEO_FLIP); 7029 break; 7030 case CAM_STREAM_TYPE_SNAPSHOT: 7031 case CAM_STREAM_TYPE_POSTVIEW: 7032 str = get(KEY_QC_SNAPSHOT_PICTURE_FLIP); 7033 break; 7034 default: 7035 CDBG("%s: No flip mode for stream type %d", __func__, type); 7036 break; 7037 } 7038 7039 if(str != NULL){ 7040 //Need give corresponding filp value based on flip mode strings 7041 int value = lookupAttr(FLIP_MODES_MAP, 7042 sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap), str); 7043 if(value != NAME_NOT_FOUND) 7044 flipMode = value; 7045 } 7046 7047 CDBG_HIGH("%s: the filp mode of stream type %d is %d .", __func__, type, flipMode); 7048 return flipMode; 7049 } 7050 7051 /*=========================================================================== 7052 * FUNCTION : isSnapshotFDNeeded 7053 * 7054 * DESCRIPTION: check whether Face Detection Metadata is needed 7055 * 7056 * PARAMETERS : none 7057 * 7058 * RETURN : bool type of status 7059 * 0 - need 7060 * 1 - not need 7061 *==========================================================================*/ 7062 bool QCameraParameters::isSnapshotFDNeeded() 7063 { 7064 return getInt(KEY_QC_SNAPSHOT_FD_DATA); 7065 } 7066 7067 /*=========================================================================== 7068 * FUNCTION : getStreamDimension 7069 * 7070 * DESCRIPTION: get stream dimension by its type 7071 * 7072 * PARAMETERS : 7073 * @streamType : [input] stream type 7074 * @dim : [output] stream dimension 7075 * 7076 * RETURN : int32_t type of status 7077 * NO_ERROR -- success 7078 * none-zero failure code 7079 *==========================================================================*/ 7080 int32_t QCameraParameters::getStreamDimension(cam_stream_type_t streamType, 7081 cam_dimension_t &dim) 7082 { 7083 int32_t ret = NO_ERROR; 7084 memset(&dim, 0, sizeof(cam_dimension_t)); 7085 7086 switch (streamType) { 7087 case CAM_STREAM_TYPE_PREVIEW: 7088 getPreviewSize(&dim.width, &dim.height); 7089 break; 7090 case CAM_STREAM_TYPE_POSTVIEW: 7091 getPreviewSize(&dim.width, &dim.height); 7092 break; 7093 case CAM_STREAM_TYPE_SNAPSHOT: 7094 if (getRecordingHintValue() == true) { 7095 // live snapshot 7096 getLiveSnapshotSize(dim); 7097 } else { 7098 getPictureSize(&dim.width, &dim.height); 7099 } 7100 break; 7101 case CAM_STREAM_TYPE_VIDEO: 7102 getVideoSize(&dim.width, &dim.height); 7103 break; 7104 case CAM_STREAM_TYPE_RAW: 7105 //dim = m_pCapability->raw_dim; 7106 getRawSize(dim); 7107 break; 7108 case CAM_STREAM_TYPE_METADATA: 7109 dim.width = sizeof(metadata_buffer_t); 7110 dim.height = 1; 7111 break; 7112 case CAM_STREAM_TYPE_OFFLINE_PROC: 7113 break; 7114 case CAM_STREAM_TYPE_DEFAULT: 7115 default: 7116 ALOGE("%s: no dimension for unsupported stream type %d", 7117 __func__, streamType); 7118 ret = BAD_VALUE; 7119 break; 7120 } 7121 return ret; 7122 } 7123 7124 /*=========================================================================== 7125 * FUNCTION : getPreviewHalPixelFormat 7126 * 7127 * DESCRIPTION: get preview HAL pixel format 7128 * 7129 * PARAMETERS : none 7130 * 7131 * RETURN : HAL pixel format 7132 *==========================================================================*/ 7133 int QCameraParameters::getPreviewHalPixelFormat() const 7134 { 7135 int32_t halPixelFormat; 7136 7137 switch (mPreviewFormat) { 7138 case CAM_FORMAT_YUV_420_NV12: 7139 halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP; 7140 break; 7141 case CAM_FORMAT_YUV_420_NV21: 7142 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 7143 break; 7144 case CAM_FORMAT_YUV_420_NV21_ADRENO: 7145 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO; 7146 break; 7147 case CAM_FORMAT_YUV_420_YV12: 7148 halPixelFormat = HAL_PIXEL_FORMAT_YV12; 7149 break; 7150 case CAM_FORMAT_YUV_420_NV12_VENUS: 7151 halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS; 7152 break; 7153 case CAM_FORMAT_YUV_422_NV16: 7154 case CAM_FORMAT_YUV_422_NV61: 7155 default: 7156 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 7157 break; 7158 } 7159 CDBG_HIGH("%s: format %d\n", __func__, halPixelFormat); 7160 return halPixelFormat; 7161 } 7162 7163 /*=========================================================================== 7164 * FUNCTION : getthumbnailSize 7165 * 7166 * DESCRIPTION: get thumbnail size 7167 * 7168 * PARAMETERS : 7169 * @width, height : [output] thumbnail width and height 7170 * 7171 * RETURN : none 7172 *==========================================================================*/ 7173 void QCameraParameters::getThumbnailSize(int *width, int *height) const 7174 { 7175 *width = getInt(KEY_JPEG_THUMBNAIL_WIDTH); 7176 *height = getInt(KEY_JPEG_THUMBNAIL_HEIGHT); 7177 } 7178 7179 /*=========================================================================== 7180 * FUNCTION : getZSLBurstInterval 7181 * 7182 * DESCRIPTION: get ZSL burst interval setting 7183 * 7184 * PARAMETERS : none 7185 * 7186 * RETURN : ZSL burst interval value 7187 *==========================================================================*/ 7188 int QCameraParameters::getZSLBurstInterval() 7189 { 7190 int interval = getInt(KEY_QC_ZSL_BURST_INTERVAL); 7191 if (interval < 0) { 7192 interval = 1; 7193 } 7194 return interval; 7195 } 7196 7197 /*=========================================================================== 7198 * FUNCTION : getZSLQueueDepth 7199 * 7200 * DESCRIPTION: get ZSL queue depth 7201 * 7202 * PARAMETERS : none 7203 * 7204 * RETURN : ZSL queue depth value 7205 *==========================================================================*/ 7206 int QCameraParameters::getZSLQueueDepth() 7207 { 7208 int qdepth = getInt(KEY_QC_ZSL_QUEUE_DEPTH); 7209 if (qdepth < 0) { 7210 qdepth = 2; 7211 } 7212 return qdepth; 7213 } 7214 7215 /*=========================================================================== 7216 * FUNCTION : getZSLBackLookCount 7217 * 7218 * DESCRIPTION: get ZSL backlook count setting 7219 * 7220 * PARAMETERS : none 7221 * 7222 * RETURN : ZSL backlook count value 7223 *==========================================================================*/ 7224 int QCameraParameters::getZSLBackLookCount() 7225 { 7226 int look_back = getInt(KEY_QC_ZSL_BURST_LOOKBACK); 7227 if (look_back < 0) { 7228 look_back = 2; 7229 } 7230 return look_back; 7231 } 7232 7233 /*=========================================================================== 7234 * FUNCTION : getZSLMaxUnmatchedFrames 7235 * 7236 * DESCRIPTION: get allowed ZSL max unmatched frames number 7237 * 7238 * PARAMETERS : none 7239 * 7240 * RETURN : ZSL backlook count value 7241 *==========================================================================*/ 7242 int QCameraParameters::getMaxUnmatchedFramesInQueue() 7243 { 7244 return m_pCapability->min_num_pp_bufs + (m_nBurstNum / 10); 7245 } 7246 7247 /*=========================================================================== 7248 * FUNCTION : setRecordingHintValue 7249 * 7250 * DESCRIPTION: set recording hint 7251 * 7252 * PARAMETERS : 7253 * @value : video hint value 7254 * 7255 * RETURN : int32_t type of status 7256 * NO_ERROR -- success 7257 * none-zero failure code 7258 *==========================================================================*/ 7259 int QCameraParameters::setRecordingHintValue(int32_t value) 7260 { 7261 CDBG_HIGH("%s: VideoHint = %d", __func__, value); 7262 bool newValue = (value > 0)? true : false; 7263 7264 if ( m_bRecordingHint != newValue ) { 7265 m_bNeedRestart = true; 7266 m_bRecordingHint_new = newValue; 7267 } else { 7268 m_bRecordingHint_new = m_bRecordingHint; 7269 } 7270 return AddSetParmEntryToBatch(m_pParamBuf, 7271 CAM_INTF_PARM_RECORDING_HINT, 7272 sizeof(value), 7273 &value); 7274 } 7275 7276 /*=========================================================================== 7277 * FUNCTION : getNumOfSnapshots 7278 * 7279 * DESCRIPTION: get number of snapshot per shutter 7280 * 7281 * PARAMETERS : none 7282 * 7283 * RETURN : number of snapshot per shutter 7284 *==========================================================================*/ 7285 uint8_t QCameraParameters::getNumOfSnapshots() 7286 { 7287 int numOfSnapshot = getInt(KEY_QC_NUM_SNAPSHOT_PER_SHUTTER); 7288 if (numOfSnapshot <= 0) { 7289 numOfSnapshot = 1; // set to default value 7290 } 7291 7292 /* update the count for refocus */ 7293 if (isUbiRefocus()) 7294 numOfSnapshot += UfOutputCount(); 7295 7296 return (uint8_t)numOfSnapshot; 7297 } 7298 7299 /*=========================================================================== 7300 * FUNCTION : getBurstCountForAdvancedCapture 7301 * 7302 * DESCRIPTION: get burst count for advanced capture. 7303 * 7304 * PARAMETERS : none 7305 * 7306 * RETURN : number of snapshot required for advanced capture. 7307 *==========================================================================*/ 7308 uint8_t QCameraParameters::getBurstCountForAdvancedCapture() 7309 { 7310 int burstCount = 0; 7311 if (isUbiFocusEnabled()) { 7312 //number of snapshots required for Ubi Focus. 7313 burstCount = m_pCapability->ubifocus_af_bracketing_need.burst_count; 7314 } else if (isOptiZoomEnabled()) { 7315 //number of snapshots required for Opti Zoom. 7316 burstCount = m_pCapability->opti_zoom_settings_need.burst_count; 7317 } else if (isChromaFlashEnabled()) { 7318 //number of snapshots required for Chroma Flash. 7319 //TODO: remove hardcoded value, add in capability. 7320 burstCount = 2; 7321 } else if (isHDREnabled()) { 7322 //number of snapshots required for HDR. 7323 burstCount = m_pCapability->hdr_bracketing_setting.num_frames; 7324 } else if (isAEBracketEnabled()) { 7325 burstCount = 0; 7326 const char *str_val = m_AEBracketingClient.values; 7327 if ((str_val != NULL) && (strlen(str_val) > 0)) { 7328 char prop[PROPERTY_VALUE_MAX]; 7329 memset(prop, 0, sizeof(prop)); 7330 strcpy(prop, str_val); 7331 char *saveptr = NULL; 7332 char *token = strtok_r(prop, ",", &saveptr); 7333 while (token != NULL) { 7334 token = strtok_r(NULL, ",", &saveptr); 7335 burstCount++; 7336 } 7337 } 7338 } 7339 7340 if (burstCount <= 0) { 7341 burstCount = 1; 7342 } 7343 return (uint8_t)burstCount; 7344 } 7345 7346 /*=========================================================================== 7347 * FUNCTION : getNumOfRetroSnapshots 7348 * 7349 * DESCRIPTION: get number of retro active snapshots per shutter 7350 * 7351 * PARAMETERS : none 7352 * 7353 * RETURN : number of retro active snapshots per shutter 7354 *==========================================================================*/ 7355 uint8_t QCameraParameters::getNumOfRetroSnapshots() 7356 { 7357 int numOfRetroSnapshots = getInt(KEY_QC_NUM_RETRO_BURST_PER_SHUTTER); 7358 if (numOfRetroSnapshots < 0) { 7359 numOfRetroSnapshots = 0; 7360 } 7361 CDBG_HIGH("%s: [ZSL Retro] : numOfRetroSnaps - %d", __func__, numOfRetroSnapshots); 7362 return (uint8_t)numOfRetroSnapshots; 7363 } 7364 7365 /*=========================================================================== 7366 * FUNCTION : getBurstLEDOnPeriod 7367 * 7368 * DESCRIPTION: get burst LED on period 7369 * 7370 * PARAMETERS : none 7371 * 7372 * RETURN : burst LED on period 7373 *==========================================================================*/ 7374 int QCameraParameters::getBurstLEDOnPeriod() 7375 { 7376 CDBG_HIGH("%s: [ZSL Retro] burst LED ON period: %d", __func__, m_nBurstLEDOnPeriod); 7377 return m_nBurstLEDOnPeriod; 7378 } 7379 7380 /*=========================================================================== 7381 * FUNCTION : getNumOfExtraHDRInBufsIfNeeded 7382 * 7383 * DESCRIPTION: get number of extra input buffers needed by HDR 7384 * 7385 * PARAMETERS : none 7386 * 7387 * RETURN : number of extra buffers needed by HDR; 0 if not HDR enabled 7388 *==========================================================================*/ 7389 uint8_t QCameraParameters::getNumOfExtraHDRInBufsIfNeeded() 7390 { 7391 uint8_t numOfBufs = 0; 7392 7393 if (isHDREnabled()) { 7394 numOfBufs += m_pCapability->hdr_bracketing_setting.num_frames; 7395 if (isHDR1xFrameEnabled() && isHDR1xExtraBufferNeeded()) { 7396 numOfBufs++; 7397 } 7398 numOfBufs--; // Only additional buffers need to be returned 7399 } 7400 7401 return numOfBufs * getBurstNum(); 7402 } 7403 7404 /*=========================================================================== 7405 * FUNCTION : getNumOfExtraHDROutBufsIfNeeded 7406 * 7407 * DESCRIPTION: get number of extra output buffers needed by HDR 7408 * 7409 * PARAMETERS : none 7410 * 7411 * RETURN : number of extra buffers needed by HDR; 0 if not HDR enabled 7412 *==========================================================================*/ 7413 uint8_t QCameraParameters::getNumOfExtraHDROutBufsIfNeeded() 7414 { 7415 uint8_t numOfBufs = 0; 7416 7417 if (isHDREnabled() && isHDR1xFrameEnabled()) { 7418 numOfBufs++; 7419 } 7420 7421 return numOfBufs * getBurstNum(); 7422 } 7423 7424 /*=========================================================================== 7425 * FUNCTION : getBurstNum 7426 * 7427 * DESCRIPTION: get burst number of snapshot 7428 * 7429 * PARAMETERS : none 7430 * 7431 * RETURN : number of burst 7432 *==========================================================================*/ 7433 int QCameraParameters::getBurstNum() 7434 { 7435 CDBG_HIGH("%s: m_nBurstNum = %d", __func__, m_nBurstNum); 7436 return m_nBurstNum; 7437 } 7438 7439 /*=========================================================================== 7440 * FUNCTION : getJpegQuality 7441 * 7442 * DESCRIPTION: get jpeg encoding quality 7443 * 7444 * PARAMETERS : none 7445 * 7446 * RETURN : jpeg encoding quality 7447 *==========================================================================*/ 7448 int QCameraParameters::getJpegQuality() 7449 { 7450 int quality = getInt(KEY_JPEG_QUALITY); 7451 if (quality < 0) { 7452 quality = 85; // set to default quality value 7453 } 7454 return quality; 7455 } 7456 7457 /*=========================================================================== 7458 * FUNCTION : getJpegRotation 7459 * 7460 * DESCRIPTION: get rotation value 7461 * 7462 * PARAMETERS : none 7463 * 7464 * RETURN : rotation value 7465 *==========================================================================*/ 7466 int QCameraParameters::getJpegRotation() { 7467 int rotation = getInt(KEY_ROTATION); 7468 if (rotation < 0) { 7469 rotation = 0; 7470 } 7471 return rotation; 7472 } 7473 7474 /*=========================================================================== 7475 * FUNCTION : parseGPSCoordinate 7476 * 7477 * DESCRIPTION: parse GPS coordinate string 7478 * 7479 * PARAMETERS : 7480 * @coord_str : [input] coordinate string 7481 * @coord : [output] ptr to struct to store coordinate 7482 * 7483 * RETURN : int32_t type of status 7484 * NO_ERROR -- success 7485 * none-zero failure code 7486 *==========================================================================*/ 7487 int QCameraParameters::parseGPSCoordinate(const char *coord_str, rat_t* coord) 7488 { 7489 if(coord == NULL) { 7490 ALOGE("%s: error, invalid argument coord == NULL", __func__); 7491 return BAD_VALUE; 7492 } 7493 float degF = atof(coord_str); 7494 if (degF < 0) { 7495 degF = -degF; 7496 } 7497 float minF = (degF - (int) degF) * 60; 7498 float secF = (minF - (int) minF) * 60; 7499 7500 getRational(&coord[0], (int)degF, 1); 7501 getRational(&coord[1], (int)minF, 1); 7502 getRational(&coord[2], (int)(secF * 10000), 10000); 7503 return NO_ERROR; 7504 } 7505 7506 /*=========================================================================== 7507 * FUNCTION : getExifDateTime 7508 * 7509 * DESCRIPTION: query exif date time 7510 * 7511 * PARAMETERS : 7512 * @dateTime : string to store exif date time 7513 * @count : lenght of the dateTime string 7514 * 7515 * RETURN : int32_t type of status 7516 * NO_ERROR -- success 7517 * none-zero failure code 7518 *==========================================================================*/ 7519 int32_t QCameraParameters::getExifDateTime(char *dateTime, uint32_t &count) 7520 { 7521 //get time and date from system 7522 time_t rawtime; 7523 struct tm * timeinfo = NULL; 7524 memset(&rawtime, 0, sizeof(rawtime)); 7525 time(&rawtime); 7526 timeinfo = localtime (&rawtime); 7527 if (timeinfo != NULL && count >= 20) { 7528 //Write datetime according to EXIF Spec 7529 //"YYYY:MM:DD HH:MM:SS" (20 chars including \0) 7530 snprintf(dateTime, 20, "%04d:%02d:%02d %02d:%02d:%02d", 7531 timeinfo->tm_year + 1900, timeinfo->tm_mon + 1, 7532 timeinfo->tm_mday, timeinfo->tm_hour, 7533 timeinfo->tm_min, timeinfo->tm_sec); 7534 count = 20; 7535 return NO_ERROR; 7536 } 7537 return UNKNOWN_ERROR; 7538 } 7539 7540 /*=========================================================================== 7541 * FUNCTION : getRational 7542 * 7543 * DESCRIPTION: compose rational struct 7544 * 7545 * PARAMETERS : 7546 * @rat : ptr to struct to store rational info 7547 * @num :num of the rational 7548 * @denom : denom of the rational 7549 * 7550 * RETURN : int32_t type of status 7551 * NO_ERROR -- success 7552 * none-zero failure code 7553 *==========================================================================*/ 7554 int32_t QCameraParameters::getRational(rat_t *rat, int num, int denom) 7555 { 7556 if (NULL == rat) { 7557 ALOGE("%s: NULL rat input", __func__); 7558 return BAD_VALUE; 7559 } 7560 rat->num = num; 7561 rat->denom = denom; 7562 return NO_ERROR; 7563 } 7564 7565 /*=========================================================================== 7566 * FUNCTION : getExifFocalLength 7567 * 7568 * DESCRIPTION: get exif focal lenght 7569 * 7570 * PARAMETERS : 7571 * @focalLength : ptr to rational strcut to store focal lenght 7572 * 7573 * RETURN : int32_t type of status 7574 * NO_ERROR -- success 7575 * none-zero failure code 7576 *==========================================================================*/ 7577 int32_t QCameraParameters::getExifFocalLength(rat_t *focalLength) 7578 { 7579 int focalLengthValue = 7580 (int)(getFloat(QCameraParameters::KEY_FOCAL_LENGTH) * FOCAL_LENGTH_DECIMAL_PRECISION); 7581 return getRational(focalLength, focalLengthValue, FOCAL_LENGTH_DECIMAL_PRECISION); 7582 } 7583 7584 /*=========================================================================== 7585 * FUNCTION : getExifIsoSpeed 7586 * 7587 * DESCRIPTION: get exif ISO speed 7588 * 7589 * PARAMETERS : none 7590 * 7591 * RETURN : ISO speed value 7592 *==========================================================================*/ 7593 uint16_t QCameraParameters::getExifIsoSpeed() 7594 { 7595 uint16_t isoSpeed = 0; 7596 const char *iso_str = get(QCameraParameters::KEY_QC_ISO_MODE); 7597 int iso_index = lookupAttr(ISO_MODES_MAP, 7598 sizeof(ISO_MODES_MAP)/sizeof(ISO_MODES_MAP[0]), iso_str); 7599 switch (iso_index) { 7600 case CAM_ISO_MODE_AUTO: 7601 isoSpeed = 0; 7602 break; 7603 case CAM_ISO_MODE_DEBLUR: 7604 isoSpeed = 1; 7605 break; 7606 case CAM_ISO_MODE_100: 7607 isoSpeed = 100; 7608 break; 7609 case CAM_ISO_MODE_200: 7610 isoSpeed = 200; 7611 break; 7612 case CAM_ISO_MODE_400: 7613 isoSpeed = 400; 7614 break; 7615 case CAM_ISO_MODE_800: 7616 isoSpeed = 800; 7617 break; 7618 case CAM_ISO_MODE_1600: 7619 isoSpeed = 1600; 7620 break; 7621 } 7622 return isoSpeed; 7623 } 7624 7625 /*=========================================================================== 7626 * FUNCTION : getExifGpsProcessingMethod 7627 * 7628 * DESCRIPTION: get GPS processing method 7629 * 7630 * PARAMETERS : 7631 * @gpsProcessingMethod : string to store GPS process method 7632 * @count : lenght of the string 7633 * 7634 * RETURN : int32_t type of status 7635 * NO_ERROR -- success 7636 * none-zero failure code 7637 *==========================================================================*/ 7638 int32_t QCameraParameters::getExifGpsProcessingMethod(char *gpsProcessingMethod, 7639 uint32_t &count) 7640 { 7641 const char *str = get(KEY_GPS_PROCESSING_METHOD); 7642 if(str != NULL) { 7643 memcpy(gpsProcessingMethod, ExifAsciiPrefix, EXIF_ASCII_PREFIX_SIZE); 7644 count = EXIF_ASCII_PREFIX_SIZE; 7645 strncpy(gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE, str, strlen(str)); 7646 count += strlen(str); 7647 gpsProcessingMethod[count++] = '\0'; // increase 1 for the last NULL char 7648 return NO_ERROR; 7649 } else { 7650 return BAD_VALUE; 7651 } 7652 } 7653 7654 /*=========================================================================== 7655 * FUNCTION : getExifLatitude 7656 * 7657 * DESCRIPTION: get exif latitude 7658 * 7659 * PARAMETERS : 7660 * @latitude : ptr to rational struct to store latitude info 7661 * @ladRef : charater to indicate latitude reference 7662 * 7663 * RETURN : int32_t type of status 7664 * NO_ERROR -- success 7665 * none-zero failure code 7666 *==========================================================================*/ 7667 int32_t QCameraParameters::getExifLatitude(rat_t *latitude, 7668 char *latRef) 7669 { 7670 const char *str = get(KEY_GPS_LATITUDE); 7671 if(str != NULL) { 7672 parseGPSCoordinate(str, latitude); 7673 7674 //set Latitude Ref 7675 float latitudeValue = getFloat(KEY_GPS_LATITUDE); 7676 if(latitudeValue < 0.0f) { 7677 latRef[0] = 'S'; 7678 } else { 7679 latRef[0] = 'N'; 7680 } 7681 latRef[1] = '\0'; 7682 return NO_ERROR; 7683 }else{ 7684 return BAD_VALUE; 7685 } 7686 } 7687 7688 /*=========================================================================== 7689 * FUNCTION : getExifLongitude 7690 * 7691 * DESCRIPTION: get exif longitude 7692 * 7693 * PARAMETERS : 7694 * @longitude : ptr to rational struct to store longitude info 7695 * @lonRef : charater to indicate longitude reference 7696 * 7697 * RETURN : int32_t type of status 7698 * NO_ERROR -- success 7699 * none-zero failure code 7700 *==========================================================================*/ 7701 int32_t QCameraParameters::getExifLongitude(rat_t *longitude, 7702 char *lonRef) 7703 { 7704 const char *str = get(KEY_GPS_LONGITUDE); 7705 if(str != NULL) { 7706 parseGPSCoordinate(str, longitude); 7707 7708 //set Longitude Ref 7709 float longitudeValue = getFloat(KEY_GPS_LONGITUDE); 7710 if(longitudeValue < 0.0f) { 7711 lonRef[0] = 'W'; 7712 } else { 7713 lonRef[0] = 'E'; 7714 } 7715 lonRef[1] = '\0'; 7716 return NO_ERROR; 7717 }else{ 7718 return BAD_VALUE; 7719 } 7720 } 7721 7722 /*=========================================================================== 7723 * FUNCTION : getExifAltitude 7724 * 7725 * DESCRIPTION: get exif altitude 7726 * 7727 * PARAMETERS : 7728 * @altitude : ptr to rational struct to store altitude info 7729 * @altRef : charater to indicate altitude reference 7730 * 7731 * RETURN : int32_t type of status 7732 * NO_ERROR -- success 7733 * none-zero failure code 7734 *==========================================================================*/ 7735 int32_t QCameraParameters::getExifAltitude(rat_t *altitude, 7736 char *altRef) 7737 { 7738 const char *str = get(KEY_GPS_ALTITUDE); 7739 if(str != NULL) { 7740 double value = atof(str); 7741 *altRef = 0; 7742 if(value < 0){ 7743 *altRef = 1; 7744 value = -value; 7745 } 7746 return getRational(altitude, value*1000, 1000); 7747 }else{ 7748 return BAD_VALUE; 7749 } 7750 } 7751 7752 /*=========================================================================== 7753 * FUNCTION : getExifGpsDateTimeStamp 7754 * 7755 * DESCRIPTION: get exif GPS date time stamp 7756 * 7757 * PARAMETERS : 7758 * @gpsDateStamp : GPS date time stamp string 7759 * @bufLen : length of the string 7760 * @gpsTimeStamp : ptr to rational struct to store time stamp info 7761 * 7762 * RETURN : int32_t type of status 7763 * NO_ERROR -- success 7764 * none-zero failure code 7765 *==========================================================================*/ 7766 int32_t QCameraParameters::getExifGpsDateTimeStamp(char *gpsDateStamp, 7767 uint32_t bufLen, 7768 rat_t *gpsTimeStamp) 7769 { 7770 const char *str = get(KEY_GPS_TIMESTAMP); 7771 if(str != NULL) { 7772 time_t unixTime = (time_t)atol(str); 7773 struct tm *UTCTimestamp = gmtime(&unixTime); 7774 7775 strftime(gpsDateStamp, bufLen, "%Y:%m:%d", UTCTimestamp); 7776 7777 getRational(&gpsTimeStamp[0], UTCTimestamp->tm_hour, 1); 7778 getRational(&gpsTimeStamp[1], UTCTimestamp->tm_min, 1); 7779 getRational(&gpsTimeStamp[2], UTCTimestamp->tm_sec, 1); 7780 7781 return NO_ERROR; 7782 } else { 7783 return BAD_VALUE; 7784 } 7785 } 7786 7787 /*=========================================================================== 7788 * FUNCTION : updateFocusDistances 7789 * 7790 * DESCRIPTION: update focus distances 7791 * 7792 * PARAMETERS : 7793 * @focusDistances : ptr to focus distance info 7794 * 7795 * RETURN : int32_t type of status 7796 * NO_ERROR -- success 7797 * none-zero failure code 7798 *==========================================================================*/ 7799 int32_t QCameraParameters::updateFocusDistances(cam_focus_distances_info_t *focusDistances) 7800 { 7801 String8 str; 7802 char buffer[32] = {0}; 7803 //set all distances to infinity if focus mode is infinity 7804 if(mFocusMode == CAM_FOCUS_MODE_INFINITY) { 7805 str.append("Infinity,Infinity,Infinity"); 7806 } else { 7807 snprintf(buffer, sizeof(buffer), "%f", focusDistances->focus_distance[0]); 7808 str.append(buffer); 7809 snprintf(buffer, sizeof(buffer), ",%f", focusDistances->focus_distance[1]); 7810 str.append(buffer); 7811 snprintf(buffer, sizeof(buffer), ",%f", focusDistances->focus_distance[2]); 7812 str.append(buffer); 7813 } 7814 CDBG_HIGH("%s: setting KEY_FOCUS_DISTANCES as %s", __FUNCTION__, str.string()); 7815 set(QCameraParameters::KEY_FOCUS_DISTANCES, str.string()); 7816 return NO_ERROR; 7817 } 7818 7819 /*=========================================================================== 7820 * FUNCTION : updateRecordingHintValue 7821 * 7822 * DESCRIPTION: update recording hint locally and to daemon 7823 * 7824 * PARAMETERS : 7825 * @value : video hint value 7826 * 7827 * RETURN : int32_t type of status 7828 * NO_ERROR -- success 7829 * none-zero failure code 7830 *==========================================================================*/ 7831 int32_t QCameraParameters::updateRecordingHintValue(int32_t value) 7832 { 7833 int32_t rc = NO_ERROR; 7834 if(initBatchUpdate(m_pParamBuf) < 0 ) { 7835 ALOGE("%s:Failed to initialize group update table", __func__); 7836 return BAD_TYPE; 7837 } 7838 7839 rc = setRecordingHintValue(value); 7840 if (rc != NO_ERROR) { 7841 ALOGE("%s:Failed to update table", __func__); 7842 return rc; 7843 } 7844 7845 rc = commitSetBatch(); 7846 if (rc != NO_ERROR) { 7847 ALOGE("%s:Failed to update recording hint", __func__); 7848 return rc; 7849 } 7850 7851 return rc; 7852 } 7853 7854 /*=========================================================================== 7855 * FUNCTION : setHistogram 7856 * 7857 * DESCRIPTION: set histogram 7858 * 7859 * PARAMETERS : 7860 * @enabled : if histogram is enabled 7861 * 7862 * RETURN : int32_t type of status 7863 * NO_ERROR -- success 7864 * none-zero failure code 7865 *==========================================================================*/ 7866 int32_t QCameraParameters::setHistogram(bool enabled) 7867 { 7868 if(m_bHistogramEnabled == enabled) { 7869 CDBG_HIGH("%s: histogram flag not changed, no ops here", __func__); 7870 return NO_ERROR; 7871 } 7872 7873 // set parm for histogram 7874 if(initBatchUpdate(m_pParamBuf) < 0 ) { 7875 ALOGE("%s:Failed to initialize group update table", __func__); 7876 return BAD_TYPE; 7877 } 7878 7879 int32_t value = enabled; 7880 int32_t rc = NO_ERROR; 7881 rc = AddSetParmEntryToBatch(m_pParamBuf, 7882 CAM_INTF_PARM_HISTOGRAM, 7883 sizeof(value), 7884 &value); 7885 if (rc != NO_ERROR) { 7886 ALOGE("%s:Failed to update table", __func__); 7887 return rc; 7888 } 7889 7890 rc = commitSetBatch(); 7891 if (rc != NO_ERROR) { 7892 ALOGE("%s:Failed to set histogram", __func__); 7893 return rc; 7894 } 7895 7896 m_bHistogramEnabled = enabled; 7897 7898 CDBG_HIGH(" Histogram -> %s", m_bHistogramEnabled ? "Enabled" : "Disabled"); 7899 7900 return rc; 7901 } 7902 7903 /*=========================================================================== 7904 * FUNCTION : setFaceDetectionOption 7905 * 7906 * DESCRIPTION: set if face detection is enabled by SendCommand 7907 * 7908 * PARAMETERS : 7909 * @enabled : bool flag if face detection should be enabled 7910 * 7911 * RETURN : int32_t type of status 7912 * NO_ERROR -- success 7913 * none-zero failure code 7914 *==========================================================================*/ 7915 int32_t QCameraParameters::setFaceDetectionOption(bool enabled) 7916 { 7917 m_bFaceDetectionOn = enabled; 7918 return NO_ERROR; 7919 } 7920 7921 /*=========================================================================== 7922 * FUNCTION : setFaceDetection 7923 * 7924 * DESCRIPTION: set face detection 7925 * 7926 * PARAMETERS : 7927 * @enabled : if face detection is enabled 7928 * @initCommit : if configuration list need to be initialized and commited 7929 * 7930 * RETURN : int32_t type of status 7931 * NO_ERROR -- success 7932 * none-zero failure code 7933 *==========================================================================*/ 7934 int32_t QCameraParameters::setFaceDetection(bool enabled, bool initCommit) 7935 { 7936 int faceProcMask = m_nFaceProcMask; 7937 // set face detection mask 7938 if (enabled) { 7939 faceProcMask |= CAM_FACE_PROCESS_MASK_DETECTION; 7940 } else { 7941 faceProcMask &= ~CAM_FACE_PROCESS_MASK_DETECTION; 7942 } 7943 7944 if(m_nFaceProcMask == faceProcMask) { 7945 CDBG_HIGH("%s: face process mask not changed, no ops here", __func__); 7946 return NO_ERROR; 7947 } 7948 7949 m_nFaceProcMask = faceProcMask; 7950 7951 // set parm for face detection 7952 int requested_faces = getInt(KEY_QC_MAX_NUM_REQUESTED_FACES); 7953 cam_fd_set_parm_t fd_set_parm; 7954 memset(&fd_set_parm, 0, sizeof(cam_fd_set_parm_t)); 7955 fd_set_parm.fd_mode = faceProcMask; 7956 fd_set_parm.num_fd = requested_faces; 7957 7958 CDBG_HIGH("[KPI Perf] %s: PROFILE_FACE_DETECTION_VALUE = %d num_fd = %d", 7959 __func__, faceProcMask,requested_faces); 7960 7961 if (initCommit) { 7962 if(initBatchUpdate(m_pParamBuf) < 0 ) { 7963 ALOGE("%s:Failed to initialize group update table", __func__); 7964 return BAD_TYPE; 7965 } 7966 } 7967 7968 int32_t rc = NO_ERROR; 7969 7970 rc = AddSetParmEntryToBatch(m_pParamBuf, 7971 CAM_INTF_PARM_FD, 7972 sizeof(fd_set_parm), 7973 &fd_set_parm); 7974 if (rc != NO_ERROR) { 7975 ALOGE("%s:Failed to update table", __func__); 7976 return rc; 7977 } 7978 7979 if (initCommit) { 7980 rc = commitSetBatch(); 7981 if (rc != NO_ERROR) { 7982 ALOGE("%s:Failed to set face detection parm", __func__); 7983 return rc; 7984 } 7985 } 7986 7987 CDBG_HIGH("%s: FaceProcMask -> %d", __func__, m_nFaceProcMask); 7988 7989 return rc; 7990 } 7991 7992 /*=========================================================================== 7993 * FUNCTION : setFrameSkip 7994 * 7995 * DESCRIPTION: send ISP frame skip pattern to camera daemon 7996 * 7997 * PARAMETERS : 7998 * @pattern : skip pattern for ISP 7999 * 8000 * RETURN : int32_t type of status 8001 * NO_ERROR -- success 8002 * none-zero failure code 8003 *==========================================================================*/ 8004 int32_t QCameraParameters::setFrameSkip(enum msm_vfe_frame_skip_pattern pattern) 8005 { 8006 int32_t rc = NO_ERROR; 8007 int32_t value = (int32_t)pattern; 8008 8009 if ( m_pParamBuf == NULL ) { 8010 return NO_INIT; 8011 } 8012 8013 if(initBatchUpdate(m_pParamBuf) < 0 ) { 8014 ALOGE("%s:Failed to initialize group update table", __func__); 8015 return BAD_TYPE; 8016 } 8017 8018 rc = AddSetParmEntryToBatch(m_pParamBuf, 8019 CAM_INTF_PARM_FRAMESKIP, 8020 sizeof(value), 8021 &value); 8022 if (rc != NO_ERROR) { 8023 ALOGE("%s:Failed to update table", __func__); 8024 return rc; 8025 } 8026 8027 rc = commitSetBatch(); 8028 if (rc != NO_ERROR) { 8029 ALOGE("%s:Failed to set frameskip info parm", __func__); 8030 return rc; 8031 } 8032 8033 return rc; 8034 } 8035 8036 int32_t QCameraParameters::updateRAW(cam_dimension_t max_dim) 8037 { 8038 int32_t rc = NO_ERROR; 8039 cam_dimension_t raw_dim; 8040 8041 if (max_dim.width == 0 || max_dim.height == 0) { 8042 max_dim = m_pCapability->raw_dim[0]; 8043 } 8044 8045 if(initBatchUpdate(m_pParamBuf) < 0 ) { 8046 ALOGE("%s:Failed to initialize group update table", __func__); 8047 return BAD_TYPE; 8048 } 8049 8050 rc = AddSetParmEntryToBatch(m_pParamBuf, 8051 CAM_INTF_PARM_MAX_DIMENSION, 8052 sizeof(cam_dimension_t), 8053 &max_dim); 8054 if (rc != NO_ERROR) { 8055 ALOGE("%s:Failed to update table for CAM_INTF_PARM_MAX_DIMENSION ", __func__); 8056 return rc; 8057 } 8058 8059 rc = commitSetBatch(); 8060 if (rc != NO_ERROR) { 8061 ALOGE("%s:Failed to set lock CAM_INTF_PARM_MAX_DIMENSION parm", __func__); 8062 return rc; 8063 } 8064 8065 if(initBatchUpdate(m_pParamBuf) < 0 ) { 8066 ALOGE("%s:Failed to initialize group update table", __func__); 8067 return BAD_TYPE; 8068 } 8069 8070 rc = AddGetParmEntryToBatch(m_pParamBuf, 8071 CAM_INTF_PARM_RAW_DIMENSION); 8072 if (rc != NO_ERROR) { 8073 ALOGE("%s:Failed to get CAM_INTF_PARM_RAW_DIMENSION", __func__); 8074 return rc; 8075 } 8076 8077 rc = commitGetBatch(); 8078 if (rc != NO_ERROR) { 8079 ALOGE("%s:Failed to get commit CAM_INTF_PARM_RAW_DIMENSION", __func__); 8080 return rc; 8081 } 8082 memcpy(&raw_dim, 8083 POINTER_OF_PARAM(CAM_INTF_PARM_RAW_DIMENSION,m_pParamBuf), 8084 sizeof(cam_dimension_t)); 8085 CDBG_HIGH("%s : RAW Dimension = %d X %d",__func__,raw_dim.width,raw_dim.height); 8086 if (raw_dim.width == 0 || raw_dim.height == 0) { 8087 ALOGE("%s: Error getting RAW size. Setting to Capability value",__func__); 8088 raw_dim = m_pCapability->raw_dim[0]; 8089 } 8090 setRawSize(raw_dim); 8091 return rc; 8092 } 8093 8094 /*=========================================================================== 8095 * FUNCTION : setHDRSceneEnable 8096 * 8097 * DESCRIPTION: sets hdr scene deteced flag 8098 * 8099 * PARAMETERS : 8100 * @bflag : hdr scene deteced 8101 * 8102 * RETURN : nothing 8103 *==========================================================================*/ 8104 void QCameraParameters::setHDRSceneEnable(bool bflag) 8105 { 8106 bool bupdate = false; 8107 if (m_HDRSceneEnabled != bflag) { 8108 bupdate = true; 8109 } 8110 m_HDRSceneEnabled = bflag; 8111 8112 if (bupdate) { 8113 updateFlash(true); 8114 } 8115 } 8116 8117 /*=========================================================================== 8118 * FUNCTION : getASDStateString 8119 * 8120 * DESCRIPTION: get ASD result in string format 8121 * 8122 * PARAMETERS : 8123 * @scene : selected scene mode 8124 * 8125 * RETURN : int32_t type of status 8126 * NO_ERROR -- success 8127 * none-zero failure code 8128 *==========================================================================*/ 8129 const char *QCameraParameters::getASDStateString(cam_auto_scene_t scene) 8130 { 8131 switch (scene) { 8132 case S_NORMAL : 8133 return "Normal"; 8134 case S_SCENERY: 8135 return "Scenery"; 8136 case S_PORTRAIT: 8137 return "Portrait"; 8138 case S_PORTRAIT_BACKLIGHT: 8139 return "Portrait-Backlight"; 8140 case S_SCENERY_BACKLIGHT: 8141 return "Scenery-Backlight"; 8142 case S_BACKLIGHT: 8143 return "Backlight"; 8144 default: 8145 return "<Unknown!>"; 8146 } 8147 } 8148 8149 /*=========================================================================== 8150 * FUNCTION : parseNDimVector 8151 * 8152 * DESCRIPTION: helper function to parse a string like "(1, 2, 3, 4, ..., N)" 8153 * into N-dimension vector 8154 * 8155 * PARAMETERS : 8156 * @str : string to be parsed 8157 * @num : output array of size N to store vector element values 8158 * @N : number of dimension 8159 * @delim : delimeter to seperete string 8160 * 8161 * RETURN : int32_t type of status 8162 * NO_ERROR -- success 8163 * none-zero failure code 8164 *==========================================================================*/ 8165 int32_t QCameraParameters::parseNDimVector(const char *str, int *num, int N, char delim = ',') 8166 { 8167 char *start, *end; 8168 if (num == NULL) { 8169 ALOGE("%s: Invalid output array (num == NULL)", __func__); 8170 return BAD_VALUE; 8171 } 8172 8173 //check if string starts and ends with parantheses 8174 if(str[0] != '(' || str[strlen(str)-1] != ')') { 8175 ALOGE("%s: Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)", 8176 __func__, str); 8177 return BAD_VALUE; 8178 } 8179 start = (char*) str; 8180 start++; 8181 for(int i=0; i<N; i++) { 8182 *(num+i) = (int) strtol(start, &end, 10); 8183 if(*end != delim && i < N-1) { 8184 ALOGE("%s: Cannot find delimeter '%c' in string \"%s\". end = %c", 8185 __func__, delim, str, *end); 8186 return -1; 8187 } 8188 start = end+1; 8189 } 8190 return NO_ERROR; 8191 } 8192 8193 /*=========================================================================== 8194 * FUNCTION : parseCameraAreaString 8195 * 8196 * DESCRIPTION: helper function to parse a string of camera areas like 8197 * "(1, 2, 3, 4, 5),(1, 2, 3, 4, 5),..." 8198 * 8199 * PARAMETERS : 8200 * @str : string to be parsed 8201 * @max_num_areas : max number of areas 8202 * @pAreas : ptr to struct to store areas 8203 * @num_areas_found : number of areas found 8204 * 8205 * RETURN : int32_t type of status 8206 * NO_ERROR -- success 8207 * none-zero failure code 8208 *==========================================================================*/ 8209 int32_t QCameraParameters::parseCameraAreaString(const char *str, 8210 int max_num_areas, 8211 cam_area_t *pAreas, 8212 int& num_areas_found) 8213 { 8214 char area_str[32]; 8215 const char *start, *end, *p; 8216 start = str; end = NULL; 8217 int values[5], index=0; 8218 num_areas_found = 0; 8219 8220 memset(values, 0, sizeof(values)); 8221 while(start != NULL) { 8222 if(*start != '(') { 8223 ALOGE("%s: error: Ill formatted area string: %s", __func__, str); 8224 return BAD_VALUE; 8225 } 8226 end = strchr(start, ')'); 8227 if(end == NULL) { 8228 ALOGE("%s: error: Ill formatted area string: %s", __func__, str); 8229 return BAD_VALUE; 8230 } 8231 int i; 8232 for (i=0,p=start; p<=end; p++, i++) { 8233 area_str[i] = *p; 8234 } 8235 area_str[i] = '\0'; 8236 if(parseNDimVector(area_str, values, 5) < 0){ 8237 ALOGE("%s: error: Failed to parse the area string: %s", __func__, area_str); 8238 return BAD_VALUE; 8239 } 8240 // no more areas than max_num_areas are accepted. 8241 if(index >= max_num_areas) { 8242 ALOGE("%s: error: too many areas specified %s", __func__, str); 8243 return BAD_VALUE; 8244 } 8245 pAreas[index].rect.left = values[0]; 8246 pAreas[index].rect.top = values[1]; 8247 pAreas[index].rect.width = values[2] - values[0]; 8248 pAreas[index].rect.height = values[3] - values[1]; 8249 pAreas[index].weight = values[4]; 8250 8251 index++; 8252 start = strchr(end, '('); // serach for next '(' 8253 } 8254 num_areas_found = index; 8255 return 0; 8256 } 8257 8258 /*=========================================================================== 8259 * FUNCTION : validateCameraAreas 8260 * 8261 * DESCRIPTION: helper function to validate camera areas within (-1000, 1000) 8262 * 8263 * PARAMETERS : 8264 * @areas : ptr to array of areas 8265 * @num_areas : number of areas 8266 * 8267 * RETURN : true -- area is in valid range 8268 * false -- not valid 8269 *==========================================================================*/ 8270 bool QCameraParameters::validateCameraAreas(cam_area_t *areas, int num_areas) 8271 { 8272 // special case: default area 8273 if (num_areas == 1 && 8274 areas[0].rect.left == 0 && 8275 areas[0].rect.top == 0 && 8276 areas[0].rect.width == 0 && 8277 areas[0].rect.height == 0 && 8278 areas[0].weight == 0) { 8279 return true; 8280 } 8281 8282 for(int i = 0; i < num_areas; i++) { 8283 // left should be >= -1000 8284 if(areas[i].rect.left < -1000) { 8285 return false; 8286 } 8287 8288 // top should be >= -1000 8289 if(areas[i].rect.top < -1000) { 8290 return false; 8291 } 8292 8293 // width or height should be > 0 8294 if (areas[i].rect.width <= 0 || areas[i].rect.height <= 0) { 8295 return false; 8296 } 8297 8298 // right should be <= 1000 8299 if(areas[i].rect.left + areas[i].rect.width > 1000) { 8300 return false; 8301 } 8302 8303 // bottom should be <= 1000 8304 if(areas[i].rect.top + areas[i].rect.height > 1000) { 8305 return false; 8306 } 8307 8308 // weight should be within (1, 1000) 8309 if (areas[i].weight < 1 || areas[i].weight > 1000) { 8310 return false; 8311 } 8312 } 8313 return true; 8314 } 8315 8316 /*=========================================================================== 8317 * FUNCTION : isYUVFrameInfoNeeded 8318 * 8319 * DESCRIPTION: In AE-Bracket mode, we need set yuv buffer information for up-layer 8320 * 8321 * PARAMETERS : none 8322 * 8323 * RETURN : true: needed 8324 * false: no need 8325 *==========================================================================*/ 8326 bool QCameraParameters::isYUVFrameInfoNeeded() 8327 { 8328 //In AE-Bracket mode, we need set raw buffer information for up-layer 8329 if(!isNV21PictureFormat() && !isNV16PictureFormat()){ 8330 return false; 8331 } 8332 const char *aecBracketStr = get(KEY_QC_AE_BRACKET_HDR); 8333 8334 int value = lookupAttr(BRACKETING_MODES_MAP, 8335 sizeof(BRACKETING_MODES_MAP)/sizeof(QCameraMap), 8336 aecBracketStr); 8337 CDBG_HIGH("%s: aecBracketStr=%s, value=%d.", __func__, aecBracketStr, value); 8338 return (value == CAM_EXP_BRACKETING_ON); 8339 } 8340 8341 /*=========================================================================== 8342 * FUNCTION : getFrameFmtString 8343 * 8344 * DESCRIPTION: get string name of frame format 8345 * 8346 * PARAMETERS : 8347 * @frame : frame format 8348 * 8349 * RETURN : string name of frame format 8350 *==========================================================================*/ 8351 const char *QCameraParameters::getFrameFmtString(cam_format_t fmt) 8352 { 8353 return lookupNameByValue(PICTURE_TYPES_MAP, 8354 sizeof(PICTURE_TYPES_MAP)/sizeof(QCameraMap), 8355 fmt); 8356 } 8357 8358 /*=========================================================================== 8359 * FUNCTION : initBatchUpdate 8360 * 8361 * DESCRIPTION: init camera parameters buf entries 8362 * 8363 * PARAMETERS : 8364 * @p_table : ptr to parameter buffer 8365 * 8366 * RETURN : int32_t type of status 8367 * NO_ERROR -- success 8368 * none-zero failure code 8369 *==========================================================================*/ 8370 int32_t QCameraParameters::initBatchUpdate(parm_buffer_t *p_table) 8371 { 8372 m_tempMap.clear(); 8373 8374 memset(p_table, 0, sizeof(parm_buffer_t)); 8375 return NO_ERROR; 8376 } 8377 8378 /*=========================================================================== 8379 * FUNCTION : AddSetParmEntryToBatch 8380 * 8381 * DESCRIPTION: add set parameter entry into batch 8382 * 8383 * PARAMETERS : 8384 * @p_table : ptr to parameter buffer 8385 * @paramType : parameter type 8386 * @paramLength : length of parameter value 8387 * @paramValue : ptr to parameter value 8388 * 8389 * RETURN : int32_t type of status 8390 * NO_ERROR -- success 8391 * none-zero failure code 8392 *==========================================================================*/ 8393 int32_t QCameraParameters::AddSetParmEntryToBatch(parm_buffer_t *p_table, 8394 cam_intf_parm_type_t paramType, 8395 uint32_t paramLength, 8396 void *paramValue) 8397 { 8398 void* dst; 8399 if ((NULL == p_table) || (NULL == paramValue) || 8400 (paramType >= CAM_INTF_PARM_MAX)) { 8401 ALOGE("%s: Error invalid param. p_table: %p, paramValue: %p, " 8402 "paramType: %d", __func__, p_table, paramValue, paramType); 8403 return BAD_VALUE; 8404 } 8405 /************************************************************************* 8406 * Copy contents into entry * 8407 *************************************************************************/ 8408 if (paramLength > get_size_of(paramType)) { 8409 ALOGE("%s:Size of input larger than max entry size. paramType: %d " 8410 "paramLength: %d sizeof(paramType): %d", 8411 __func__, paramType, paramLength, get_size_of(paramType)); 8412 return BAD_VALUE; 8413 } 8414 8415 dst = get_pointer_of(paramType, p_table); 8416 if (NULL != dst) { 8417 memcpy(dst, paramValue, paramLength); 8418 p_table->is_valid[paramType] = 1; 8419 } 8420 return NO_ERROR; 8421 } 8422 8423 /*=========================================================================== 8424 * FUNCTION : AddGetParmEntryToBatch 8425 * 8426 * DESCRIPTION: add get parameter entry into batch 8427 * 8428 * PARAMETERS : 8429 * @p_table : ptr to parameter buffer 8430 * @paramType : parameter type 8431 * 8432 * RETURN : int32_t type of status 8433 * NO_ERROR -- success 8434 * none-zero failure code 8435 *==========================================================================*/ 8436 int32_t QCameraParameters::AddGetParmEntryToBatch(parm_buffer_t *p_table, 8437 cam_intf_parm_type_t paramType) 8438 { 8439 if ((p_table == NULL) || (paramType >= CAM_INTF_PARM_MAX)) { 8440 ALOGE("%s: Error invalid param. p_table: %p, paramType: %d", 8441 __func__, p_table, paramType); 8442 return BAD_VALUE; 8443 } 8444 /* Set the is_reqd flag for this param so that backend can fill the value*/ 8445 p_table->is_reqd[paramType] = 1; 8446 8447 return NO_ERROR; 8448 } 8449 8450 /*=========================================================================== 8451 * FUNCTION : commitSetBatch 8452 * 8453 * DESCRIPTION: commit all set parameters in the batch work to backend 8454 * 8455 * PARAMETERS : none 8456 * 8457 * RETURN : int32_t type of status 8458 * NO_ERROR -- success 8459 * none-zero failure code 8460 *==========================================================================*/ 8461 int32_t QCameraParameters::commitSetBatch() 8462 { 8463 int32_t rc = NO_ERROR; 8464 int32_t i = 0; 8465 8466 /* Loop to check if atleast one entry is valid */ 8467 for(i = 0; i < CAM_INTF_PARM_MAX; i++){ 8468 if(m_pParamBuf->is_valid[i]) 8469 break; 8470 } 8471 8472 if (i < CAM_INTF_PARM_MAX) { 8473 rc = m_pCamOpsTbl->ops->set_parms(m_pCamOpsTbl->camera_handle, m_pParamBuf); 8474 } 8475 if (rc == NO_ERROR) { 8476 // commit change from temp storage into param map 8477 rc = commitParamChanges(); 8478 } 8479 return rc; 8480 } 8481 8482 /*=========================================================================== 8483 * FUNCTION : commitGetBatch 8484 * 8485 * DESCRIPTION: commit all get parameters in the batch work to backend 8486 * 8487 * PARAMETERS : none 8488 * 8489 * RETURN : int32_t type of status 8490 * NO_ERROR -- success 8491 * none-zero failure code 8492 *==========================================================================*/ 8493 int32_t QCameraParameters::commitGetBatch() 8494 { 8495 int32_t rc = NO_ERROR; 8496 int32_t i = 0; 8497 8498 /* Loop to check if atleast one entry is valid */ 8499 for(i = 0; i < CAM_INTF_PARM_MAX; i++){ 8500 if(m_pParamBuf->is_valid[i]) 8501 break; 8502 } 8503 8504 if (i < CAM_INTF_PARM_MAX) { 8505 return m_pCamOpsTbl->ops->get_parms(m_pCamOpsTbl->camera_handle, m_pParamBuf); 8506 } else { 8507 return NO_ERROR; 8508 } 8509 return rc; 8510 } 8511 8512 /*=========================================================================== 8513 * FUNCTION : updateParamEntry 8514 * 8515 * DESCRIPTION: update a parameter entry in the local temp map obj 8516 * 8517 * PARAMETERS : 8518 * @key : key of the entry 8519 * @value : value of the entry 8520 * 8521 * RETURN : int32_t type of status 8522 * NO_ERROR -- success 8523 * none-zero failure code 8524 *==========================================================================*/ 8525 int32_t QCameraParameters::updateParamEntry(const char *key, const char *value) 8526 { 8527 m_tempMap.replaceValueFor(String8(key), String8(value)); 8528 return NO_ERROR; 8529 } 8530 8531 /*=========================================================================== 8532 * FUNCTION : commitParamChanges 8533 * 8534 * DESCRIPTION: commit all changes in local temp map obj into parameter obj 8535 * 8536 * PARAMETERS : none 8537 * 8538 * RETURN : int32_t type of status 8539 * NO_ERROR -- success 8540 * none-zero failure code 8541 *==========================================================================*/ 8542 int32_t QCameraParameters::commitParamChanges() 8543 { 8544 size_t size = m_tempMap.size(); 8545 for (size_t i = 0; i < size; i++) { 8546 String8 k, v; 8547 k = m_tempMap.keyAt(i); 8548 v = m_tempMap.valueAt(i); 8549 set(k, v); 8550 } 8551 m_tempMap.clear(); 8552 8553 // update local changes 8554 m_bRecordingHint = m_bRecordingHint_new; 8555 m_bZslMode = m_bZslMode_new; 8556 8557 /* After applying scene mode auto, 8558 Camera effects need to be reapplied */ 8559 if ( m_bSceneTransitionAuto ) { 8560 m_bUpdateEffects = true; 8561 m_bSceneTransitionAuto = false; 8562 } 8563 8564 if ( m_bReleaseTorchCamera && ( NULL != m_pTorch) ) { 8565 m_pTorch->releaseTorchCamera(); 8566 m_bReleaseTorchCamera = false; 8567 } 8568 8569 8570 return NO_ERROR; 8571 } 8572 8573 /*=========================================================================== 8574 * FUNCTION : QCameraReprocScaleParam 8575 * 8576 * DESCRIPTION: constructor of QCameraReprocScaleParam 8577 * 8578 * PARAMETERS : none 8579 * 8580 * RETURN : none 8581 *==========================================================================*/ 8582 QCameraReprocScaleParam::QCameraReprocScaleParam(QCameraParameters *parent) 8583 : mParent(parent), 8584 mScaleEnabled(false), 8585 mIsUnderScaling(false), 8586 mScaleDirection(0), 8587 mNeedScaleCnt(0), 8588 mSensorSizeTblCnt(0), 8589 mSensorSizeTbl(NULL), 8590 mTotalSizeTblCnt(0) 8591 { 8592 mPicSizeFromAPK.width = 0; 8593 mPicSizeFromAPK.height = 0; 8594 mPicSizeSetted.width = 0; 8595 mPicSizeSetted.height = 0; 8596 memset(mNeedScaledSizeTbl, 0, sizeof(mNeedScaledSizeTbl)); 8597 memset(mTotalSizeTbl, 0, sizeof(mTotalSizeTbl)); 8598 } 8599 8600 /*=========================================================================== 8601 * FUNCTION : ~~QCameraReprocScaleParam 8602 * 8603 * DESCRIPTION: destructor of QCameraReprocScaleParam 8604 * 8605 * PARAMETERS : none 8606 * 8607 * RETURN : none 8608 *==========================================================================*/ 8609 QCameraReprocScaleParam::~QCameraReprocScaleParam() 8610 { 8611 //do nothing now. 8612 } 8613 8614 /*=========================================================================== 8615 * FUNCTION : setScaledSizeTbl 8616 * 8617 * DESCRIPTION: re-set picture size table with dimensions that need scaling if Reproc Scale is enabled 8618 * 8619 * PARAMETERS : 8620 * @scale_cnt : count of picture sizes that want scale 8621 * @scale_tbl : picture size table that want scale 8622 * @org_cnt : sensor supported picture size count 8623 * @org_tbl : sensor supported picture size table 8624 * 8625 * RETURN : int32_t type of status 8626 * NO_ERROR -- success 8627 * none-zero failure code 8628 *==========================================================================*/ 8629 int32_t QCameraReprocScaleParam::setScaleSizeTbl(uint8_t scale_cnt, cam_dimension_t *scale_tbl, uint8_t org_cnt, cam_dimension_t *org_tbl) 8630 { 8631 int32_t rc = NO_ERROR; 8632 int i; 8633 mNeedScaleCnt = 0; 8634 8635 if(!mScaleEnabled || scale_cnt <=0 || scale_tbl == NULL || org_cnt <=0 || org_tbl == NULL){ 8636 return BAD_VALUE; // Do not need scale, so also need not reset picture size table 8637 } 8638 8639 mSensorSizeTblCnt = org_cnt; 8640 mSensorSizeTbl = org_tbl; 8641 mNeedScaleCnt = checkScaleSizeTable(scale_cnt, scale_tbl, org_cnt, org_tbl); 8642 if(mNeedScaleCnt <= 0){ 8643 ALOGE("%s: do not have picture sizes need scaling.", __func__); 8644 return BAD_VALUE; 8645 } 8646 8647 if(mNeedScaleCnt + org_cnt > MAX_SIZES_CNT){ 8648 ALOGE("%s: picture size list exceed the max count.", __func__); 8649 return BAD_VALUE; 8650 } 8651 8652 //get the total picture size table 8653 mTotalSizeTblCnt = mNeedScaleCnt + org_cnt; 8654 for(i = 0; i < mNeedScaleCnt; i++){ 8655 mTotalSizeTbl[i].width = mNeedScaledSizeTbl[i].width; 8656 mTotalSizeTbl[i].height = mNeedScaledSizeTbl[i].height; 8657 CDBG_HIGH("%s: scale picture size: i =%d, width=%d, height=%d.", __func__, 8658 i, mTotalSizeTbl[i].width, mTotalSizeTbl[i].height); 8659 } 8660 for(; i < mTotalSizeTblCnt; i++){ 8661 mTotalSizeTbl[i].width = org_tbl[i-mNeedScaleCnt].width; 8662 mTotalSizeTbl[i].height = org_tbl[i-mNeedScaleCnt].height; 8663 CDBG_HIGH("%s: sensor supportted picture size: i =%d, width=%d, height=%d.", __func__, 8664 i, mTotalSizeTbl[i].width, mTotalSizeTbl[i].height); 8665 } 8666 return rc; 8667 } 8668 8669 /*=========================================================================== 8670 * FUNCTION : getScaledSizeTblCnt 8671 * 8672 * DESCRIPTION: get picture size cnt that need scale 8673 * 8674 * PARAMETERS : none 8675 * 8676 * RETURN : uint8_t type of picture size count 8677 *==========================================================================*/ 8678 uint8_t QCameraReprocScaleParam::getScaleSizeTblCnt() 8679 { 8680 return mNeedScaleCnt; 8681 } 8682 8683 /*=========================================================================== 8684 * FUNCTION : getScaledSizeTbl 8685 * 8686 * DESCRIPTION: get picture size table that need scale 8687 * 8688 * PARAMETERS : none 8689 * 8690 * RETURN : cam_dimension_t list of picture size table 8691 *==========================================================================*/ 8692 cam_dimension_t *QCameraReprocScaleParam::getScaledSizeTbl() 8693 { 8694 if(!mScaleEnabled) 8695 return NULL; 8696 8697 return mNeedScaledSizeTbl; 8698 } 8699 8700 /*=========================================================================== 8701 * FUNCTION : setScaleEnable 8702 * 8703 * DESCRIPTION: enable or disable Reproc Scale 8704 * 8705 * PARAMETERS : 8706 * @enabled : enable: 1; disable 0 8707 * 8708 * RETURN : none 8709 *==========================================================================*/ 8710 void QCameraReprocScaleParam::setScaleEnable(bool enabled) 8711 { 8712 mScaleEnabled = enabled; 8713 } 8714 8715 /*=========================================================================== 8716 * FUNCTION : isScaleEnabled 8717 * 8718 * DESCRIPTION: check if Reproc Scale is enabled 8719 * 8720 * PARAMETERS : none 8721 * 8722 * RETURN : bool type of status 8723 *==========================================================================*/ 8724 bool QCameraReprocScaleParam::isScaleEnabled() 8725 { 8726 return mScaleEnabled; 8727 } 8728 8729 /*=========================================================================== 8730 * FUNCTION : isScalePicSize 8731 * 8732 * DESCRIPTION: check if current picture size is from Scale Table 8733 * 8734 * PARAMETERS : 8735 * @width : current picture width 8736 * @height : current picture height 8737 * 8738 * RETURN : bool type of status 8739 *==========================================================================*/ 8740 bool QCameraReprocScaleParam::isScalePicSize(int width, int height) 8741 { 8742 //Check if the picture size is in scale table 8743 if(mNeedScaleCnt <= 0) 8744 return FALSE; 8745 8746 for(int i = 0; i < mNeedScaleCnt; i++){ 8747 if(mNeedScaledSizeTbl[i].width == width 8748 && mNeedScaledSizeTbl[i].height == height){ 8749 //found match 8750 return TRUE; 8751 } 8752 } 8753 8754 ALOGE("%s: Not in scale picture size table.", __func__); 8755 return FALSE; 8756 } 8757 8758 /*=========================================================================== 8759 * FUNCTION : isValidatePicSize 8760 * 8761 * DESCRIPTION: check if current picture size is validate 8762 * 8763 * PARAMETERS : 8764 * @width : current picture width 8765 * @height : current picture height 8766 * 8767 * RETURN : bool type of status 8768 *==========================================================================*/ 8769 bool QCameraReprocScaleParam::isValidatePicSize(int width, int height) 8770 { 8771 int i = 0; 8772 8773 for(i = 0; i < mSensorSizeTblCnt; i++){ 8774 if(mSensorSizeTbl[i].width == width 8775 && mSensorSizeTbl[i].height== height){ 8776 return TRUE; 8777 } 8778 } 8779 8780 for(i = 0; i < mNeedScaleCnt; i++){ 8781 if(mNeedScaledSizeTbl[i].width == width 8782 && mNeedScaledSizeTbl[i].height== height){ 8783 return TRUE; 8784 } 8785 } 8786 8787 ALOGE("%s: Invalidate input picture size.", __func__); 8788 return FALSE; 8789 } 8790 8791 /*=========================================================================== 8792 * FUNCTION : setSensorSupportedPicSize 8793 * 8794 * DESCRIPTION: set sensor supported picture size. 8795 * For Snapshot stream size configuration, we need use sensor supported size. 8796 * We will use CPP to do Scaling based on output Snapshot stream. 8797 * 8798 * PARAMETERS : none 8799 * 8800 * RETURN : int32_t type of status 8801 * NO_ERROR -- success 8802 * none-zero failure code 8803 *==========================================================================*/ 8804 int32_t QCameraReprocScaleParam::setSensorSupportedPicSize() 8805 { 8806 //will find a suitable picture size (here we leave a prossibility to add other scale requirement) 8807 //Currently we only focus on upscaling, and checkScaleSizeTable() has guaranteed the dimension ratio. 8808 8809 if(!mIsUnderScaling || mSensorSizeTblCnt <= 0) 8810 return BAD_VALUE; 8811 8812 //We just get the max sensor supported size here. 8813 mPicSizeSetted.width = mSensorSizeTbl[0].width; 8814 mPicSizeSetted.height = mSensorSizeTbl[0].height; 8815 8816 return NO_ERROR; 8817 } 8818 8819 8820 /*=========================================================================== 8821 * FUNCTION : setValidatePicSize 8822 * 8823 * DESCRIPTION: set sensor supported size and change scale status. 8824 * 8825 * PARAMETERS : 8826 * @width : input picture width 8827 * @height : input picture height 8828 * 8829 * RETURN : int32_t type of status 8830 * NO_ERROR -- success 8831 * none-zero failure code 8832 *==========================================================================*/ 8833 int32_t QCameraReprocScaleParam::setValidatePicSize(int &width,int &height) 8834 { 8835 if(!mScaleEnabled) 8836 return BAD_VALUE; 8837 8838 mIsUnderScaling = FALSE; //default: not under scale 8839 8840 if(isScalePicSize(width, height)){ 8841 // input picture size need scaling operation. Record size from APK and setted 8842 mIsUnderScaling = TRUE; 8843 mPicSizeFromAPK.width = width; 8844 mPicSizeFromAPK.height = height; 8845 8846 if(setSensorSupportedPicSize() != NO_ERROR) 8847 return BAD_VALUE; 8848 8849 //re-set picture size to sensor supported size 8850 width = mPicSizeSetted.width; 8851 height = mPicSizeSetted.height; 8852 CDBG_HIGH("%s: mPicSizeFromAPK- with=%d, height=%d, mPicSizeSetted- with =%d, height=%d.", 8853 __func__, mPicSizeFromAPK.width, mPicSizeFromAPK.height, mPicSizeSetted.width, mPicSizeSetted.height); 8854 }else{ 8855 mIsUnderScaling = FALSE; 8856 //no scale is needed for input picture size 8857 if(!isValidatePicSize(width, height)){ 8858 ALOGE("%s: invalidate input picture size.", __func__); 8859 return BAD_VALUE; 8860 } 8861 mPicSizeSetted.width = width; 8862 mPicSizeSetted.height = height; 8863 } 8864 8865 CDBG_HIGH("%s: X. mIsUnderScaling=%d, width=%d, height=%d.", __func__, mIsUnderScaling, width, height); 8866 return NO_ERROR; 8867 } 8868 8869 /*=========================================================================== 8870 * FUNCTION : getPicSizeFromAPK 8871 * 8872 * DESCRIPTION: get picture size that get from APK 8873 * 8874 * PARAMETERS : 8875 * @width : input width 8876 * @height : input height 8877 * 8878 * RETURN : int32_t type of status 8879 * NO_ERROR -- success 8880 * none-zero failure code 8881 *==========================================================================*/ 8882 int32_t QCameraReprocScaleParam::getPicSizeFromAPK(int &width, int &height) 8883 { 8884 if(!mIsUnderScaling) 8885 return BAD_VALUE; 8886 8887 width = mPicSizeFromAPK.width; 8888 height = mPicSizeFromAPK.height; 8889 return NO_ERROR; 8890 } 8891 8892 /*=========================================================================== 8893 * FUNCTION : getPicSizeSetted 8894 * 8895 * DESCRIPTION: get picture size that setted into mm-camera 8896 * 8897 * PARAMETERS : 8898 * @width : input width 8899 * @height : input height 8900 * 8901 * RETURN : int32_t type of status 8902 * NO_ERROR -- success 8903 * none-zero failure code 8904 *==========================================================================*/ 8905 int32_t QCameraReprocScaleParam::getPicSizeSetted(int &width, int &height) 8906 { 8907 width = mPicSizeSetted.width; 8908 height = mPicSizeSetted.height; 8909 return NO_ERROR; 8910 } 8911 8912 /*=========================================================================== 8913 * FUNCTION : isUnderScaling 8914 * 8915 * DESCRIPTION: check if we are in Reproc Scaling requirment 8916 * 8917 * PARAMETERS : none 8918 * 8919 * RETURN : bool type of status 8920 *==========================================================================*/ 8921 bool QCameraReprocScaleParam::isUnderScaling() 8922 { 8923 return mIsUnderScaling; 8924 } 8925 8926 /*=========================================================================== 8927 * FUNCTION : checkScaleSizeTable 8928 * 8929 * DESCRIPTION: check PICTURE_SIZE_NEED_SCALE to choose 8930 * 8931 * PARAMETERS : 8932 * @scale_cnt : count of picture sizes that want scale 8933 * @scale_tbl : picture size table that want scale 8934 * @org_cnt : sensor supported picture size count 8935 * @org_tbl : sensor supported picture size table 8936 * 8937 * RETURN : bool type of status 8938 *==========================================================================*/ 8939 uint8_t QCameraReprocScaleParam::checkScaleSizeTable(uint8_t scale_cnt, cam_dimension_t *scale_tbl, uint8_t org_cnt, cam_dimension_t *org_tbl) 8940 { 8941 uint8_t stbl_cnt = 0; 8942 uint8_t temp_cnt = 0; 8943 int i = 0; 8944 if(scale_cnt <=0 || scale_tbl == NULL || org_tbl == NULL || org_cnt <= 0) 8945 return stbl_cnt; 8946 8947 //get validate scale size table. Currently we only support: 8948 // 1. upscale. The scale size must larger than max sensor supported size 8949 // 2. Scale dimension ratio must be same as the max sensor supported size. 8950 temp_cnt = scale_cnt; 8951 for(i = scale_cnt-1; i >= 0; i--){ 8952 if(scale_tbl[i].width > org_tbl[0].width || 8953 (scale_tbl[i].width == org_tbl[0].width && 8954 scale_tbl[i].height > org_tbl[0].height)){ 8955 //get the smallest scale size 8956 break; 8957 } 8958 temp_cnt--; 8959 } 8960 8961 //check dimension ratio 8962 double supported_ratio = (double)org_tbl[0].width/ (double)org_tbl[0].height; 8963 for(i = 0; i < temp_cnt; i++){ 8964 double cur_ratio = (double)scale_tbl[i].width/ (double)scale_tbl[i].height; 8965 if(fabs(supported_ratio - cur_ratio) > ASPECT_TOLERANCE){ 8966 continue; 8967 } 8968 mNeedScaledSizeTbl[stbl_cnt].width = scale_tbl[i].width; 8969 mNeedScaledSizeTbl[stbl_cnt].height= scale_tbl[i].height; 8970 stbl_cnt++; 8971 } 8972 8973 return stbl_cnt; 8974 } 8975 8976 /*=========================================================================== 8977 * FUNCTION : getTotalSizeTblCnt 8978 * 8979 * DESCRIPTION: get total picture size count after adding dimensions that need scaling 8980 * 8981 * PARAMETERS : none 8982 * 8983 * RETURN : uint8_t type of picture size count 8984 *==========================================================================*/ 8985 uint8_t QCameraReprocScaleParam::getTotalSizeTblCnt() 8986 { 8987 return mTotalSizeTblCnt; 8988 } 8989 8990 /*=========================================================================== 8991 * FUNCTION : getTotalSizeTbl 8992 * 8993 * DESCRIPTION: get picture size table after adding dimensions that need scaling 8994 * 8995 * PARAMETERS : none 8996 * 8997 * RETURN : cam_dimension_t list of picture size table 8998 *==========================================================================*/ 8999 cam_dimension_t *QCameraReprocScaleParam::getTotalSizeTbl() 9000 { 9001 if(!mScaleEnabled) 9002 return NULL; 9003 9004 return mTotalSizeTbl; 9005 } 9006 9007 /*=========================================================================== 9008 * FUNCTION : isHDREnabled 9009 * 9010 * DESCRIPTION: if HDR is enabled 9011 * 9012 * PARAMETERS : none 9013 * 9014 * RETURN : true: needed 9015 * false: no need 9016 *==========================================================================*/ 9017 bool QCameraParameters::isHDREnabled() 9018 { 9019 return ((m_nBurstNum == 1) && (m_bHDREnabled || m_HDRSceneEnabled)); 9020 } 9021 9022 /*=========================================================================== 9023 * FUNCTION : isAVTimerEnabled 9024 * 9025 * DESCRIPTION: if AVTimer is enabled 9026 * 9027 * PARAMETERS : none 9028 * 9029 * RETURN : true: needed 9030 * false: no need 9031 *==========================================================================*/ 9032 bool QCameraParameters::isAVTimerEnabled() 9033 { 9034 return m_bAVTimerEnabled; 9035 } 9036 9037 /*=========================================================================== 9038 * FUNCTION : isDISEnabled 9039 * 9040 * DESCRIPTION: if DIS is enabled 9041 * 9042 * PARAMETERS : none 9043 * 9044 * RETURN : true: needed 9045 * false: no need 9046 *==========================================================================*/ 9047 bool QCameraParameters::isDISEnabled() 9048 { 9049 return m_bDISEnabled; 9050 } 9051 9052 /*=========================================================================== 9053 * FUNCTION : setStreamConfigure 9054 * 9055 * DESCRIPTION: set stream type, stream dimension for all configured streams. 9056 * 9057 * PARAMETERS : 9058 * @isCapture: Whether this configureation is for an image capture 9059 * @previewAsPostview: Use preview as postview 9060 * 9061 * RETURN : int32_t type of status 9062 * NO_ERROR -- success 9063 * none-zero failure code 9064 *==========================================================================*/ 9065 bool QCameraParameters::setStreamConfigure(bool isCapture, bool previewAsPostview) 9066 { 9067 int32_t rc = NO_ERROR; 9068 cam_stream_size_info_t stream_config_info; 9069 char value[PROPERTY_VALUE_MAX]; 9070 bool raw_yuv = false; 9071 9072 if ( m_pParamBuf == NULL ) { 9073 return NO_INIT; 9074 } 9075 9076 memset(&stream_config_info, 0, sizeof(stream_config_info)); 9077 stream_config_info.num_streams = 0; 9078 9079 property_get("persist.camera.raw_yuv", value, "0"); 9080 raw_yuv = atoi(value) > 0 ? true : false; 9081 9082 if (isZSLMode() && getRecordingHintValue() != true) { 9083 stream_config_info.type[stream_config_info.num_streams] = 9084 CAM_STREAM_TYPE_PREVIEW; 9085 getStreamDimension(CAM_STREAM_TYPE_PREVIEW, 9086 stream_config_info.stream_sizes[stream_config_info.num_streams]); 9087 stream_config_info.num_streams++; 9088 9089 stream_config_info.type[stream_config_info.num_streams] = 9090 CAM_STREAM_TYPE_SNAPSHOT; 9091 getStreamDimension(CAM_STREAM_TYPE_SNAPSHOT, 9092 stream_config_info.stream_sizes[stream_config_info.num_streams]); 9093 stream_config_info.num_streams++; 9094 9095 } else if (!isCapture) { 9096 if (m_bRecordingHint) { 9097 if (!is4k2kVideoResolution()) { 9098 stream_config_info.type[stream_config_info.num_streams] = 9099 CAM_STREAM_TYPE_SNAPSHOT; 9100 getStreamDimension(CAM_STREAM_TYPE_SNAPSHOT, 9101 stream_config_info.stream_sizes[stream_config_info.num_streams]); 9102 stream_config_info.num_streams++; 9103 } 9104 9105 stream_config_info.type[stream_config_info.num_streams] = 9106 CAM_STREAM_TYPE_VIDEO; 9107 getStreamDimension(CAM_STREAM_TYPE_VIDEO, 9108 stream_config_info.stream_sizes[stream_config_info.num_streams]); 9109 stream_config_info.num_streams++; 9110 } 9111 9112 stream_config_info.type[stream_config_info.num_streams] = 9113 CAM_STREAM_TYPE_PREVIEW; 9114 getStreamDimension(CAM_STREAM_TYPE_PREVIEW, 9115 stream_config_info.stream_sizes[stream_config_info.num_streams]); 9116 stream_config_info.num_streams++; 9117 } else { 9118 if (isJpegPictureFormat() || isNV16PictureFormat() || isNV21PictureFormat()) { 9119 stream_config_info.type[stream_config_info.num_streams] = 9120 CAM_STREAM_TYPE_SNAPSHOT; 9121 getStreamDimension(CAM_STREAM_TYPE_SNAPSHOT, 9122 stream_config_info.stream_sizes[stream_config_info.num_streams]); 9123 stream_config_info.num_streams++; 9124 9125 if (previewAsPostview) { 9126 stream_config_info.type[stream_config_info.num_streams] = 9127 CAM_STREAM_TYPE_PREVIEW; 9128 getStreamDimension(CAM_STREAM_TYPE_PREVIEW, 9129 stream_config_info.stream_sizes[stream_config_info.num_streams]); 9130 stream_config_info.num_streams++; 9131 } else { 9132 stream_config_info.type[stream_config_info.num_streams] = 9133 CAM_STREAM_TYPE_POSTVIEW; 9134 getStreamDimension(CAM_STREAM_TYPE_POSTVIEW, 9135 stream_config_info.stream_sizes[stream_config_info.num_streams]); 9136 stream_config_info.num_streams++; 9137 } 9138 } 9139 } 9140 if (raw_yuv) { 9141 stream_config_info.type[stream_config_info.num_streams] = 9142 CAM_STREAM_TYPE_RAW; 9143 getStreamDimension(CAM_STREAM_TYPE_RAW, 9144 stream_config_info.stream_sizes[stream_config_info.num_streams]); 9145 stream_config_info.num_streams++; 9146 } 9147 9148 if(initBatchUpdate(m_pParamBuf) < 0 ) { 9149 ALOGE("%s:Failed to initialize group update table", __func__); 9150 return BAD_TYPE; 9151 } 9152 9153 rc = AddSetParmEntryToBatch(m_pParamBuf, 9154 CAM_INTF_META_STREAM_INFO, 9155 sizeof(stream_config_info), 9156 &stream_config_info); 9157 if (rc != NO_ERROR) { 9158 ALOGE("%s:Failed to update table", __func__); 9159 return rc; 9160 } 9161 9162 rc = commitSetBatch(); 9163 if (rc != NO_ERROR) { 9164 ALOGE("%s:Failed to set stream info parm", __func__); 9165 return rc; 9166 } 9167 9168 return rc; 9169 } 9170 9171 /*=========================================================================== 9172 * FUNCTION : needThumbnailReprocess 9173 * 9174 * DESCRIPTION: Check if thumbnail reprocessing is needed 9175 * 9176 * PARAMETERS : @pFeatureMask - feature mask 9177 * 9178 * RETURN : true: needed 9179 * false: no need 9180 *==========================================================================*/ 9181 bool QCameraParameters::needThumbnailReprocess(uint32_t *pFeatureMask) 9182 { 9183 if (isUbiFocusEnabled() || isChromaFlashEnabled() || 9184 isOptiZoomEnabled()) { 9185 *pFeatureMask &= ~CAM_QCOM_FEATURE_CHROMA_FLASH; 9186 *pFeatureMask &= ~CAM_QCOM_FEATURE_UBIFOCUS; 9187 *pFeatureMask &= ~CAM_QCOM_FEATURE_OPTIZOOM; 9188 return false; 9189 } else { 9190 return true; 9191 } 9192 } 9193 9194 /*=========================================================================== 9195 * FUNCTION : getNumOfExtraBuffersForImageProc 9196 * 9197 * DESCRIPTION: get number of extra input buffers needed by image processing 9198 * 9199 * PARAMETERS : none 9200 * 9201 * RETURN : number of extra buffers needed by ImageProc; 9202 * 0 if not ImageProc enabled 9203 *==========================================================================*/ 9204 uint8_t QCameraParameters::getNumOfExtraBuffersForImageProc() 9205 { 9206 uint8_t numOfBufs = 0; 9207 9208 if (isUbiFocusEnabled()) { 9209 numOfBufs += m_pCapability->ubifocus_af_bracketing_need.burst_count - 1; 9210 if (isUbiRefocus()) { 9211 numOfBufs += 9212 m_pCapability->ubifocus_af_bracketing_need.burst_count + 1; 9213 } 9214 } else if (m_bOptiZoomOn) { 9215 numOfBufs += m_pCapability->opti_zoom_settings_need.burst_count - 1; 9216 } else if (isChromaFlashEnabled()) { 9217 numOfBufs += 1; /* flash and non flash */ 9218 } 9219 9220 return numOfBufs * getBurstNum(); 9221 } 9222 9223 /*=========================================================================== 9224 * FUNCTION : is4k2kVideoResolution 9225 * 9226 * DESCRIPTION: if resolution is 4k x 2k or true 4k x 2k 9227 * 9228 * PARAMETERS : none 9229 * 9230 * RETURN : true: video resolution is 4k x 2k 9231 * false: video resolution is not 4k x 2k 9232 *==========================================================================*/ 9233 bool QCameraParameters::is4k2kVideoResolution() 9234 { 9235 bool enabled = false; 9236 cam_dimension_t resolution; 9237 getVideoSize(&resolution.width, &resolution.height); 9238 if (!(resolution.width < 3840 && resolution.height < 2160)) { 9239 enabled = true; 9240 } 9241 return enabled; 9242 } 9243 /*=========================================================================== 9244 * FUNCTION : dump 9245 * 9246 * DESCRIPTION: Composes a string based on current configuration 9247 * 9248 * PARAMETERS : none 9249 * 9250 * RETURN : Formatted string 9251 *==========================================================================*/ 9252 String8 QCameraParameters::dump() 9253 { 9254 String8 str("\n"); 9255 char s[128]; 9256 9257 snprintf(s, 128, "Preview Pixel Fmt: %d\n", getPreviewHalPixelFormat()); 9258 str += s; 9259 9260 snprintf(s, 128, "ZSL Burst Interval: %d\n", getZSLBurstInterval()); 9261 str += s; 9262 9263 snprintf(s, 128, "ZSL Queue Depth: %d\n", getZSLQueueDepth()); 9264 str += s; 9265 9266 snprintf(s, 128, "ZSL Back Look Count %d\n", getZSLBackLookCount()); 9267 str += s; 9268 9269 snprintf(s, 128, "Max Unmatched Frames In Queue: %d\n", 9270 getMaxUnmatchedFramesInQueue()); 9271 str += s; 9272 9273 snprintf(s, 128, "Is ZSL Mode: %d\n", isZSLMode()); 9274 str += s; 9275 9276 snprintf(s, 128, "Is No Display Mode: %d\n", isNoDisplayMode()); 9277 str += s; 9278 9279 snprintf(s, 128, "Is WNR Enabled: %d\n", isWNREnabled()); 9280 str += s; 9281 9282 snprintf(s, 128, "isHfrMode: %d\n", isHfrMode()); 9283 str += s; 9284 9285 snprintf(s, 128, "getNumOfSnapshots: %d\n", getNumOfSnapshots()); 9286 str += s; 9287 9288 snprintf(s, 128, "getNumOfExtraHDRInBufsIfNeeded: %d\n", 9289 getNumOfExtraHDRInBufsIfNeeded()); 9290 str += s; 9291 9292 snprintf(s, 128, "getNumOfExtraHDROutBufsIfNeeded: %d\n", 9293 getNumOfExtraHDROutBufsIfNeeded()); 9294 str += s; 9295 9296 snprintf(s, 128, "getBurstNum: %d\n", getBurstNum()); 9297 str += s; 9298 9299 snprintf(s, 128, "getRecordingHintValue: %d\n", getRecordingHintValue()); 9300 str += s; 9301 9302 snprintf(s, 128, "getJpegQuality: %d\n", getJpegQuality()); 9303 str += s; 9304 9305 snprintf(s, 128, "getJpegRotation: %d\n", getJpegRotation()); 9306 str += s; 9307 9308 snprintf(s, 128, "isHistogramEnabled: %d\n", isHistogramEnabled()); 9309 str += s; 9310 9311 snprintf(s, 128, "isFaceDetectionEnabled: %d\n", isFaceDetectionEnabled()); 9312 str += s; 9313 9314 snprintf(s, 128, "isHDREnabled: %d\n", isHDREnabled()); 9315 str += s; 9316 9317 snprintf(s, 128, "isAutoHDREnabled: %d\n", isAutoHDREnabled()); 9318 str += s; 9319 9320 snprintf(s, 128, "isAVTimerEnabled: %d\n", isAVTimerEnabled()); 9321 str += s; 9322 9323 snprintf(s, 128, "getFocusMode: %d\n", getFocusMode()); 9324 str += s; 9325 9326 snprintf(s, 128, "isJpegPictureFormat: %d\n", isJpegPictureFormat()); 9327 str += s; 9328 9329 snprintf(s, 128, "isNV16PictureFormat: %d\n", isNV16PictureFormat()); 9330 str += s; 9331 9332 snprintf(s, 128, "isNV21PictureFormat: %d\n", isNV21PictureFormat()); 9333 str += s; 9334 9335 snprintf(s, 128, "isSnapshotFDNeeded: %d\n", isSnapshotFDNeeded()); 9336 str += s; 9337 9338 snprintf(s, 128, "isHDR1xFrameEnabled: %d\n", isHDR1xFrameEnabled()); 9339 str += s; 9340 9341 snprintf(s, 128, "isYUVFrameInfoNeeded: %d\n", isYUVFrameInfoNeeded()); 9342 str += s; 9343 9344 snprintf(s, 128, "isHDR1xExtraBufferNeeded: %d\n", 9345 isHDR1xExtraBufferNeeded()); 9346 str += s; 9347 9348 snprintf(s, 128, "isHDROutputCropEnabled: %d\n", isHDROutputCropEnabled()); 9349 str += s; 9350 9351 snprintf(s, 128, "isPreviewFlipChanged: %d\n", isPreviewFlipChanged()); 9352 str += s; 9353 9354 snprintf(s, 128, "isVideoFlipChanged: %d\n", isVideoFlipChanged()); 9355 str += s; 9356 9357 snprintf(s, 128, "isSnapshotFlipChanged: %d\n", isSnapshotFlipChanged()); 9358 str += s; 9359 9360 snprintf(s, 128, "isHDRThumbnailProcessNeeded: %d\n", 9361 isHDRThumbnailProcessNeeded()); 9362 str += s; 9363 9364 snprintf(s, 128, "getAutoFlickerMode: %d\n", getAutoFlickerMode()); 9365 str += s; 9366 9367 snprintf(s, 128, "getNumOfExtraBuffersForImageProc: %d\n", 9368 getNumOfExtraBuffersForImageProc()); 9369 str += s; 9370 9371 snprintf(s, 128, "isUbiFocusEnabled: %d\n", isUbiFocusEnabled()); 9372 str += s; 9373 9374 snprintf(s, 128, "isChromaFlashEnabled: %d\n", isChromaFlashEnabled()); 9375 str += s; 9376 9377 snprintf(s, 128, "isOptiZoomEnabled: %d\n", isOptiZoomEnabled()); 9378 str += s; 9379 9380 snprintf(s, 128, "getBurstCountForAdvancedCapture: %d\n", 9381 getBurstCountForAdvancedCapture()); 9382 str += s; 9383 9384 return str; 9385 } 9386 }; // namespace qcamera 9387
