QCameraParameters.cpp revision 2f073d4cfa214187fc326377a1e0eecad84eaf3d
1/* Copyright (c) 2012-2013, 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 44namespace qcamera { 45// Parameter keys to communicate between camera application and driver. 46const char QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES[] = "hfr-size-values"; 47const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_MODE[] = "preview-frame-rate-mode"; 48const char QCameraParameters::KEY_QC_SUPPORTED_PREVIEW_FRAME_RATE_MODES[] = "preview-frame-rate-modes"; 49const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE[] = "frame-rate-auto"; 50const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE[] = "frame-rate-fixed"; 51const char QCameraParameters::KEY_QC_TOUCH_AF_AEC[] = "touch-af-aec"; 52const char QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC[] = "touch-af-aec-values"; 53const char QCameraParameters::KEY_QC_TOUCH_INDEX_AEC[] = "touch-index-aec"; 54const char QCameraParameters::KEY_QC_TOUCH_INDEX_AF[] = "touch-index-af"; 55const char QCameraParameters::KEY_QC_SCENE_DETECT[] = "scene-detect"; 56const char QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT[] = "scene-detect-values"; 57const char QCameraParameters::KEY_QC_ISO_MODE[] = "iso"; 58const char QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES[] = "iso-values"; 59const char QCameraParameters::KEY_QC_LENSSHADE[] = "lensshade"; 60const char QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES[] = "lensshade-values"; 61const char QCameraParameters::KEY_QC_AUTO_EXPOSURE[] = "auto-exposure"; 62const char QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE[] = "auto-exposure-values"; 63const char QCameraParameters::KEY_QC_DENOISE[] = "denoise"; 64const char QCameraParameters::KEY_QC_SUPPORTED_DENOISE[] = "denoise-values"; 65const char QCameraParameters::KEY_QC_FOCUS_ALGO[] = "selectable-zone-af"; 66const char QCameraParameters::KEY_QC_SUPPORTED_FOCUS_ALGOS[] = "selectable-zone-af-values"; 67const char QCameraParameters::KEY_QC_FACE_DETECTION[] = "face-detection"; 68const char QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION[] = "face-detection-values"; 69const char QCameraParameters::KEY_QC_FACE_RECOGNITION[] = "face-recognition"; 70const char QCameraParameters::KEY_QC_SUPPORTED_FACE_RECOGNITION[] = "face-recognition-values"; 71const char QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT[] = "mce"; 72const char QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES[] = "mce-values"; 73const char QCameraParameters::KEY_QC_DIS[] = "dis"; 74const char QCameraParameters::KEY_QC_SUPPORTED_DIS_MODES[] = "dis-values"; 75const char QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE[] = "video-hfr"; 76const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[] = "video-hfr-values"; 77const char QCameraParameters::KEY_QC_REDEYE_REDUCTION[] = "redeye-reduction"; 78const char QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION[] = "redeye-reduction-values"; 79const char QCameraParameters::KEY_QC_HIGH_DYNAMIC_RANGE_IMAGING[] = "hdr"; 80const char QCameraParameters::KEY_QC_SUPPORTED_HDR_IMAGING_MODES[] = "hdr-values"; 81const char QCameraParameters::KEY_QC_ZSL[] = "zsl"; 82const char QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES[] = "zsl-values"; 83const char QCameraParameters::KEY_QC_ZSL_BURST_INTERVAL[] = "capture-burst-interval"; 84const char QCameraParameters::KEY_QC_ZSL_BURST_LOOKBACK[] = "capture-burst-retroactive"; 85const char QCameraParameters::KEY_QC_ZSL_QUEUE_DEPTH[] = "capture-burst-queue-depth"; 86const char QCameraParameters::KEY_QC_CAMERA_MODE[] = "camera-mode"; 87const char QCameraParameters::KEY_QC_AE_BRACKET_HDR[] = "ae-bracket-hdr"; 88const char QCameraParameters::KEY_QC_SUPPORTED_AE_BRACKET_MODES[] = "ae-bracket-hdr-values"; 89const char QCameraParameters::KEY_QC_SUPPORTED_RAW_FORMATS[] = "raw-format-values"; 90const char QCameraParameters::KEY_QC_RAW_FORMAT[] = "raw-format"; 91const char QCameraParameters::KEY_QC_ORIENTATION[] = "orientation"; 92const char QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF[] = "selectable-zone-af"; 93const char QCameraParameters::KEY_QC_CAPTURE_BURST_EXPOSURE[] = "capture-burst-exposures"; 94const char QCameraParameters::KEY_QC_NUM_SNAPSHOT_PER_SHUTTER[] = "num-snaps-per-shutter"; 95const char QCameraParameters::KEY_QC_NO_DISPLAY_MODE[] = "no-display-mode"; 96const char QCameraParameters::KEY_QC_RAW_PICUTRE_SIZE[] = "raw-size"; 97const char QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] = "skinToneEnhancement-values"; 98const char QCameraParameters::KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES[] = "supported-live-snapshot-sizes"; 99const char QCameraParameters::KEY_QC_HDR_NEED_1X[] = "hdr-need-1x"; 100const char QCameraParameters::KEY_QC_PREVIEW_FLIP[] = "preview-flip"; 101const char QCameraParameters::KEY_QC_VIDEO_FLIP[] = "video-flip"; 102const char QCameraParameters::KEY_QC_SNAPSHOT_PICTURE_FLIP[] = "snapshot-picture-flip"; 103const char QCameraParameters::KEY_QC_SUPPORTED_FLIP_MODES[] = "flip-mode-values"; 104const char QCameraParameters::KEY_QC_VIDEO_HDR[] = "video-hdr"; 105const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HDR_MODES[] = "video-hdr-values"; 106 107// Values for effect settings. 108const char QCameraParameters::EFFECT_EMBOSS[] = "emboss"; 109const char QCameraParameters::EFFECT_SKETCH[] = "sketch"; 110const char QCameraParameters::EFFECT_NEON[] = "neon"; 111 112// Values for auto exposure settings. 113const char QCameraParameters::TOUCH_AF_AEC_OFF[] = "touch-off"; 114const char QCameraParameters::TOUCH_AF_AEC_ON[] = "touch-on"; 115 116// Values for scene mode settings. 117const char QCameraParameters::SCENE_MODE_ASD[] = "asd"; // corresponds to CAMERA_BESTSHOT_AUTO in HAL 118const char QCameraParameters::SCENE_MODE_BACKLIGHT[] = "backlight"; 119const char QCameraParameters::SCENE_MODE_FLOWERS[] = "flowers"; 120const char QCameraParameters::SCENE_MODE_AR[] = "AR"; 121const char QCameraParameters::SCENE_MODE_HDR[] = "hdr"; 122 123// Formats for setPreviewFormat and setPictureFormat. 124const char QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO[] = "yuv420sp-adreno"; 125const char QCameraParameters::PIXEL_FORMAT_YV12[] = "yuv420p"; 126const char QCameraParameters::PIXEL_FORMAT_NV12[] = "nv12"; 127 128// Values for raw image formats 129const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV[] = "yuv-raw8-yuyv"; 130const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU[] = "yuv-raw8-yvyu"; 131const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY[] = "yuv-raw8-uyvy"; 132const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY[] = "yuv-raw8-vyuy"; 133const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG[] = "bayer-qcom-8gbrg"; 134const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG[] = "bayer-qcom-8grbg"; 135const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB[] = "bayer-qcom-8rggb"; 136const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR[] = "bayer-qcom-8bggr"; 137const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG[] = "bayer-qcom-10gbrg"; 138const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG[] = "bayer-qcom-10grbg"; 139const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB[] = "bayer-qcom-10rggb"; 140const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR[] = "bayer-qcom-10bggr"; 141const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG[] = "bayer-qcom-12gbrg"; 142const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG[] = "bayer-qcom-12grbg"; 143const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB[] = "bayer-qcom-12rggb"; 144const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR[] = "bayer-qcom-12bggr"; 145const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG[] = "bayer-mipi-8gbrg"; 146const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG[] = "bayer-mipi-8grbg"; 147const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB[] = "bayer-mipi-8rggb"; 148const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR[] = "bayer-mipi-8bggr"; 149const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG[] = "bayer-mipi-10gbrg"; 150const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG[] = "bayer-mipi-10grbg"; 151const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB[] = "bayer-mipi-10rggb"; 152const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR[] = "bayer-mipi-10bggr"; 153const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG[] = "bayer-mipi-12gbrg"; 154const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG[] = "bayer-mipi-12grbg"; 155const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB[] = "bayer-mipi-12rggb"; 156const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR[] = "bayer-mipi-12bggr"; 157const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG[] = "bayer-ideal-qcom-8gbrg"; 158const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG[] = "bayer-ideal-qcom-8grbg"; 159const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB[] = "bayer-ideal-qcom-8rggb"; 160const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR[] = "bayer-ideal-qcom-8bggr"; 161const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG[] = "bayer-ideal-qcom-10gbrg"; 162const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG[] = "bayer-ideal-qcom-10grbg"; 163const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB[] = "bayer-ideal-qcom-10rggb"; 164const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR[] = "bayer-ideal-qcom-10bggr"; 165const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG[] = "bayer-ideal-qcom-12gbrg"; 166const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG[] = "bayer-ideal-qcom-12grbg"; 167const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB[] = "bayer-ideal-qcom-12rggb"; 168const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR[] = "bayer-ideal-qcom-12bggr"; 169const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG[] = "bayer-ideal-mipi-8gbrg"; 170const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG[] = "bayer-ideal-mipi-8grbg"; 171const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB[] = "bayer-ideal-mipi-8rggb"; 172const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR[] = "bayer-ideal-mipi-8bggr"; 173const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG[] = "bayer-ideal-mipi-10gbrg"; 174const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG[] = "bayer-ideal-mipi-10grbg"; 175const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB[] = "bayer-ideal-mipi-10rggb"; 176const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR[] = "bayer-ideal-mipi-10bggr"; 177const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG[] = "bayer-ideal-mipi-12gbrg"; 178const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG[] = "bayer-ideal-mipi-12grbg"; 179const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB[] = "bayer-ideal-mipi-12rggb"; 180const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR[] = "bayer-ideal-mipi-12bggr"; 181const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG[] = "bayer-ideal-plain8-8gbrg"; 182const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG[] = "bayer-ideal-plain8-8grbg"; 183const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB[] = "bayer-ideal-plain8-8rggb"; 184const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR[] = "bayer-ideal-plain8-8bggr"; 185const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG[] = "bayer-ideal-plain16-8gbrg"; 186const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG[] = "bayer-ideal-plain16-8grbg"; 187const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB[] = "bayer-ideal-plain16-8rggb"; 188const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR[] = "bayer-ideal-plain16-8bggr"; 189const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG[] = "bayer-ideal-plain16-10gbrg"; 190const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG[] = "bayer-ideal-plain16-10grbg"; 191const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB[] = "bayer-ideal-plain16-10rggb"; 192const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR[] = "bayer-ideal-plain16-10bggr"; 193const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG[] = "bayer-ideal-plain16-12gbrg"; 194const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG[] = "bayer-ideal-plain16-12grbg"; 195const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB[] = "bayer-ideal-plain16-12rggb"; 196const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR[] = "bayer-ideal-plain16-12bggr"; 197 198// Values for ISO Settings 199const char QCameraParameters::ISO_AUTO[] = "auto"; 200const char QCameraParameters::ISO_HJR[] = "ISO_HJR"; 201const char QCameraParameters::ISO_100[] = "ISO100"; 202const char QCameraParameters::ISO_200[] = "ISO200"; 203const char QCameraParameters::ISO_400[] = "ISO400"; 204const char QCameraParameters::ISO_800[] = "ISO800"; 205const char QCameraParameters::ISO_1600[] = "ISO1600"; 206 207// Values for auto exposure settings. 208const char QCameraParameters::AUTO_EXPOSURE_FRAME_AVG[] = "frame-average"; 209const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED[] = "center-weighted"; 210const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING[] = "spot-metering"; 211const char QCameraParameters::AUTO_EXPOSURE_SMART_METERING[] = "smart-metering"; 212const char QCameraParameters::AUTO_EXPOSURE_USER_METERING[] = "user-metering"; 213const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING_ADV[] = "spot-metering-adv"; 214const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED_ADV[] = "center-weighted-adv"; 215 216const char QCameraParameters::KEY_QC_GPS_LATITUDE_REF[] = "gps-latitude-ref"; 217const char QCameraParameters::KEY_QC_GPS_LONGITUDE_REF[] = "gps-longitude-ref"; 218const char QCameraParameters::KEY_QC_GPS_ALTITUDE_REF[] = "gps-altitude-ref"; 219const char QCameraParameters::KEY_QC_GPS_STATUS[] = "gps-status"; 220 221const char QCameraParameters::KEY_QC_HISTOGRAM[] = "histogram"; 222const char QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES[] = "histogram-values"; 223 224const char QCameraParameters::VALUE_ENABLE[] = "enable"; 225const char QCameraParameters::VALUE_DISABLE[] = "disable"; 226const char QCameraParameters::VALUE_OFF[] = "off"; 227const char QCameraParameters::VALUE_ON[] = "on"; 228const char QCameraParameters::VALUE_TRUE[] = "true"; 229const char QCameraParameters::VALUE_FALSE[] = "false"; 230 231const char QCameraParameters::KEY_QC_SHARPNESS[] = "sharpness"; 232const char QCameraParameters::KEY_QC_MIN_SHARPNESS[] = "min-sharpness"; 233const char QCameraParameters::KEY_QC_MAX_SHARPNESS[] = "max-sharpness"; 234const char QCameraParameters::KEY_QC_SHARPNESS_STEP[] = "sharpness-step"; 235const char QCameraParameters::KEY_QC_CONTRAST[] = "contrast"; 236const char QCameraParameters::KEY_QC_MIN_CONTRAST[] = "min-contrast"; 237const char QCameraParameters::KEY_QC_MAX_CONTRAST[] = "max-contrast"; 238const char QCameraParameters::KEY_QC_CONTRAST_STEP[] = "contrast-step"; 239const char QCameraParameters::KEY_QC_SATURATION[] = "saturation"; 240const char QCameraParameters::KEY_QC_MIN_SATURATION[] = "min-saturation"; 241const char QCameraParameters::KEY_QC_MAX_SATURATION[] = "max-saturation"; 242const char QCameraParameters::KEY_QC_SATURATION_STEP[] = "saturation-step"; 243const char QCameraParameters::KEY_QC_BRIGHTNESS[] = "luma-adaptation"; 244const char QCameraParameters::KEY_QC_MIN_BRIGHTNESS[] = "min-brightness"; 245const char QCameraParameters::KEY_QC_MAX_BRIGHTNESS[] = "max-brightness"; 246const char QCameraParameters::KEY_QC_BRIGHTNESS_STEP[] = "brightness-step"; 247const char QCameraParameters::KEY_QC_SCE_FACTOR[] = "skinToneEnhancement"; 248const char QCameraParameters::KEY_QC_MIN_SCE_FACTOR[] = "min-sce-factor"; 249const char QCameraParameters::KEY_QC_MAX_SCE_FACTOR[] = "max-sce-factor"; 250const char QCameraParameters::KEY_QC_SCE_FACTOR_STEP[] = "sce-factor-step"; 251 252const char QCameraParameters::KEY_QC_SUPPORTED_CAMERA_FEATURES[] = "qc-camera-features"; 253const char QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES[] = "qc-max-num-requested-faces"; 254 255//Values for DENOISE 256const char QCameraParameters::DENOISE_OFF[] = "denoise-off"; 257const char QCameraParameters::DENOISE_ON[] = "denoise-on"; 258 259// Values for selectable zone af Settings 260const char QCameraParameters::FOCUS_ALGO_AUTO[] = "auto"; 261const char QCameraParameters::FOCUS_ALGO_SPOT_METERING[] = "spot-metering"; 262const char QCameraParameters::FOCUS_ALGO_CENTER_WEIGHTED[] = "center-weighted"; 263const char QCameraParameters::FOCUS_ALGO_FRAME_AVERAGE[] = "frame-average"; 264 265// Values for HFR settings. 266const char QCameraParameters::VIDEO_HFR_OFF[] = "off"; 267const char QCameraParameters::VIDEO_HFR_2X[] = "60"; 268const char QCameraParameters::VIDEO_HFR_3X[] = "90"; 269const char QCameraParameters::VIDEO_HFR_4X[] = "120"; 270const char QCameraParameters::VIDEO_HFR_5X[] = "150"; 271 272// Values for HDR Bracketing settings. 273const char QCameraParameters::AE_BRACKET_OFF[] = "Off"; 274const char QCameraParameters::AE_BRACKET[] = "AE-Bracket"; 275 276// Values for FLIP settings. 277const char QCameraParameters::FLIP_MODE_OFF[] = "off"; 278const char QCameraParameters::FLIP_MODE_V[] = "flip-v"; 279const char QCameraParameters::FLIP_MODE_H[] = "flip-h"; 280const char QCameraParameters::FLIP_MODE_VH[] = "flip-vh"; 281 282static const char* portrait = "portrait"; 283static const char* landscape = "landscape"; 284 285const cam_dimension_t QCameraParameters::THUMBNAIL_SIZES_MAP[] = { 286 { 512, 288 }, //1.777778 287 { 480, 288 }, //1.666667 288 { 256, 154 }, //1.66233 289 { 432, 288 }, //1.5 290 { 320, 240 }, //1.33333 291 { 176, 144 }, //1.222222 292 { 0, 0 } // required by Android SDK 293}; 294 295const QCameraParameters::QCameraMap QCameraParameters::AUTO_EXPOSURE_MAP[] = { 296 { AUTO_EXPOSURE_FRAME_AVG, CAM_AEC_MODE_FRAME_AVERAGE }, 297 { AUTO_EXPOSURE_CENTER_WEIGHTED, CAM_AEC_MODE_CENTER_WEIGHTED }, 298 { AUTO_EXPOSURE_SPOT_METERING, CAM_AEC_MODE_SPOT_METERING }, 299 { AUTO_EXPOSURE_SMART_METERING, CAM_AEC_MODE_SMART_METERING }, 300 { AUTO_EXPOSURE_USER_METERING, CAM_AEC_MODE_USER_METERING }, 301 { AUTO_EXPOSURE_SPOT_METERING_ADV, CAM_AEC_MODE_SPOT_METERING_ADV }, 302 { AUTO_EXPOSURE_CENTER_WEIGHTED_ADV, CAM_AEC_MODE_CENTER_WEIGHTED_ADV }, 303}; 304 305const QCameraParameters::QCameraMap QCameraParameters::PREVIEW_FORMATS_MAP[] = { 306 {PIXEL_FORMAT_YUV420SP, CAM_FORMAT_YUV_420_NV21}, 307 {PIXEL_FORMAT_YUV420P, CAM_FORMAT_YUV_420_YV12}, 308 {PIXEL_FORMAT_YUV420SP_ADRENO, CAM_FORMAT_YUV_420_NV21_ADRENO}, 309 {PIXEL_FORMAT_YV12, CAM_FORMAT_YUV_420_YV12}, 310 {PIXEL_FORMAT_NV12, CAM_FORMAT_YUV_420_NV12} 311}; 312 313const QCameraParameters::QCameraMap QCameraParameters::PICTURE_TYPES_MAP[] = { 314 {PIXEL_FORMAT_JPEG, CAM_FORMAT_JPEG}, 315 {QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV, CAM_FORMAT_YUV_RAW_8BIT_YUYV}, 316 {QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU, CAM_FORMAT_YUV_RAW_8BIT_YVYU}, 317 {QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY, CAM_FORMAT_YUV_RAW_8BIT_UYVY}, 318 {QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY, CAM_FORMAT_YUV_RAW_8BIT_VYUY}, 319 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GBRG}, 320 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GRBG}, 321 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_RGGB}, 322 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_BGGR}, 323 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GBRG}, 324 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GRBG}, 325 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_RGGB}, 326 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_BGGR}, 327 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GBRG}, 328 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GRBG}, 329 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_RGGB}, 330 {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_BGGR}, 331 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GBRG}, 332 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GRBG}, 333 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_RGGB}, 334 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_BGGR}, 335 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG}, 336 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GRBG}, 337 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_RGGB}, 338 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_BGGR}, 339 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GBRG}, 340 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GRBG}, 341 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_RGGB}, 342 {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_BGGR}, 343 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GBRG}, 344 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GRBG}, 345 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_RGGB}, 346 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_BGGR}, 347 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GBRG}, 348 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GRBG}, 349 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_RGGB}, 350 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_BGGR}, 351 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GBRG}, 352 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GRBG}, 353 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_RGGB}, 354 {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_BGGR}, 355 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GBRG}, 356 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GRBG}, 357 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_RGGB}, 358 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_BGGR}, 359 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GBRG}, 360 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GRBG}, 361 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_RGGB}, 362 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_BGGR}, 363 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GBRG}, 364 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GRBG}, 365 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_RGGB}, 366 {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_BGGR}, 367 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GBRG}, 368 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GRBG}, 369 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_RGGB}, 370 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_BGGR}, 371 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GBRG}, 372 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GRBG}, 373 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_RGGB}, 374 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_BGGR}, 375 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GBRG}, 376 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GRBG}, 377 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_RGGB}, 378 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_BGGR}, 379 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GBRG}, 380 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GRBG}, 381 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_RGGB}, 382 {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_BGGR} 383}; 384 385const QCameraParameters::QCameraMap QCameraParameters::RAW_FORMATS_MAP[] = { 386}; 387 388const QCameraParameters::QCameraMap QCameraParameters::FOCUS_MODES_MAP[] = { 389 { FOCUS_MODE_AUTO, CAM_FOCUS_MODE_AUTO }, 390 { FOCUS_MODE_INFINITY, CAM_FOCUS_MODE_INFINITY }, 391 { FOCUS_MODE_MACRO, CAM_FOCUS_MODE_MACRO }, 392 { FOCUS_MODE_FIXED, CAM_FOCUS_MODE_FIXED }, 393 { FOCUS_MODE_EDOF, CAM_FOCUS_MODE_EDOF }, 394 { FOCUS_MODE_CONTINUOUS_PICTURE, CAM_FOCUS_MODE_CONTINOUS_PICTURE }, 395 { FOCUS_MODE_CONTINUOUS_VIDEO, CAM_FOCUS_MODE_CONTINOUS_VIDEO } 396}; 397 398const QCameraParameters::QCameraMap QCameraParameters::EFFECT_MODES_MAP[] = { 399 { EFFECT_NONE, CAM_EFFECT_MODE_OFF }, 400 { EFFECT_MONO, CAM_EFFECT_MODE_MONO }, 401 { EFFECT_NEGATIVE, CAM_EFFECT_MODE_NEGATIVE }, 402 { EFFECT_SOLARIZE, CAM_EFFECT_MODE_SOLARIZE }, 403 { EFFECT_SEPIA, CAM_EFFECT_MODE_SEPIA }, 404 { EFFECT_POSTERIZE, CAM_EFFECT_MODE_POSTERIZE }, 405 { EFFECT_WHITEBOARD, CAM_EFFECT_MODE_WHITEBOARD }, 406 { EFFECT_BLACKBOARD, CAM_EFFECT_MODE_BLACKBOARD }, 407 { EFFECT_AQUA, CAM_EFFECT_MODE_AQUA }, 408 { EFFECT_EMBOSS, CAM_EFFECT_MODE_EMBOSS }, 409 { EFFECT_SKETCH, CAM_EFFECT_MODE_SKETCH }, 410 { EFFECT_NEON, CAM_EFFECT_MODE_NEON } 411}; 412 413const QCameraParameters::QCameraMap QCameraParameters::SCENE_MODES_MAP[] = { 414 { SCENE_MODE_AUTO, CAM_SCENE_MODE_OFF }, 415 { SCENE_MODE_ACTION, CAM_SCENE_MODE_ACTION }, 416 { SCENE_MODE_PORTRAIT, CAM_SCENE_MODE_PORTRAIT }, 417 { SCENE_MODE_LANDSCAPE, CAM_SCENE_MODE_LANDSCAPE }, 418 { SCENE_MODE_NIGHT, CAM_SCENE_MODE_NIGHT }, 419 { SCENE_MODE_NIGHT_PORTRAIT, CAM_SCENE_MODE_NIGHT_PORTRAIT }, 420 { SCENE_MODE_THEATRE, CAM_SCENE_MODE_THEATRE }, 421 { SCENE_MODE_BEACH, CAM_SCENE_MODE_BEACH }, 422 { SCENE_MODE_SNOW, CAM_SCENE_MODE_SNOW }, 423 { SCENE_MODE_SUNSET, CAM_SCENE_MODE_SUNSET }, 424 { SCENE_MODE_STEADYPHOTO, CAM_SCENE_MODE_ANTISHAKE }, 425 { SCENE_MODE_FIREWORKS , CAM_SCENE_MODE_FIREWORKS }, 426 { SCENE_MODE_SPORTS , CAM_SCENE_MODE_SPORTS }, 427 { SCENE_MODE_PARTY, CAM_SCENE_MODE_PARTY }, 428 { SCENE_MODE_CANDLELIGHT, CAM_SCENE_MODE_CANDLELIGHT }, 429 { SCENE_MODE_ASD, CAM_SCENE_MODE_AUTO }, 430 { SCENE_MODE_BACKLIGHT, CAM_SCENE_MODE_BACKLIGHT }, 431 { SCENE_MODE_FLOWERS, CAM_SCENE_MODE_FLOWERS }, 432 { SCENE_MODE_AR, CAM_SCENE_MODE_AR }, 433 { SCENE_MODE_HDR, CAM_SCENE_MODE_OFF }, 434}; 435 436const QCameraParameters::QCameraMap QCameraParameters::FLASH_MODES_MAP[] = { 437 { FLASH_MODE_OFF, CAM_FLASH_MODE_OFF }, 438 { FLASH_MODE_AUTO, CAM_FLASH_MODE_AUTO }, 439 { FLASH_MODE_ON, CAM_FLASH_MODE_ON }, 440 { FLASH_MODE_TORCH, CAM_FLASH_MODE_TORCH } 441}; 442 443const QCameraParameters::QCameraMap QCameraParameters::FOCUS_ALGO_MAP[] = { 444 { FOCUS_ALGO_AUTO, CAM_FOCUS_ALGO_AUTO }, 445 { FOCUS_ALGO_SPOT_METERING, CAM_FOCUS_ALGO_SPOT }, 446 { FOCUS_ALGO_CENTER_WEIGHTED, CAM_FOCUS_ALGO_CENTER_WEIGHTED }, 447 { FOCUS_ALGO_FRAME_AVERAGE, CAM_FOCUS_ALGO_AVERAGE } 448}; 449 450const QCameraParameters::QCameraMap QCameraParameters::WHITE_BALANCE_MODES_MAP[] = { 451 { WHITE_BALANCE_AUTO, CAM_WB_MODE_AUTO }, 452 { WHITE_BALANCE_INCANDESCENT, CAM_WB_MODE_INCANDESCENT }, 453 { WHITE_BALANCE_FLUORESCENT, CAM_WB_MODE_FLUORESCENT }, 454 { WHITE_BALANCE_WARM_FLUORESCENT,CAM_WB_MODE_WARM_FLUORESCENT}, 455 { WHITE_BALANCE_DAYLIGHT, CAM_WB_MODE_DAYLIGHT }, 456 { WHITE_BALANCE_CLOUDY_DAYLIGHT, CAM_WB_MODE_CLOUDY_DAYLIGHT }, 457 { WHITE_BALANCE_TWILIGHT, CAM_WB_MODE_TWILIGHT }, 458 { WHITE_BALANCE_SHADE, CAM_WB_MODE_SHADE } 459}; 460 461const QCameraParameters::QCameraMap QCameraParameters::ANTIBANDING_MODES_MAP[] = { 462 { ANTIBANDING_OFF, CAM_ANTIBANDING_MODE_OFF }, 463 { ANTIBANDING_50HZ, CAM_ANTIBANDING_MODE_50HZ }, 464 { ANTIBANDING_60HZ, CAM_ANTIBANDING_MODE_60HZ }, 465 { ANTIBANDING_AUTO, CAM_ANTIBANDING_MODE_AUTO } 466}; 467 468const QCameraParameters::QCameraMap QCameraParameters::ISO_MODES_MAP[] = { 469 { ISO_AUTO, CAM_ISO_MODE_AUTO }, 470 { ISO_HJR, CAM_ISO_MODE_DEBLUR }, 471 { ISO_100, CAM_ISO_MODE_100 }, 472 { ISO_200, CAM_ISO_MODE_200 }, 473 { ISO_400, CAM_ISO_MODE_400 }, 474 { ISO_800, CAM_ISO_MODE_800 }, 475 { ISO_1600, CAM_ISO_MODE_1600 } 476}; 477 478const QCameraParameters::QCameraMap QCameraParameters::HFR_MODES_MAP[] = { 479 { VIDEO_HFR_OFF, CAM_HFR_MODE_OFF }, 480 { VIDEO_HFR_2X, CAM_HFR_MODE_60FPS }, 481 { VIDEO_HFR_3X, CAM_HFR_MODE_90FPS }, 482 { VIDEO_HFR_4X, CAM_HFR_MODE_120FPS }, 483 { VIDEO_HFR_5X, CAM_HFR_MODE_150FPS } 484}; 485 486const QCameraParameters::QCameraMap QCameraParameters::BRACKETING_MODES_MAP[] = { 487 { AE_BRACKET_OFF, CAM_EXP_BRACKETING_OFF }, 488 { AE_BRACKET, CAM_EXP_BRACKETING_ON } 489}; 490 491const QCameraParameters::QCameraMap QCameraParameters::ON_OFF_MODES_MAP[] = { 492 { VALUE_OFF, 0 }, 493 { VALUE_ON, 1 } 494}; 495 496const QCameraParameters::QCameraMap QCameraParameters::TOUCH_AF_AEC_MODES_MAP[] = { 497 { QCameraParameters::TOUCH_AF_AEC_OFF, 0 }, 498 { QCameraParameters::TOUCH_AF_AEC_ON, 1 } 499}; 500 501const QCameraParameters::QCameraMap QCameraParameters::ENABLE_DISABLE_MODES_MAP[] = { 502 { VALUE_ENABLE, 1 }, 503 { VALUE_DISABLE, 0 } 504}; 505 506const QCameraParameters::QCameraMap QCameraParameters::DENOISE_ON_OFF_MODES_MAP[] = { 507 { DENOISE_OFF, 0 }, 508 { DENOISE_ON, 1 } 509}; 510 511const QCameraParameters::QCameraMap QCameraParameters::TRUE_FALSE_MODES_MAP[] = { 512 { VALUE_FALSE, 0}, 513 { VALUE_TRUE, 1} 514}; 515 516const QCameraParameters::QCameraMap QCameraParameters::FLIP_MODES_MAP[] = { 517 {FLIP_MODE_OFF, 0}, 518 {FLIP_MODE_V, FLIP_V}, 519 {FLIP_MODE_H, FLIP_H}, 520 {FLIP_MODE_VH, FLIP_V_H} 521}; 522 523#define DEFAULT_CAMERA_AREA "(0, 0, 0, 0, 0)" 524#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX ) 525 526/*=========================================================================== 527 * FUNCTION : QCameraParameters 528 * 529 * DESCRIPTION: default constructor of QCameraParameters 530 * 531 * PARAMETERS : none 532 * 533 * RETURN : None 534 *==========================================================================*/ 535QCameraParameters::QCameraParameters() 536 : CameraParameters(), 537 m_pCapability(NULL), 538 m_pCamOpsTbl(NULL), 539 m_pParamHeap(NULL), 540 m_pParamBuf(NULL), 541 m_bZslMode(false), 542 m_bRecordingHint(false), 543 m_bHistogramEnabled(false), 544 m_nFaceProcMask(0), 545 m_bDebugFps(false), 546 mFocusMode(CAM_FOCUS_MODE_MAX), 547 mPreviewFormat(CAM_FORMAT_YUV_420_NV21), 548 mPictureFormat(CAM_FORMAT_JPEG), 549 m_bNeedRestart(false), 550 m_bNoDisplayMode(false), 551 m_bWNROn(false), 552 m_bNeedLockCAF(false), 553 m_bCAFLocked(false), 554 m_bAFRunning(false), 555 m_tempMap() 556{ 557 char value[32]; 558 // TODO: may move to parameter instead of sysprop 559 property_get("persist.debug.sf.showfps", value, "0"); 560 m_bDebugFps = atoi(value) > 0 ? true : false; 561 562 // For thermal mode, it should be set as system property 563 // because system property applies to all applications, while 564 // parameters only apply to specific app. 565 property_get("persist.camera.thermal.mode", value, "fps"); 566 if (!strcmp(value, "frameskip")) { 567 m_ThermalMode = QCAMERA_THERMAL_ADJUST_FRAMESKIP; 568 } else { 569 if (strcmp(value, "fps")) 570 ALOGE("%s: Invalid camera thermal mode %s", __func__, value); 571 m_ThermalMode = QCAMERA_THERMAL_ADJUST_FPS; 572 } 573 574 memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize)); 575} 576 577/*=========================================================================== 578 * FUNCTION : QCameraParameters 579 * 580 * DESCRIPTION: constructor of QCameraParameters 581 * 582 * PARAMETERS : 583 * @params : parameters in string 584 * 585 * RETURN : None 586 *==========================================================================*/ 587QCameraParameters::QCameraParameters(const String8 ¶ms) 588 : CameraParameters(params), 589 m_pCapability(NULL), 590 m_pCamOpsTbl(NULL), 591 m_pParamHeap(NULL), 592 m_pParamBuf(NULL), 593 m_bZslMode(false), 594 m_bRecordingHint(false), 595 m_bHistogramEnabled(false), 596 m_nFaceProcMask(0), 597 m_bDebugFps(false), 598 mFocusMode(CAM_FOCUS_MODE_MAX), 599 mPreviewFormat(CAM_FORMAT_YUV_420_NV21), 600 mPictureFormat(CAM_FORMAT_JPEG), 601 m_bNeedRestart(false), 602 m_bNoDisplayMode(false), 603 m_bWNROn(false), 604 m_bNeedLockCAF(false), 605 m_bCAFLocked(false), 606 m_bAFRunning(false), 607 m_tempMap() 608{ 609 memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize)); 610} 611 612/*=========================================================================== 613 * FUNCTION : ~QCameraParameters 614 * 615 * DESCRIPTION: deconstructor of QCameraParameters 616 * 617 * PARAMETERS : none 618 * 619 * RETURN : None 620 *==========================================================================*/ 621QCameraParameters::~QCameraParameters() 622{ 623 deinit(); 624} 625 626/*=========================================================================== 627 * FUNCTION : createSizesString 628 * 629 * DESCRIPTION: create string obj contains array of dimensions 630 * 631 * PARAMETERS : 632 * @sizes : array of dimensions 633 * @len : size of dimension array 634 * 635 * RETURN : string obj 636 *==========================================================================*/ 637String8 QCameraParameters::createSizesString(const cam_dimension_t *sizes, int len) 638{ 639 String8 str; 640 char buffer[32]; 641 642 if (len > 0) { 643 snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height); 644 str.append(buffer); 645 } 646 for (int i = 1; i < len; i++) { 647 snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height); 648 str.append(buffer); 649 } 650 return str; 651} 652 653/*=========================================================================== 654 * FUNCTION : createValuesString 655 * 656 * DESCRIPTION: create string obj contains array of values from map when matched 657 * from input values array 658 * 659 * PARAMETERS : 660 * @values : array of values 661 * @len : size of values array 662 * @map : map contains the mapping between values and enums 663 * @map_len : size of the map 664 * 665 * RETURN : string obj 666 *==========================================================================*/ 667String8 QCameraParameters::createValuesString(const int *values, 668 int len, 669 const QCameraMap* map, 670 int map_len) 671{ 672 String8 str; 673 int count = 0; 674 675 for (int i = 0; i < len; i++ ) { 676 for (int j = 0; j < map_len; j ++) 677 if (map[j].val == values[i]) { 678 if (NULL != map[j].desc) { 679 if (count > 0) { 680 str.append(","); 681 } 682 str.append(map[j].desc); 683 count++; 684 break; //loop j 685 } 686 } 687 } 688 return str; 689} 690 691/*=========================================================================== 692 * FUNCTION : createValuesStringFromMap 693 * 694 * DESCRIPTION: create string obj contains array of values directly from map 695 * 696 * PARAMETERS : 697 * @map : map contains the mapping between values and enums 698 * @map_len : size of the map 699 * 700 * RETURN : string obj 701 *==========================================================================*/ 702String8 QCameraParameters::createValuesStringFromMap(const QCameraMap* map, 703 int map_len) 704{ 705 String8 str; 706 707 for (int i = 0; i < map_len; i++) { 708 if (NULL != map[i].desc) { 709 if (i > 0) { 710 str.append(","); 711 } 712 str.append(map[i].desc); 713 } 714 } 715 return str; 716} 717 718/*=========================================================================== 719 * FUNCTION : createZoomRatioValuesString 720 * 721 * DESCRIPTION: create string obj contains array of zoom ratio values 722 * 723 * PARAMETERS : 724 * @zoomRaios : array of zoom ratios 725 * @length : size of the array 726 * 727 * RETURN : string obj 728 *==========================================================================*/ 729String8 QCameraParameters::createZoomRatioValuesString(int *zoomRatios, int length) 730{ 731 String8 str; 732 char buffer[32] = {0}; 733 734 if(length > 0){ 735 snprintf(buffer, sizeof(buffer), "%d", zoomRatios[0]); 736 str.append(buffer); 737 } 738 739 for (int i =1;i<length;i++){ 740 memset(buffer, 0, sizeof(buffer)); 741 snprintf(buffer, sizeof(buffer), ",%d", zoomRatios[i]); 742 str.append(buffer); 743 } 744 return str; 745} 746 747/*=========================================================================== 748 * FUNCTION : createHfrValuesString 749 * 750 * DESCRIPTION: create string obj contains array of hfr values from map when 751 * matched from input hfr values 752 * 753 * PARAMETERS : 754 * @values : array of hfr info 755 * @len : size of the array 756 * @map : map of hfr string value and enum 757 * map_len : size of map 758 * 759 * RETURN : string obj 760 *==========================================================================*/ 761String8 QCameraParameters::createHfrValuesString( 762 const cam_hfr_info_t *values, 763 int len, 764 const QCameraMap* map, 765 int map_len) 766{ 767 String8 str; 768 int count = 0; 769 770 for (int i = 0; i < len; i++ ) { 771 for (int j = 0; j < map_len; j ++) 772 if (map[j].val == (int)values[i].mode) { 773 if (NULL != map[j].desc) { 774 if (count > 0) { 775 str.append(","); 776 } 777 str.append(map[j].desc); 778 count++; 779 break; //loop j 780 } 781 } 782 } 783 return str; 784} 785 786/*=========================================================================== 787 * FUNCTION : createHfrSizesString 788 * 789 * DESCRIPTION: create string obj contains array of hfr sizes 790 * 791 * PARAMETERS : 792 * @values : array of hfr info 793 * @len : size of the array 794 * 795 * RETURN : string obj 796 *==========================================================================*/ 797String8 QCameraParameters::createHfrSizesString( 798 const cam_hfr_info_t *values, 799 int len) 800{ 801 String8 str; 802 char buffer[32]; 803 804 if (len > 0) { 805 snprintf(buffer, sizeof(buffer), "%dx%d", 806 values[0].dim.width, values[0].dim.height); 807 str.append(buffer); 808 } 809 for (int i = 1; i < len; i++) { 810 snprintf(buffer, sizeof(buffer), ",%dx%d", 811 values[i].dim.width, values[i].dim.height); 812 str.append(buffer); 813 } 814 return str; 815} 816 817/*=========================================================================== 818 * FUNCTION : createFpsString 819 * 820 * DESCRIPTION: create string obj contains array of FPS rates 821 * 822 * PARAMETERS : 823 * @fps : array of fps ranges 824 * @len : size of the array 825 * 826 * RETURN : string obj 827 *==========================================================================*/ 828String8 QCameraParameters::createFpsString(const cam_fps_range_t *fps, int len) 829{ 830 String8 str; 831 char buffer[32]; 832 833 for (int i = 0; i < len; i++ ) { 834 snprintf(buffer, sizeof(buffer), "%d", int(fps[i].max_fps * 1000)); 835 str.append(buffer); 836 if (i < len-1) 837 str.append(","); 838 } 839 return str; 840} 841 842/*=========================================================================== 843 * FUNCTION : createFpsRangeString 844 * 845 * DESCRIPTION: create string obj contains array of FPS ranges 846 * 847 * PARAMETERS : 848 * @fps : array of fps ranges 849 * @len : size of the array 850 * @default_fps_index : reference to index of default fps range 851 * 852 * RETURN : string obj 853 *==========================================================================*/ 854String8 QCameraParameters::createFpsRangeString(const cam_fps_range_t* fps, 855 int len, 856 int &default_fps_index) 857{ 858 String8 str; 859 char buffer[32]; 860 int max_range = 0; 861 int min_fps, max_fps; 862 863 if (len > 0) { 864 min_fps = int(fps[0].min_fps * 1000); 865 max_fps = int(fps[0].max_fps * 1000); 866 max_range = max_fps - min_fps; 867 default_fps_index = 0; 868 snprintf(buffer, sizeof(buffer), "(%d,%d)", min_fps, max_fps); 869 str.append(buffer); 870 } 871 for (int i = 1; i < len; i++) { 872 min_fps = int(fps[i].min_fps * 1000); 873 max_fps = int(fps[i].max_fps * 1000); 874 if (max_range < (max_fps - min_fps)) { 875 max_range = max_fps - min_fps; 876 default_fps_index = i; 877 } 878 snprintf(buffer, sizeof(buffer), ",(%d,%d)", min_fps, max_fps); 879 str.append(buffer); 880 } 881 return str; 882} 883 884/*=========================================================================== 885 * FUNCTION : lookupAttr 886 * 887 * DESCRIPTION: lookup a value by its name 888 * 889 * PARAMETERS : 890 * @attr : map contains <name, value> 891 * @len : size of the map 892 * @name : name to be looked up 893 * 894 * RETURN : valid value if found 895 * NAME_NOT_FOUND if not found 896 *==========================================================================*/ 897int QCameraParameters::lookupAttr(const QCameraMap arr[], int len, const char *name) 898{ 899 if (name) { 900 for (int i = 0; i < len; i++) { 901 if (!strcmp(arr[i].desc, name)) 902 return arr[i].val; 903 } 904 } 905 return NAME_NOT_FOUND; 906} 907 908/*=========================================================================== 909 * FUNCTION : lookupNameByValue 910 * 911 * DESCRIPTION: lookup a name by its value 912 * 913 * PARAMETERS : 914 * @attr : map contains <name, value> 915 * @len : size of the map 916 * @value : value to be looked up 917 * 918 * RETURN : name str or NULL if not found 919 *==========================================================================*/ 920const char *QCameraParameters::lookupNameByValue(const QCameraMap arr[], int len, int value) 921{ 922 for (int i = 0; i < len; i++) { 923 if (arr[i].val == value) { 924 return arr[i].desc; 925 } 926 } 927 return NULL; 928} 929 930/*=========================================================================== 931 * FUNCTION : setPreviewSize 932 * 933 * DESCRIPTION: set preview size from user setting 934 * 935 * PARAMETERS : 936 * @params : user setting parameters 937 * 938 * RETURN : int32_t type of status 939 * NO_ERROR -- success 940 * none-zero failure code 941 *==========================================================================*/ 942int32_t QCameraParameters::setPreviewSize(const QCameraParameters& params) 943{ 944 int width, height; 945 params.getPreviewSize(&width, &height); 946 ALOGV("Requested preview size %d x %d", width, height); 947 948 // Validate the preview size 949 for (size_t i = 0; i < m_pCapability->preview_sizes_tbl_cnt; ++i) { 950 if (width == m_pCapability->preview_sizes_tbl[i].width 951 && height == m_pCapability->preview_sizes_tbl[i].height) { 952 // check if need to restart preview in case of preview size change 953 int old_width, old_height; 954 CameraParameters::getPreviewSize(&old_width, &old_height); 955 if (width != old_width || height != old_height) { 956 m_bNeedRestart = true; 957 } 958 959 // set the new value 960 char val[32]; 961 sprintf(val, "%dx%d", width, height); 962 updateParamEntry(KEY_PREVIEW_SIZE, val); 963 ALOGV("%s: %s", __func__, val); 964 return NO_ERROR; 965 } 966 } 967 ALOGE("Invalid preview size requested: %dx%d", width, height); 968 return BAD_VALUE; 969} 970 971/*=========================================================================== 972 * FUNCTION : setPictureSize 973 * 974 * DESCRIPTION: set picture size from user setting 975 * 976 * PARAMETERS : 977 * @params : user setting parameters 978 * 979 * RETURN : int32_t type of status 980 * NO_ERROR -- success 981 * none-zero failure code 982 *==========================================================================*/ 983int32_t QCameraParameters::setPictureSize(const QCameraParameters& params) 984{ 985 int width, height; 986 params.getPictureSize(&width, &height); 987 ALOGV("Requested picture size %d x %d", width, height); 988 989 // Validate the picture size 990 for (size_t i = 0; i < m_pCapability->picture_sizes_tbl_cnt; ++i) { 991 if (width == m_pCapability->picture_sizes_tbl[i].width 992 && height == m_pCapability->picture_sizes_tbl[i].height) { 993 // check if need to restart preview in case of picture size change 994 int old_width, old_height; 995 CameraParameters::getPictureSize(&old_width, &old_height); 996 if ((m_bZslMode || m_bRecordingHint) && 997 (width != old_width || height != old_height)) { 998 m_bNeedRestart = true; 999 } 1000 1001 // set the new value 1002 char val[32]; 1003 sprintf(val, "%dx%d", width, height); 1004 updateParamEntry(KEY_PICTURE_SIZE, val); 1005 ALOGV("%s: %s", __func__, val); 1006 return NO_ERROR; 1007 } 1008 } 1009 ALOGE("Invalid picture size requested: %dx%d", width, height); 1010 return BAD_VALUE; 1011} 1012 1013/*=========================================================================== 1014 * FUNCTION : setVideoSize 1015 * 1016 * DESCRIPTION: set video size from user setting 1017 * 1018 * PARAMETERS : 1019 * @params : user setting parameters 1020 * 1021 * RETURN : int32_t type of status 1022 * NO_ERROR -- success 1023 * none-zero failure code 1024 *==========================================================================*/ 1025int32_t QCameraParameters::setVideoSize(const QCameraParameters& params) 1026{ 1027 const char *str= NULL; 1028 int width, height; 1029 str = params.get(KEY_VIDEO_SIZE); 1030 if(!str) { 1031 //If application didn't set this parameter string, use the values from 1032 //getPreviewSize() as video dimensions. 1033 params.getPreviewSize(&width, &height); 1034 ALOGE("No Record Size requested, use the preview dimensions"); 1035 } else { 1036 params.getVideoSize(&width, &height); 1037 } 1038 1039 // Validate the video size 1040 for (size_t i = 0; i < m_pCapability->video_sizes_tbl_cnt; ++i) { 1041 if (width == m_pCapability->video_sizes_tbl[i].width 1042 && height == m_pCapability->video_sizes_tbl[i].height) { 1043 // check if need to restart preview in case of video size change 1044 int old_width, old_height; 1045 CameraParameters::getVideoSize(&old_width, &old_height); 1046 if (m_bRecordingHint && 1047 (width != old_width || height != old_height)) { 1048 m_bNeedRestart = true; 1049 } 1050 1051 // set the new value 1052 char val[32]; 1053 sprintf(val, "%dx%d", width, height); 1054 updateParamEntry(KEY_VIDEO_SIZE, val); 1055 ALOGV("%s: %s", __func__, val); 1056 return NO_ERROR; 1057 } 1058 } 1059 1060 ALOGE("Invalid video size requested: %dx%d", width, height); 1061 return BAD_VALUE; 1062} 1063 1064/*=========================================================================== 1065 * FUNCTION : setLiveSnapshotSize 1066 * 1067 * DESCRIPTION: set live snapshot size 1068 * 1069 * PARAMETERS : 1070 * @params : user setting parameters 1071 * 1072 * RETURN : int32_t type of status 1073 * NO_ERROR -- success 1074 * none-zero failure code 1075 *==========================================================================*/ 1076int32_t QCameraParameters::setLiveSnapshotSize(const QCameraParameters& params) 1077{ 1078 char value[32]; 1079 property_get("persist.camera.opt.livepic", value, "1"); 1080 bool useOptimal = atoi(value) > 0 ? true : false; 1081 1082 // use picture size from user setting 1083 params.getPictureSize(&m_LiveSnapshotSize.width, &m_LiveSnapshotSize.height); 1084 1085 if (useOptimal) { 1086 bool found = false; 1087 1088 // first check if picture size is within the list of supported sizes 1089 for (int i = 0; i < m_pCapability->livesnapshot_sizes_tbl_cnt; ++i) { 1090 if (m_LiveSnapshotSize.width == m_pCapability->livesnapshot_sizes_tbl[i].width && 1091 m_LiveSnapshotSize.height == m_pCapability->livesnapshot_sizes_tbl[i].height) { 1092 found = true; 1093 break; 1094 } 1095 } 1096 1097 if (!found) { 1098 // use optimal live snapshot size from supported list, 1099 // that has same preview aspect ratio 1100 int width = 0, height = 0; 1101 params.getPreviewSize(&width, &height); 1102 1103 double previewAspectRatio = (double)width / height; 1104 for (int i = 0; i < m_pCapability->livesnapshot_sizes_tbl_cnt; ++i) { 1105 double ratio = (double)m_pCapability->livesnapshot_sizes_tbl[i].width / 1106 m_pCapability->livesnapshot_sizes_tbl[i].height; 1107 if (fabs(previewAspectRatio - ratio) <= ASPECT_TOLERANCE) { 1108 m_LiveSnapshotSize = m_pCapability->livesnapshot_sizes_tbl[i]; 1109 found = true; 1110 break; 1111 } 1112 } 1113 1114 if (!found) { 1115 // Cannot find matching aspect ration from supported live snapshot list 1116 // fall back to picture size 1117 ALOGI("%s: Cannot find matching aspect ratio, fall back to pic size", __func__); 1118 } 1119 } 1120 } 1121 ALOGI("%s: live snapshot size %d x %d", __func__, 1122 m_LiveSnapshotSize.width, m_LiveSnapshotSize.height); 1123 1124 return NO_ERROR; 1125} 1126 1127/*=========================================================================== 1128 * FUNCTION : setPreviewFormat 1129 * 1130 * DESCRIPTION: set preview format from user setting 1131 * 1132 * PARAMETERS : 1133 * @params : user setting parameters 1134 * 1135 * RETURN : int32_t type of status 1136 * NO_ERROR -- success 1137 * none-zero failure code 1138 *==========================================================================*/ 1139int32_t QCameraParameters::setPreviewFormat(const QCameraParameters& params) 1140{ 1141 const char *str = params.getPreviewFormat(); 1142 int32_t previewFormat = 1143 lookupAttr(PREVIEW_FORMATS_MAP, 1144 sizeof(PREVIEW_FORMATS_MAP) / sizeof(QCameraMap), 1145 str); 1146 if (previewFormat != NAME_NOT_FOUND) { 1147 mPreviewFormat = (cam_format_t)previewFormat; 1148 1149 updateParamEntry(KEY_PREVIEW_FORMAT, str); 1150 ALOGV("%s: format %d\n", __func__, mPreviewFormat); 1151 return NO_ERROR; 1152 } 1153 ALOGE("Invalid preview format value: %s", (str == NULL) ? "NULL" : str); 1154 return BAD_VALUE; 1155} 1156 1157/*=========================================================================== 1158 * FUNCTION : setPictureFormat 1159 * 1160 * DESCRIPTION: set picture format from user setting 1161 * 1162 * PARAMETERS : 1163 * @params : user setting parameters 1164 * 1165 * RETURN : int32_t type of status 1166 * NO_ERROR -- success 1167 * none-zero failure code 1168 *==========================================================================*/ 1169int32_t QCameraParameters::setPictureFormat(const QCameraParameters& params) 1170{ 1171 const char *str = params.getPictureFormat(); 1172 int32_t pictureFormat = 1173 lookupAttr(PICTURE_TYPES_MAP, 1174 sizeof(PICTURE_TYPES_MAP) / sizeof(QCameraMap), 1175 str); 1176 if (pictureFormat != NAME_NOT_FOUND) { 1177 mPictureFormat = pictureFormat; 1178 1179 updateParamEntry(KEY_PICTURE_FORMAT, str); 1180 ALOGE("%s: format %d\n", __func__, mPictureFormat); 1181 return NO_ERROR; 1182 } 1183 ALOGE("Invalid picture format value: %s", (str == NULL) ? "NULL" : str); 1184 return BAD_VALUE; 1185} 1186 1187/*=========================================================================== 1188 * FUNCTION : setJpegThumbnailSize 1189 * 1190 * DESCRIPTION: set jpeg thumbnail size from user setting 1191 * 1192 * PARAMETERS : 1193 * @params : user setting parameters 1194 * 1195 * RETURN : int32_t type of status 1196 * NO_ERROR -- success 1197 * none-zero failure code 1198 *==========================================================================*/ 1199int32_t QCameraParameters::setJpegThumbnailSize(const QCameraParameters& params) 1200{ 1201 int width = params.getInt(KEY_JPEG_THUMBNAIL_WIDTH); 1202 int height = params.getInt(KEY_JPEG_THUMBNAIL_HEIGHT); 1203 1204 ALOGV("requested jpeg thumbnail size %d x %d", width, height); 1205 1206 int sizes_cnt = sizeof(THUMBNAIL_SIZES_MAP) / sizeof(cam_dimension_t); 1207 1208 int pic_width = 0, pic_height = 0; 1209 params.getPictureSize(&pic_width, &pic_height); 1210 if (pic_height == 0) { 1211 ALOGE("%s: picture size is invalid (%d x %d)", __func__, pic_width, pic_height); 1212 return BAD_VALUE; 1213 } 1214 double picAspectRatio = (double)pic_width / pic_height; 1215 1216 int optimalWidth = 0, optimalHeight = 0; 1217 if (width != 0 || height != 0) { 1218 // If input jpeg thumnmail size is (0,0), meaning no thumbnail needed 1219 // hornor this setting. 1220 // Otherwise, find optimal jpeg thumbnail size that has same aspect ration 1221 // as picture size 1222 1223 // Try to find a size matches aspect ratio and has the largest width 1224 for (int i = 0; i < sizes_cnt; i++) { 1225 if (THUMBNAIL_SIZES_MAP[i].height == 0) { 1226 // No thumbnail case, just skip 1227 continue; 1228 } 1229 double ratio = 1230 (double)THUMBNAIL_SIZES_MAP[i].width / THUMBNAIL_SIZES_MAP[i].height; 1231 if (fabs(ratio - picAspectRatio) > ASPECT_TOLERANCE) { 1232 continue; 1233 } 1234 if (THUMBNAIL_SIZES_MAP[i].width > optimalWidth) { 1235 optimalWidth = THUMBNAIL_SIZES_MAP[i].width; 1236 optimalHeight = THUMBNAIL_SIZES_MAP[i].height; 1237 } 1238 } 1239 } 1240 1241 char val[16]; 1242 sprintf(val, "%d", optimalWidth); 1243 updateParamEntry(KEY_JPEG_THUMBNAIL_WIDTH, val); 1244 sprintf(val, "%d", optimalHeight); 1245 updateParamEntry(KEY_JPEG_THUMBNAIL_HEIGHT, val); 1246 return NO_ERROR; 1247} 1248 1249/*=========================================================================== 1250 * FUNCTION : setJpegQuality 1251 * 1252 * DESCRIPTION: set jpeg encpding quality from user setting 1253 * 1254 * PARAMETERS : 1255 * @params : user setting parameters 1256 * 1257 * RETURN : int32_t type of status 1258 * NO_ERROR -- success 1259 * none-zero failure code 1260 *==========================================================================*/ 1261int32_t QCameraParameters::setJpegQuality(const QCameraParameters& params) 1262{ 1263 int32_t rc = NO_ERROR; 1264 int quality = params.getInt(KEY_JPEG_QUALITY); 1265 if (quality >= 0 && quality <= 100) { 1266 set(KEY_JPEG_QUALITY, quality); 1267 } else { 1268 ALOGE("%s: Invalid jpeg quality=%d", __func__, quality); 1269 rc = BAD_VALUE; 1270 } 1271 1272 quality = params.getInt(KEY_JPEG_THUMBNAIL_QUALITY); 1273 if (quality >= 0 && quality <= 100) { 1274 char val[16]; 1275 sprintf(val, "%d", quality); 1276 updateParamEntry(KEY_JPEG_THUMBNAIL_QUALITY, val); 1277 } else { 1278 ALOGE("%s: Invalid jpeg thumbnail quality=%d", __func__, quality); 1279 rc = BAD_VALUE; 1280 } 1281 return rc; 1282} 1283 1284/*=========================================================================== 1285 * FUNCTION : setOrientaion 1286 * 1287 * DESCRIPTION: set orientaion from user setting 1288 * 1289 * PARAMETERS : 1290 * @params : user setting parameters 1291 * 1292 * RETURN : int32_t type of status 1293 * NO_ERROR -- success 1294 * none-zero failure code 1295 *==========================================================================*/ 1296int32_t QCameraParameters::setOrientation(const QCameraParameters& params) 1297{ 1298 const char *str = params.get(KEY_QC_ORIENTATION); 1299 1300 if (str != NULL) { 1301 if (strcmp(str, portrait) == 0 || strcmp(str, landscape) == 0) { 1302 // Camera service needs this to decide if the preview frames and raw 1303 // pictures should be rotated. 1304 updateParamEntry(KEY_QC_ORIENTATION, str); 1305 } else { 1306 ALOGE("%s: Invalid orientation value: %s", __func__, str); 1307 return BAD_VALUE; 1308 } 1309 } 1310 return NO_ERROR; 1311} 1312 1313/*=========================================================================== 1314 * FUNCTION : setAutoExposure 1315 * 1316 * DESCRIPTION: set auto exposure value from user setting 1317 * 1318 * PARAMETERS : 1319 * @params : user setting parameters 1320 * 1321 * RETURN : int32_t type of status 1322 * NO_ERROR -- success 1323 * none-zero failure code 1324 *==========================================================================*/ 1325int32_t QCameraParameters::setAutoExposure(const QCameraParameters& params) 1326{ 1327 const char *str = params.get(KEY_QC_AUTO_EXPOSURE); 1328 const char *prev_str = get(KEY_QC_AUTO_EXPOSURE); 1329 if (str != NULL) { 1330 if (prev_str == NULL || 1331 strcmp(str, prev_str) != 0) { 1332 return setAutoExposure(str); 1333 } 1334 } 1335 return NO_ERROR; 1336} 1337 1338/*=========================================================================== 1339 * FUNCTION : setPreviewFpsRange 1340 * 1341 * DESCRIPTION: set preview FPS range from user setting 1342 * 1343 * PARAMETERS : 1344 * @params : user setting parameters 1345 * 1346 * RETURN : int32_t type of status 1347 * NO_ERROR -- success 1348 * none-zero failure code 1349 *==========================================================================*/ 1350int32_t QCameraParameters::setPreviewFpsRange(const QCameraParameters& params) 1351{ 1352 int minFps,maxFps; 1353 int prevMinFps, prevMaxFps; 1354 int rc = NO_ERROR; 1355 bool found = false; 1356 1357 CameraParameters::getPreviewFpsRange(&prevMinFps, &prevMaxFps); 1358 ALOGV("%s: Existing FpsRange Values:(%d, %d)", __func__, prevMinFps, prevMaxFps); 1359 params.getPreviewFpsRange(&minFps, &maxFps); 1360 ALOGV("%s: Requested FpsRange Values:(%d, %d)", __func__, minFps, maxFps); 1361 1362 if(minFps == prevMinFps && maxFps == prevMaxFps) { 1363 ALOGV("%s: No change in FpsRange", __func__); 1364 rc = NO_ERROR; 1365 goto end; 1366 } 1367 for(int i = 0; i < m_pCapability->fps_ranges_tbl_cnt; i++) { 1368 // if the value is in the supported list 1369 if(minFps >= m_pCapability->fps_ranges_tbl[i].min_fps * 1000 && 1370 maxFps <= m_pCapability->fps_ranges_tbl[i].max_fps * 1000) { 1371 found = true; 1372 ALOGV("%s: FPS i=%d : minFps = %d, maxFps = %d ", __func__, i, minFps, maxFps); 1373 setPreviewFpsRange(minFps, maxFps); 1374 break; 1375 } 1376 } 1377 if(found == false){ 1378 ALOGE("%s: error: FPS range value not supported", __func__); 1379 rc = BAD_VALUE; 1380 } 1381end: 1382 return rc; 1383} 1384 1385/*=========================================================================== 1386 * FUNCTION : setPreviewFrameRate 1387 * 1388 * DESCRIPTION: set preview frame rate from user setting 1389 * 1390 * PARAMETERS : 1391 * @params : user setting parameters 1392 * 1393 * RETURN : int32_t type of status 1394 * NO_ERROR -- success 1395 * none-zero failure code 1396 *==========================================================================*/ 1397int32_t QCameraParameters::setPreviewFrameRate(const QCameraParameters& params) 1398{ 1399 uint16_t fps = (uint16_t)params.getPreviewFrameRate(); 1400 ALOGV("%s: requested preview frame rate is %d", __func__, fps); 1401 CameraParameters::setPreviewFrameRate(fps); 1402 return NO_ERROR; 1403} 1404 1405/*=========================================================================== 1406 * FUNCTION : setEffect 1407 * 1408 * DESCRIPTION: set effect value from user setting 1409 * 1410 * PARAMETERS : 1411 * @params : user setting parameters 1412 * 1413 * RETURN : int32_t type of status 1414 * NO_ERROR -- success 1415 * none-zero failure code 1416 *==========================================================================*/ 1417int32_t QCameraParameters::setEffect(const QCameraParameters& params) 1418{ 1419 const char *str = params.get(KEY_EFFECT); 1420 const char *prev_str = get(KEY_EFFECT); 1421 if (str != NULL) { 1422 if (prev_str == NULL || 1423 strcmp(str, prev_str) != 0) { 1424 return setEffect(str); 1425 } 1426 } 1427 return NO_ERROR; 1428} 1429 1430/*=========================================================================== 1431 * FUNCTION : setFocusMode 1432 * 1433 * DESCRIPTION: set focus mode from user setting 1434 * 1435 * PARAMETERS : 1436 * @params : user setting parameters 1437 * 1438 * RETURN : int32_t type of status 1439 * NO_ERROR -- success 1440 * none-zero failure code 1441 *==========================================================================*/ 1442int32_t QCameraParameters::setFocusMode(const QCameraParameters& params) 1443{ 1444 const char *str = params.get(KEY_FOCUS_MODE); 1445 const char *prev_str = get(KEY_FOCUS_MODE); 1446 if (str != NULL) { 1447 if (prev_str == NULL || 1448 strcmp(str, prev_str) != 0) { 1449 return setFocusMode(str); 1450 } 1451 } 1452 return NO_ERROR; 1453} 1454 1455/*=========================================================================== 1456 * FUNCTION : setBrightness 1457 * 1458 * DESCRIPTION: set brightness control value from user setting 1459 * 1460 * PARAMETERS : 1461 * @params : user setting parameters 1462 * 1463 * RETURN : int32_t type of status 1464 * NO_ERROR -- success 1465 * none-zero failure code 1466 *==========================================================================*/ 1467int32_t QCameraParameters::setBrightness(const QCameraParameters& params) 1468{ 1469 int currentBrightness = getInt(KEY_QC_BRIGHTNESS); 1470 int brightness = params.getInt(KEY_QC_BRIGHTNESS); 1471 if (currentBrightness != brightness) { 1472 if (brightness >= m_pCapability->brightness_ctrl.min_value && 1473 brightness <= m_pCapability->brightness_ctrl.max_value) { 1474 ALOGV(" new brightness value : %d ", brightness); 1475 return setBrightness(brightness); 1476 } else { 1477 ALOGE("%s: invalid value %d out of (%d, %d)", 1478 __func__, brightness, 1479 m_pCapability->brightness_ctrl.min_value, 1480 m_pCapability->brightness_ctrl.max_value); 1481 return BAD_VALUE; 1482 } 1483 } else { 1484 ALOGV("%s: No brightness value changed.", __func__); 1485 return NO_ERROR; 1486 } 1487} 1488 1489/*=========================================================================== 1490 * FUNCTION : setSharpness 1491 * 1492 * DESCRIPTION: set sharpness control value from user setting 1493 * 1494 * PARAMETERS : 1495 * @params : user setting parameters 1496 * 1497 * RETURN : int32_t type of status 1498 * NO_ERROR -- success 1499 * none-zero failure code 1500 *==========================================================================*/ 1501int32_t QCameraParameters::setSharpness(const QCameraParameters& params) 1502{ 1503 int shaprness = params.getInt(KEY_QC_SHARPNESS); 1504 int prev_sharp = getInt(KEY_QC_SHARPNESS); 1505 if (prev_sharp != shaprness) { 1506 if((shaprness >= m_pCapability->sharpness_ctrl.min_value) && 1507 (shaprness <= m_pCapability->sharpness_ctrl.max_value)) { 1508 ALOGV(" new sharpness value : %d ", shaprness); 1509 return setSharpness(shaprness); 1510 } else { 1511 ALOGE("%s: invalid value %d out of (%d, %d)", 1512 __func__, shaprness, 1513 m_pCapability->sharpness_ctrl.min_value, 1514 m_pCapability->sharpness_ctrl.max_value); 1515 return BAD_VALUE; 1516 } 1517 } else { 1518 ALOGV("%s: No value change in shaprness", __func__); 1519 return NO_ERROR; 1520 } 1521} 1522 1523/*=========================================================================== 1524 * FUNCTION : setSkintoneEnahancement 1525 * 1526 * DESCRIPTION: set skin tone enhancement factor from user setting 1527 * 1528 * PARAMETERS : 1529 * @params : user setting parameters 1530 * 1531 * RETURN : int32_t type of status 1532 * NO_ERROR -- success 1533 * none-zero failure code 1534 *==========================================================================*/ 1535int32_t QCameraParameters::setSkinToneEnhancement(const QCameraParameters& params) 1536{ 1537 int sceFactor = params.getInt(KEY_QC_SCE_FACTOR); 1538 int prev_sceFactor = getInt(KEY_QC_SCE_FACTOR); 1539 if (prev_sceFactor != sceFactor) { 1540 if((sceFactor >= m_pCapability->sce_ctrl.min_value) && 1541 (sceFactor <= m_pCapability->sce_ctrl.max_value)) { 1542 ALOGV(" new Skintone Enhancement value : %d ", sceFactor); 1543 return setSkinToneEnhancement(sceFactor); 1544 } else { 1545 ALOGE("%s: invalid value %d out of (%d, %d)", 1546 __func__, sceFactor, 1547 m_pCapability->sce_ctrl.min_value, 1548 m_pCapability->sce_ctrl.max_value); 1549 return BAD_VALUE; 1550 } 1551 } else { 1552 ALOGV("%s: No value change in skintone enhancement factor", __func__); 1553 return NO_ERROR; 1554 } 1555} 1556 1557/*=========================================================================== 1558 * FUNCTION : setSaturation 1559 * 1560 * DESCRIPTION: set saturation control value from user setting 1561 * 1562 * PARAMETERS : 1563 * @params : user setting parameters 1564 * 1565 * RETURN : int32_t type of status 1566 * NO_ERROR -- success 1567 * none-zero failure code 1568 *==========================================================================*/ 1569int32_t QCameraParameters::setSaturation(const QCameraParameters& params) 1570{ 1571 int saturation = params.getInt(KEY_QC_SATURATION); 1572 int prev_sat = getInt(KEY_QC_SATURATION); 1573 if (prev_sat != saturation) { 1574 if((saturation >= m_pCapability->saturation_ctrl.min_value) && 1575 (saturation <= m_pCapability->saturation_ctrl.max_value)) { 1576 ALOGV(" new saturation value : %d ", saturation); 1577 return setSaturation(saturation); 1578 } else { 1579 ALOGE("%s: invalid value %d out of (%d, %d)", 1580 __func__, saturation, 1581 m_pCapability->saturation_ctrl.min_value, 1582 m_pCapability->saturation_ctrl.max_value); 1583 return BAD_VALUE; 1584 } 1585 } else { 1586 ALOGV("%s: No value change in saturation factor", __func__); 1587 return NO_ERROR; 1588 } 1589} 1590 1591/*=========================================================================== 1592 * FUNCTION : setContrast 1593 * 1594 * DESCRIPTION: set contrast control value from user setting 1595 * 1596 * PARAMETERS : 1597 * @params : user setting parameters 1598 * 1599 * RETURN : int32_t type of status 1600 * NO_ERROR -- success 1601 * none-zero failure code 1602 *==========================================================================*/ 1603int32_t QCameraParameters::setContrast(const QCameraParameters& params) 1604{ 1605 int contrast = params.getInt(KEY_QC_CONTRAST); 1606 int prev_contrast = getInt(KEY_QC_CONTRAST); 1607 if (prev_contrast != contrast) { 1608 if((contrast >= m_pCapability->contrast_ctrl.min_value) && 1609 (contrast <= m_pCapability->contrast_ctrl.max_value)) { 1610 ALOGV(" new contrast value : %d ", contrast); 1611 int32_t rc = setContrast(contrast); 1612 return rc; 1613 } else { 1614 ALOGE("%s: invalid value %d out of (%d, %d)", 1615 __func__, contrast, 1616 m_pCapability->contrast_ctrl.min_value, 1617 m_pCapability->contrast_ctrl.max_value); 1618 return BAD_VALUE; 1619 } 1620 } else { 1621 ALOGV("%s: No value change in contrast", __func__); 1622 return NO_ERROR; 1623 } 1624} 1625 1626/*=========================================================================== 1627 * FUNCTION : setExposureCompensation 1628 * 1629 * DESCRIPTION: set exposure compensation value from user setting 1630 * 1631 * PARAMETERS : 1632 * @params : user setting parameters 1633 * 1634 * RETURN : int32_t type of status 1635 * NO_ERROR -- success 1636 * none-zero failure code 1637 *==========================================================================*/ 1638int32_t QCameraParameters::setExposureCompensation(const QCameraParameters & params) 1639{ 1640 int expComp = params.getInt(KEY_EXPOSURE_COMPENSATION); 1641 int prev_expComp = getInt(KEY_EXPOSURE_COMPENSATION); 1642 if (prev_expComp != expComp) { 1643 if((expComp >= m_pCapability->exposure_compensation_min) && 1644 (expComp <= m_pCapability->exposure_compensation_max)) { 1645 ALOGV(" new Exposure Compensation value : %d ", expComp); 1646 return setExposureCompensation(expComp); 1647 } else { 1648 ALOGE("%s: invalid value %d out of (%d, %d)", 1649 __func__, expComp, 1650 m_pCapability->exposure_compensation_min, 1651 m_pCapability->exposure_compensation_max); 1652 return BAD_VALUE; 1653 } 1654 } else { 1655 ALOGV("%s: No value change in Exposure Compensation", __func__); 1656 return NO_ERROR; 1657 } 1658} 1659 1660/*=========================================================================== 1661 * FUNCTION : setWhiteBalance 1662 * 1663 * DESCRIPTION: set white balance value from user setting 1664 * 1665 * PARAMETERS : 1666 * @params : user setting parameters 1667 * 1668 * RETURN : int32_t type of status 1669 * NO_ERROR -- success 1670 * none-zero failure code 1671 *==========================================================================*/ 1672int32_t QCameraParameters::setWhiteBalance(const QCameraParameters& params) 1673{ 1674 const char *str = params.get(KEY_WHITE_BALANCE); 1675 const char *prev_str = get(KEY_WHITE_BALANCE); 1676 if (str != NULL) { 1677 if (prev_str == NULL || 1678 strcmp(str, prev_str) != 0) { 1679 return setWhiteBalance(str); 1680 } 1681 } 1682 return NO_ERROR; 1683} 1684 1685/*=========================================================================== 1686 * FUNCTION : setAntibanding 1687 * 1688 * DESCRIPTION: set antibanding value from user setting 1689 * 1690 * PARAMETERS : 1691 * @params : user setting parameters 1692 * 1693 * RETURN : int32_t type of status 1694 * NO_ERROR -- success 1695 * none-zero failure code 1696 *==========================================================================*/ 1697int32_t QCameraParameters::setAntibanding(const QCameraParameters& params) 1698{ 1699 const char *str = params.get(KEY_ANTIBANDING); 1700 const char *prev_str = get(KEY_ANTIBANDING); 1701 if (str != NULL) { 1702 if (prev_str == NULL || 1703 strcmp(str, prev_str) != 0) { 1704 return setAntibanding(str); 1705 } 1706 } 1707 return NO_ERROR; 1708} 1709 1710/*=========================================================================== 1711 * FUNCTION : setSceneDetect 1712 * 1713 * DESCRIPTION: set scenen detect value from user setting 1714 * 1715 * PARAMETERS : 1716 * @params : user setting parameters 1717 * 1718 * RETURN : int32_t type of status 1719 * NO_ERROR -- success 1720 * none-zero failure code 1721 *==========================================================================*/ 1722int32_t QCameraParameters::setSceneDetect(const QCameraParameters& params) 1723{ 1724 const char *str = params.get(KEY_QC_SCENE_DETECT); 1725 const char *prev_str = get(KEY_QC_SCENE_DETECT); 1726 if (str != NULL) { 1727 if (prev_str == NULL || 1728 strcmp(str, prev_str) != 0) { 1729 return setSceneDetect(str); 1730 } 1731 } 1732 return NO_ERROR; 1733} 1734 1735/*=========================================================================== 1736 * FUNCTION : setVideoHDR 1737 * 1738 * DESCRIPTION: set video HDR value from user setting 1739 * 1740 * PARAMETERS : 1741 * @params : user setting parameters 1742 * 1743 * RETURN : int32_t type of status 1744 * NO_ERROR -- success 1745 * none-zero failure code 1746 *==========================================================================*/ 1747int32_t QCameraParameters::setVideoHDR(const QCameraParameters& params) 1748{ 1749 const char *str = params.get(KEY_QC_VIDEO_HDR); 1750 const char *prev_str = get(KEY_QC_VIDEO_HDR); 1751 if (str != NULL) { 1752 if (prev_str == NULL || 1753 strcmp(str, prev_str) != 0) { 1754 return setVideoHDR(str); 1755 } 1756 } 1757 return NO_ERROR; 1758} 1759 1760/*=========================================================================== 1761 * FUNCTION : setFaceRecognition 1762 * 1763 * DESCRIPTION: set face recognition mode from user setting 1764 * 1765 * PARAMETERS : 1766 * @params : user setting parameters 1767 * 1768 * RETURN : int32_t type of status 1769 * NO_ERROR -- success 1770 * none-zero failure code 1771 *==========================================================================*/ 1772int32_t QCameraParameters::setFaceRecognition(const QCameraParameters& params) 1773{ 1774 const char *str = params.get(KEY_QC_FACE_RECOGNITION); 1775 const char *prev_str = get(KEY_QC_FACE_RECOGNITION); 1776 if (str != NULL) { 1777 if (prev_str == NULL || 1778 strcmp(str, prev_str) != 0) { 1779 int maxFaces = params.getInt(KEY_QC_MAX_NUM_REQUESTED_FACES); 1780 return setFaceRecognition(str, maxFaces); 1781 } 1782 } 1783 return NO_ERROR; 1784} 1785 1786/*=========================================================================== 1787 * FUNCTION : setZoom 1788 * 1789 * DESCRIPTION: set zoom value from user setting 1790 * 1791 * PARAMETERS : 1792 * @params : user setting parameters 1793 * 1794 * RETURN : int32_t type of status 1795 * NO_ERROR -- success 1796 * none-zero failure code 1797 *==========================================================================*/ 1798int32_t QCameraParameters::setZoom(const QCameraParameters& params) 1799{ 1800 if ((m_pCapability->zoom_supported == 0 || 1801 m_pCapability->zoom_ratio_tbl_cnt == 0)) { 1802 ALOGD("%s: no zoom support", __func__); 1803 return NO_ERROR; 1804 } 1805 1806 int zoomLevel = params.getInt(KEY_ZOOM); 1807 if((zoomLevel < 0) || 1808 (zoomLevel >= m_pCapability->zoom_ratio_tbl_cnt)) { 1809 ALOGE("%s: invalid value %d out of (%d, %d)", 1810 __func__, zoomLevel, 1811 0, m_pCapability->zoom_ratio_tbl_cnt-1); 1812 return BAD_VALUE; 1813 } 1814 1815 int prevZoomLevel = getInt(KEY_ZOOM); 1816 if (prevZoomLevel == zoomLevel) { 1817 ALOGV("%s: No value change in contrast", __func__); 1818 return NO_ERROR; 1819 } 1820 1821 return setZoom(zoomLevel); 1822} 1823 1824/*=========================================================================== 1825 * FUNCTION : setISOValue 1826 * 1827 * DESCRIPTION: set ISO value from user setting 1828 * 1829 * PARAMETERS : 1830 * @params : user setting parameters 1831 * 1832 * RETURN : int32_t type of status 1833 * NO_ERROR -- success 1834 * none-zero failure code 1835 *==========================================================================*/ 1836int32_t QCameraParameters::setISOValue(const QCameraParameters& params) 1837{ 1838 const char *str = params.get(KEY_QC_ISO_MODE); 1839 const char *prev_str = get(KEY_QC_ISO_MODE); 1840 if (str != NULL) { 1841 if (prev_str == NULL || 1842 strcmp(str, prev_str) != 0) { 1843 return setISOValue(str); 1844 } 1845 } 1846 return NO_ERROR; 1847} 1848 1849/*=========================================================================== 1850 * FUNCTION : setRotation 1851 * 1852 * DESCRIPTION: set rotation value from user setting 1853 * 1854 * PARAMETERS : 1855 * @params : user setting parameters 1856 * 1857 * RETURN : int32_t type of status 1858 * NO_ERROR -- success 1859 * none-zero failure code 1860 *==========================================================================*/ 1861int32_t QCameraParameters::setRotation(const QCameraParameters& params) 1862{ 1863 int rotation = params.getInt(KEY_ROTATION); 1864 if (rotation != -1) { 1865 if (rotation == 0 || rotation == 90 || 1866 rotation == 180 || rotation == 270) { 1867 set(KEY_ROTATION, rotation); 1868 } else { 1869 ALOGE("Invalid rotation value: %d", rotation); 1870 return BAD_VALUE; 1871 } 1872 } 1873 return NO_ERROR; 1874} 1875 1876/*=========================================================================== 1877 * FUNCTION : setFlash 1878 * 1879 * DESCRIPTION: set flash mode from user setting 1880 * 1881 * PARAMETERS : 1882 * @params : user setting parameters 1883 * 1884 * RETURN : int32_t type of status 1885 * NO_ERROR -- success 1886 * none-zero failure code 1887 *==========================================================================*/ 1888int32_t QCameraParameters::setFlash(const QCameraParameters& params) 1889{ 1890 const char *str = params.get(KEY_FLASH_MODE); 1891 const char *prev_str = get(KEY_FLASH_MODE); 1892 if (str != NULL) { 1893 if (prev_str == NULL || 1894 strcmp(str, prev_str) != 0) { 1895 return setFlash(str); 1896 } 1897 } 1898 return NO_ERROR; 1899} 1900 1901/*=========================================================================== 1902 * FUNCTION : setAecLock 1903 * 1904 * DESCRIPTION: set AEC lock value from user setting 1905 * 1906 * PARAMETERS : 1907 * @params : user setting parameters 1908 * 1909 * RETURN : int32_t type of status 1910 * NO_ERROR -- success 1911 * none-zero failure code 1912 *==========================================================================*/ 1913int32_t QCameraParameters::setAecLock(const QCameraParameters& params) 1914{ 1915 const char *str = params.get(KEY_AUTO_EXPOSURE_LOCK); 1916 const char *prev_str = get(KEY_AUTO_EXPOSURE_LOCK); 1917 if (str != NULL) { 1918 if (prev_str == NULL || 1919 strcmp(str, prev_str) != 0) { 1920 return setAecLock(str); 1921 } 1922 } 1923 return NO_ERROR; 1924} 1925 1926/*=========================================================================== 1927 * FUNCTION : setAwbLock 1928 * 1929 * DESCRIPTION: set AWB lock from user setting 1930 * 1931 * PARAMETERS : 1932 * @params : user setting parameters 1933 * 1934 * RETURN : int32_t type of status 1935 * NO_ERROR -- success 1936 * none-zero failure code 1937 *==========================================================================*/ 1938int32_t QCameraParameters::setAwbLock(const QCameraParameters& params) 1939{ 1940 const char *str = params.get(KEY_AUTO_WHITEBALANCE_LOCK); 1941 const char *prev_str = get(KEY_AUTO_WHITEBALANCE_LOCK); 1942 if (str != NULL) { 1943 if (prev_str == NULL || 1944 strcmp(str, prev_str) != 0) { 1945 return setAwbLock(str); 1946 } 1947 } 1948 return NO_ERROR; 1949} 1950 1951/*=========================================================================== 1952 * FUNCTION : setMCEValue 1953 * 1954 * DESCRIPTION: set memory color enhancement value from user setting 1955 * 1956 * PARAMETERS : 1957 * @params : user setting parameters 1958 * 1959 * RETURN : int32_t type of status 1960 * NO_ERROR -- success 1961 * none-zero failure code 1962 *==========================================================================*/ 1963int32_t QCameraParameters::setMCEValue(const QCameraParameters& params) 1964{ 1965 const char *str = params.get(KEY_QC_MEMORY_COLOR_ENHANCEMENT); 1966 const char *prev_str = get(KEY_QC_MEMORY_COLOR_ENHANCEMENT); 1967 if (str != NULL) { 1968 if (prev_str == NULL || 1969 strcmp(str, prev_str) != 0) { 1970 return setMCEValue(str); 1971 } 1972 } 1973 return NO_ERROR; 1974} 1975 1976/*=========================================================================== 1977 * FUNCTION : setDISValue 1978 * 1979 * DESCRIPTION: enable/disable DIS from user setting 1980 * 1981 * PARAMETERS : 1982 * @params : user setting parameters 1983 * 1984 * RETURN : int32_t type of status 1985 * NO_ERROR -- success 1986 * none-zero failure code 1987 *==========================================================================*/ 1988int32_t QCameraParameters::setDISValue(const QCameraParameters& params) 1989{ 1990 const char *str = params.get(KEY_QC_DIS); 1991 const char *prev_str = get(KEY_QC_DIS); 1992 if (str != NULL) { 1993 if (prev_str == NULL || 1994 strcmp(str, prev_str) != 0) { 1995 return setDISValue(str); 1996 } 1997 } 1998 return NO_ERROR; 1999} 2000 2001/*=========================================================================== 2002 * FUNCTION : setHighFrameRate 2003 * 2004 * DESCRIPTION: set hight frame rate value from user setting 2005 * 2006 * PARAMETERS : 2007 * @params : user setting parameters 2008 * 2009 * RETURN : int32_t type of status 2010 * NO_ERROR -- success 2011 * none-zero failure code 2012 *==========================================================================*/ 2013int32_t QCameraParameters::setHighFrameRate(const QCameraParameters& params) 2014{ 2015 const char *str = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE); 2016 const char *prev_str = get(KEY_QC_VIDEO_HIGH_FRAME_RATE); 2017 if (str != NULL) { 2018 if (prev_str == NULL || 2019 strcmp(str, prev_str) != 0) { 2020 return setHighFrameRate(str); 2021 } 2022 } 2023 return NO_ERROR; 2024} 2025 2026/*=========================================================================== 2027 * FUNCTION : setLensShadeValue 2028 * 2029 * DESCRIPTION: set lens shade value from user setting 2030 * 2031 * PARAMETERS : 2032 * @params : user setting parameters 2033 * 2034 * RETURN : int32_t type of status 2035 * NO_ERROR -- success 2036 * none-zero failure code 2037 *==========================================================================*/ 2038int32_t QCameraParameters::setLensShadeValue(const QCameraParameters& params) 2039{ 2040 const char *str = params.get(KEY_QC_LENSSHADE); 2041 const char *prev_str = get(KEY_QC_LENSSHADE); 2042 if (str != NULL) { 2043 if (prev_str == NULL || 2044 strcmp(str, prev_str) != 0) { 2045 return setLensShadeValue(str); 2046 } 2047 } 2048 return NO_ERROR; 2049} 2050 2051/*=========================================================================== 2052 * FUNCTION : setFocusAreas 2053 * 2054 * DESCRIPTION: set focus areas from user setting 2055 * 2056 * PARAMETERS : 2057 * @params : user setting parameters 2058 * 2059 * RETURN : int32_t type of status 2060 * NO_ERROR -- success 2061 * none-zero failure code 2062 *==========================================================================*/ 2063int32_t QCameraParameters::setFocusAreas(const QCameraParameters& params) 2064{ 2065 const char *str = params.get(KEY_FOCUS_AREAS); 2066 if (str != NULL) { 2067 int max_num_af_areas = getInt(KEY_MAX_NUM_FOCUS_AREAS); 2068 if(max_num_af_areas == 0) { 2069 ALOGE("%s: max num of AF area is 0, cannot set focus areas", __func__); 2070 return BAD_VALUE; 2071 } 2072 2073 const char *prev_str = get(KEY_FOCUS_AREAS); 2074 if (prev_str == NULL || 2075 strcmp(str, prev_str) != 0) { 2076 return setFocusAreas(str); 2077 } 2078 } 2079 return NO_ERROR; 2080} 2081 2082/*=========================================================================== 2083 * FUNCTION : setMeteringAreas 2084 * 2085 * DESCRIPTION: set metering areas from user setting 2086 * 2087 * PARAMETERS : 2088 * @params : user setting parameters 2089 * 2090 * RETURN : int32_t type of status 2091 * NO_ERROR -- success 2092 * none-zero failure code 2093 *==========================================================================*/ 2094int32_t QCameraParameters::setMeteringAreas(const QCameraParameters& params) 2095{ 2096 const char *str = params.get(KEY_METERING_AREAS); 2097 if (str != NULL) { 2098 int max_num_mtr_areas = getInt(KEY_MAX_NUM_METERING_AREAS); 2099 if(max_num_mtr_areas == 0) { 2100 ALOGE("%s: max num of metering areas is 0, cannot set focus areas", __func__); 2101 return BAD_VALUE; 2102 } 2103 2104 const char *prev_str = get(KEY_METERING_AREAS); 2105 if (prev_str == NULL || 2106 strcmp(str, prev_str) != 0) { 2107 return setMeteringAreas(str); 2108 } 2109 } 2110 return NO_ERROR; 2111} 2112 2113/*=========================================================================== 2114 * FUNCTION : setSceneMode 2115 * 2116 * DESCRIPTION: set scenen mode from user setting 2117 * 2118 * PARAMETERS : 2119 * @params : user setting parameters 2120 * 2121 * RETURN : int32_t type of status 2122 * NO_ERROR -- success 2123 * none-zero failure code 2124 *==========================================================================*/ 2125int32_t QCameraParameters::setSceneMode(const QCameraParameters& params) 2126{ 2127 const char *str = params.get(KEY_SCENE_MODE); 2128 const char *prev_str = get(KEY_SCENE_MODE); 2129 if (str != NULL) { 2130 if (prev_str == NULL || 2131 strcmp(str, prev_str) != 0) { 2132 if ((strcmp(str, SCENE_MODE_HDR) == 0) || 2133 ((prev_str != NULL) && (strcmp(prev_str, SCENE_MODE_HDR) == 0))) { 2134 ALOGD("%s: scene mode changed between HDR and non-HDR, need restart", __func__); 2135 m_bNeedRestart = true; 2136 2137 // set if hdr 1x image is needed 2138 const char *need_hdr_1x = params.get(KEY_QC_HDR_NEED_1X); 2139 int32_t value = 0; 2140 if (need_hdr_1x != NULL && strcmp(need_hdr_1x, VALUE_TRUE) == 0) { 2141 value = 1; 2142 updateParamEntry(KEY_QC_HDR_NEED_1X, need_hdr_1x); 2143 AddSetParmEntryToBatch(m_pParamBuf, 2144 CAM_INTF_PARM_HDR_NEED_1X, 2145 sizeof(value), 2146 &value); 2147 } 2148 } 2149 return setSceneMode(str); 2150 } 2151 } 2152 return NO_ERROR; 2153} 2154 2155/*=========================================================================== 2156 * FUNCTION : setSelectableZoneAf 2157 * 2158 * DESCRIPTION: set selectable zone auto focus value from user setting 2159 * 2160 * PARAMETERS : 2161 * @params : user setting parameters 2162 * 2163 * RETURN : int32_t type of status 2164 * NO_ERROR -- success 2165 * none-zero failure code 2166 *==========================================================================*/ 2167int32_t QCameraParameters::setSelectableZoneAf(const QCameraParameters& params) 2168{ 2169 const char *str = params.get(KEY_QC_SELECTABLE_ZONE_AF); 2170 const char *prev_str = get(KEY_QC_SELECTABLE_ZONE_AF); 2171 if (str != NULL) { 2172 if (prev_str == NULL || 2173 strcmp(str, prev_str) != 0) { 2174 return setSelectableZoneAf(str); 2175 } 2176 } 2177 return NO_ERROR; 2178} 2179 2180/*=========================================================================== 2181 * FUNCTION : setAEBracket 2182 * 2183 * DESCRIPTION: set AE bracket from user setting 2184 * 2185 * PARAMETERS : 2186 * @params : user setting parameters 2187 * 2188 * RETURN : int32_t type of status 2189 * NO_ERROR -- success 2190 * none-zero failure code 2191 *==========================================================================*/ 2192int32_t QCameraParameters::setAEBracket(const QCameraParameters& params) 2193{ 2194 const char *scene_mode = params.get(KEY_SCENE_MODE); 2195 if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) { 2196 ALOGE("%s: scene mode is HDR, overwrite AE bracket setting to off", __func__); 2197 return setAEBracket(AE_BRACKET_OFF); 2198 } 2199 2200 const char *expStr = params.get(KEY_QC_CAPTURE_BURST_EXPOSURE); 2201 if (NULL != expStr && strlen(expStr) > 0) { 2202 set(KEY_QC_CAPTURE_BURST_EXPOSURE, expStr); 2203 } else { 2204 char prop[PROPERTY_VALUE_MAX]; 2205 memset(prop, 0, sizeof(prop)); 2206 property_get("persist.capture.burst.exposures", prop, ""); 2207 if (strlen(prop) > 0) { 2208 set(KEY_QC_CAPTURE_BURST_EXPOSURE, prop); 2209 } else { 2210 remove(KEY_QC_CAPTURE_BURST_EXPOSURE); 2211 } 2212 } 2213 2214 const char *str = params.get(KEY_QC_AE_BRACKET_HDR); 2215 const char *prev_str = get(KEY_QC_AE_BRACKET_HDR); 2216 if (str != NULL) { 2217 if (prev_str == NULL || 2218 strcmp(str, prev_str) != 0) { 2219 return setAEBracket(str); 2220 } 2221 } 2222 return NO_ERROR; 2223} 2224 2225/*=========================================================================== 2226 * FUNCTION : setRedeyeReduction 2227 * 2228 * DESCRIPTION: set red eye reduction setting from user setting 2229 * 2230 * PARAMETERS : 2231 * @params : user setting parameters 2232 * 2233 * RETURN : int32_t type of status 2234 * NO_ERROR -- success 2235 * none-zero failure code 2236 *==========================================================================*/ 2237int32_t QCameraParameters::setRedeyeReduction(const QCameraParameters& params) 2238{ 2239 const char *str = params.get(KEY_QC_REDEYE_REDUCTION); 2240 const char *prev_str = get(KEY_QC_REDEYE_REDUCTION); 2241 if (str != NULL) { 2242 if (prev_str == NULL || 2243 strcmp(str, prev_str) != 0) { 2244 return setRedeyeReduction(str); 2245 } 2246 } 2247 return NO_ERROR; 2248} 2249 2250/*=========================================================================== 2251 * FUNCTION : setGpsLocation 2252 * 2253 * DESCRIPTION: set GPS location information from user setting 2254 * 2255 * PARAMETERS : 2256 * @params : user setting parameters 2257 * 2258 * RETURN : int32_t type of status 2259 * NO_ERROR -- success 2260 * none-zero failure code 2261 *==========================================================================*/ 2262int32_t QCameraParameters::setGpsLocation(const QCameraParameters& params) 2263{ 2264 const char *method = params.get(KEY_GPS_PROCESSING_METHOD); 2265 if (method) { 2266 set(KEY_GPS_PROCESSING_METHOD, method); 2267 }else { 2268 remove(KEY_GPS_PROCESSING_METHOD); 2269 } 2270 2271 const char *latitude = params.get(KEY_GPS_LATITUDE); 2272 if (latitude) { 2273 set(KEY_GPS_LATITUDE, latitude); 2274 }else { 2275 remove(KEY_GPS_LATITUDE); 2276 } 2277 2278 const char *latitudeRef = params.get(KEY_QC_GPS_LATITUDE_REF); 2279 if (latitudeRef) { 2280 set(KEY_QC_GPS_LATITUDE_REF, latitudeRef); 2281 }else { 2282 remove(KEY_QC_GPS_LATITUDE_REF); 2283 } 2284 2285 const char *longitude = params.get(KEY_GPS_LONGITUDE); 2286 if (longitude) { 2287 set(KEY_GPS_LONGITUDE, longitude); 2288 }else { 2289 remove(KEY_GPS_LONGITUDE); 2290 } 2291 2292 const char *longitudeRef = params.get(KEY_QC_GPS_LONGITUDE_REF); 2293 if (longitudeRef) { 2294 set(KEY_QC_GPS_LONGITUDE_REF, longitudeRef); 2295 }else { 2296 remove(KEY_QC_GPS_LONGITUDE_REF); 2297 } 2298 2299 const char *altitudeRef = params.get(KEY_QC_GPS_ALTITUDE_REF); 2300 if (altitudeRef) { 2301 set(KEY_QC_GPS_ALTITUDE_REF, altitudeRef); 2302 }else { 2303 remove(KEY_QC_GPS_ALTITUDE_REF); 2304 } 2305 2306 const char *altitude = params.get(KEY_GPS_ALTITUDE); 2307 if (altitude) { 2308 set(KEY_GPS_ALTITUDE, altitude); 2309 }else { 2310 remove(KEY_GPS_ALTITUDE); 2311 } 2312 2313 const char *status = params.get(KEY_QC_GPS_STATUS); 2314 if (status) { 2315 set(KEY_QC_GPS_STATUS, status); 2316 } else { 2317 remove(KEY_QC_GPS_STATUS); 2318 } 2319 2320 const char *timestamp = params.get(KEY_GPS_TIMESTAMP); 2321 if (timestamp) { 2322 set(KEY_GPS_TIMESTAMP, timestamp); 2323 }else { 2324 remove(KEY_GPS_TIMESTAMP); 2325 } 2326 return NO_ERROR; 2327} 2328 2329/*=========================================================================== 2330 * FUNCTION : setNumOfSnapshot 2331 * 2332 * DESCRIPTION: set number of snapshot per shutter from user setting 2333 * 2334 * PARAMETERS : none 2335 * 2336 * RETURN : int32_t type of status 2337 * NO_ERROR -- success 2338 * none-zero failure code 2339 *==========================================================================*/ 2340int32_t QCameraParameters::setNumOfSnapshot() 2341{ 2342 int nBurstNum = getBurstNum(); 2343 uint8_t nExpnum = 0; 2344 2345 const char *scene_mode = get(KEY_SCENE_MODE); 2346 if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) { 2347 /* According to Android SDK, only one snapshot, 2348 * but OEM might have different requirement */ 2349 const char *need_hdr_1x = get(KEY_QC_HDR_NEED_1X); 2350 if (need_hdr_1x != NULL && strcmp(need_hdr_1x, VALUE_TRUE) == 0) { 2351 nExpnum = 2; // HDR needs both 1X and processed img 2352 } else { 2353 nExpnum = 1; // HDR only needs processed img 2354 } 2355 } else { 2356 const char *bracket_str = get(KEY_QC_AE_BRACKET_HDR); 2357 if (bracket_str != NULL && strlen(bracket_str) > 0) { 2358 int value = lookupAttr(BRACKETING_MODES_MAP, 2359 sizeof(BRACKETING_MODES_MAP)/sizeof(QCameraMap), 2360 bracket_str); 2361 switch (value) { 2362 case CAM_EXP_BRACKETING_ON: 2363 { 2364 nExpnum = 0; 2365 const char *str_val = get(KEY_QC_CAPTURE_BURST_EXPOSURE); 2366 if ((str_val != NULL) && (strlen(str_val) > 0)) { 2367 char prop[PROPERTY_VALUE_MAX]; 2368 memset(prop, 0, sizeof(prop)); 2369 strcpy(prop, str_val); 2370 char *saveptr = NULL; 2371 char *token = strtok_r(prop, ",", &saveptr); 2372 while (token != NULL) { 2373 token = strtok_r(NULL, ",", &saveptr); 2374 nExpnum++; 2375 } 2376 } 2377 if (nExpnum == 0) { 2378 nExpnum = 1; 2379 } 2380 } 2381 break; 2382 default: 2383 nExpnum = 1; 2384 break; 2385 } 2386 } 2387 } 2388 2389 ALOGD("%s: nBurstNum = %d, nExpnum = %d", __func__, nBurstNum, nExpnum); 2390 set(KEY_QC_NUM_SNAPSHOT_PER_SHUTTER, nBurstNum * nExpnum); 2391 return NO_ERROR; 2392} 2393 2394/*=========================================================================== 2395 * FUNCTION : setRecordingHint 2396 * 2397 * DESCRIPTION: set recording hint value from user setting 2398 * 2399 * PARAMETERS : 2400 * @params : user setting parameters 2401 * 2402 * RETURN : int32_t type of status 2403 * NO_ERROR -- success 2404 * none-zero failure code 2405 *==========================================================================*/ 2406int32_t QCameraParameters::setRecordingHint(const QCameraParameters& params) 2407{ 2408 const char * str = params.get(KEY_RECORDING_HINT); 2409 const char *prev_str = get(KEY_RECORDING_HINT); 2410 if (str != NULL) { 2411 if (prev_str == NULL || strcmp(str, prev_str) != 0) { 2412 int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP, 2413 sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap), 2414 str); 2415 if(value != NAME_NOT_FOUND){ 2416 updateParamEntry(KEY_RECORDING_HINT, str); 2417 setRecordingHintValue(value); 2418 return NO_ERROR; 2419 } else { 2420 ALOGE("Invalid recording hint value: %s", str); 2421 return BAD_VALUE; 2422 } 2423 } 2424 } 2425 return NO_ERROR; 2426} 2427 2428/*=========================================================================== 2429 * FUNCTION : setNoDisplayMode 2430 * 2431 * DESCRIPTION: set no display mode from user setting 2432 * 2433 * PARAMETERS : 2434 * @params : user setting parameters 2435 * 2436 * RETURN : int32_t type of status 2437 * NO_ERROR -- success 2438 * none-zero failure code 2439 *==========================================================================*/ 2440int32_t QCameraParameters::setNoDisplayMode(const QCameraParameters& params) 2441{ 2442 const char *str_val = params.get(KEY_QC_NO_DISPLAY_MODE); 2443 const char *prev_str = get(KEY_QC_NO_DISPLAY_MODE); 2444 if(str_val && strlen(str_val) > 0) { 2445 if (prev_str == NULL || strcmp(str_val, prev_str) != 0) { 2446 m_bNoDisplayMode = atoi(str_val); 2447 updateParamEntry(KEY_QC_NO_DISPLAY_MODE, str_val); 2448 m_bNeedRestart = true; 2449 } 2450 } else { 2451 m_bNoDisplayMode = false; 2452 } 2453 ALOGD("Param m_bNoDisplayMode = %d", m_bNoDisplayMode); 2454 return NO_ERROR; 2455} 2456 2457/*=========================================================================== 2458 * FUNCTION : setZslMode 2459 * 2460 * DESCRIPTION: set ZSL mode from user setting 2461 * 2462 * PARAMETERS : 2463 * @params : user setting parameters 2464 * 2465 * RETURN : int32_t type of status 2466 * NO_ERROR -- success 2467 * none-zero failure code 2468 *==========================================================================*/ 2469int32_t QCameraParameters::setZslMode(const QCameraParameters& params) 2470{ 2471 const char *str_val = params.get(KEY_QC_ZSL); 2472 const char *prev_val = get(KEY_QC_ZSL); 2473 2474 if (str_val != NULL) { 2475 if (prev_val == NULL || strcmp(str_val, prev_val) != 0) { 2476 int32_t value = lookupAttr(ON_OFF_MODES_MAP, 2477 sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap), 2478 str_val); 2479 if (value != NAME_NOT_FOUND) { 2480 updateParamEntry(KEY_QC_ZSL, str_val); 2481 m_bZslMode = (value > 0)? true : false; 2482 2483 // ZSL mode changed, need restart preview 2484 m_bNeedRestart = true; 2485 2486 return AddSetParmEntryToBatch(m_pParamBuf, 2487 CAM_INTF_PARM_ZSL_MODE, 2488 sizeof(value), 2489 &value); 2490 } else { 2491 ALOGE("Invalid ZSL mode value: %s", str_val); 2492 return BAD_VALUE; 2493 } 2494 } 2495 } 2496 return NO_ERROR; 2497} 2498 2499/*=========================================================================== 2500 * FUNCTION : setWaveletDenoise 2501 * 2502 * DESCRIPTION: set wavelet denoise value from user setting 2503 * 2504 * PARAMETERS : 2505 * @params : user setting parameters 2506 * 2507 * RETURN : int32_t type of status 2508 * NO_ERROR -- success 2509 * none-zero failure code 2510 *==========================================================================*/ 2511int32_t QCameraParameters::setWaveletDenoise(const QCameraParameters& params) 2512{ 2513 const char *str = params.get(KEY_QC_DENOISE); 2514 const char *prev_str = get(KEY_QC_DENOISE); 2515 if (str != NULL) { 2516 if (prev_str == NULL || 2517 strcmp(str, prev_str) != 0) { 2518 return setWaveletDenoise(str); 2519 } 2520 } 2521 return NO_ERROR; 2522} 2523 2524/*=========================================================================== 2525 * FUNCTION : setCameraMode 2526 * 2527 * DESCRIPTION: set camera mode from user setting 2528 * 2529 * PARAMETERS : 2530 * @params : user setting parameters 2531 * 2532 * RETURN : int32_t type of status 2533 * NO_ERROR -- success 2534 * none-zero failure code 2535 *==========================================================================*/ 2536int32_t QCameraParameters::setCameraMode(const QCameraParameters& params) 2537{ 2538 const char *str = params.get(KEY_QC_CAMERA_MODE); 2539 if (str != NULL) { 2540 set(KEY_QC_CAMERA_MODE, str); 2541 } else { 2542 remove(KEY_QC_CAMERA_MODE); 2543 } 2544 return NO_ERROR; 2545} 2546 2547/*=========================================================================== 2548 * FUNCTION : setZslAttributes 2549 * 2550 * DESCRIPTION: set ZSL related attributes from user setting 2551 * 2552 * PARAMETERS : 2553 * @params : user setting parameters 2554 * 2555 * RETURN : int32_t type of status 2556 * NO_ERROR -- success 2557 * none-zero failure code 2558 *==========================================================================*/ 2559int32_t QCameraParameters::setZslAttributes(const QCameraParameters& params) 2560{ 2561 // TODO: may switch to pure param instead of sysprop 2562 char prop[32]; 2563 2564 const char *str = params.get(KEY_QC_ZSL_BURST_INTERVAL); 2565 if (str != NULL) { 2566 set(KEY_QC_ZSL_BURST_INTERVAL, str); 2567 } else { 2568 memset(prop, 0, sizeof(prop)); 2569 property_get("persist.camera.zsl.interval", prop, "1"); 2570 set(KEY_QC_ZSL_BURST_INTERVAL, prop); 2571 } 2572 2573 str = params.get(KEY_QC_ZSL_BURST_LOOKBACK); 2574 if (str != NULL) { 2575 set(KEY_QC_ZSL_BURST_LOOKBACK, str); 2576 } else { 2577 memset(prop, 0, sizeof(prop)); 2578 property_get("persist.camera.zsl.backlookcnt", prop, "2"); 2579 set(KEY_QC_ZSL_BURST_LOOKBACK, prop); 2580 } 2581 2582 str = params.get(KEY_QC_ZSL_QUEUE_DEPTH); 2583 if (str != NULL) { 2584 set(KEY_QC_ZSL_QUEUE_DEPTH, str); 2585 } else { 2586 memset(prop, 0, sizeof(prop)); 2587 property_get("persist.camera.zsl.queuedepth", prop, "2"); 2588 set(KEY_QC_ZSL_QUEUE_DEPTH, prop); 2589 } 2590 2591 return NO_ERROR; 2592} 2593 2594/*=========================================================================== 2595 * FUNCTION : setFlip 2596 * 2597 * DESCRIPTION: set preview/ video/ picture flip mode from user setting 2598 * 2599 * PARAMETERS : 2600 * @params : user setting parameters 2601 * 2602 * RETURN : int32_t type of status 2603 * NO_ERROR -- success 2604 * none-zero failure code 2605 *==========================================================================*/ 2606int32_t QCameraParameters::setFlip(const QCameraParameters& params) 2607{ 2608 if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_FLIP) == 0) { 2609 ALOGD("%s: flip is not supported.", __func__); 2610 return NO_ERROR; 2611 } 2612 2613 //check preview flip setting 2614 const char *str = params.get(KEY_QC_PREVIEW_FLIP); 2615 if(str != NULL){ 2616 int32_t value = lookupAttr(FLIP_MODES_MAP, 2617 sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap), 2618 str); 2619 if(value != NAME_NOT_FOUND){ 2620 set(KEY_QC_PREVIEW_FLIP, str); 2621 } 2622 } 2623 2624 // check video filp setting 2625 str = params.get(KEY_QC_VIDEO_FLIP); 2626 if(str != NULL){ 2627 int32_t value = lookupAttr(FLIP_MODES_MAP, 2628 sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap), 2629 str); 2630 if(value != NAME_NOT_FOUND){ 2631 set(KEY_QC_VIDEO_FLIP, str); 2632 } 2633 } 2634 2635 // check picture filp setting 2636 str = params.get(KEY_QC_SNAPSHOT_PICTURE_FLIP); 2637 if(str != NULL){ 2638 int32_t value = lookupAttr(FLIP_MODES_MAP, 2639 sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap), 2640 str); 2641 if(value != NAME_NOT_FOUND){ 2642 set(KEY_QC_SNAPSHOT_PICTURE_FLIP, str); 2643 } 2644 } 2645 2646 return NO_ERROR; 2647} 2648 2649/*=========================================================================== 2650 * FUNCTION : updateParameters 2651 * 2652 * DESCRIPTION: update parameters from user setting 2653 * 2654 * PARAMETERS : 2655 * @params : user setting parameters 2656 * @needRestart : [output] if preview need restart upon setting changes 2657 * 2658 * RETURN : int32_t type of status 2659 * NO_ERROR -- success 2660 * none-zero failure code 2661 *==========================================================================*/ 2662int32_t QCameraParameters::updateParameters(QCameraParameters& params, 2663 bool &needRestart) 2664{ 2665 int32_t final_rc = NO_ERROR; 2666 int32_t rc; 2667 m_bNeedRestart = false; 2668 2669 if(initBatchUpdate(m_pParamBuf) < 0 ) { 2670 ALOGE("%s:Failed to initialize group update table",__func__); 2671 rc = BAD_TYPE; 2672 goto UPDATE_PARAM_DONE; 2673 } 2674 2675 if ((rc = setPreviewSize(params))) final_rc = rc; 2676 if ((rc = setVideoSize(params))) final_rc = rc; 2677 if ((rc = setPictureSize(params))) final_rc = rc; 2678 if ((rc = setLiveSnapshotSize(params))) final_rc = rc; 2679 if ((rc = setPreviewFormat(params))) final_rc = rc; 2680 if ((rc = setPictureFormat(params))) final_rc = rc; 2681 if ((rc = setJpegThumbnailSize(params))) final_rc = rc; 2682 if ((rc = setJpegQuality(params))) final_rc = rc; 2683 if ((rc = setOrientation(params))) final_rc = rc; 2684 if ((rc = setRotation(params))) final_rc = rc; 2685 if ((rc = setNoDisplayMode(params))) final_rc = rc; 2686 if ((rc = setZslMode(params))) final_rc = rc; 2687 if ((rc = setZslAttributes(params))) final_rc = rc; 2688 if ((rc = setCameraMode(params))) final_rc = rc; 2689 if ((rc = setRecordingHint(params))) final_rc = rc; 2690 2691 if ((rc = setPreviewFpsRange(params))) final_rc = rc; 2692 if ((rc = setPreviewFrameRate(params))) final_rc = rc; 2693 if ((rc = setAutoExposure(params))) final_rc = rc; 2694 if ((rc = setEffect(params))) final_rc = rc; 2695 if ((rc = setBrightness(params))) final_rc = rc; 2696 if ((rc = setZoom(params))) final_rc = rc; 2697 if ((rc = setSharpness(params))) final_rc = rc; 2698 if ((rc = setSaturation(params))) final_rc = rc; 2699 if ((rc = setContrast(params))) final_rc = rc; 2700 if ((rc = setFocusMode(params))) final_rc = rc; 2701 if ((rc = setISOValue(params))) final_rc = rc; 2702 if ((rc = setSkinToneEnhancement(params))) final_rc = rc; 2703 if ((rc = setFlash(params))) final_rc = rc; 2704 if ((rc = setAecLock(params))) final_rc = rc; 2705 if ((rc = setAwbLock(params))) final_rc = rc; 2706 if ((rc = setLensShadeValue(params))) final_rc = rc; 2707 if ((rc = setMCEValue(params))) final_rc = rc; 2708 if ((rc = setDISValue(params))) final_rc = rc; 2709 if ((rc = setHighFrameRate(params))) final_rc = rc; 2710 if ((rc = setAntibanding(params))) final_rc = rc; 2711 if ((rc = setExposureCompensation(params))) final_rc = rc; 2712 if ((rc = setWhiteBalance(params))) final_rc = rc; 2713 if ((rc = setSceneMode(params))) final_rc = rc; 2714 if ((rc = setFocusAreas(params))) final_rc = rc; 2715 if ((rc = setMeteringAreas(params))) final_rc = rc; 2716 if ((rc = setSelectableZoneAf(params))) final_rc = rc; 2717 if ((rc = setRedeyeReduction(params))) final_rc = rc; 2718 if ((rc = setAEBracket(params))) final_rc = rc; 2719 if ((rc = setGpsLocation(params))) final_rc = rc; 2720 if ((rc = setWaveletDenoise(params))) final_rc = rc; 2721 if ((rc = setFaceRecognition(params))) final_rc = rc; 2722 if ((rc = setFlip(params))) final_rc = rc; 2723 if ((rc = setVideoHDR(params))) final_rc = rc; 2724 2725UPDATE_PARAM_DONE: 2726 needRestart = m_bNeedRestart; 2727 return final_rc; 2728} 2729 2730/*=========================================================================== 2731 * FUNCTION : commitParameters 2732 * 2733 * DESCRIPTION: commit parameter changes to backend 2734 * 2735 * PARAMETERS : none 2736 * 2737 * RETURN : int32_t type of status 2738 * NO_ERROR -- success 2739 * none-zero failure code 2740 *==========================================================================*/ 2741int32_t QCameraParameters::commitParameters() 2742{ 2743 return commitSetBatch(); 2744} 2745 2746/*=========================================================================== 2747 * FUNCTION : initDefaultParameters 2748 * 2749 * DESCRIPTION: initialize default parameters for the first time 2750 * 2751 * PARAMETERS : none 2752 * 2753 * RETURN : int32_t type of status 2754 * NO_ERROR -- success 2755 * none-zero failure code 2756 *==========================================================================*/ 2757int32_t QCameraParameters::initDefaultParameters() 2758{ 2759 if(initBatchUpdate(m_pParamBuf) < 0 ) { 2760 ALOGE("%s:Failed to initialize group update table", __func__); 2761 return BAD_TYPE; 2762 } 2763 2764 /*************************Initialize Values******************************/ 2765 // Set read only parameters from camera capability 2766 set(KEY_SMOOTH_ZOOM_SUPPORTED, 2767 m_pCapability->smooth_zoom_supported? VALUE_TRUE : VALUE_FALSE); 2768 set(KEY_ZOOM_SUPPORTED, 2769 m_pCapability->zoom_supported? VALUE_TRUE : VALUE_FALSE); 2770 set(KEY_VIDEO_SNAPSHOT_SUPPORTED, 2771 m_pCapability->video_snapshot_supported? VALUE_TRUE : VALUE_FALSE); 2772 set(KEY_VIDEO_STABILIZATION_SUPPORTED, 2773 m_pCapability->video_stablization_supported? VALUE_TRUE : VALUE_FALSE); 2774 set(KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, 2775 m_pCapability->auto_exposure_lock_supported? VALUE_TRUE : VALUE_FALSE); 2776 set(KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, 2777 m_pCapability->auto_wb_lock_supported? VALUE_TRUE : VALUE_FALSE); 2778 set(KEY_QC_SUPPORTED_CAMERA_FEATURES, 2779 m_pCapability->qcom_supported_feature_mask); 2780 set(KEY_MAX_NUM_DETECTED_FACES_HW, m_pCapability->max_num_roi); 2781 set(KEY_MAX_NUM_DETECTED_FACES_SW, m_pCapability->max_num_roi); 2782 set(KEY_QC_MAX_NUM_REQUESTED_FACES, m_pCapability->max_num_roi); 2783 // Set focal length, horizontal view angle, and vertical view angle 2784 setFloat(KEY_FOCAL_LENGTH, m_pCapability->focal_length); 2785 setFloat(KEY_HORIZONTAL_VIEW_ANGLE, m_pCapability->hor_view_angle); 2786 setFloat(KEY_VERTICAL_VIEW_ANGLE, m_pCapability->ver_view_angle); 2787 2788 // Set supported preview sizes 2789 if (m_pCapability->preview_sizes_tbl_cnt > 0 && 2790 m_pCapability->preview_sizes_tbl_cnt <= MAX_SIZES_CNT) { 2791 String8 previewSizeValues = createSizesString( 2792 m_pCapability->preview_sizes_tbl, m_pCapability->preview_sizes_tbl_cnt); 2793 set(KEY_SUPPORTED_PREVIEW_SIZES, previewSizeValues.string()); 2794 ALOGD("%s: supported preview sizes: %s", __func__, previewSizeValues.string()); 2795 // Set default preview size 2796 CameraParameters::setPreviewSize(m_pCapability->preview_sizes_tbl[0].width, 2797 m_pCapability->preview_sizes_tbl[0].height); 2798 } else { 2799 ALOGE("%s: supported preview sizes cnt is 0 or exceeds max!!!", __func__); 2800 } 2801 2802 // Set supported video sizes 2803 if (m_pCapability->video_sizes_tbl_cnt > 0 && 2804 m_pCapability->video_sizes_tbl_cnt <= MAX_SIZES_CNT) { 2805 String8 videoSizeValues = createSizesString( 2806 m_pCapability->video_sizes_tbl, m_pCapability->video_sizes_tbl_cnt); 2807 set(KEY_SUPPORTED_VIDEO_SIZES, videoSizeValues.string()); 2808 ALOGD("%s: supported video sizes: %s", __func__, videoSizeValues.string()); 2809 // Set default video size 2810 CameraParameters::setVideoSize(m_pCapability->video_sizes_tbl[0].width, 2811 m_pCapability->video_sizes_tbl[0].height); 2812 2813 //Set preferred Preview size for video 2814 String8 vSize = createSizesString(&m_pCapability->video_sizes_tbl[0], 1); 2815 set(KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, vSize.string()); 2816 } else { 2817 ALOGE("%s: supported video sizes cnt is 0 or exceeds max!!!", __func__); 2818 } 2819 2820 // Set supported picture sizes 2821 if (m_pCapability->picture_sizes_tbl_cnt > 0 && 2822 m_pCapability->picture_sizes_tbl_cnt <= MAX_SIZES_CNT) { 2823 String8 pictureSizeValues = createSizesString( 2824 m_pCapability->picture_sizes_tbl, m_pCapability->picture_sizes_tbl_cnt); 2825 set(KEY_SUPPORTED_PICTURE_SIZES, pictureSizeValues.string()); 2826 ALOGD("%s: supported pic sizes: %s", __func__, pictureSizeValues.string()); 2827 // Set default picture size to the smallest resolution 2828 CameraParameters::setPictureSize( 2829 m_pCapability->picture_sizes_tbl[m_pCapability->picture_sizes_tbl_cnt-1].width, 2830 m_pCapability->picture_sizes_tbl[m_pCapability->picture_sizes_tbl_cnt-1].height); 2831 } else { 2832 ALOGE("%s: supported picture sizes cnt is 0 or exceeds max!!!", __func__); 2833 } 2834 2835 // Set supported thumbnail sizes 2836 String8 thumbnailSizeValues = createSizesString( 2837 THUMBNAIL_SIZES_MAP, 2838 sizeof(THUMBNAIL_SIZES_MAP)/sizeof(cam_dimension_t)); 2839 set(KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, thumbnailSizeValues.string()); 2840 // Set default thumnail size 2841 set(KEY_JPEG_THUMBNAIL_WIDTH, THUMBNAIL_SIZES_MAP[0].width); 2842 set(KEY_JPEG_THUMBNAIL_HEIGHT, THUMBNAIL_SIZES_MAP[0].height); 2843 2844 // Set supported livesnapshot sizes 2845 if (m_pCapability->livesnapshot_sizes_tbl_cnt > 0 && 2846 m_pCapability->livesnapshot_sizes_tbl_cnt <= MAX_SIZES_CNT) { 2847 String8 liveSnpashotSizeValues = createSizesString( 2848 m_pCapability->livesnapshot_sizes_tbl, 2849 m_pCapability->livesnapshot_sizes_tbl_cnt); 2850 set(KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES, liveSnpashotSizeValues.string()); 2851 ALOGI("%s: supported live snapshot sizes: %s", __func__, liveSnpashotSizeValues.string()); 2852 m_LiveSnapshotSize = 2853 m_pCapability->livesnapshot_sizes_tbl[m_pCapability->livesnapshot_sizes_tbl_cnt-1]; 2854 } 2855 2856 // Set supported preview formats 2857 String8 previewFormatValues = createValuesString( 2858 (int *)m_pCapability->supported_preview_fmts, 2859 m_pCapability->supported_preview_fmt_cnt, 2860 PREVIEW_FORMATS_MAP, 2861 sizeof(PREVIEW_FORMATS_MAP)/sizeof(QCameraMap)); 2862 set(KEY_SUPPORTED_PREVIEW_FORMATS, previewFormatValues.string()); 2863 // Set default preview format 2864 CameraParameters::setPreviewFormat(PIXEL_FORMAT_YUV420SP); 2865 2866 // Set default Video Format 2867 set(KEY_VIDEO_FRAME_FORMAT, PIXEL_FORMAT_YUV420SP); 2868 2869 // Set supported picture formats 2870 String8 pictureTypeValues(PIXEL_FORMAT_JPEG); 2871 String8 str = createValuesString( 2872 (int *)m_pCapability->supported_raw_fmts, 2873 m_pCapability->supported_raw_fmt_cnt, 2874 PICTURE_TYPES_MAP, 2875 sizeof(PICTURE_TYPES_MAP)/sizeof(QCameraMap)); 2876 if (str.string() != NULL) { 2877 pictureTypeValues.append(","); 2878 pictureTypeValues.append(str); 2879 } 2880 2881 set(KEY_SUPPORTED_PICTURE_FORMATS, pictureTypeValues.string()); 2882 // Set default picture Format 2883 CameraParameters::setPictureFormat(PIXEL_FORMAT_JPEG); 2884 // Set raw image size 2885 char raw_size_str[32]; 2886 snprintf(raw_size_str, sizeof(raw_size_str), "%dx%d", 2887 m_pCapability->raw_dim.width, m_pCapability->raw_dim.height); 2888 set(KEY_QC_RAW_PICUTRE_SIZE, raw_size_str); 2889 2890 //set default jpeg quality and thumbnail quality 2891 set(KEY_JPEG_QUALITY, 85); 2892 set(KEY_JPEG_THUMBNAIL_QUALITY, 85); 2893 2894 // Set FPS ranges 2895 if (m_pCapability->fps_ranges_tbl_cnt > 0 && 2896 m_pCapability->fps_ranges_tbl_cnt <= MAX_SIZES_CNT) { 2897 int default_fps_index = 0; 2898 String8 fpsRangeValues = createFpsRangeString(m_pCapability->fps_ranges_tbl, 2899 m_pCapability->fps_ranges_tbl_cnt, 2900 default_fps_index); 2901 set(KEY_SUPPORTED_PREVIEW_FPS_RANGE, fpsRangeValues.string()); 2902 2903 int min_fps = 2904 int(m_pCapability->fps_ranges_tbl[default_fps_index].min_fps * 1000); 2905 int max_fps = 2906 int(m_pCapability->fps_ranges_tbl[default_fps_index].max_fps * 1000); 2907 setPreviewFpsRange(min_fps, max_fps); 2908 2909 // Set legacy preview fps 2910 String8 fpsValues = createFpsString(m_pCapability->fps_ranges_tbl, 2911 m_pCapability->fps_ranges_tbl_cnt); 2912 set(KEY_SUPPORTED_PREVIEW_FRAME_RATES, fpsValues.string()); 2913 CameraParameters::setPreviewFrameRate(max_fps); 2914 } else { 2915 ALOGE("%s: supported fps ranges cnt is 0 or exceeds max!!!", __func__); 2916 } 2917 2918 // Set supported focus modes 2919 if (m_pCapability->supported_focus_modes_cnt > 0) { 2920 String8 focusModeValues = createValuesString( 2921 (int *)m_pCapability->supported_focus_modes, 2922 m_pCapability->supported_focus_modes_cnt, 2923 FOCUS_MODES_MAP, 2924 sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap)); 2925 set(KEY_SUPPORTED_FOCUS_MODES, focusModeValues); 2926 2927 // Set default focus mode and update corresponding parameter buf 2928 const char *focusMode = lookupNameByValue(FOCUS_MODES_MAP, 2929 sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap), 2930 m_pCapability->supported_focus_modes[0]); 2931 if (focusMode != NULL) { 2932 setFocusMode(focusMode); 2933 } else { 2934 setFocusMode(FOCUS_MODE_FIXED); 2935 } 2936 } else { 2937 ALOGE("%s: supported focus modes cnt is 0!!!", __func__); 2938 } 2939 2940 // Set focus areas 2941 if (m_pCapability->max_num_focus_areas > MAX_ROI) { 2942 m_pCapability->max_num_focus_areas = MAX_ROI; 2943 } 2944 set(KEY_MAX_NUM_FOCUS_AREAS, m_pCapability->max_num_focus_areas); 2945 if (m_pCapability->max_num_focus_areas > 0) { 2946 setFocusAreas(DEFAULT_CAMERA_AREA); 2947 } 2948 2949 // Set metering areas 2950 if (m_pCapability->max_num_metering_areas > MAX_ROI) { 2951 m_pCapability->max_num_metering_areas = MAX_ROI; 2952 } 2953 set(KEY_MAX_NUM_METERING_AREAS, m_pCapability->max_num_metering_areas); 2954 if (m_pCapability->max_num_metering_areas > 0) { 2955 setMeteringAreas(DEFAULT_CAMERA_AREA); 2956 } 2957 2958 // Set Saturation 2959 set(KEY_QC_MIN_SATURATION, m_pCapability->saturation_ctrl.min_value); 2960 set(KEY_QC_MAX_SATURATION, m_pCapability->saturation_ctrl.max_value); 2961 set(KEY_QC_SATURATION_STEP, m_pCapability->saturation_ctrl.step); 2962 setSaturation(m_pCapability->saturation_ctrl.def_value); 2963 2964 // Set Sharpness 2965 set(KEY_QC_MIN_SHARPNESS, m_pCapability->sharpness_ctrl.min_value); 2966 set(KEY_QC_MAX_SHARPNESS, m_pCapability->sharpness_ctrl.max_value); 2967 set(KEY_QC_SHARPNESS_STEP, m_pCapability->sharpness_ctrl.step); 2968 setSharpness(m_pCapability->sharpness_ctrl.def_value); 2969 2970 // Set Contrast 2971 set(KEY_QC_MIN_CONTRAST, m_pCapability->contrast_ctrl.min_value); 2972 set(KEY_QC_MAX_CONTRAST, m_pCapability->contrast_ctrl.max_value); 2973 set(KEY_QC_CONTRAST_STEP, m_pCapability->contrast_ctrl.step); 2974 setContrast(m_pCapability->contrast_ctrl.def_value); 2975 2976 // Set SCE factor 2977 set(KEY_QC_MIN_SCE_FACTOR, m_pCapability->sce_ctrl.min_value); // -100 2978 set(KEY_QC_MAX_SCE_FACTOR, m_pCapability->sce_ctrl.max_value); // 100 2979 set(KEY_QC_SCE_FACTOR_STEP, m_pCapability->sce_ctrl.step); // 10 2980 setSkinToneEnhancement(m_pCapability->sce_ctrl.def_value); // 0 2981 2982 // Set Brightness 2983 set(KEY_QC_MIN_BRIGHTNESS, m_pCapability->brightness_ctrl.min_value); // 0 2984 set(KEY_QC_MAX_BRIGHTNESS, m_pCapability->brightness_ctrl.max_value); // 6 2985 set(KEY_QC_BRIGHTNESS_STEP, m_pCapability->brightness_ctrl.step); // 1 2986 setBrightness(m_pCapability->brightness_ctrl.def_value); 2987 2988 // Set Auto exposure 2989 String8 autoExposureValues = createValuesString( 2990 (int *)m_pCapability->supported_aec_modes, 2991 m_pCapability->supported_aec_modes_cnt, 2992 AUTO_EXPOSURE_MAP, 2993 sizeof(AUTO_EXPOSURE_MAP) / sizeof(QCameraMap)); 2994 set(KEY_QC_SUPPORTED_AUTO_EXPOSURE, autoExposureValues.string()); 2995 setAutoExposure(AUTO_EXPOSURE_FRAME_AVG); 2996 2997 // Set Exposure Compensation 2998 set(KEY_MAX_EXPOSURE_COMPENSATION, m_pCapability->exposure_compensation_max); // 12 2999 set(KEY_MIN_EXPOSURE_COMPENSATION, m_pCapability->exposure_compensation_min); // -12 3000 setFloat(KEY_EXPOSURE_COMPENSATION_STEP, m_pCapability->exposure_compensation_step); // 1/6 3001 setExposureCompensation(m_pCapability->exposure_compensation_default); // 0 3002 3003 // Set Antibanding 3004 String8 antibandingValues = createValuesString( 3005 (int *)m_pCapability->supported_antibandings, 3006 m_pCapability->supported_antibandings_cnt, 3007 ANTIBANDING_MODES_MAP, 3008 sizeof(ANTIBANDING_MODES_MAP) / sizeof(QCameraMap)); 3009 set(KEY_SUPPORTED_ANTIBANDING, antibandingValues); 3010 setAntibanding(ANTIBANDING_OFF); 3011 3012 // Set Effect 3013 String8 effectValues = createValuesString( 3014 (int *)m_pCapability->supported_effects, 3015 m_pCapability->supported_effects_cnt, 3016 EFFECT_MODES_MAP, 3017 sizeof(EFFECT_MODES_MAP) / sizeof(QCameraMap)); 3018 set(KEY_SUPPORTED_EFFECTS, effectValues); 3019 setEffect(EFFECT_NONE); 3020 3021 // Set WhiteBalance 3022 String8 whitebalanceValues = createValuesString( 3023 (int *)m_pCapability->supported_white_balances, 3024 m_pCapability->supported_white_balances_cnt, 3025 WHITE_BALANCE_MODES_MAP, 3026 sizeof(WHITE_BALANCE_MODES_MAP) / sizeof(QCameraMap)); 3027 set(KEY_SUPPORTED_WHITE_BALANCE, whitebalanceValues); 3028 setWhiteBalance(WHITE_BALANCE_AUTO); 3029 3030 // Set Flash mode 3031 String8 flashValues = createValuesString( 3032 (int *)m_pCapability->supported_flash_modes, 3033 m_pCapability->supported_flash_modes_cnt, 3034 FLASH_MODES_MAP, 3035 sizeof(FLASH_MODES_MAP) / sizeof(QCameraMap)); 3036 set(KEY_SUPPORTED_FLASH_MODES, flashValues); 3037 setFlash(FLASH_MODE_OFF); 3038 3039 // Set Scene Mode 3040 String8 sceneModeValues = createValuesString( 3041 (int *)m_pCapability->supported_scene_modes, 3042 m_pCapability->supported_scene_modes_cnt, 3043 SCENE_MODES_MAP, 3044 sizeof(SCENE_MODES_MAP) / sizeof(QCameraMap)); 3045 set(KEY_SUPPORTED_SCENE_MODES, sceneModeValues); 3046 setSceneMode(SCENE_MODE_AUTO); 3047 3048 // Set ISO Mode 3049 String8 isoValues = createValuesString( 3050 (int *)m_pCapability->supported_iso_modes, 3051 m_pCapability->supported_iso_modes_cnt, 3052 ISO_MODES_MAP, 3053 sizeof(ISO_MODES_MAP) / sizeof(QCameraMap)); 3054 set(KEY_QC_SUPPORTED_ISO_MODES, isoValues); 3055 setISOValue(ISO_AUTO); 3056 3057 // Set HFR 3058 String8 hfrValues = createHfrValuesString( 3059 m_pCapability->hfr_tbl, 3060 m_pCapability->hfr_tbl_cnt, 3061 HFR_MODES_MAP, 3062 sizeof(HFR_MODES_MAP) / sizeof(QCameraMap)); 3063 set(KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES, hfrValues.string()); 3064 String8 hfrSizeValues = createHfrSizesString( 3065 m_pCapability->hfr_tbl, 3066 m_pCapability->hfr_tbl_cnt); 3067 set(KEY_QC_SUPPORTED_HFR_SIZES, hfrSizeValues.string()); 3068 setHighFrameRate(VIDEO_HFR_OFF); 3069 3070 // Set Focus algorithms 3071 String8 focusAlgoValues = createValuesString( 3072 (int *)m_pCapability->supported_focus_algos, 3073 m_pCapability->supported_focus_algos_cnt, 3074 FOCUS_ALGO_MAP, 3075 sizeof(FOCUS_ALGO_MAP) / sizeof(QCameraMap)); 3076 set(KEY_QC_SUPPORTED_FOCUS_ALGOS, focusAlgoValues); 3077 setSelectableZoneAf(FOCUS_ALGO_AUTO); 3078 3079 // Set Zoom Ratios 3080 if (m_pCapability->zoom_supported > 0) { 3081 String8 zoomRatioValues = createZoomRatioValuesString( 3082 m_pCapability->zoom_ratio_tbl, 3083 m_pCapability->zoom_ratio_tbl_cnt); 3084 set(KEY_ZOOM_RATIOS, zoomRatioValues); 3085 set(KEY_MAX_ZOOM, m_pCapability->zoom_ratio_tbl_cnt - 1); 3086 setZoom(0); 3087 } 3088 3089 // Set Bracketing/HDR 3090 char prop[PROPERTY_VALUE_MAX]; 3091 memset(prop, 0, sizeof(prop)); 3092 property_get("persist.capture.burst.exposures", prop, ""); 3093 if (strlen(prop) > 0) { 3094 set(KEY_QC_CAPTURE_BURST_EXPOSURE, prop); 3095 } 3096 String8 bracketingValues = createValuesStringFromMap( 3097 BRACKETING_MODES_MAP, 3098 sizeof(BRACKETING_MODES_MAP) / sizeof(QCameraMap)); 3099 set(KEY_QC_SUPPORTED_AE_BRACKET_MODES, bracketingValues); 3100 setAEBracket(AE_BRACKET_OFF); 3101 3102 // Set Denoise 3103 String8 denoiseValues = createValuesStringFromMap( 3104 DENOISE_ON_OFF_MODES_MAP, sizeof(DENOISE_ON_OFF_MODES_MAP) / sizeof(QCameraMap)); 3105 set(KEY_QC_SUPPORTED_DENOISE, denoiseValues.string()); 3106 setWaveletDenoise(DENOISE_OFF); 3107 3108 // Set feature enable/disable 3109 String8 enableDisableValues = createValuesStringFromMap( 3110 ENABLE_DISABLE_MODES_MAP, sizeof(ENABLE_DISABLE_MODES_MAP) / sizeof(QCameraMap)); 3111 3112 // Set Lens Shading 3113 set(KEY_QC_SUPPORTED_LENSSHADE_MODES, enableDisableValues); 3114 setLensShadeValue(VALUE_ENABLE); 3115 3116 // Set MCE 3117 set(KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES, enableDisableValues); 3118 setMCEValue(VALUE_ENABLE); 3119 3120 // Set DIS 3121 set(KEY_QC_SUPPORTED_DIS_MODES, enableDisableValues); 3122 setDISValue(VALUE_DISABLE); 3123 3124 // Set Histogram 3125 set(KEY_QC_SUPPORTED_HISTOGRAM_MODES, enableDisableValues); 3126 set(KEY_QC_HISTOGRAM, VALUE_DISABLE); 3127 3128 //Set Red Eye Reduction 3129 set(KEY_QC_SUPPORTED_REDEYE_REDUCTION, enableDisableValues); 3130 setRedeyeReduction(VALUE_DISABLE); 3131 3132 //Set SkinTone Enhancement 3133 set(KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES, enableDisableValues); 3134 3135 // Set feature on/off 3136 String8 onOffValues = createValuesStringFromMap( 3137 ON_OFF_MODES_MAP, sizeof(ON_OFF_MODES_MAP) / sizeof(QCameraMap)); 3138 3139 //Set Scene Detection 3140 set(KEY_QC_SUPPORTED_SCENE_DETECT, onOffValues); 3141 setSceneDetect(VALUE_OFF); 3142 3143 //Set Face Detection 3144 set(KEY_QC_SUPPORTED_FACE_DETECTION, onOffValues); 3145 set(KEY_QC_FACE_DETECTION, VALUE_OFF); 3146 3147 //Set Face Recognition 3148 set(KEY_QC_SUPPORTED_FACE_RECOGNITION, onOffValues); 3149 set(KEY_QC_FACE_RECOGNITION, VALUE_OFF); 3150 3151 //Set ZSL 3152 set(KEY_QC_SUPPORTED_ZSL_MODES, onOffValues); 3153 set(KEY_QC_ZSL, VALUE_OFF); 3154 m_bZslMode =true; 3155 3156 //Set video HDR 3157 if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_VIDEO_HDR) > 0) { 3158 set(KEY_QC_SUPPORTED_VIDEO_HDR_MODES, onOffValues); 3159 set(KEY_QC_VIDEO_HDR, VALUE_OFF); 3160 } 3161 3162 //Set Touch AF/AEC 3163 String8 touchValues = createValuesStringFromMap( 3164 TOUCH_AF_AEC_MODES_MAP, sizeof(TOUCH_AF_AEC_MODES_MAP) / sizeof(QCameraMap)); 3165 3166 set(KEY_QC_SUPPORTED_TOUCH_AF_AEC, touchValues); 3167 set(KEY_QC_TOUCH_AF_AEC, TOUCH_AF_AEC_OFF); 3168 3169 //set flip mode 3170 if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_FLIP) > 0) { 3171 String8 flipModes = createValuesStringFromMap( 3172 FLIP_MODES_MAP, sizeof(FLIP_MODES_MAP) / sizeof(QCameraMap)); 3173 set(KEY_QC_SUPPORTED_FLIP_MODES, flipModes); 3174 set(KEY_QC_PREVIEW_FLIP, FLIP_MODE_OFF); 3175 set(KEY_QC_VIDEO_FLIP, FLIP_MODE_OFF); 3176 set(KEY_QC_SNAPSHOT_PICTURE_FLIP, FLIP_MODE_OFF); 3177 } 3178 3179 // Set default Auto Exposure lock value 3180 setAecLock(VALUE_FALSE); 3181 3182 // Set default AWB_LOCK lock value 3183 setAwbLock(VALUE_FALSE); 3184 3185 // Set default Camera mode 3186 set(KEY_QC_CAMERA_MODE, 0); 3187 3188 // TODO: hardcode for now until mctl add support for min_num_pp_bufs 3189 m_pCapability->min_num_pp_bufs = 3; 3190 3191 int32_t rc = commitParameters(); 3192 if (rc == NO_ERROR) { 3193 rc = setNumOfSnapshot(); 3194 } 3195 return rc; 3196} 3197 3198/*=========================================================================== 3199 * FUNCTION : init 3200 * 3201 * DESCRIPTION: initialize parameter obj 3202 * 3203 * PARAMETERS : 3204 * @capabilities : ptr to camera capabilities 3205 * @mmops : ptr to memory ops table for mapping/unmapping 3206 * 3207 * RETURN : int32_t type of status 3208 * NO_ERROR -- success 3209 * none-zero failure code 3210 *==========================================================================*/ 3211int32_t QCameraParameters::init(cam_capability_t *capabilities, mm_camera_vtbl_t *mmOps) 3212{ 3213 int32_t rc = NO_ERROR; 3214 3215 m_pCapability = capabilities; 3216 m_pCamOpsTbl = mmOps; 3217 3218 //Allocate Set Param Buffer 3219 m_pParamHeap = new QCameraHeapMemory(); 3220 rc = m_pParamHeap->allocate(1, sizeof(parm_buffer_t)); 3221 if(rc != OK) { 3222 rc = NO_MEMORY; 3223 ALOGE("Failed to allocate SETPARM Heap memory"); 3224 goto TRANS_INIT_ERROR1; 3225 } 3226 3227 //Map memory for parameters buffer 3228 rc = m_pCamOpsTbl->ops->map_buf(m_pCamOpsTbl->camera_handle, 3229 CAM_MAPPING_BUF_TYPE_PARM_BUF, 3230 m_pParamHeap->getFd(0), 3231 sizeof(parm_buffer_t)); 3232 if(rc < 0) { 3233 ALOGE("%s:failed to map SETPARM buffer",__func__); 3234 rc = FAILED_TRANSACTION; 3235 goto TRANS_INIT_ERROR2; 3236 } 3237 m_pParamBuf = (parm_buffer_t*) DATA_PTR(m_pParamHeap,0); 3238 3239 initDefaultParameters(); 3240 3241 goto TRANS_INIT_DONE; 3242 3243TRANS_INIT_ERROR2: 3244 m_pParamHeap->deallocate(); 3245 3246TRANS_INIT_ERROR1: 3247 delete m_pParamHeap; 3248 m_pParamHeap = NULL; 3249 3250TRANS_INIT_DONE: 3251 return rc; 3252} 3253 3254/*=========================================================================== 3255 * FUNCTION : deinit 3256 * 3257 * DESCRIPTION: deinitialize 3258 * 3259 * PARAMETERS : none 3260 * 3261 * RETURN : none 3262 *==========================================================================*/ 3263void QCameraParameters::deinit() 3264{ 3265 //clear all entries in the map 3266 String8 emptyStr; 3267 QCameraParameters::unflatten(emptyStr); 3268 3269 if (NULL != m_pCamOpsTbl) { 3270 m_pCamOpsTbl->ops->unmap_buf( 3271 m_pCamOpsTbl->camera_handle, 3272 CAM_MAPPING_BUF_TYPE_PARM_BUF); 3273 m_pCamOpsTbl = NULL; 3274 } 3275 m_pCapability = NULL; 3276 if (NULL != m_pParamHeap) { 3277 m_pParamHeap->deallocate(); 3278 delete m_pParamHeap; 3279 m_pParamHeap = NULL; 3280 m_pParamBuf = NULL; 3281 } 3282 3283 m_tempMap.clear(); 3284} 3285 3286/*=========================================================================== 3287 * FUNCTION : parse_pair 3288 * 3289 * DESCRIPTION: helper function to parse string like "640x480" or "10000,20000" 3290 * 3291 * PARAMETERS : 3292 * @str : input string to be parse 3293 * @first : [output] first value of the pair 3294 * @second : [output] second value of the pair 3295 * @delim : [input] delimeter to seperate the pair 3296 * @endptr : [output] ptr to the end of the pair string 3297 * 3298 * RETURN : int32_t type of status 3299 * NO_ERROR -- success 3300 * none-zero failure code 3301 *==========================================================================*/ 3302int32_t QCameraParameters::parse_pair(const char *str, 3303 int *first, 3304 int *second, 3305 char delim, 3306 char **endptr = NULL) 3307{ 3308 // Find the first integer. 3309 char *end; 3310 int w = (int)strtol(str, &end, 10); 3311 // If a delimeter does not immediately follow, give up. 3312 if (*end != delim) { 3313 ALOGE("Cannot find delimeter (%c) in str=%s", delim, str); 3314 return BAD_VALUE; 3315 } 3316 3317 // Find the second integer, immediately after the delimeter. 3318 int h = (int)strtol(end+1, &end, 10); 3319 3320 *first = w; 3321 *second = h; 3322 3323 if (endptr) { 3324 *endptr = end; 3325 } 3326 3327 return NO_ERROR; 3328} 3329 3330/*=========================================================================== 3331 * FUNCTION : parseSizesList 3332 * 3333 * DESCRIPTION: helper function to parse string containing sizes 3334 * 3335 * PARAMETERS : 3336 * @sizesStr: [input] input string to be parse 3337 * @sizes : [output] reference to store parsed sizes 3338 * 3339 * RETURN : none 3340 *==========================================================================*/ 3341void QCameraParameters::parseSizesList(const char *sizesStr, Vector<Size> &sizes) 3342{ 3343 if (sizesStr == 0) { 3344 return; 3345 } 3346 3347 char *sizeStartPtr = (char *)sizesStr; 3348 3349 while (true) { 3350 int width, height; 3351 int success = parse_pair(sizeStartPtr, &width, &height, 'x', 3352 &sizeStartPtr); 3353 if (success == -1 || (*sizeStartPtr != ',' && *sizeStartPtr != '\0')) { 3354 ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr); 3355 return; 3356 } 3357 sizes.push(Size(width, height)); 3358 3359 if (*sizeStartPtr == '\0') { 3360 return; 3361 } 3362 sizeStartPtr++; 3363 } 3364} 3365 3366/*=========================================================================== 3367 * FUNCTION : getSupportedHfrSizes 3368 * 3369 * DESCRIPTION: return supported HFR sizes 3370 * 3371 * PARAMETERS : 3372 * @sizes : [output] reference to a vector storing supported HFR sizes 3373 * 3374 * RETURN : none 3375 *==========================================================================*/ 3376void QCameraParameters::getSupportedHfrSizes(Vector<Size> &sizes) 3377{ 3378 const char *hfrSizesStr = get(KEY_QC_SUPPORTED_HFR_SIZES); 3379 parseSizesList(hfrSizesStr, sizes); 3380} 3381 3382/*=========================================================================== 3383 * FUNCTION : adjustPreviewFpsRanges 3384 * 3385 * DESCRIPTION: adjust preview FPS ranges 3386 * according to external events 3387 * 3388 * PARAMETERS : 3389 * @minFPS : min FPS value 3390 * @maxFPS : max FPS value 3391 * 3392 * RETURN : int32_t type of status 3393 * NO_ERROR -- success 3394 * none-zero failure code 3395 *==========================================================================*/ 3396int32_t QCameraParameters::adjustPreviewFpsRange(cam_fps_range_t *fpsRange) 3397{ 3398 if ( fpsRange == NULL ) { 3399 return BAD_VALUE; 3400 } 3401 3402 int32_t rc = initBatchUpdate(m_pParamBuf); 3403 if ( rc != NO_ERROR ) { 3404 ALOGE("%s:Failed to initialize group update table", __func__); 3405 return rc; 3406 } 3407 3408 rc = AddSetParmEntryToBatch(m_pParamBuf, 3409 CAM_INTF_PARM_FPS_RANGE, 3410 sizeof(cam_fps_range_t), 3411 fpsRange); 3412 if ( rc != NO_ERROR ) { 3413 ALOGE("%s: Parameters batch failed",__func__); 3414 return rc; 3415 } 3416 3417 rc = commitSetBatch(); 3418 if ( rc != NO_ERROR ) { 3419 ALOGE("%s:Failed to commit batch parameters", __func__); 3420 return rc; 3421 } 3422 3423 return rc; 3424} 3425 3426/*=========================================================================== 3427 * FUNCTION : setPreviewFpsRanges 3428 * 3429 * DESCRIPTION: set preview FPS ranges 3430 * 3431 * PARAMETERS : 3432 * @minFPS : min FPS value 3433 * @maxFPS : max FPS value 3434 * 3435 * RETURN : int32_t type of status 3436 * NO_ERROR -- success 3437 * none-zero failure code 3438 *==========================================================================*/ 3439int32_t QCameraParameters::setPreviewFpsRange(int minFPS, int maxFPS) 3440{ 3441 char str[32]; 3442 snprintf(str, sizeof(str), "%d,%d", minFPS, maxFPS); 3443 ALOGD("%s: Setting preview fps range %s", __func__, str); 3444 updateParamEntry(KEY_PREVIEW_FPS_RANGE, str); 3445 cam_fps_range_t fps_range = {(float)(minFPS / 1000.0), (float)(maxFPS / 1000.0)}; 3446 return AddSetParmEntryToBatch(m_pParamBuf, 3447 CAM_INTF_PARM_FPS_RANGE, 3448 sizeof(cam_fps_range_t), 3449 &fps_range); 3450} 3451 3452/*=========================================================================== 3453 * FUNCTION : setAutoExposure 3454 * 3455 * DESCRIPTION: set auto exposure 3456 * 3457 * PARAMETERS : 3458 * @autoExp : auto exposure value string 3459 * 3460 * RETURN : int32_t type of status 3461 * NO_ERROR -- success 3462 * none-zero failure code 3463 *==========================================================================*/ 3464int32_t QCameraParameters::setAutoExposure(const char *autoExp) 3465{ 3466 if (autoExp != NULL) { 3467 int32_t value = lookupAttr(AUTO_EXPOSURE_MAP, 3468 sizeof(AUTO_EXPOSURE_MAP)/sizeof(AUTO_EXPOSURE_MAP[0]), 3469 autoExp); 3470 if (value != NAME_NOT_FOUND) { 3471 ALOGD("%s: Setting auto exposure %s", __func__, autoExp); 3472 updateParamEntry(KEY_QC_AUTO_EXPOSURE, autoExp); 3473 return AddSetParmEntryToBatch(m_pParamBuf, 3474 CAM_INTF_PARM_AEC_ALGO_TYPE, 3475 sizeof(value), 3476 &value); 3477 } 3478 } 3479 ALOGE("Invalid auto exposure value: %s", (autoExp == NULL) ? "NULL" : autoExp); 3480 return BAD_VALUE; 3481} 3482 3483/*=========================================================================== 3484 * FUNCTION : setEffect 3485 * 3486 * DESCRIPTION: set effect 3487 * 3488 * PARAMETERS : 3489 * @effect : effect value string 3490 * 3491 * RETURN : int32_t type of status 3492 * NO_ERROR -- success 3493 * none-zero failure code 3494 *==========================================================================*/ 3495int32_t QCameraParameters::setEffect(const char *effect) 3496{ 3497 if (effect != NULL) { 3498 int32_t value = lookupAttr(EFFECT_MODES_MAP, 3499 sizeof(EFFECT_MODES_MAP)/sizeof(QCameraMap), 3500 effect); 3501 if (value != NAME_NOT_FOUND) { 3502 ALOGD("%s: Setting effect %s", __func__, effect); 3503 updateParamEntry(KEY_EFFECT, effect); 3504 return AddSetParmEntryToBatch(m_pParamBuf, 3505 CAM_INTF_PARM_EFFECT, 3506 sizeof(value), 3507 &value); 3508 } 3509 } 3510 ALOGE("Invalid effect value: %s", (effect == NULL) ? "NULL" : effect); 3511 return BAD_VALUE; 3512} 3513 3514/*=========================================================================== 3515 * FUNCTION : setBrightness 3516 * 3517 * DESCRIPTION: set brightness control value 3518 * 3519 * PARAMETERS : 3520 * @brightness : brightness control value 3521 * 3522 * RETURN : int32_t type of status 3523 * NO_ERROR -- success 3524 * none-zero failure code 3525 *==========================================================================*/ 3526int32_t QCameraParameters::setBrightness(int brightness) 3527{ 3528 char val[16]; 3529 sprintf(val, "%d", brightness); 3530 updateParamEntry(KEY_QC_BRIGHTNESS, val); 3531 3532 int32_t value = brightness; 3533 ALOGD("%s: Setting brightness %s", __func__, val); 3534 return AddSetParmEntryToBatch(m_pParamBuf, 3535 CAM_INTF_PARM_BRIGHTNESS, 3536 sizeof(value), 3537 &value); 3538} 3539 3540/*=========================================================================== 3541 * FUNCTION : setFocusMode 3542 * 3543 * DESCRIPTION: set focus mode 3544 * 3545 * PARAMETERS : 3546 * @focusMode : focus mode value string 3547 * 3548 * RETURN : int32_t type of status 3549 * NO_ERROR -- success 3550 * none-zero failure code 3551 *==========================================================================*/ 3552int32_t QCameraParameters::setFocusMode(const char *focusMode) 3553{ 3554 if (focusMode != NULL) { 3555 int32_t value = lookupAttr(FOCUS_MODES_MAP, 3556 sizeof(FOCUS_MODES_MAP)/sizeof(QCameraMap), 3557 focusMode); 3558 if (value != NAME_NOT_FOUND) { 3559 ALOGD("%s: Setting focus mode %s", __func__, focusMode); 3560 mFocusMode = (cam_focus_mode_type)value; 3561 3562 // reset need lock CAF flag 3563 m_bNeedLockCAF = false; 3564 m_bCAFLocked = false; 3565 m_bAFRunning = false; 3566 3567 updateParamEntry(KEY_FOCUS_MODE, focusMode); 3568 return AddSetParmEntryToBatch(m_pParamBuf, 3569 CAM_INTF_PARM_FOCUS_MODE, 3570 sizeof(value), 3571 &value); 3572 } 3573 } 3574 ALOGE("Invalid focus mode value: %s", (focusMode == NULL) ? "NULL" : focusMode); 3575 return BAD_VALUE; 3576} 3577 3578/*=========================================================================== 3579 * FUNCTION : setSharpness 3580 * 3581 * DESCRIPTION: set sharpness control value 3582 * 3583 * PARAMETERS : 3584 * @sharpness : sharpness control value 3585 * 3586 * RETURN : int32_t type of status 3587 * NO_ERROR -- success 3588 * none-zero failure code 3589 *==========================================================================*/ 3590int32_t QCameraParameters::setSharpness(int sharpness) 3591{ 3592 char val[16]; 3593 sprintf(val, "%d", sharpness); 3594 updateParamEntry(KEY_QC_SHARPNESS, val); 3595 ALOGD("%s: Setting sharpness %s", __func__, val); 3596 3597 int32_t value = sharpness; 3598 return AddSetParmEntryToBatch(m_pParamBuf, 3599 CAM_INTF_PARM_SHARPNESS, 3600 sizeof(value), 3601 &value); 3602} 3603 3604/*=========================================================================== 3605 * FUNCTION : setSkinToneEnhancement 3606 * 3607 * DESCRIPTION: set skin tone enhancement value 3608 * 3609 * PARAMETERS : 3610 * @sceFactore : skin tone enhancement factor value 3611 * 3612 * RETURN : int32_t type of status 3613 * NO_ERROR -- success 3614 * none-zero failure code 3615 *==========================================================================*/ 3616int32_t QCameraParameters::setSkinToneEnhancement(int sceFactor) 3617{ 3618 char val[16]; 3619 sprintf(val, "%d", sceFactor); 3620 updateParamEntry(KEY_QC_SCE_FACTOR, val); 3621 ALOGD("%s: Setting skintone enhancement %s", __func__, val); 3622 3623 int32_t value = sceFactor; 3624 return AddSetParmEntryToBatch(m_pParamBuf, 3625 CAM_INTF_PARM_SCE_FACTOR, 3626 sizeof(value), 3627 &value); 3628} 3629 3630/*=========================================================================== 3631 * FUNCTION : setSaturation 3632 * 3633 * DESCRIPTION: set saturation control value 3634 * 3635 * PARAMETERS : 3636 * @saturation : saturation control value 3637 * 3638 * RETURN : int32_t type of status 3639 * NO_ERROR -- success 3640 * none-zero failure code 3641 *==========================================================================*/ 3642int32_t QCameraParameters::setSaturation(int saturation) 3643{ 3644 char val[16]; 3645 sprintf(val, "%d", saturation); 3646 updateParamEntry(KEY_QC_SATURATION, val); 3647 ALOGD("%s: Setting saturation %s", __func__, val); 3648 3649 int32_t value = saturation; 3650 return AddSetParmEntryToBatch(m_pParamBuf, 3651 CAM_INTF_PARM_SATURATION, 3652 sizeof(value), 3653 &value); 3654} 3655 3656/*=========================================================================== 3657 * FUNCTION : setContrast 3658 * 3659 * DESCRIPTION: set contrast control value 3660 * 3661 * PARAMETERS : 3662 * @contrast : contrast control value 3663 * 3664 * RETURN : int32_t type of status 3665 * NO_ERROR -- success 3666 * none-zero failure code 3667 *==========================================================================*/ 3668int32_t QCameraParameters::setContrast(int contrast) 3669{ 3670 char val[16]; 3671 sprintf(val, "%d", contrast); 3672 updateParamEntry(KEY_QC_CONTRAST, val); 3673 ALOGD("%s: Setting contrast %s", __func__, val); 3674 3675 int32_t value = contrast; 3676 return AddSetParmEntryToBatch(m_pParamBuf, 3677 CAM_INTF_PARM_CONTRAST, 3678 sizeof(value), 3679 &value); 3680} 3681 3682/*=========================================================================== 3683 * FUNCTION : setSceneDetect 3684 * 3685 * DESCRIPTION: set scenen detect value 3686 * 3687 * PARAMETERS : 3688 * @sceneDetect : scene detect value string 3689 * 3690 * RETURN : int32_t type of status 3691 * NO_ERROR -- success 3692 * none-zero failure code 3693 *==========================================================================*/ 3694int32_t QCameraParameters::setSceneDetect(const char *sceneDetect) 3695{ 3696 if (sceneDetect != NULL) { 3697 int32_t value = lookupAttr(ON_OFF_MODES_MAP, 3698 sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap), 3699 sceneDetect); 3700 if (value != NAME_NOT_FOUND) { 3701 ALOGD("%s: Setting Scene Detect %s", __func__, sceneDetect); 3702 updateParamEntry(KEY_QC_SCENE_DETECT, sceneDetect); 3703 return AddSetParmEntryToBatch(m_pParamBuf, 3704 CAM_INTF_PARM_ASD_ENABLE, 3705 sizeof(value), 3706 &value); 3707 } 3708 } 3709 ALOGE("Invalid Scene Detect value: %s", 3710 (sceneDetect == NULL) ? "NULL" : sceneDetect); 3711 return BAD_VALUE; 3712} 3713 3714/*=========================================================================== 3715 * FUNCTION : setVideoHDR 3716 * 3717 * DESCRIPTION: set video HDR value 3718 * 3719 * PARAMETERS : 3720 * @videoHDR : svideo HDR value string 3721 * 3722 * RETURN : int32_t type of status 3723 * NO_ERROR -- success 3724 * none-zero failure code 3725 *==========================================================================*/ 3726int32_t QCameraParameters::setVideoHDR(const char *videoHDR) 3727{ 3728 if (videoHDR != NULL) { 3729 int32_t value = lookupAttr(ON_OFF_MODES_MAP, 3730 sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap), 3731 videoHDR); 3732 if (value != NAME_NOT_FOUND) { 3733 ALOGD("%s: Setting Video HDR %s", __func__, videoHDR); 3734 updateParamEntry(KEY_QC_VIDEO_HDR, videoHDR); 3735 return AddSetParmEntryToBatch(m_pParamBuf, 3736 CAM_INTF_PARM_VIDEO_HDR, 3737 sizeof(value), 3738 &value); 3739 } 3740 } 3741 ALOGE("Invalid Video HDR value: %s", 3742 (videoHDR == NULL) ? "NULL" : videoHDR); 3743 return BAD_VALUE; 3744} 3745 3746/*=========================================================================== 3747 * FUNCTION : setFaceRecognition 3748 * 3749 * DESCRIPTION: set face recognition value 3750 * 3751 * PARAMETERS : 3752 * @faceRecog : face recognition value string 3753 * @maxFaces : number of max faces to be detected/recognized 3754 * 3755 * RETURN : int32_t type of status 3756 * NO_ERROR -- success 3757 * none-zero failure code 3758 *==========================================================================*/ 3759int32_t QCameraParameters::setFaceRecognition(const char *faceRecog, int maxFaces) 3760{ 3761 if (faceRecog != NULL) { 3762 int32_t value = lookupAttr(ON_OFF_MODES_MAP, 3763 sizeof(ON_OFF_MODES_MAP)/sizeof(QCameraMap), 3764 faceRecog); 3765 if (value != NAME_NOT_FOUND) { 3766 ALOGD("%s: Setting face recognition %s", __func__, faceRecog); 3767 updateParamEntry(KEY_QC_FACE_RECOGNITION, faceRecog); 3768 3769 int faceProcMask = m_nFaceProcMask; 3770 if (value > 0) { 3771 faceProcMask |= CAM_FACE_PROCESS_MASK_RECOGNITION; 3772 } else { 3773 faceProcMask &= ~CAM_FACE_PROCESS_MASK_RECOGNITION; 3774 } 3775 3776 if(m_nFaceProcMask == faceProcMask) { 3777 ALOGD("%s: face process mask not changed, no ops here", __func__); 3778 return NO_ERROR; 3779 } 3780 m_nFaceProcMask = faceProcMask; 3781 ALOGD("%s: FaceProcMask -> %d", __func__, m_nFaceProcMask); 3782 3783 // set parm for face process 3784 cam_fd_set_parm_t fd_set_parm; 3785 memset(&fd_set_parm, 0, sizeof(cam_fd_set_parm_t)); 3786 fd_set_parm.fd_mode = m_nFaceProcMask; 3787 fd_set_parm.num_fd = maxFaces; 3788 3789 return AddSetParmEntryToBatch(m_pParamBuf, 3790 CAM_INTF_PARM_FD, 3791 sizeof(fd_set_parm), 3792 &fd_set_parm); 3793 } 3794 } 3795 ALOGE("Invalid face recognition value: %s", (faceRecog == NULL) ? "NULL" : faceRecog); 3796 return BAD_VALUE; 3797} 3798 3799/*=========================================================================== 3800 * FUNCTION : setZoom 3801 * 3802 * DESCRIPTION: set zoom level 3803 * 3804 * PARAMETERS : 3805 * @zoom_level : zoom level 3806 * 3807 * RETURN : int32_t type of status 3808 * NO_ERROR -- success 3809 * none-zero failure code 3810 *==========================================================================*/ 3811int32_t QCameraParameters::setZoom(int zoom_level) 3812{ 3813 char val[16]; 3814 sprintf(val, "%d", zoom_level); 3815 updateParamEntry(KEY_ZOOM, val); 3816 3817 return AddSetParmEntryToBatch(m_pParamBuf, 3818 CAM_INTF_PARM_ZOOM, 3819 sizeof(zoom_level), 3820 &zoom_level); 3821} 3822 3823/*=========================================================================== 3824 * FUNCTION : setISOValue 3825 * 3826 * DESCRIPTION: set ISO value 3827 * 3828 * PARAMETERS : 3829 * @isoValue : ISO value string 3830 * 3831 * RETURN : int32_t type of status 3832 * NO_ERROR -- success 3833 * none-zero failure code 3834 *==========================================================================*/ 3835int32_t QCameraParameters::setISOValue(const char *isoValue) 3836{ 3837 if (isoValue != NULL) { 3838 int32_t value = lookupAttr(ISO_MODES_MAP, 3839 sizeof(ISO_MODES_MAP)/sizeof(QCameraMap), 3840 isoValue); 3841 if (value != NAME_NOT_FOUND) { 3842 ALOGD("%s: Setting ISO value %s", __func__, isoValue); 3843 updateParamEntry(KEY_QC_ISO_MODE, isoValue); 3844 return AddSetParmEntryToBatch(m_pParamBuf, 3845 CAM_INTF_PARM_ISO, 3846 sizeof(value), 3847 &value); 3848 } 3849 } 3850 ALOGE("Invalid ISO value: %s", 3851 (isoValue == NULL) ? "NULL" : isoValue); 3852 return BAD_VALUE; 3853} 3854 3855/*=========================================================================== 3856 * FUNCTION : setFlash 3857 * 3858 * DESCRIPTION: set f;ash mode 3859 * 3860 * PARAMETERS : 3861 * @flashStr : LED flash mode value string 3862 * 3863 * RETURN : int32_t type of status 3864 * NO_ERROR -- success 3865 * none-zero failure code 3866 *==========================================================================*/ 3867int32_t QCameraParameters::setFlash(const char *flashStr) 3868{ 3869 if (flashStr != NULL) { 3870 int32_t value = lookupAttr(FLASH_MODES_MAP, 3871 sizeof(FLASH_MODES_MAP)/sizeof(QCameraMap), 3872 flashStr); 3873 if (value != NAME_NOT_FOUND) { 3874 ALOGD("%s: Setting Flash value %s", __func__, flashStr); 3875 updateParamEntry(KEY_FLASH_MODE, flashStr); 3876 return AddSetParmEntryToBatch(m_pParamBuf, 3877 CAM_INTF_PARM_LED_MODE, 3878 sizeof(value), 3879 &value); 3880 } 3881 } 3882 ALOGE("Invalid flash value: %s", (flashStr == NULL) ? "NULL" : flashStr); 3883 return BAD_VALUE; 3884} 3885 3886/*=========================================================================== 3887 * FUNCTION : setAecLock 3888 * 3889 * DESCRIPTION: set AEC lock value 3890 * 3891 * PARAMETERS : 3892 * @aecLockStr : AEC lock value string 3893 * 3894 * RETURN : int32_t type of status 3895 * NO_ERROR -- success 3896 * none-zero failure code 3897 *==========================================================================*/ 3898int32_t QCameraParameters::setAecLock(const char *aecLockStr) 3899{ 3900 if (aecLockStr != NULL) { 3901 int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP, 3902 sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap), 3903 aecLockStr); 3904 if (value != NAME_NOT_FOUND) { 3905 ALOGD("%s: Setting AECLock value %s", __func__, aecLockStr); 3906 updateParamEntry(KEY_AUTO_EXPOSURE_LOCK, aecLockStr); 3907 return AddSetParmEntryToBatch(m_pParamBuf, 3908 CAM_INTF_PARM_AEC_LOCK, 3909 sizeof(value), 3910 &value); 3911 } 3912 } 3913 ALOGE("Invalid AECLock value: %s", (aecLockStr == NULL) ? "NULL" : aecLockStr); 3914 return BAD_VALUE; 3915} 3916 3917/*=========================================================================== 3918 * FUNCTION : setAwbLock 3919 * 3920 * DESCRIPTION: set AWB lock value 3921 * 3922 * PARAMETERS : 3923 * @awbLockStr : AWB lock value string 3924 * 3925 * RETURN : int32_t type of status 3926 * NO_ERROR -- success 3927 * none-zero failure code 3928 *==========================================================================*/ 3929int32_t QCameraParameters::setAwbLock(const char *awbLockStr) 3930{ 3931 if (awbLockStr != NULL) { 3932 int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP, 3933 sizeof(TRUE_FALSE_MODES_MAP)/sizeof(QCameraMap), 3934 awbLockStr); 3935 if (value != NAME_NOT_FOUND) { 3936 ALOGD("%s: Setting AWBLock value %s", __func__, awbLockStr); 3937 updateParamEntry(KEY_AUTO_WHITEBALANCE_LOCK, awbLockStr); 3938 return AddSetParmEntryToBatch(m_pParamBuf, 3939 CAM_INTF_PARM_AWB_LOCK, 3940 sizeof(value), 3941 &value); 3942 } 3943 } 3944 ALOGE("Invalid AWBLock value: %s", (awbLockStr == NULL) ? "NULL" : awbLockStr); 3945 return BAD_VALUE; 3946} 3947 3948/*=========================================================================== 3949 * FUNCTION : setMCEValue 3950 * 3951 * DESCRIPTION: set memory color enhancement value 3952 * 3953 * PARAMETERS : 3954 * @mceStr : MCE value string 3955 * 3956 * RETURN : int32_t type of status 3957 * NO_ERROR -- success 3958 * none-zero failure code 3959 *==========================================================================*/ 3960int32_t QCameraParameters::setMCEValue(const char *mceStr) 3961{ 3962 if (mceStr != NULL) { 3963 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 3964 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 3965 mceStr); 3966 if (value != NAME_NOT_FOUND) { 3967 ALOGD("%s: Setting AWBLock value %s", __func__, mceStr); 3968 updateParamEntry(KEY_QC_MEMORY_COLOR_ENHANCEMENT, mceStr); 3969 return AddSetParmEntryToBatch(m_pParamBuf, 3970 CAM_INTF_PARM_MCE, 3971 sizeof(value), 3972 &value); 3973 } 3974 } 3975 ALOGE("Invalid MCE value: %s", (mceStr == NULL) ? "NULL" : mceStr); 3976 return BAD_VALUE; 3977} 3978 3979/*=========================================================================== 3980 * FUNCTION : setDISValue 3981 * 3982 * DESCRIPTION: set DIS value 3983 * 3984 * PARAMETERS : 3985 * @disStr : DIS value string 3986 * 3987 * RETURN : int32_t type of status 3988 * NO_ERROR -- success 3989 * none-zero failure code 3990 *==========================================================================*/ 3991int32_t QCameraParameters::setDISValue(const char *disStr) 3992{ 3993 if (disStr != NULL) { 3994 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 3995 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 3996 disStr); 3997 if (value != NAME_NOT_FOUND) { 3998 ALOGD("%s: Setting DIS value %s", __func__, disStr); 3999 updateParamEntry(KEY_QC_DIS, disStr); 4000 return AddSetParmEntryToBatch(m_pParamBuf, 4001 CAM_INTF_PARM_DIS_ENABLE, 4002 sizeof(value), 4003 &value); 4004 } 4005 } 4006 ALOGE("Invalid DIS value: %s", (disStr == NULL) ? "NULL" : disStr); 4007 return BAD_VALUE; 4008} 4009 4010/*=========================================================================== 4011 * FUNCTION : setHighFrameRate 4012 * 4013 * DESCRIPTION: set high frame rate 4014 * 4015 * PARAMETERS : 4016 * @hfrStr : HFR value string 4017 * 4018 * RETURN : int32_t type of status 4019 * NO_ERROR -- success 4020 * none-zero failure code 4021 *==========================================================================*/ 4022int32_t QCameraParameters::setHighFrameRate(const char *hfrStr) 4023{ 4024 if (hfrStr != NULL) { 4025 int32_t value = lookupAttr(HFR_MODES_MAP, 4026 sizeof(HFR_MODES_MAP)/sizeof(QCameraMap), 4027 hfrStr); 4028 if (value != NAME_NOT_FOUND) { 4029 // if HFR is enabled, change live snapshot size 4030 if (value > CAM_HFR_MODE_OFF) { 4031 for (int i = 0; i < m_pCapability->hfr_tbl_cnt; i++) { 4032 if (m_pCapability->hfr_tbl[i].mode == value) { 4033 m_LiveSnapshotSize = m_pCapability->hfr_tbl[i].dim; 4034 break; 4035 } 4036 } 4037 } 4038 4039 // HFR value changed, need to restart preview 4040 m_bNeedRestart = true; 4041 // Set HFR value 4042 ALOGD("%s: Setting HFR value %s", __func__, hfrStr); 4043 updateParamEntry(KEY_QC_VIDEO_HIGH_FRAME_RATE, hfrStr); 4044 return AddSetParmEntryToBatch(m_pParamBuf, 4045 CAM_INTF_PARM_HFR, 4046 sizeof(value), 4047 &value); 4048 } 4049 } 4050 ALOGE("Invalid HFR value: %s", (hfrStr == NULL) ? "NULL" : hfrStr); 4051 return BAD_VALUE; 4052} 4053 4054/*=========================================================================== 4055 * FUNCTION : setLensShadeValue 4056 * 4057 * DESCRIPTION: set lens shade value 4058 * 4059 * PARAMETERS : 4060 * @lensSahdeStr : lens shade value string 4061 * 4062 * RETURN : int32_t type of status 4063 * NO_ERROR -- success 4064 * none-zero failure code 4065 *==========================================================================*/ 4066int32_t QCameraParameters::setLensShadeValue(const char *lensShadeStr) 4067{ 4068 if (lensShadeStr != NULL) { 4069 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 4070 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 4071 lensShadeStr); 4072 if (value != NAME_NOT_FOUND) { 4073 ALOGD("%s: Setting LensShade value %s", __func__, lensShadeStr); 4074 updateParamEntry(KEY_QC_LENSSHADE, lensShadeStr); 4075 return AddSetParmEntryToBatch(m_pParamBuf, 4076 CAM_INTF_PARM_ROLLOFF, 4077 sizeof(value), 4078 &value); 4079 } 4080 } 4081 ALOGE("Invalid LensShade value: %s", 4082 (lensShadeStr == NULL) ? "NULL" : lensShadeStr); 4083 return BAD_VALUE; 4084} 4085 4086/*=========================================================================== 4087 * FUNCTION : setExposureCompensation 4088 * 4089 * DESCRIPTION: set exposure compensation value 4090 * 4091 * PARAMETERS : 4092 * @expComp : exposure compensation value 4093 * 4094 * RETURN : int32_t type of status 4095 * NO_ERROR -- success 4096 * none-zero failure code 4097 *==========================================================================*/ 4098int32_t QCameraParameters::setExposureCompensation(int expComp) 4099{ 4100 char val[16]; 4101 sprintf(val, "%d", expComp); 4102 updateParamEntry(KEY_EXPOSURE_COMPENSATION, val); 4103 4104 // Don't need to pass step as part of setParameter because 4105 // camera daemon is already aware of it. 4106 return AddSetParmEntryToBatch(m_pParamBuf, 4107 CAM_INTF_PARM_EXPOSURE_COMPENSATION, 4108 sizeof(expComp), 4109 &expComp); 4110} 4111 4112/*=========================================================================== 4113 * FUNCTION : setWhiteBalance 4114 * 4115 * DESCRIPTION: set white balance mode 4116 * 4117 * PARAMETERS : 4118 * @wbStr : white balance mode value string 4119 * 4120 * RETURN : int32_t type of status 4121 * NO_ERROR -- success 4122 * none-zero failure code 4123 *==========================================================================*/ 4124int32_t QCameraParameters::setWhiteBalance(const char *wbStr) 4125{ 4126 if (wbStr != NULL) { 4127 int32_t value = lookupAttr(WHITE_BALANCE_MODES_MAP, 4128 sizeof(WHITE_BALANCE_MODES_MAP)/sizeof(QCameraMap), 4129 wbStr); 4130 if (value != NAME_NOT_FOUND) { 4131 ALOGD("%s: Setting WhiteBalance value %s", __func__, wbStr); 4132 updateParamEntry(KEY_WHITE_BALANCE, wbStr); 4133 return AddSetParmEntryToBatch(m_pParamBuf, 4134 CAM_INTF_PARM_WHITE_BALANCE, 4135 sizeof(value), 4136 &value); 4137 } 4138 } 4139 ALOGE("Invalid WhiteBalance value: %s", (wbStr == NULL) ? "NULL" : wbStr); 4140 return BAD_VALUE; 4141} 4142 4143/*=========================================================================== 4144 * FUNCTION : setAntibanding 4145 * 4146 * DESCRIPTION: set antibanding value 4147 * 4148 * PARAMETERS : 4149 * @antiBandingStr : antibanding value string 4150 * 4151 * RETURN : int32_t type of status 4152 * NO_ERROR -- success 4153 * none-zero failure code 4154 *==========================================================================*/ 4155int32_t QCameraParameters::setAntibanding(const char *antiBandingStr) 4156{ 4157 if (antiBandingStr != NULL) { 4158 int32_t value = lookupAttr(ANTIBANDING_MODES_MAP, 4159 sizeof(ANTIBANDING_MODES_MAP)/sizeof(QCameraMap), 4160 antiBandingStr); 4161 if (value != NAME_NOT_FOUND) { 4162 ALOGD("%s: Setting AntiBanding value %s", __func__, antiBandingStr); 4163 updateParamEntry(KEY_ANTIBANDING, antiBandingStr); 4164 return AddSetParmEntryToBatch(m_pParamBuf, 4165 CAM_INTF_PARM_ANTIBANDING, 4166 sizeof(value), 4167 &value); 4168 } 4169 } 4170 ALOGE("Invalid AntiBanding value: %s", 4171 (antiBandingStr == NULL) ? "NULL" : antiBandingStr); 4172 return BAD_VALUE; 4173} 4174 4175/*=========================================================================== 4176 * FUNCTION : setFocusAreas 4177 * 4178 * DESCRIPTION: set focus areas 4179 * 4180 * PARAMETERS : 4181 * @focusAreasStr : focus areas value string 4182 * 4183 * RETURN : int32_t type of status 4184 * NO_ERROR -- success 4185 * none-zero failure code 4186 *==========================================================================*/ 4187int32_t QCameraParameters::setFocusAreas(const char *focusAreasStr) 4188{ 4189 if (m_pCapability->max_num_focus_areas == 0 || 4190 focusAreasStr == NULL) { 4191 ALOGI("%s: Parameter string is null", __func__); 4192 return NO_ERROR; 4193 } 4194 4195 cam_area_t *areas = (cam_area_t *)malloc(sizeof(cam_area_t) * m_pCapability->max_num_focus_areas); 4196 if (NULL == areas) { 4197 ALOGE("%s: No memory for areas", __func__); 4198 return NO_MEMORY; 4199 } 4200 memset(areas, 0, sizeof(cam_area_t) * m_pCapability->max_num_focus_areas); 4201 int num_areas_found = 0; 4202 if (parseCameraAreaString(focusAreasStr, 4203 m_pCapability->max_num_focus_areas, 4204 areas, 4205 num_areas_found) != NO_ERROR) { 4206 ALOGE("%s: Failed to parse the string: %s", __func__, focusAreasStr); 4207 free(areas); 4208 return BAD_VALUE; 4209 } 4210 4211 if (validateCameraAreas(areas, num_areas_found) == false) { 4212 ALOGE("%s: invalid areas specified : %s", __func__, focusAreasStr); 4213 free(areas); 4214 return BAD_VALUE; 4215 } 4216 4217 updateParamEntry(KEY_FOCUS_AREAS, focusAreasStr); 4218 4219 //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0, 4220 //so no action is takenby the lower layer 4221 if (num_areas_found == 1 && 4222 areas[0].rect.left == 0 && 4223 areas[0].rect.top == 0 && 4224 areas[0].rect.width == 0 && 4225 areas[0].rect.height == 0 && 4226 areas[0].weight == 0) { 4227 num_areas_found = 0; 4228 } 4229 4230 int previewWidth, previewHeight; 4231 getPreviewSize(&previewWidth, &previewHeight); 4232 cam_roi_info_t af_roi_value; 4233 memset(&af_roi_value, 0, sizeof(cam_roi_info_t)); 4234 af_roi_value.num_roi = num_areas_found; 4235 for (int i = 0; i < num_areas_found; i++) { 4236 ALOGD("%s: FocusArea[%d] = (%d, %d, %d, %d)", 4237 __func__, i, (areas[i].rect.top), (areas[i].rect.left), 4238 (areas[i].rect.width), (areas[i].rect.height)); 4239 4240 //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) 4241 af_roi_value.roi[i].left = (int32_t)((areas[i].rect.left + 1000.0f) * (previewWidth / 2000.0f)); 4242 af_roi_value.roi[i].top = (int32_t)((areas[i].rect.top + 1000.0f) * (previewHeight / 2000.0f)); 4243 af_roi_value.roi[i].width = (int32_t)(areas[i].rect.width * previewWidth / 2000.0f); 4244 af_roi_value.roi[i].height = (int32_t)(areas[i].rect.height * previewHeight / 2000.0f); 4245 af_roi_value.weight[i] = areas[i].weight; 4246 } 4247 free(areas); 4248 return AddSetParmEntryToBatch(m_pParamBuf, 4249 CAM_INTF_PARM_AF_ROI, 4250 sizeof(af_roi_value), 4251 &af_roi_value); 4252} 4253 4254/*=========================================================================== 4255 * FUNCTION : setMeteringAreas 4256 * 4257 * DESCRIPTION: set metering areas value 4258 * 4259 * PARAMETERS : 4260 * @meteringAreasStr : metering areas value string 4261 * 4262 * RETURN : int32_t type of status 4263 * NO_ERROR -- success 4264 * none-zero failure code 4265 *==========================================================================*/ 4266int32_t QCameraParameters::setMeteringAreas(const char *meteringAreasStr) 4267{ 4268 if (m_pCapability->max_num_metering_areas == 0 || 4269 meteringAreasStr == NULL) { 4270 ALOGI("%s: Parameter string is null", __func__); 4271 return NO_ERROR; 4272 } 4273 4274 cam_area_t *areas = (cam_area_t *)malloc(sizeof(cam_area_t) * m_pCapability->max_num_metering_areas); 4275 if (NULL == areas) { 4276 ALOGE("%s: No memory for areas", __func__); 4277 return NO_MEMORY; 4278 } 4279 memset(areas, 0, sizeof(cam_area_t) * m_pCapability->max_num_metering_areas); 4280 int num_areas_found = 0; 4281 if (parseCameraAreaString(meteringAreasStr, 4282 m_pCapability->max_num_metering_areas, 4283 areas, 4284 num_areas_found) < 0) { 4285 ALOGE("%s: Failed to parse the string: %s", __func__, meteringAreasStr); 4286 free(areas); 4287 return BAD_VALUE; 4288 } 4289 4290 if (validateCameraAreas(areas, num_areas_found) == false) { 4291 ALOGE("%s: invalid areas specified : %s", __func__, meteringAreasStr); 4292 free(areas); 4293 return BAD_VALUE; 4294 } 4295 4296 updateParamEntry(KEY_METERING_AREAS, meteringAreasStr); 4297 4298 //for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0, 4299 //so no action is takenby the lower layer 4300 if (num_areas_found == 1 && 4301 areas[0].rect.left == 0 && 4302 areas[0].rect.top == 0 && 4303 areas[0].rect.width == 0 && 4304 areas[0].rect.height == 0 && 4305 areas[0].weight == 0) { 4306 num_areas_found = 0; 4307 } 4308 cam_set_aec_roi_t aec_roi_value; 4309 int previewWidth, previewHeight; 4310 getPreviewSize(&previewWidth, &previewHeight); 4311 4312 memset(&aec_roi_value, 0, sizeof(cam_set_aec_roi_t)); 4313 if (num_areas_found > 0) { 4314 aec_roi_value.aec_roi_enable = CAM_AEC_ROI_ON; 4315 aec_roi_value.aec_roi_type = CAM_AEC_ROI_BY_COORDINATE; 4316 4317 for (int i = 0; i < num_areas_found; i++) { 4318 ALOGD("%s: MeteringArea[%d] = (%d, %d, %d, %d)", 4319 __func__, i, (areas[i].rect.top), (areas[i].rect.left), 4320 (areas[i].rect.width), (areas[i].rect.height)); 4321 4322 //transform the coords from (-1000, 1000) to (0, previewWidth or previewHeight) 4323 aec_roi_value.cam_aec_roi_position.coordinate[i].x = 4324 (uint32_t)(((areas[i].rect.left + areas[i].rect.width / 2) + 1000.0f) * previewWidth / 2000.0f) ; 4325 aec_roi_value.cam_aec_roi_position.coordinate[i].y = 4326 (uint32_t)(((areas[i].rect.top + areas[i].rect.height / 2) + 1000.0f) * previewHeight / 2000.0f) ; 4327 } 4328 } else { 4329 aec_roi_value.aec_roi_enable = CAM_AEC_ROI_OFF; 4330 } 4331 free(areas); 4332 return AddSetParmEntryToBatch(m_pParamBuf, 4333 CAM_INTF_PARM_AEC_ROI, 4334 sizeof(aec_roi_value), 4335 &aec_roi_value); 4336} 4337 4338/*=========================================================================== 4339 * FUNCTION : setSceneMode 4340 * 4341 * DESCRIPTION: set scene mode 4342 * 4343 * PARAMETERS : 4344 * @sceneModeStr : scene mode value string 4345 * 4346 * RETURN : int32_t type of status 4347 * NO_ERROR -- success 4348 * none-zero failure code 4349 *==========================================================================*/ 4350int32_t QCameraParameters::setSceneMode(const char *sceneModeStr) 4351{ 4352 if (sceneModeStr != NULL) { 4353 int32_t value = lookupAttr(SCENE_MODES_MAP, 4354 sizeof(SCENE_MODES_MAP)/sizeof(QCameraMap), 4355 sceneModeStr); 4356 if (value != NAME_NOT_FOUND) { 4357 ALOGV("%s: Setting SceneMode %s", __func__, sceneModeStr); 4358 updateParamEntry(KEY_SCENE_MODE, sceneModeStr); 4359 int32_t rc = AddSetParmEntryToBatch(m_pParamBuf, 4360 CAM_INTF_PARM_BESTSHOT_MODE, 4361 sizeof(value), 4362 &value); 4363 return rc; 4364 } 4365 } 4366 ALOGE("%s: Invalid Secene Mode: %s", 4367 __func__, (sceneModeStr == NULL) ? "NULL" : sceneModeStr); 4368 return BAD_VALUE; 4369} 4370 4371/*=========================================================================== 4372 * FUNCTION : setSelectableZoneAf 4373 * 4374 * DESCRIPTION: set selectable zone AF algorithm 4375 * 4376 * PARAMETERS : 4377 * @selZoneAFStr : selectable zone AF algorithm value string 4378 * 4379 * RETURN : int32_t type of status 4380 * NO_ERROR -- success 4381 * none-zero failure code 4382 *==========================================================================*/ 4383int32_t QCameraParameters::setSelectableZoneAf(const char *selZoneAFStr) 4384{ 4385 if (selZoneAFStr != NULL) { 4386 int32_t value = lookupAttr(FOCUS_ALGO_MAP, 4387 sizeof(FOCUS_ALGO_MAP)/sizeof(QCameraMap), 4388 selZoneAFStr); 4389 if (value != NAME_NOT_FOUND) { 4390 ALOGV("%s: Setting Selectable Zone AF value %s", __func__, selZoneAFStr); 4391 updateParamEntry(KEY_QC_SELECTABLE_ZONE_AF, selZoneAFStr); 4392 return AddSetParmEntryToBatch(m_pParamBuf, 4393 CAM_INTF_PARM_FOCUS_ALGO_TYPE, 4394 sizeof(value), 4395 &value); 4396 } 4397 } 4398 ALOGE("%s: Invalid selectable zone af value: %s", 4399 __func__, (selZoneAFStr == NULL) ? "NULL" : selZoneAFStr); 4400 return BAD_VALUE; 4401} 4402 4403/*=========================================================================== 4404 * FUNCTION : setAEBracket 4405 * 4406 * DESCRIPTION: set AE bracket value 4407 * 4408 * PARAMETERS : 4409 * @aecBracketStr : AE bracket value string 4410 * 4411 * RETURN : int32_t type of status 4412 * NO_ERROR -- success 4413 * none-zero failure code 4414 *==========================================================================*/ 4415int32_t QCameraParameters::setAEBracket(const char *aecBracketStr) 4416{ 4417 if (aecBracketStr == NULL) { 4418 ALOGI("%s: setAEBracket with NULL value", __func__); 4419 return NO_ERROR; 4420 } 4421 4422 cam_exp_bracketing_t expBracket; 4423 memset(&expBracket, 0, sizeof(expBracket)); 4424 4425 int value = lookupAttr(BRACKETING_MODES_MAP, 4426 sizeof(BRACKETING_MODES_MAP)/sizeof(QCameraMap), 4427 aecBracketStr); 4428 switch (value) { 4429 case CAM_EXP_BRACKETING_ON: 4430 { 4431 ALOGV("%s, EXP_BRACKETING_ON", __func__); 4432 const char *str_val = get(KEY_QC_CAPTURE_BURST_EXPOSURE); 4433 if ((str_val != NULL) && (strlen(str_val)>0)) { 4434 expBracket.mode = CAM_EXP_BRACKETING_ON; 4435 strlcpy(expBracket.values, str_val, MAX_EXP_BRACKETING_LENGTH); 4436 ALOGI("%s: setting Exposure Bracketing value of %s", 4437 __func__, expBracket.values); 4438 } 4439 else { 4440 /* Apps not set capture-burst-exposures, error case fall into bracketing off mode */ 4441 ALOGI("%s: capture-burst-exposures not set, back to HDR OFF mode", __func__); 4442 expBracket.mode = CAM_EXP_BRACKETING_OFF; 4443 } 4444 } 4445 break; 4446 default: 4447 { 4448 ALOGD("%s, EXP_BRACKETING_OFF", __func__); 4449 expBracket.mode = CAM_EXP_BRACKETING_OFF; 4450 } 4451 break; 4452 } 4453 4454 /* save the value*/ 4455 updateParamEntry(KEY_QC_AE_BRACKET_HDR, aecBracketStr); 4456 return AddSetParmEntryToBatch(m_pParamBuf, 4457 CAM_INTF_PARM_HDR, 4458 sizeof(expBracket), 4459 &expBracket); 4460} 4461 4462/*=========================================================================== 4463 * FUNCTION : setRedeyeReduction 4464 * 4465 * DESCRIPTION: set red eye reduction value 4466 * 4467 * PARAMETERS : 4468 * @redeyeStr : red eye reduction value string 4469 * 4470 * RETURN : int32_t type of status 4471 * NO_ERROR -- success 4472 * none-zero failure code 4473 *==========================================================================*/ 4474int32_t QCameraParameters::setRedeyeReduction(const char *redeyeStr) 4475{ 4476 if (redeyeStr != NULL) { 4477 int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP, 4478 sizeof(ENABLE_DISABLE_MODES_MAP)/sizeof(QCameraMap), 4479 redeyeStr); 4480 if (value != NAME_NOT_FOUND) { 4481 ALOGV("%s: Setting RedEye Reduce value %s", __func__, redeyeStr); 4482 updateParamEntry(KEY_QC_REDEYE_REDUCTION, redeyeStr); 4483 return AddSetParmEntryToBatch(m_pParamBuf, 4484 CAM_INTF_PARM_REDEYE_REDUCTION, 4485 sizeof(value), 4486 &value); 4487 } 4488 } 4489 ALOGE("%s: Invalid RedEye Reduce value: %s", 4490 __func__, (redeyeStr == NULL) ? "NULL" : redeyeStr); 4491 return BAD_VALUE; 4492} 4493 4494/*=========================================================================== 4495 * FUNCTION : getWaveletDenoiseProcessPlate 4496 * 4497 * DESCRIPTION: query wavelet denoise process plate 4498 * 4499 * PARAMETERS : None 4500 * 4501 * RETURN : WNR prcocess plate vlaue 4502 *==========================================================================*/ 4503cam_denoise_process_type_t QCameraParameters::getWaveletDenoiseProcessPlate() 4504{ 4505 char prop[PROPERTY_VALUE_MAX]; 4506 memset(prop, 0, sizeof(prop)); 4507 property_get("persist.denoise.process.plates", prop, "0"); 4508 int processPlate = atoi(prop); 4509 switch(processPlate) { 4510 case 0: 4511 return CAM_WAVELET_DENOISE_YCBCR_PLANE; 4512 case 1: 4513 return CAM_WAVELET_DENOISE_CBCR_ONLY; 4514 case 2: 4515 return CAM_WAVELET_DENOISE_STREAMLINE_YCBCR; 4516 case 3: 4517 return CAM_WAVELET_DENOISE_STREAMLINED_CBCR; 4518 default: 4519 return CAM_WAVELET_DENOISE_STREAMLINE_YCBCR; 4520 } 4521} 4522 4523/*=========================================================================== 4524 * FUNCTION : setWaveletDenoise 4525 * 4526 * DESCRIPTION: set wavelet denoise value 4527 * 4528 * PARAMETERS : 4529 * @wnrStr : wavelet denoise value string 4530 * 4531 * RETURN : int32_t type of status 4532 * NO_ERROR -- success 4533 * none-zero failure code 4534 *==========================================================================*/ 4535int32_t QCameraParameters::setWaveletDenoise(const char *wnrStr) 4536{ 4537 if (wnrStr != NULL) { 4538 int value = lookupAttr(DENOISE_ON_OFF_MODES_MAP, 4539 sizeof(DENOISE_ON_OFF_MODES_MAP)/sizeof(QCameraMap), 4540 wnrStr); 4541 if (value != NAME_NOT_FOUND) { 4542 updateParamEntry(KEY_QC_DENOISE, wnrStr); 4543 4544 cam_denoise_param_t temp; 4545 memset(&temp, 0, sizeof(temp)); 4546 temp.denoise_enable = value; 4547 m_bWNROn = (value != 0); 4548 if (m_bWNROn) { 4549 temp.process_plates = getWaveletDenoiseProcessPlate(); 4550 } 4551 ALOGI("%s: Denoise enable=%d, plates=%d", 4552 __func__, temp.denoise_enable, temp.process_plates); 4553 return AddSetParmEntryToBatch(m_pParamBuf, 4554 CAM_INTF_PARM_WAVELET_DENOISE, 4555 sizeof(temp), 4556 &temp); 4557 } 4558 } 4559 ALOGE("%s: Invalid Denoise value: %s", __func__, (wnrStr == NULL) ? "NULL" : wnrStr); 4560 return BAD_VALUE; 4561} 4562 4563/*=========================================================================== 4564 * FUNCTION : setPreviewFrameRateMode 4565 * 4566 * DESCRIPTION: set preview frame rate mode 4567 * 4568 * PARAMETERS : 4569 * @mode : preview frame rate mode 4570 * 4571 * RETURN : none 4572 *==========================================================================*/ 4573void QCameraParameters::setPreviewFrameRateMode(const char *mode) 4574{ 4575 set(KEY_QC_PREVIEW_FRAME_RATE_MODE, mode); 4576} 4577 4578/*=========================================================================== 4579 * FUNCTION : getPreviewFrameRateMode 4580 * 4581 * DESCRIPTION: get preview frame rate mode 4582 * 4583 * PARAMETERS : none 4584 * 4585 * RETURN : preview frame rate mode string 4586 *==========================================================================*/ 4587const char *QCameraParameters::getPreviewFrameRateMode() const 4588{ 4589 return get(KEY_QC_PREVIEW_FRAME_RATE_MODE); 4590} 4591 4592/*=========================================================================== 4593 * FUNCTION : setTouchIndexAec 4594 * 4595 * DESCRIPTION: set touch index AEC 4596 * 4597 * PARAMETERS : 4598 * @x,y : 4599 * 4600 * RETURN : none 4601 *==========================================================================*/ 4602void QCameraParameters::setTouchIndexAec(int x, int y) 4603{ 4604 char str[32]; 4605 snprintf(str, sizeof(str), "%dx%d", x, y); 4606 set(KEY_QC_TOUCH_INDEX_AEC, str); 4607} 4608 4609/*=========================================================================== 4610 * FUNCTION : getTouchIndexAec 4611 * 4612 * DESCRIPTION: get touch index AEC 4613 * 4614 * PARAMETERS : 4615 * @x,y : 4616 * 4617 * RETURN : none 4618 *==========================================================================*/ 4619void QCameraParameters::getTouchIndexAec(int *x, int *y) 4620{ 4621 *x = -1; 4622 *y = -1; 4623 4624 // Get the current string, if it doesn't exist, leave the -1x-1 4625 const char *p = get(KEY_QC_TOUCH_INDEX_AEC); 4626 if (p == 0) 4627 return; 4628 4629 int tempX, tempY; 4630 if (parse_pair(p, &tempX, &tempY, 'x') == 0) { 4631 *x = tempX; 4632 *y = tempY; 4633 } 4634} 4635 4636/*=========================================================================== 4637 * FUNCTION : setTouchIndexAf 4638 * 4639 * DESCRIPTION: set touch index AF 4640 * 4641 * PARAMETERS : 4642 * @x,y : 4643 * 4644 * RETURN : none 4645 *==========================================================================*/ 4646void QCameraParameters::setTouchIndexAf(int x, int y) 4647{ 4648 char str[32]; 4649 snprintf(str, sizeof(str), "%dx%d", x, y); 4650 set(KEY_QC_TOUCH_INDEX_AF, str); 4651} 4652 4653/*=========================================================================== 4654 * FUNCTION : getTouchIndexAf 4655 * 4656 * DESCRIPTION: get touch index AF 4657 * 4658 * PARAMETERS : 4659 * @x,y : 4660 * 4661 * RETURN : none 4662 *==========================================================================*/ 4663void QCameraParameters::getTouchIndexAf(int *x, int *y) 4664{ 4665 *x = -1; 4666 *y = -1; 4667 4668 // Get the current string, if it doesn't exist, leave the -1x-1 4669 const char *p = get(KEY_QC_TOUCH_INDEX_AF); 4670 if (p == 0) 4671 return; 4672 4673 int tempX, tempY; 4674 if (parse_pair(p, &tempX, &tempY, 'x') == 0) { 4675 *x = tempX; 4676 *y = tempY; 4677 } 4678} 4679 4680/*=========================================================================== 4681 * FUNCTION : getStreamFormat 4682 * 4683 * DESCRIPTION: get stream format by its type 4684 * 4685 * PARAMETERS : 4686 * @streamType : [input] stream type 4687 * @format : [output] stream format 4688 * 4689 * RETURN : int32_t type of status 4690 * NO_ERROR -- success 4691 * none-zero failure code 4692 *==========================================================================*/ 4693int32_t QCameraParameters::getStreamFormat(cam_stream_type_t streamType, 4694 cam_format_t &format) 4695{ 4696 int32_t ret = NO_ERROR; 4697 4698 format = CAM_FORMAT_MAX; 4699 switch (streamType) { 4700 case CAM_STREAM_TYPE_PREVIEW: 4701 case CAM_STREAM_TYPE_POSTVIEW: 4702 format = mPreviewFormat; 4703 break; 4704 case CAM_STREAM_TYPE_SNAPSHOT: 4705 format = CAM_FORMAT_YUV_420_NV21; 4706 break; 4707 case CAM_STREAM_TYPE_VIDEO: 4708 format = CAM_FORMAT_YUV_420_NV12; 4709 break; 4710 case CAM_STREAM_TYPE_RAW: 4711 if (mPictureFormat >= CAM_FORMAT_YUV_RAW_8BIT_YUYV) { 4712 format = (cam_format_t)mPictureFormat; 4713 } else { 4714 ALOGE("%s: invalid raw picture format: %d", __func__, mPictureFormat); 4715 ret = BAD_VALUE; 4716 } 4717 break; 4718 case CAM_STREAM_TYPE_METADATA: 4719 case CAM_STREAM_TYPE_OFFLINE_PROC: 4720 case CAM_STREAM_TYPE_DEFAULT: 4721 default: 4722 break; 4723 } 4724 4725 return ret; 4726} 4727 4728/*=========================================================================== 4729 * FUNCTION : getFlipMode 4730 * 4731 * DESCRIPTION: get flip mode 4732 * 4733 * PARAMETERS : 4734 * @cam_intf_parm_type_t : [input] stream type 4735 * 4736 * RETURN : int type of flip mode 4737 * 0 - no filp 4738 * 1 - FLIP_H 4739 * 2 - FLIP_V 4740 * 3 - FLIP_H | FLIP_V 4741 *==========================================================================*/ 4742int QCameraParameters::getFlipMode(cam_stream_type_t type) 4743{ 4744 const char *str = NULL; 4745 int flipMode = 0; // no flip 4746 4747 switch(type){ 4748 case CAM_STREAM_TYPE_PREVIEW: 4749 str = get(KEY_QC_PREVIEW_FLIP); 4750 break; 4751 case CAM_STREAM_TYPE_VIDEO: 4752 str = get(KEY_QC_VIDEO_FLIP); 4753 break; 4754 case CAM_STREAM_TYPE_SNAPSHOT: 4755 str = get(KEY_QC_SNAPSHOT_PICTURE_FLIP); 4756 break; 4757 default: 4758 ALOGI("%s: No flip mode for stream type %d", __func__, type); 4759 break; 4760 } 4761 4762 if(str != NULL){ 4763 //Need give corresponding filp value based on flip mode strings 4764 int value = lookupAttr(FLIP_MODES_MAP, 4765 sizeof(FLIP_MODES_MAP)/sizeof(QCameraMap), str); 4766 if(value != NAME_NOT_FOUND) 4767 flipMode = value; 4768 } 4769 4770 ALOGD("%s: the filp mode of stream type %d is %d .", __func__, type, flipMode); 4771 return flipMode; 4772} 4773 4774/*=========================================================================== 4775 * FUNCTION : getStreamDimension 4776 * 4777 * DESCRIPTION: get stream dimension by its type 4778 * 4779 * PARAMETERS : 4780 * @streamType : [input] stream type 4781 * @dim : [output] stream dimension 4782 * 4783 * RETURN : int32_t type of status 4784 * NO_ERROR -- success 4785 * none-zero failure code 4786 *==========================================================================*/ 4787int32_t QCameraParameters::getStreamDimension(cam_stream_type_t streamType, 4788 cam_dimension_t &dim) 4789{ 4790 int32_t ret = NO_ERROR; 4791 4792 memset(&dim, 0, sizeof(cam_dimension_t)); 4793 4794 switch (streamType) { 4795 case CAM_STREAM_TYPE_PREVIEW: 4796 getPreviewSize(&dim.width, &dim.height); 4797 break; 4798 case CAM_STREAM_TYPE_POSTVIEW: 4799 getPreviewSize(&dim.width, &dim.height); 4800 break; 4801 case CAM_STREAM_TYPE_SNAPSHOT: 4802 if (getRecordingHintValue() == true) { 4803 // live snapshot 4804 getLiveSnapshotSize(dim); 4805 } else { 4806 getPictureSize(&dim.width, &dim.height); 4807 } 4808 break; 4809 case CAM_STREAM_TYPE_VIDEO: 4810 getVideoSize(&dim.width, &dim.height); 4811 break; 4812 case CAM_STREAM_TYPE_RAW: 4813 dim = m_pCapability->raw_dim; 4814 break; 4815 case CAM_STREAM_TYPE_METADATA: 4816 dim.width = sizeof(cam_metadata_info_t); 4817 dim.height = 1; 4818 break; 4819 case CAM_STREAM_TYPE_OFFLINE_PROC: 4820 break; 4821 case CAM_STREAM_TYPE_DEFAULT: 4822 default: 4823 ALOGE("%s: no dimension for unsupported stream type %d", 4824 __func__, streamType); 4825 ret = BAD_VALUE; 4826 break; 4827 } 4828 return ret; 4829} 4830 4831/*=========================================================================== 4832 * FUNCTION : getPreviewHalPixelFormat 4833 * 4834 * DESCRIPTION: get preview HAL pixel format 4835 * 4836 * PARAMETERS : none 4837 * 4838 * RETURN : HAL pixel format 4839 *==========================================================================*/ 4840int QCameraParameters::getPreviewHalPixelFormat() const 4841{ 4842 int32_t halPixelFormat; 4843 4844 switch (mPreviewFormat) { 4845 case CAM_FORMAT_YUV_420_NV12: 4846 halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP; 4847 break; 4848 case CAM_FORMAT_YUV_420_NV21: 4849 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 4850 break; 4851 case CAM_FORMAT_YUV_420_NV21_ADRENO: 4852 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO; 4853 break; 4854 case CAM_FORMAT_YUV_420_YV12: 4855 halPixelFormat = HAL_PIXEL_FORMAT_YV12; 4856 break; 4857 case CAM_FORMAT_YUV_422_NV16: 4858 case CAM_FORMAT_YUV_422_NV61: 4859 default: 4860 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 4861 break; 4862 } 4863 ALOGE("%s: format %d\n", __func__, halPixelFormat); 4864 return halPixelFormat; 4865} 4866 4867/*=========================================================================== 4868 * FUNCTION : getthumbnailSize 4869 * 4870 * DESCRIPTION: get thumbnail size 4871 * 4872 * PARAMETERS : 4873 * @width, height : [output] thumbnail width and height 4874 * 4875 * RETURN : none 4876 *==========================================================================*/ 4877void QCameraParameters::getThumbnailSize(int *width, int *height) const 4878{ 4879 *width = getInt(KEY_JPEG_THUMBNAIL_WIDTH); 4880 *height = getInt(KEY_JPEG_THUMBNAIL_HEIGHT); 4881} 4882 4883/*=========================================================================== 4884 * FUNCTION : getZSLBurstInterval 4885 * 4886 * DESCRIPTION: get ZSL burst interval setting 4887 * 4888 * PARAMETERS : none 4889 * 4890 * RETURN : ZSL burst interval value 4891 *==========================================================================*/ 4892int QCameraParameters::getZSLBurstInterval() 4893{ 4894 int interval = getInt(KEY_QC_ZSL_BURST_INTERVAL); 4895 if (interval < 0) { 4896 interval = 1; 4897 } 4898 return interval; 4899} 4900 4901/*=========================================================================== 4902 * FUNCTION : getZSLQueueDepth 4903 * 4904 * DESCRIPTION: get ZSL queue depth 4905 * 4906 * PARAMETERS : none 4907 * 4908 * RETURN : ZSL queue depth value 4909 *==========================================================================*/ 4910int QCameraParameters::getZSLQueueDepth() 4911{ 4912 int qdepth = getInt(KEY_QC_ZSL_QUEUE_DEPTH); 4913 if (qdepth < 0) { 4914 qdepth = 2; 4915 } 4916 return qdepth; 4917} 4918 4919/*=========================================================================== 4920 * FUNCTION : getZSLBackLookCount 4921 * 4922 * DESCRIPTION: get ZSL backlook count setting 4923 * 4924 * PARAMETERS : none 4925 * 4926 * RETURN : ZSL backlook count value 4927 *==========================================================================*/ 4928int QCameraParameters::getZSLBackLookCount() 4929{ 4930 int look_back = getInt(KEY_QC_ZSL_BURST_LOOKBACK); 4931 if (look_back < 0) { 4932 look_back = 2; 4933 } 4934 return look_back; 4935} 4936 4937/*=========================================================================== 4938 * FUNCTION : getZSLMaxUnmatchedFrames 4939 * 4940 * DESCRIPTION: get allowed ZSL max unmatched frames number 4941 * 4942 * PARAMETERS : none 4943 * 4944 * RETURN : ZSL backlook count value 4945 *==========================================================================*/ 4946int QCameraParameters::getMaxUnmatchedFramesInQueue() 4947{ 4948 return m_pCapability->min_num_pp_bufs; 4949} 4950 4951/*=========================================================================== 4952 * FUNCTION : setRecordingHintValue 4953 * 4954 * DESCRIPTION: set recording hint 4955 * 4956 * PARAMETERS : 4957 * @value : video hint value 4958 * 4959 * RETURN : int32_t type of status 4960 * NO_ERROR -- success 4961 * none-zero failure code 4962 *==========================================================================*/ 4963int QCameraParameters::setRecordingHintValue(int32_t value) 4964{ 4965 ALOGD("%s: VideoHint = %d", __func__, value); 4966 m_bRecordingHint = (value > 0)? true : false; 4967 return AddSetParmEntryToBatch(m_pParamBuf, 4968 CAM_INTF_PARM_RECORDING_HINT, 4969 sizeof(value), 4970 &value); 4971} 4972 4973/*=========================================================================== 4974 * FUNCTION : getNumOfSnapshots 4975 * 4976 * DESCRIPTION: get number of snapshot per shutter 4977 * 4978 * PARAMETERS : none 4979 * 4980 * RETURN : number of snapshot per shutter 4981 *==========================================================================*/ 4982uint8_t QCameraParameters::getNumOfSnapshots() 4983{ 4984 int numOfSnapshot = getInt(KEY_QC_NUM_SNAPSHOT_PER_SHUTTER); 4985 if (numOfSnapshot <= 0) { 4986 numOfSnapshot = 1; // set to default value 4987 } 4988 return (uint8_t)numOfSnapshot; 4989} 4990 4991/*=========================================================================== 4992 * FUNCTION : getNumOfExtraHDRBufsIfNeeded 4993 * 4994 * DESCRIPTION: get number of extra buffers needed by HDR if HDR is enabled 4995 * 4996 * PARAMETERS : none 4997 * 4998 * RETURN : number of extra buffer needed by HDR; 0 if not HDR enabled 4999 *==========================================================================*/ 5000uint8_t QCameraParameters::getNumOfExtraHDRBufsIfNeeded() 5001{ 5002 uint8_t numOfBufs = 0; 5003 const char *scene_mode = get(KEY_SCENE_MODE); 5004 if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) { 5005 // HDR mode 5006 numOfBufs = getBurstNum() * m_pCapability->min_num_hdr_bufs; 5007 } 5008 return numOfBufs; 5009} 5010 5011/*=========================================================================== 5012 * FUNCTION : getNumOfHDRBufsIfNeeded 5013 * 5014 * DESCRIPTION: get number of buffers needed by HDR if HDR is enabled 5015 * 5016 * PARAMETERS : none 5017 * 5018 * RETURN : number of buffer needed by HDR; 0 if not HDR enabled 5019 *==========================================================================*/ 5020uint8_t QCameraParameters::getNumOfHDRBufsIfNeeded() 5021{ 5022 uint8_t numOfBufs = 0; 5023 const char *scene_mode = get(KEY_SCENE_MODE); 5024 if (scene_mode != NULL && strcmp(scene_mode, SCENE_MODE_HDR) == 0) { 5025 // HDR mode 5026 const char *need_hdr_1x = get(KEY_QC_HDR_NEED_1X); 5027 if (need_hdr_1x != NULL && strcmp(need_hdr_1x, VALUE_TRUE) == 0) { 5028 numOfBufs = 2; // HDR needs both 1X and processed img 5029 } else { 5030 numOfBufs = 1; // HDR only needs processed img 5031 } 5032 5033 numOfBufs += m_pCapability->min_num_hdr_bufs; 5034 } 5035 return numOfBufs; 5036} 5037 5038/*=========================================================================== 5039 * FUNCTION : getBurstNum 5040 * 5041 * DESCRIPTION: get burst number of snapshot 5042 * 5043 * PARAMETERS : none 5044 * 5045 * RETURN : number of burst 5046 *==========================================================================*/ 5047int QCameraParameters::getBurstNum() 5048{ 5049 char prop[PROPERTY_VALUE_MAX]; 5050 memset(prop, 0, sizeof(prop)); 5051 property_get("persist.camera.snapshot.number", prop, "0"); 5052 int nBurstNum = atoi(prop); 5053 if (nBurstNum > 0) { 5054 ALOGD("%s: Reading burst number = %d from properties", 5055 __func__, nBurstNum); 5056 } else { 5057 nBurstNum = 1; 5058 } 5059 return nBurstNum; 5060} 5061 5062/*=========================================================================== 5063 * FUNCTION : getJpegQuality 5064 * 5065 * DESCRIPTION: get jpeg encoding quality 5066 * 5067 * PARAMETERS : none 5068 * 5069 * RETURN : jpeg encoding quality 5070 *==========================================================================*/ 5071int QCameraParameters::getJpegQuality() 5072{ 5073 int quality = getInt(KEY_JPEG_QUALITY); 5074 if (quality < 0) { 5075 quality = 85; // set to default quality value 5076 } 5077 return quality; 5078} 5079 5080/*=========================================================================== 5081 * FUNCTION : getJpegRotation 5082 * 5083 * DESCRIPTION: get rotation value 5084 * 5085 * PARAMETERS : none 5086 * 5087 * RETURN : rotation value 5088 *==========================================================================*/ 5089int QCameraParameters::getJpegRotation() { 5090 int rotation = getInt(KEY_ROTATION); 5091 if (rotation < 0) { 5092 rotation = 0; 5093 } 5094 return rotation; 5095} 5096 5097/*=========================================================================== 5098 * FUNCTION : parseGPSCoordinate 5099 * 5100 * DESCRIPTION: parse GPS coordinate string 5101 * 5102 * PARAMETERS : 5103 * @coord_str : [input] coordinate string 5104 * @coord : [output] ptr to struct to store coordinate 5105 * 5106 * RETURN : int32_t type of status 5107 * NO_ERROR -- success 5108 * none-zero failure code 5109 *==========================================================================*/ 5110int QCameraParameters::parseGPSCoordinate(const char *coord_str, rat_t* coord) 5111{ 5112 if(coord == NULL) { 5113 ALOGE("%s: error, invalid argument coord == NULL", __func__); 5114 return BAD_VALUE; 5115 } 5116 float degF = atof(coord_str); 5117 if (degF < 0) { 5118 degF = -degF; 5119 } 5120 float minF = (degF - (int) degF) * 60; 5121 float secF = (minF - (int) minF) * 60; 5122 5123 getRational(&coord[0], (int)degF, 1); 5124 getRational(&coord[1], (int)minF, 1); 5125 getRational(&coord[2], (int)(secF * 10000), 10000); 5126 return NO_ERROR; 5127} 5128 5129/*=========================================================================== 5130 * FUNCTION : getExifDateTime 5131 * 5132 * DESCRIPTION: query exif date time 5133 * 5134 * PARAMETERS : 5135 * @dateTime : string to store exif date time 5136 * @count : lenght of the dateTime string 5137 * 5138 * RETURN : int32_t type of status 5139 * NO_ERROR -- success 5140 * none-zero failure code 5141 *==========================================================================*/ 5142int32_t QCameraParameters::getExifDateTime(char *dateTime, uint32_t &count) 5143{ 5144 //get time and date from system 5145 time_t rawtime; 5146 struct tm * timeinfo; 5147 time(&rawtime); 5148 timeinfo = localtime (&rawtime); 5149 //Write datetime according to EXIF Spec 5150 //"YYYY:MM:DD HH:MM:SS" (20 chars including \0) 5151 snprintf(dateTime, 20, "%04d:%02d:%02d %02d:%02d:%02d", 5152 timeinfo->tm_year + 1900, timeinfo->tm_mon + 1, 5153 timeinfo->tm_mday, timeinfo->tm_hour, 5154 timeinfo->tm_min, timeinfo->tm_sec); 5155 count = 20; 5156 5157 return NO_ERROR; 5158} 5159 5160/*=========================================================================== 5161 * FUNCTION : getRational 5162 * 5163 * DESCRIPTION: compose rational struct 5164 * 5165 * PARAMETERS : 5166 * @rat : ptr to struct to store rational info 5167 * @num :num of the rational 5168 * @denom : denom of the rational 5169 * 5170 * RETURN : int32_t type of status 5171 * NO_ERROR -- success 5172 * none-zero failure code 5173 *==========================================================================*/ 5174int32_t QCameraParameters::getRational(rat_t *rat, int num, int denom) 5175{ 5176 if (NULL == rat) { 5177 ALOGE("%s: NULL rat input", __func__); 5178 return BAD_VALUE; 5179 } 5180 rat->num = num; 5181 rat->denom = denom; 5182 return NO_ERROR; 5183} 5184 5185/*=========================================================================== 5186 * FUNCTION : getExifFocalLength 5187 * 5188 * DESCRIPTION: get exif focal lenght 5189 * 5190 * PARAMETERS : 5191 * @focalLength : ptr to rational strcut to store focal lenght 5192 * 5193 * RETURN : int32_t type of status 5194 * NO_ERROR -- success 5195 * none-zero failure code 5196 *==========================================================================*/ 5197int32_t QCameraParameters::getExifFocalLength(rat_t *focalLength) 5198{ 5199 int focalLengthValue = 5200 (int)(getFloat(QCameraParameters::KEY_FOCAL_LENGTH) * FOCAL_LENGTH_DECIMAL_PRECISION); 5201 return getRational(focalLength, focalLengthValue, FOCAL_LENGTH_DECIMAL_PRECISION); 5202} 5203 5204/*=========================================================================== 5205 * FUNCTION : getExifIsoSpeed 5206 * 5207 * DESCRIPTION: get exif ISO speed 5208 * 5209 * PARAMETERS : none 5210 * 5211 * RETURN : ISO speed value 5212 *==========================================================================*/ 5213uint16_t QCameraParameters::getExifIsoSpeed() 5214{ 5215 uint16_t isoSpeed = 0; 5216 const char *iso_str = get(QCameraParameters::KEY_QC_ISO_MODE); 5217 int iso_index = lookupAttr(ISO_MODES_MAP, 5218 sizeof(ISO_MODES_MAP)/sizeof(ISO_MODES_MAP[0]), iso_str); 5219 switch (iso_index) { 5220 case CAM_ISO_MODE_AUTO: 5221 isoSpeed = 0; 5222 break; 5223 case CAM_ISO_MODE_DEBLUR: 5224 isoSpeed = 1; 5225 break; 5226 case CAM_ISO_MODE_100: 5227 isoSpeed = 100; 5228 break; 5229 case CAM_ISO_MODE_200: 5230 isoSpeed = 200; 5231 break; 5232 case CAM_ISO_MODE_400: 5233 isoSpeed = 400; 5234 break; 5235 case CAM_ISO_MODE_800: 5236 isoSpeed = 800; 5237 break; 5238 case CAM_ISO_MODE_1600: 5239 isoSpeed = 1600; 5240 break; 5241 } 5242 return isoSpeed; 5243} 5244 5245/*=========================================================================== 5246 * FUNCTION : getExifGpsProcessingMethod 5247 * 5248 * DESCRIPTION: get GPS processing method 5249 * 5250 * PARAMETERS : 5251 * @gpsProcessingMethod : string to store GPS process method 5252 * @count : lenght of the string 5253 * 5254 * RETURN : int32_t type of status 5255 * NO_ERROR -- success 5256 * none-zero failure code 5257 *==========================================================================*/ 5258int32_t QCameraParameters::getExifGpsProcessingMethod(char *gpsProcessingMethod, 5259 uint32_t &count) 5260{ 5261 const char *str = get(KEY_GPS_PROCESSING_METHOD); 5262 if(str != NULL) { 5263 memcpy(gpsProcessingMethod, ExifAsciiPrefix, EXIF_ASCII_PREFIX_SIZE); 5264 count = EXIF_ASCII_PREFIX_SIZE; 5265 strncpy(gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE, str, strlen(str)); 5266 count += strlen(str); 5267 gpsProcessingMethod[count++] = '\0'; // increase 1 for the last NULL char 5268 return NO_ERROR; 5269 } else { 5270 return BAD_VALUE; 5271 } 5272} 5273 5274/*=========================================================================== 5275 * FUNCTION : getExifLatitude 5276 * 5277 * DESCRIPTION: get exif latitude 5278 * 5279 * PARAMETERS : 5280 * @latitude : ptr to rational struct to store latitude info 5281 * @ladRef : charater to indicate latitude reference 5282 * 5283 * RETURN : int32_t type of status 5284 * NO_ERROR -- success 5285 * none-zero failure code 5286 *==========================================================================*/ 5287int32_t QCameraParameters::getExifLatitude(rat_t *latitude, 5288 char *latRef) 5289{ 5290 const char *str = get(KEY_GPS_LATITUDE); 5291 if(str != NULL) { 5292 parseGPSCoordinate(str, latitude); 5293 5294 //set Latitude Ref 5295 float latitudeValue = getFloat(KEY_GPS_LATITUDE); 5296 if(latitudeValue < 0.0f) { 5297 latRef[0] = 'S'; 5298 } else { 5299 latRef[0] = 'N'; 5300 } 5301 latRef[1] = '\0'; 5302 return NO_ERROR; 5303 }else{ 5304 return BAD_VALUE; 5305 } 5306} 5307 5308/*=========================================================================== 5309 * FUNCTION : getExifLongitude 5310 * 5311 * DESCRIPTION: get exif longitude 5312 * 5313 * PARAMETERS : 5314 * @longitude : ptr to rational struct to store longitude info 5315 * @lonRef : charater to indicate longitude reference 5316 * 5317 * RETURN : int32_t type of status 5318 * NO_ERROR -- success 5319 * none-zero failure code 5320 *==========================================================================*/ 5321int32_t QCameraParameters::getExifLongitude(rat_t *longitude, 5322 char *lonRef) 5323{ 5324 const char *str = get(KEY_GPS_LONGITUDE); 5325 if(str != NULL) { 5326 parseGPSCoordinate(str, longitude); 5327 5328 //set Longitude Ref 5329 float longitudeValue = getFloat(KEY_GPS_LONGITUDE); 5330 if(longitudeValue < 0.0f) { 5331 lonRef[0] = 'W'; 5332 } else { 5333 lonRef[0] = 'E'; 5334 } 5335 lonRef[1] = '\0'; 5336 return NO_ERROR; 5337 }else{ 5338 return BAD_VALUE; 5339 } 5340} 5341 5342/*=========================================================================== 5343 * FUNCTION : getExifAltitude 5344 * 5345 * DESCRIPTION: get exif altitude 5346 * 5347 * PARAMETERS : 5348 * @altitude : ptr to rational struct to store altitude info 5349 * @altRef : charater to indicate altitude reference 5350 * 5351 * RETURN : int32_t type of status 5352 * NO_ERROR -- success 5353 * none-zero failure code 5354 *==========================================================================*/ 5355int32_t QCameraParameters::getExifAltitude(rat_t *altitude, 5356 char *altRef) 5357{ 5358 const char *str = get(KEY_GPS_ALTITUDE); 5359 if(str != NULL) { 5360 double value = atof(str); 5361 *altRef = 0; 5362 if(value < 0){ 5363 *altRef = 1; 5364 value = -value; 5365 } 5366 return getRational(altitude, value*1000, 1000); 5367 }else{ 5368 return BAD_VALUE; 5369 } 5370} 5371 5372/*=========================================================================== 5373 * FUNCTION : getExifGpsDateTimeStamp 5374 * 5375 * DESCRIPTION: get exif GPS date time stamp 5376 * 5377 * PARAMETERS : 5378 * @gpsDateStamp : GPS date time stamp string 5379 * @bufLen : length of the string 5380 * @gpsTimeStamp : ptr to rational struct to store time stamp info 5381 * 5382 * RETURN : int32_t type of status 5383 * NO_ERROR -- success 5384 * none-zero failure code 5385 *==========================================================================*/ 5386int32_t QCameraParameters::getExifGpsDateTimeStamp(char *gpsDateStamp, 5387 uint32_t bufLen, 5388 rat_t *gpsTimeStamp) 5389{ 5390 const char *str = get(KEY_GPS_TIMESTAMP); 5391 if(str != NULL) { 5392 time_t unixTime = (time_t)atol(str); 5393 struct tm *UTCTimestamp = gmtime(&unixTime); 5394 5395 strftime(gpsDateStamp, bufLen, "%Y:%m:%d", UTCTimestamp); 5396 5397 getRational(&gpsTimeStamp[0], UTCTimestamp->tm_hour, 1); 5398 getRational(&gpsTimeStamp[1], UTCTimestamp->tm_min, 1); 5399 getRational(&gpsTimeStamp[2], UTCTimestamp->tm_sec, 1); 5400 5401 return NO_ERROR; 5402 } else { 5403 return BAD_VALUE; 5404 } 5405} 5406 5407/*=========================================================================== 5408 * FUNCTION : updateFocusDistances 5409 * 5410 * DESCRIPTION: update focus distances 5411 * 5412 * PARAMETERS : 5413 * @focusDistances : ptr to focus distance info 5414 * 5415 * RETURN : int32_t type of status 5416 * NO_ERROR -- success 5417 * none-zero failure code 5418 *==========================================================================*/ 5419int32_t QCameraParameters::updateFocusDistances(cam_focus_distances_info_t *focusDistances) 5420{ 5421 String8 str; 5422 char buffer[32] = {0}; 5423 //set all distances to infinity if focus mode is infinity 5424 if(mFocusMode == CAM_FOCUS_MODE_INFINITY) { 5425 str.append("Infinity,Infinity,Infinity"); 5426 } else { 5427 snprintf(buffer, sizeof(buffer), "%f", focusDistances->focus_distance[0]); 5428 str.append(buffer); 5429 snprintf(buffer, sizeof(buffer), ",%f", focusDistances->focus_distance[1]); 5430 str.append(buffer); 5431 snprintf(buffer, sizeof(buffer), ",%f", focusDistances->focus_distance[2]); 5432 str.append(buffer); 5433 } 5434 ALOGD("%s: setting KEY_FOCUS_DISTANCES as %s", __FUNCTION__, str.string()); 5435 set(QCameraParameters::KEY_FOCUS_DISTANCES, str.string()); 5436 return NO_ERROR; 5437} 5438 5439/*=========================================================================== 5440 * FUNCTION : setHistogram 5441 * 5442 * DESCRIPTION: set histogram 5443 * 5444 * PARAMETERS : 5445 * @enabled : if histogram is enabled 5446 * 5447 * RETURN : int32_t type of status 5448 * NO_ERROR -- success 5449 * none-zero failure code 5450 *==========================================================================*/ 5451int32_t QCameraParameters::setHistogram(bool enabled) 5452{ 5453 if(m_bHistogramEnabled == enabled) { 5454 ALOGD("%s: histogram flag not changed, no ops here", __func__); 5455 return NO_ERROR; 5456 } 5457 5458 // set parm for histogram 5459 if(initBatchUpdate(m_pParamBuf) < 0 ) { 5460 ALOGE("%s:Failed to initialize group update table", __func__); 5461 return BAD_TYPE; 5462 } 5463 5464 int32_t value = enabled; 5465 int32_t rc = NO_ERROR; 5466 rc = AddSetParmEntryToBatch(m_pParamBuf, 5467 CAM_INTF_PARM_HISTOGRAM, 5468 sizeof(value), 5469 &value); 5470 if (rc != NO_ERROR) { 5471 ALOGE("%s:Failed to update table", __func__); 5472 return rc; 5473 } 5474 5475 rc = commitSetBatch(); 5476 if (rc != NO_ERROR) { 5477 ALOGE("%s:Failed to set histogram", __func__); 5478 return rc; 5479 } 5480 5481 m_bHistogramEnabled = enabled; 5482 5483 ALOGD(" Histogram -> %s", m_bHistogramEnabled ? "Enabled" : "Disabled"); 5484 5485 return rc; 5486} 5487 5488/*=========================================================================== 5489 * FUNCTION : setFaceDetection 5490 * 5491 * DESCRIPTION: set face detection 5492 * 5493 * PARAMETERS : 5494 * @enabled : if face detection is enabled 5495 * 5496 * RETURN : int32_t type of status 5497 * NO_ERROR -- success 5498 * none-zero failure code 5499 *==========================================================================*/ 5500int32_t QCameraParameters::setFaceDetection(bool enabled) 5501{ 5502 int faceProcMask = m_nFaceProcMask; 5503 // set face detection mask 5504 if (enabled) { 5505 faceProcMask |= CAM_FACE_PROCESS_MASK_DETECTION; 5506 } else { 5507 faceProcMask &= ~CAM_FACE_PROCESS_MASK_DETECTION; 5508 } 5509 5510 if(m_nFaceProcMask == faceProcMask) { 5511 ALOGD("%s: face process mask not changed, no ops here", __func__); 5512 return NO_ERROR; 5513 } 5514 5515 // set parm for face detection 5516 int requested_faces = getInt(KEY_QC_MAX_NUM_REQUESTED_FACES); 5517 cam_fd_set_parm_t fd_set_parm; 5518 memset(&fd_set_parm, 0, sizeof(cam_fd_set_parm_t)); 5519 fd_set_parm.fd_mode = faceProcMask; 5520 fd_set_parm.num_fd = requested_faces; 5521 5522 if(initBatchUpdate(m_pParamBuf) < 0 ) { 5523 ALOGE("%s:Failed to initialize group update table", __func__); 5524 return BAD_TYPE; 5525 } 5526 int32_t rc = NO_ERROR; 5527 5528 rc = AddSetParmEntryToBatch(m_pParamBuf, 5529 CAM_INTF_PARM_FD, 5530 sizeof(fd_set_parm), 5531 &fd_set_parm); 5532 if (rc != NO_ERROR) { 5533 ALOGE("%s:Failed to update table", __func__); 5534 return rc; 5535 } 5536 5537 rc = commitSetBatch(); 5538 if (rc != NO_ERROR) { 5539 ALOGE("%s:Failed to set face detection parm", __func__); 5540 return rc; 5541 } 5542 5543 m_nFaceProcMask = faceProcMask; 5544 ALOGD("%s: FaceProcMask -> %d", __func__, m_nFaceProcMask); 5545 5546 return rc; 5547} 5548 5549/*=========================================================================== 5550 * FUNCTION : setLockCAF 5551 * 5552 * DESCRIPTION: Lock CAF 5553 * 5554 * PARAMETERS : 5555 * @bLock : if CAF needs to be locked 5556 * 5557 * RETURN : int32_t type of status 5558 * NO_ERROR -- success 5559 * none-zero failure code 5560 *==========================================================================*/ 5561int32_t QCameraParameters::setLockCAF(bool bLock) 5562{ 5563 if(initBatchUpdate(m_pParamBuf) < 0 ) { 5564 ALOGE("%s:Failed to initialize group update table", __func__); 5565 return BAD_TYPE; 5566 } 5567 int32_t rc = NO_ERROR; 5568 int32_t value = bLock; 5569 5570 rc = AddSetParmEntryToBatch(m_pParamBuf, 5571 CAM_INTF_PARM_LOCK_CAF, 5572 sizeof(value), 5573 &value); 5574 if (rc != NO_ERROR) { 5575 ALOGE("%s:Failed to update table", __func__); 5576 return rc; 5577 } 5578 5579 rc = commitSetBatch(); 5580 if (rc != NO_ERROR) { 5581 ALOGE("%s:Failed to set lock CAF parm", __func__); 5582 return rc; 5583 } else { 5584 m_bCAFLocked = bLock; 5585 return NO_ERROR; 5586 } 5587} 5588 5589/*=========================================================================== 5590 * FUNCTION : setBundleInfo 5591 * 5592 * DESCRIPTION: send bundle info of a channel to backend 5593 * 5594 * PARAMETERS : 5595 * @bundle_info : reference to bundle info struct 5596 * 5597 * RETURN : int32_t type of status 5598 * NO_ERROR -- success 5599 * none-zero failure code 5600 *==========================================================================*/ 5601int32_t QCameraParameters::setBundleInfo(cam_bundle_config_t &bundle_info) 5602{ 5603 int32_t rc = NO_ERROR; 5604 5605 if(initBatchUpdate(m_pParamBuf) < 0 ) { 5606 ALOGE("%s:Failed to initialize group update table", __func__); 5607 return BAD_TYPE; 5608 } 5609 5610 rc = AddSetParmEntryToBatch(m_pParamBuf, 5611 CAM_INTF_PARM_SET_BUNDLE, 5612 sizeof(cam_bundle_config_t), 5613 &bundle_info); 5614 if (rc != NO_ERROR) { 5615 ALOGE("%s:Failed to update table", __func__); 5616 return rc; 5617 } 5618 5619 rc = commitSetBatch(); 5620 if (rc != NO_ERROR) { 5621 ALOGE("%s:Failed to set bundle info parm", __func__); 5622 return rc; 5623 } 5624 5625 return rc; 5626} 5627 5628/*=========================================================================== 5629 * FUNCTION : setFrameSkip 5630 * 5631 * DESCRIPTION: send ISP frame skip pattern to camera daemon 5632 * 5633 * PARAMETERS : 5634 * @pattern : skip pattern for ISP 5635 * 5636 * RETURN : int32_t type of status 5637 * NO_ERROR -- success 5638 * none-zero failure code 5639 *==========================================================================*/ 5640int32_t QCameraParameters::setFrameSkip(enum msm_vfe_frame_skip_pattern pattern) 5641{ 5642 int32_t rc = NO_ERROR; 5643 int32_t value = (int32_t)pattern; 5644 5645 if(initBatchUpdate(m_pParamBuf) < 0 ) { 5646 ALOGE("%s:Failed to initialize group update table", __func__); 5647 return BAD_TYPE; 5648 } 5649 5650 rc = AddSetParmEntryToBatch(m_pParamBuf, 5651 CAM_INTF_PARM_FRAMESKIP, 5652 sizeof(value), 5653 &value); 5654 if (rc != NO_ERROR) { 5655 ALOGE("%s:Failed to update table", __func__); 5656 return rc; 5657 } 5658 5659 rc = commitSetBatch(); 5660 if (rc != NO_ERROR) { 5661 ALOGE("%s:Failed to set frameskip info parm", __func__); 5662 return rc; 5663 } 5664 5665 return rc; 5666} 5667 5668/*=========================================================================== 5669 * FUNCTION : parseNDimVector 5670 * 5671 * DESCRIPTION: helper function to parse a string like "(1, 2, 3, 4, ..., N)" 5672 * into N-dimension vector 5673 * 5674 * PARAMETERS : 5675 * @str : string to be parsed 5676 * @num : output array of size N to store vector element values 5677 * @N : number of dimension 5678 * @delim : delimeter to seperete string 5679 * 5680 * RETURN : int32_t type of status 5681 * NO_ERROR -- success 5682 * none-zero failure code 5683 *==========================================================================*/ 5684int32_t QCameraParameters::parseNDimVector(const char *str, int *num, int N, char delim = ',') 5685{ 5686 char *start, *end; 5687 if (num == NULL) { 5688 ALOGE("%s: Invalid output array (num == NULL)", __func__); 5689 return BAD_VALUE; 5690 } 5691 5692 //check if string starts and ends with parantheses 5693 if(str[0] != '(' || str[strlen(str)-1] != ')') { 5694 ALOGE("%s: Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)", 5695 __func__, str); 5696 return BAD_VALUE; 5697 } 5698 start = (char*) str; 5699 start++; 5700 for(int i=0; i<N; i++) { 5701 *(num+i) = (int) strtol(start, &end, 10); 5702 if(*end != delim && i < N-1) { 5703 ALOGE("%s: Cannot find delimeter '%c' in string \"%s\". end = %c", 5704 __func__, delim, str, *end); 5705 return -1; 5706 } 5707 start = end+1; 5708 } 5709 return NO_ERROR; 5710} 5711 5712/*=========================================================================== 5713 * FUNCTION : parseCameraAreaString 5714 * 5715 * DESCRIPTION: helper function to parse a string of camera areas like 5716 * "(1, 2, 3, 4, 5),(1, 2, 3, 4, 5),..." 5717 * 5718 * PARAMETERS : 5719 * @str : string to be parsed 5720 * @max_num_areas : max number of areas 5721 * @pAreas : ptr to struct to store areas 5722 * @num_areas_found : number of areas found 5723 * 5724 * RETURN : int32_t type of status 5725 * NO_ERROR -- success 5726 * none-zero failure code 5727 *==========================================================================*/ 5728int32_t QCameraParameters::parseCameraAreaString(const char *str, 5729 int max_num_areas, 5730 cam_area_t *pAreas, 5731 int& num_areas_found) 5732{ 5733 char area_str[32]; 5734 const char *start, *end, *p; 5735 start = str; end = NULL; 5736 int values[5], index=0; 5737 num_areas_found = 0; 5738 5739 memset(values, 0, sizeof(values)); 5740 while(start != NULL) { 5741 if(*start != '(') { 5742 ALOGE("%s: error: Ill formatted area string: %s", __func__, str); 5743 return BAD_VALUE; 5744 } 5745 end = strchr(start, ')'); 5746 if(end == NULL) { 5747 ALOGE("%s: error: Ill formatted area string: %s", __func__, str); 5748 return BAD_VALUE; 5749 } 5750 int i; 5751 for (i=0,p=start; p<=end; p++, i++) { 5752 area_str[i] = *p; 5753 } 5754 area_str[i] = '\0'; 5755 if(parseNDimVector(area_str, values, 5) < 0){ 5756 ALOGE("%s: error: Failed to parse the area string: %s", __func__, area_str); 5757 return BAD_VALUE; 5758 } 5759 // no more areas than max_num_areas are accepted. 5760 if(index >= max_num_areas) { 5761 ALOGE("%s: error: too many areas specified %s", __func__, str); 5762 return BAD_VALUE; 5763 } 5764 pAreas[index].rect.left = values[0]; 5765 pAreas[index].rect.top = values[1]; 5766 pAreas[index].rect.width = values[2] - values[0]; 5767 pAreas[index].rect.height = values[3] - values[1]; 5768 pAreas[index].weight = values[4]; 5769 5770 index++; 5771 start = strchr(end, '('); // serach for next '(' 5772 } 5773 num_areas_found = index; 5774 return 0; 5775} 5776 5777/*=========================================================================== 5778 * FUNCTION : validateCameraAreas 5779 * 5780 * DESCRIPTION: helper function to validate camera areas within (-1000, 1000) 5781 * 5782 * PARAMETERS : 5783 * @areas : ptr to array of areas 5784 * @num_areas : number of areas 5785 * 5786 * RETURN : true -- area is in valid range 5787 * false -- not valid 5788 *==========================================================================*/ 5789bool QCameraParameters::validateCameraAreas(cam_area_t *areas, int num_areas) 5790{ 5791 // special case: default area 5792 if (num_areas == 1 && 5793 areas[0].rect.left == 0 && 5794 areas[0].rect.top == 0 && 5795 areas[0].rect.width == 0 && 5796 areas[0].rect.height == 0 && 5797 areas[0].weight == 0) { 5798 return true; 5799 } 5800 5801 for(int i = 0; i < num_areas; i++) { 5802 // left should be >= -1000 5803 if(areas[i].rect.left < -1000) { 5804 return false; 5805 } 5806 5807 // top should be >= -1000 5808 if(areas[i].rect.top < -1000) { 5809 return false; 5810 } 5811 5812 // width or height should be > 0 5813 if (areas[i].rect.width <= 0 || areas[i].rect.height <= 0) { 5814 return false; 5815 } 5816 5817 // right should be <= 1000 5818 if(areas[i].rect.left + areas[i].rect.width > 1000) { 5819 return false; 5820 } 5821 5822 // bottom should be <= 1000 5823 if(areas[i].rect.top + areas[i].rect.height > 1000) { 5824 return false; 5825 } 5826 5827 // weight should be within (1, 1000) 5828 if (areas[i].weight < 1 || areas[i].weight > 1000) { 5829 return false; 5830 } 5831 } 5832 return true; 5833} 5834 5835/*=========================================================================== 5836 * FUNCTION : initBatchUpdate 5837 * 5838 * DESCRIPTION: init camera parameters buf entries 5839 * 5840 * PARAMETERS : 5841 * @p_table : ptr to parameter buffer 5842 * 5843 * RETURN : int32_t type of status 5844 * NO_ERROR -- success 5845 * none-zero failure code 5846 *==========================================================================*/ 5847int32_t QCameraParameters::initBatchUpdate(parm_buffer_t *p_table) 5848{ 5849 m_tempMap.clear(); 5850 5851 memset(p_table, 0, sizeof(parm_buffer_t)); 5852 p_table->first_flagged_entry = CAM_INTF_PARM_MAX; 5853 return NO_ERROR; 5854} 5855 5856/*=========================================================================== 5857 * FUNCTION : AddSetParmEntryToBatch 5858 * 5859 * DESCRIPTION: add set parameter entry into batch 5860 * 5861 * PARAMETERS : 5862 * @p_table : ptr to parameter buffer 5863 * @paramType : parameter type 5864 * @paramLength : length of parameter value 5865 * @paramValue : ptr to parameter value 5866 * 5867 * RETURN : int32_t type of status 5868 * NO_ERROR -- success 5869 * none-zero failure code 5870 *==========================================================================*/ 5871int32_t QCameraParameters::AddSetParmEntryToBatch(parm_buffer_t *p_table, 5872 cam_intf_parm_type_t paramType, 5873 uint32_t paramLength, 5874 void *paramValue) 5875{ 5876 int position = paramType; 5877 int current, next; 5878 5879 /************************************************************************* 5880 * Code to take care of linking next flags * 5881 *************************************************************************/ 5882 current = GET_FIRST_PARAM_ID(p_table); 5883 if (position == current){ 5884 //DO NOTHING 5885 } else if (position < current){ 5886 SET_NEXT_PARAM_ID(position, p_table, current); 5887 SET_FIRST_PARAM_ID(p_table, position); 5888 } else { 5889 /* Search for the position in the linked list where we need to slot in*/ 5890 while (position > GET_NEXT_PARAM_ID(current, p_table)) 5891 current = GET_NEXT_PARAM_ID(current, p_table); 5892 5893 /*If node already exists no need to alter linking*/ 5894 if (position != GET_NEXT_PARAM_ID(current, p_table)) { 5895 next = GET_NEXT_PARAM_ID(current, p_table); 5896 SET_NEXT_PARAM_ID(current, p_table, position); 5897 SET_NEXT_PARAM_ID(position, p_table, next); 5898 } 5899 } 5900 5901 /************************************************************************* 5902 * Copy contents into entry * 5903 *************************************************************************/ 5904 5905 if (paramLength > sizeof(parm_type_t)) { 5906 ALOGE("%s:Size of input larger than max entry size",__func__); 5907 return BAD_VALUE; 5908 } 5909 memcpy(POINTER_OF(paramType,p_table), paramValue, paramLength); 5910 return NO_ERROR; 5911} 5912 5913/*=========================================================================== 5914 * FUNCTION : AddGetParmEntryToBatch 5915 * 5916 * DESCRIPTION: add get parameter entry into batch 5917 * 5918 * PARAMETERS : 5919 * @p_table : ptr to parameter buffer 5920 * @paramType : parameter type 5921 * 5922 * RETURN : int32_t type of status 5923 * NO_ERROR -- success 5924 * none-zero failure code 5925 *==========================================================================*/ 5926int32_t QCameraParameters::AddGetParmEntryToBatch(parm_buffer_t *p_table, 5927 cam_intf_parm_type_t paramType) 5928{ 5929 int position = paramType; 5930 int current, next; 5931 5932 /************************************************************************* 5933 * Code to take care of linking next flags * 5934 *************************************************************************/ 5935 current = GET_FIRST_PARAM_ID(p_table); 5936 if (position == current){ 5937 //DO NOTHING 5938 } else if (position < current){ 5939 SET_NEXT_PARAM_ID(position, p_table, current); 5940 SET_FIRST_PARAM_ID(p_table, position); 5941 } else { 5942 /* Search for the position in the linked list where we need to slot in*/ 5943 while (position > GET_NEXT_PARAM_ID(current, p_table)) 5944 current = GET_NEXT_PARAM_ID(current, p_table); 5945 5946 /*If node already exists no need to alter linking*/ 5947 if (position != GET_NEXT_PARAM_ID(current, p_table)) { 5948 next=GET_NEXT_PARAM_ID(current, p_table); 5949 SET_NEXT_PARAM_ID(current, p_table, position); 5950 SET_NEXT_PARAM_ID(position, p_table, next); 5951 } 5952 } 5953 5954 return NO_ERROR; 5955} 5956 5957/*=========================================================================== 5958 * FUNCTION : commitSetBatch 5959 * 5960 * DESCRIPTION: commit all set parameters in the batch work to backend 5961 * 5962 * PARAMETERS : none 5963 * 5964 * RETURN : int32_t type of status 5965 * NO_ERROR -- success 5966 * none-zero failure code 5967 *==========================================================================*/ 5968int32_t QCameraParameters::commitSetBatch() 5969{ 5970 int32_t rc = NO_ERROR; 5971 if (m_pParamBuf->first_flagged_entry < CAM_INTF_PARM_MAX) { 5972 rc = m_pCamOpsTbl->ops->set_parms(m_pCamOpsTbl->camera_handle, m_pParamBuf); 5973 } 5974 if (rc == NO_ERROR) { 5975 // commit change from temp storage into param map 5976 rc = commitParamChanges(); 5977 } 5978 return rc; 5979} 5980 5981/*=========================================================================== 5982 * FUNCTION : commitGetBatch 5983 * 5984 * DESCRIPTION: commit all get parameters in the batch work to backend 5985 * 5986 * PARAMETERS : none 5987 * 5988 * RETURN : int32_t type of status 5989 * NO_ERROR -- success 5990 * none-zero failure code 5991 *==========================================================================*/ 5992int32_t QCameraParameters::commitGetBatch() 5993{ 5994 if (m_pParamBuf->first_flagged_entry < CAM_INTF_PARM_MAX) { 5995 return m_pCamOpsTbl->ops->get_parms(m_pCamOpsTbl->camera_handle, m_pParamBuf); 5996 } else { 5997 return NO_ERROR; 5998 } 5999} 6000 6001/*=========================================================================== 6002 * FUNCTION : updateParamEntry 6003 * 6004 * DESCRIPTION: update a parameter entry in the local temp map obj 6005 * 6006 * PARAMETERS : 6007 * @key : key of the entry 6008 * @value : value of the entry 6009 * 6010 * RETURN : int32_t type of status 6011 * NO_ERROR -- success 6012 * none-zero failure code 6013 *==========================================================================*/ 6014int32_t QCameraParameters::updateParamEntry(const char *key, const char *value) 6015{ 6016 m_tempMap.replaceValueFor(String8(key), String8(value)); 6017 return NO_ERROR; 6018} 6019 6020/*=========================================================================== 6021 * FUNCTION : commitParamChanges 6022 * 6023 * DESCRIPTION: commit all changes in local temp map obj into parameter obj 6024 * 6025 * PARAMETERS : none 6026 * 6027 * RETURN : int32_t type of status 6028 * NO_ERROR -- success 6029 * none-zero failure code 6030 *==========================================================================*/ 6031int32_t QCameraParameters::commitParamChanges() 6032{ 6033 size_t size = m_tempMap.size(); 6034 for (size_t i = 0; i < size; i++) { 6035 String8 k, v; 6036 k = m_tempMap.keyAt(i); 6037 v = m_tempMap.valueAt(i); 6038 set(k, v); 6039 } 6040 m_tempMap.clear(); 6041 return NO_ERROR; 6042} 6043 6044}; // namespace qcamera 6045