/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of The Linux Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_TAG "QCameraParameters"
// To remove
#include <cutils/properties.h>
// System dependencies
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <utils/Errors.h>
#define SYSINFO_H <SYSTEM_HEADER_PREFIX/sysinfo.h>
#include SYSINFO_H
#include "gralloc_priv.h"
#include "graphics.h"
// Camera dependencies
#include "QCameraBufferMaps.h"
#include "QCamera2HWI.h"
#include "QCameraParameters.h"
#include "QCameraTrace.h"
extern "C" {
#include "mm_camera_dbg.h"
}
#define PI 3.14159265
#define ASPECT_TOLERANCE 0.001
#define CAMERA_DEFAULT_LONGSHOT_STAGES 4
#define CAMERA_MIN_LONGSHOT_STAGES 2
#define FOCUS_PERCISION 0.0000001
namespace qcamera {
// Parameter keys to communicate between camera application and driver.
const char QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES[] = "hfr-size-values";
const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_MODE[] = "preview-frame-rate-mode";
const char QCameraParameters::KEY_QC_SUPPORTED_PREVIEW_FRAME_RATE_MODES[] = "preview-frame-rate-modes";
const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE[] = "frame-rate-auto";
const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE[] = "frame-rate-fixed";
const char QCameraParameters::KEY_QC_TOUCH_AF_AEC[] = "touch-af-aec";
const char QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC[] = "touch-af-aec-values";
const char QCameraParameters::KEY_QC_TOUCH_INDEX_AEC[] = "touch-index-aec";
const char QCameraParameters::KEY_QC_TOUCH_INDEX_AF[] = "touch-index-af";
const char QCameraParameters::KEY_QC_SCENE_DETECT[] = "scene-detect";
const char QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT[] = "scene-detect-values";
const char QCameraParameters::KEY_QC_ISO_MODE[] = "iso";
const char QCameraParameters::KEY_QC_CONTINUOUS_ISO[] = "continuous-iso";
const char QCameraParameters::KEY_QC_MIN_ISO[] = "min-iso";
const char QCameraParameters::KEY_QC_MAX_ISO[] = "max-iso";
const char QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES[] = "iso-values";
const char QCameraParameters::KEY_QC_EXPOSURE_TIME[] = "exposure-time";
const char QCameraParameters::KEY_QC_MIN_EXPOSURE_TIME[] = "min-exposure-time";
const char QCameraParameters::KEY_QC_MAX_EXPOSURE_TIME[] = "max-exposure-time";
const char QCameraParameters::KEY_QC_CURRENT_EXPOSURE_TIME[] = "cur-exposure-time";
const char QCameraParameters::KEY_QC_CURRENT_ISO[] = "cur-iso";
const char QCameraParameters::KEY_QC_LENSSHADE[] = "lensshade";
const char QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES[] = "lensshade-values";
const char QCameraParameters::KEY_QC_AUTO_EXPOSURE[] = "auto-exposure";
const char QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE[] = "auto-exposure-values";
const char QCameraParameters::KEY_QC_DENOISE[] = "denoise";
const char QCameraParameters::KEY_QC_SUPPORTED_DENOISE[] = "denoise-values";
const char QCameraParameters::KEY_QC_FOCUS_ALGO[] = "selectable-zone-af";
const char QCameraParameters::KEY_QC_SUPPORTED_FOCUS_ALGOS[] = "selectable-zone-af-values";
const char QCameraParameters::KEY_QC_MANUAL_FOCUS_POSITION[] = "manual-focus-position";
const char QCameraParameters::KEY_QC_MANUAL_FOCUS_POS_TYPE[] = "manual-focus-pos-type";
const char QCameraParameters::KEY_QC_MIN_FOCUS_POS_INDEX[] = "min-focus-pos-index";
const char QCameraParameters::KEY_QC_MAX_FOCUS_POS_INDEX[] = "max-focus-pos-index";
const char QCameraParameters::KEY_QC_MIN_FOCUS_POS_DAC[] = "min-focus-pos-dac";
const char QCameraParameters::KEY_QC_MAX_FOCUS_POS_DAC[] = "max-focus-pos-dac";
const char QCameraParameters::KEY_QC_MIN_FOCUS_POS_RATIO[] = "min-focus-pos-ratio";
const char QCameraParameters::KEY_QC_MAX_FOCUS_POS_RATIO[] = "max-focus-pos-ratio";
const char QCameraParameters::KEY_QC_FOCUS_POSITION_SCALE[] = "cur-focus-scale";
const char QCameraParameters::KEY_QC_MIN_FOCUS_POS_DIOPTER[] = "min-focus-pos-diopter";
const char QCameraParameters::KEY_QC_MAX_FOCUS_POS_DIOPTER[] = "max-focus-pos-diopter";
const char QCameraParameters::KEY_QC_FOCUS_POSITION_DIOPTER[] = "cur-focus-diopter";
const char QCameraParameters::KEY_QC_FACE_DETECTION[] = "face-detection";
const char QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION[] = "face-detection-values";
const char QCameraParameters::KEY_QC_FACE_RECOGNITION[] = "face-recognition";
const char QCameraParameters::KEY_QC_SUPPORTED_FACE_RECOGNITION[] = "face-recognition-values";
const char QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT[] = "mce";
const char QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES[] = "mce-values";
const char QCameraParameters::KEY_QC_DIS[] = "dis";
const char QCameraParameters::KEY_QC_OIS[] = "ois";
const char QCameraParameters::KEY_QC_SUPPORTED_DIS_MODES[] = "dis-values";
const char QCameraParameters::KEY_QC_SUPPORTED_OIS_MODES[] = "ois-values";
const char QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE[] = "video-hfr";
const char QCameraParameters::KEY_QC_VIDEO_HIGH_SPEED_RECORDING[] = "video-hsr";
const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[] = "video-hfr-values";
const char QCameraParameters::KEY_QC_REDEYE_REDUCTION[] = "redeye-reduction";
const char QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION[] = "redeye-reduction-values";
const char QCameraParameters::KEY_QC_HIGH_DYNAMIC_RANGE_IMAGING[] = "hdr";
const char QCameraParameters::KEY_QC_SUPPORTED_HDR_IMAGING_MODES[] = "hdr-values";
const char QCameraParameters::KEY_QC_ZSL[] = "zsl";
const char QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES[] = "zsl-values";
const char QCameraParameters::KEY_QC_ZSL_BURST_INTERVAL[] = "capture-burst-interval";
const char QCameraParameters::KEY_QC_ZSL_BURST_LOOKBACK[] = "capture-burst-retroactive";
const char QCameraParameters::KEY_QC_ZSL_QUEUE_DEPTH[] = "capture-burst-queue-depth";
const char QCameraParameters::KEY_QC_CAMERA_MODE[] = "camera-mode";
const char QCameraParameters::KEY_QC_AE_BRACKET_HDR[] = "ae-bracket-hdr";
const char QCameraParameters::KEY_QC_SUPPORTED_AE_BRACKET_MODES[] = "ae-bracket-hdr-values";
const char QCameraParameters::KEY_QC_SUPPORTED_RAW_FORMATS[] = "raw-format-values";
const char QCameraParameters::KEY_QC_RAW_FORMAT[] = "raw-format";
const char QCameraParameters::KEY_QC_ORIENTATION[] = "orientation";
const char QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF[] = "selectable-zone-af";
const char QCameraParameters::KEY_QC_CAPTURE_BURST_EXPOSURE[] = "capture-burst-exposures";
const char QCameraParameters::KEY_QC_NUM_SNAPSHOT_PER_SHUTTER[] = "num-snaps-per-shutter";
const char QCameraParameters::KEY_QC_NUM_RETRO_BURST_PER_SHUTTER[] = "num-retro-burst-per-shutter";
const char QCameraParameters::KEY_QC_SNAPSHOT_BURST_LED_ON_PERIOD[] = "zsl-burst-led-on-period";
const char QCameraParameters::KEY_QC_NO_DISPLAY_MODE[] = "no-display-mode";
const char QCameraParameters::KEY_QC_RAW_PICUTRE_SIZE[] = "raw-size";
const char QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] = "skinToneEnhancement-values";
const char QCameraParameters::KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES[] = "supported-live-snapshot-sizes";
const char QCameraParameters::KEY_QC_SUPPORTED_HDR_NEED_1X[] = "hdr-need-1x-values";
const char QCameraParameters::KEY_QC_HDR_NEED_1X[] = "hdr-need-1x";
const char QCameraParameters::KEY_QC_PREVIEW_FLIP[] = "preview-flip";
const char QCameraParameters::KEY_QC_VIDEO_FLIP[] = "video-flip";
const char QCameraParameters::KEY_QC_SNAPSHOT_PICTURE_FLIP[] = "snapshot-picture-flip";
const char QCameraParameters::KEY_QC_SUPPORTED_FLIP_MODES[] = "flip-mode-values";
const char QCameraParameters::KEY_QC_VIDEO_HDR[] = "video-hdr";
const char QCameraParameters::KEY_QC_SENSOR_HDR[] = "sensor-hdr";
const char QCameraParameters::KEY_QC_VT_ENABLE[] = "avtimer";
const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HDR_MODES[] = "video-hdr-values";
const char QCameraParameters::KEY_QC_SUPPORTED_SENSOR_HDR_MODES[] = "sensor-hdr-values";
const char QCameraParameters::KEY_QC_AUTO_HDR_ENABLE [] = "auto-hdr-enable";
const char QCameraParameters::KEY_QC_SNAPSHOT_BURST_NUM[] = "snapshot-burst-num";
const char QCameraParameters::KEY_QC_SNAPSHOT_FD_DATA[] = "snapshot-fd-data-enable";
const char QCameraParameters::KEY_QC_TINTLESS_ENABLE[] = "tintless";
const char QCameraParameters::KEY_QC_SCENE_SELECTION[] = "scene-selection";
const char QCameraParameters::KEY_QC_CDS_MODE[] = "cds-mode";
const char QCameraParameters::KEY_QC_VIDEO_CDS_MODE[] = "video-cds-mode";
const char QCameraParameters::KEY_QC_SUPPORTED_CDS_MODES[] = "cds-mode-values";
const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_CDS_MODES[] = "video-cds-mode-values";
const char QCameraParameters::KEY_QC_TNR_MODE[] = "tnr-mode";
const char QCameraParameters::KEY_QC_VIDEO_TNR_MODE[] = "video-tnr-mode";
const char QCameraParameters::KEY_QC_SUPPORTED_TNR_MODES[] = "tnr-mode-values";
const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_TNR_MODES[] = "video-tnr-mode-values";
const char QCameraParameters::KEY_QC_VIDEO_ROTATION[] = "video-rotation";
const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_ROTATION_VALUES[] = "video-rotation-values";
const char QCameraParameters::KEY_QC_AF_BRACKET[] = "af-bracket";
const char QCameraParameters::KEY_QC_SUPPORTED_AF_BRACKET_MODES[] = "af-bracket-values";
const char QCameraParameters::KEY_QC_RE_FOCUS[] = "re-focus";
const char QCameraParameters::KEY_QC_SUPPORTED_RE_FOCUS_MODES[] = "re-focus-values";
const char QCameraParameters::KEY_QC_CHROMA_FLASH[] = "chroma-flash";
const char QCameraParameters::KEY_QC_SUPPORTED_CHROMA_FLASH_MODES[] = "chroma-flash-values";
const char QCameraParameters::KEY_QC_OPTI_ZOOM[] = "opti-zoom";
const char QCameraParameters::KEY_QC_SEE_MORE[] = "see-more";
const char QCameraParameters::KEY_QC_STILL_MORE[] = "still-more";
const char QCameraParameters::KEY_QC_SUPPORTED_OPTI_ZOOM_MODES[] = "opti-zoom-values";
const char QCameraParameters::KEY_QC_HDR_MODE[] = "hdr-mode";
const char QCameraParameters::KEY_QC_SUPPORTED_KEY_QC_HDR_MODES[] = "hdr-mode-values";
const char QCameraParameters::KEY_QC_TRUE_PORTRAIT[] = "true-portrait";
const char QCameraParameters::KEY_QC_SUPPORTED_TRUE_PORTRAIT_MODES[] = "true-portrait-values";
const char QCameraParameters::KEY_QC_SUPPORTED_SEE_MORE_MODES[] = "see-more-values";
const char QCameraParameters::KEY_QC_SUPPORTED_STILL_MORE_MODES[] = "still-more-values";
const char QCameraParameters::KEY_INTERNAL_PERVIEW_RESTART[] = "internal-restart";
const char QCameraParameters::KEY_QC_RDI_MODE[] = "rdi-mode";
const char QCameraParameters::KEY_QC_SUPPORTED_RDI_MODES[] = "rdi-mode-values";
const char QCameraParameters::KEY_QC_SECURE_MODE[] = "secure-mode";
const char QCameraParameters::KEY_QC_SUPPORTED_SECURE_MODES[] = "secure-mode-values";
const char QCameraParameters::ISO_HJR[] = "ISO_HJR";
const char QCameraParameters::KEY_QC_AUTO_HDR_SUPPORTED[] = "auto-hdr-supported";
const char QCameraParameters::KEY_QC_LONGSHOT_SUPPORTED[] = "longshot-supported";
const char QCameraParameters::KEY_QC_ZSL_HDR_SUPPORTED[] = "zsl-hdr-supported";
const char QCameraParameters::KEY_QC_WB_MANUAL_CCT[] = "wb-manual-cct";
const char QCameraParameters::KEY_QC_MIN_WB_CCT[] = "min-wb-cct";
const char QCameraParameters::KEY_QC_MAX_WB_CCT[] = "max-wb-cct";
const char QCameraParameters::KEY_QC_MANUAL_WB_GAINS[] = "manual-wb-gains";
const char QCameraParameters::KEY_QC_MIN_WB_GAIN[] = "min-wb-gain";
const char QCameraParameters::KEY_QC_MAX_WB_GAIN[] = "max-wb-gain";
const char QCameraParameters::KEY_QC_MANUAL_WB_TYPE[] = "manual-wb-type";
const char QCameraParameters::KEY_QC_MANUAL_WB_VALUE[] = "manual-wb-value";
const char QCameraParameters::WHITE_BALANCE_MANUAL[] = "manual";
const char QCameraParameters::FOCUS_MODE_MANUAL_POSITION[] = "manual";
const char QCameraParameters::KEY_QC_CACHE_VIDEO_BUFFERS[] = "cache-video-buffers";
const char QCameraParameters::KEY_QC_LONG_SHOT[] = "long-shot";
const char QCameraParameters::KEY_QC_INITIAL_EXPOSURE_INDEX[] = "initial-exp-index";
const char QCameraParameters::KEY_QC_INSTANT_AEC[] = "instant-aec";
const char QCameraParameters::KEY_QC_INSTANT_CAPTURE[] = "instant-capture";
const char QCameraParameters::KEY_QC_INSTANT_AEC_SUPPORTED_MODES[] = "instant-aec-values";
const char QCameraParameters::KEY_QC_INSTANT_CAPTURE_SUPPORTED_MODES[] = "instant-capture-values";
// Values for effect settings.
const char QCameraParameters::EFFECT_EMBOSS[] = "emboss";
const char QCameraParameters::EFFECT_SKETCH[] = "sketch";
const char QCameraParameters::EFFECT_NEON[] = "neon";
const char QCameraParameters::EFFECT_BEAUTY[] = "beauty";
// Values for auto exposure settings.
const char QCameraParameters::TOUCH_AF_AEC_OFF[] = "touch-off";
const char QCameraParameters::TOUCH_AF_AEC_ON[] = "touch-on";
// Values for scene mode settings.
const char QCameraParameters::SCENE_MODE_ASD[] = "asd"; // corresponds to CAMERA_BESTSHOT_AUTO in HAL
const char QCameraParameters::SCENE_MODE_BACKLIGHT[] = "backlight";
const char QCameraParameters::SCENE_MODE_FLOWERS[] = "flowers";
const char QCameraParameters::SCENE_MODE_AR[] = "AR";
const char QCameraParameters::SCENE_MODE_HDR[] = "hdr";
// Formats for setPreviewFormat and setPictureFormat.
const char QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO[] = "yuv420sp-adreno";
const char QCameraParameters::PIXEL_FORMAT_YV12[] = "yuv420p";
const char QCameraParameters::PIXEL_FORMAT_NV12[] = "nv12";
const char QCameraParameters::QC_PIXEL_FORMAT_NV12_VENUS[] = "nv12-venus";
// Values for raw image formats
const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV[] = "yuv-raw8-yuyv";
const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU[] = "yuv-raw8-yvyu";
const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY[] = "yuv-raw8-uyvy";
const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY[] = "yuv-raw8-vyuy";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG[] = "bayer-qcom-8gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG[] = "bayer-qcom-8grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB[] = "bayer-qcom-8rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR[] = "bayer-qcom-8bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG[] = "bayer-qcom-10gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG[] = "bayer-qcom-10grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB[] = "bayer-qcom-10rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR[] = "bayer-qcom-10bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG[] = "bayer-qcom-12gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG[] = "bayer-qcom-12grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB[] = "bayer-qcom-12rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR[] = "bayer-qcom-12bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_14GBRG[] = "bayer-qcom-14gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_14GRBG[] = "bayer-qcom-14grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_14RGGB[] = "bayer-qcom-14rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_14BGGR[] = "bayer-qcom-14bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG[] = "bayer-mipi-8gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG[] = "bayer-mipi-8grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB[] = "bayer-mipi-8rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR[] = "bayer-mipi-8bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG[] = "bayer-mipi-10gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG[] = "bayer-mipi-10grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB[] = "bayer-mipi-10rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR[] = "bayer-mipi-10bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG[] = "bayer-mipi-12gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG[] = "bayer-mipi-12grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB[] = "bayer-mipi-12rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR[] = "bayer-mipi-12bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_14GBRG[] = "bayer-mipi-14gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_14GRBG[] = "bayer-mipi-14grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_14RGGB[] = "bayer-mipi-14rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_14BGGR[] = "bayer-mipi-14bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG[] = "bayer-ideal-qcom-8gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG[] = "bayer-ideal-qcom-8grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB[] = "bayer-ideal-qcom-8rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR[] = "bayer-ideal-qcom-8bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG[] = "bayer-ideal-qcom-10gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG[] = "bayer-ideal-qcom-10grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB[] = "bayer-ideal-qcom-10rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR[] = "bayer-ideal-qcom-10bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG[] = "bayer-ideal-qcom-12gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG[] = "bayer-ideal-qcom-12grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB[] = "bayer-ideal-qcom-12rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR[] = "bayer-ideal-qcom-12bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_14GBRG[] = "bayer-ideal-qcom-14gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_14GRBG[] = "bayer-ideal-qcom-14grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_14RGGB[] = "bayer-ideal-qcom-14rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_14BGGR[] = "bayer-ideal-qcom-14bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG[] = "bayer-ideal-mipi-8gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG[] = "bayer-ideal-mipi-8grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB[] = "bayer-ideal-mipi-8rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR[] = "bayer-ideal-mipi-8bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG[] = "bayer-ideal-mipi-10gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG[] = "bayer-ideal-mipi-10grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB[] = "bayer-ideal-mipi-10rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR[] = "bayer-ideal-mipi-10bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG[] = "bayer-ideal-mipi-12gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG[] = "bayer-ideal-mipi-12grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB[] = "bayer-ideal-mipi-12rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR[] = "bayer-ideal-mipi-12bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_14GBRG[] = "bayer-ideal-mipi-14gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_14GRBG[] = "bayer-ideal-mipi-14grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_14RGGB[] = "bayer-ideal-mipi-14rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_14BGGR[] = "bayer-ideal-mipi-14bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG[] = "bayer-ideal-plain8-8gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG[] = "bayer-ideal-plain8-8grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB[] = "bayer-ideal-plain8-8rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR[] = "bayer-ideal-plain8-8bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG[] = "bayer-ideal-plain16-8gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG[] = "bayer-ideal-plain16-8grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB[] = "bayer-ideal-plain16-8rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR[] = "bayer-ideal-plain16-8bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG[] = "bayer-ideal-plain16-10gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG[] = "bayer-ideal-plain16-10grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB[] = "bayer-ideal-plain16-10rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR[] = "bayer-ideal-plain16-10bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG[] = "bayer-ideal-plain16-12gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG[] = "bayer-ideal-plain16-12grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB[] = "bayer-ideal-plain16-12rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR[] = "bayer-ideal-plain16-12bggr";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_14GBRG[] = "bayer-ideal-plain16-14gbrg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_14GRBG[] = "bayer-ideal-plain16-14grbg";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_14RGGB[] = "bayer-ideal-plain16-14rggb";
const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_14BGGR[] = "bayer-ideal-plain16-14bggr";
// Values for ISO Settings
const char QCameraParameters::ISO_AUTO[] = "auto";
const char QCameraParameters::ISO_100[] = "ISO100";
const char QCameraParameters::ISO_200[] = "ISO200";
const char QCameraParameters::ISO_400[] = "ISO400";
const char QCameraParameters::ISO_800[] = "ISO800";
const char QCameraParameters::ISO_1600[] = "ISO1600";
const char QCameraParameters::ISO_3200[] = "ISO3200";
const char QCameraParameters::ISO_MANUAL[] = "manual";
// Values for auto exposure settings.
const char QCameraParameters::AUTO_EXPOSURE_FRAME_AVG[] = "frame-average";
const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED[] = "center-weighted";
const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING[] = "spot-metering";
const char QCameraParameters::AUTO_EXPOSURE_SMART_METERING[] = "smart-metering";
const char QCameraParameters::AUTO_EXPOSURE_USER_METERING[] = "user-metering";
const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING_ADV[] = "spot-metering-adv";
const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED_ADV[] = "center-weighted-adv";
// Values for instant AEC modes
const char QCameraParameters::KEY_QC_INSTANT_AEC_DISABLE[] = "0";
const char QCameraParameters::KEY_QC_INSTANT_AEC_AGGRESSIVE_AEC[] = "1";
const char QCameraParameters::KEY_QC_INSTANT_AEC_FAST_AEC[] = "2";
// Values for instant capture modes
const char QCameraParameters::KEY_QC_INSTANT_CAPTURE_DISABLE[] = "0";
const char QCameraParameters::KEY_QC_INSTANT_CAPTURE_AGGRESSIVE_AEC[] = "1";
const char QCameraParameters::KEY_QC_INSTANT_CAPTURE_FAST_AEC[] = "2";
const char QCameraParameters::KEY_QC_GPS_LATITUDE_REF[] = "gps-latitude-ref";
const char QCameraParameters::KEY_QC_GPS_LONGITUDE_REF[] = "gps-longitude-ref";
const char QCameraParameters::KEY_QC_GPS_ALTITUDE_REF[] = "gps-altitude-ref";
const char QCameraParameters::KEY_QC_GPS_STATUS[] = "gps-status";
const char QCameraParameters::KEY_QC_HISTOGRAM[] = "histogram";
const char QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES[] = "histogram-values";
const char QCameraParameters::VALUE_ENABLE[] = "enable";
const char QCameraParameters::VALUE_DISABLE[] = "disable";
const char QCameraParameters::VALUE_OFF[] = "off";
const char QCameraParameters::VALUE_ON[] = "on";
const char QCameraParameters::VALUE_TRUE[] = "true";
const char QCameraParameters::VALUE_FALSE[] = "false";
const char QCameraParameters::VALUE_FAST[] = "fast";
const char QCameraParameters::VALUE_HIGH_QUALITY[] = "high-quality";
const char QCameraParameters::KEY_QC_SHARPNESS[] = "sharpness";
const char QCameraParameters::KEY_QC_MIN_SHARPNESS[] = "min-sharpness";
const char QCameraParameters::KEY_QC_MAX_SHARPNESS[] = "max-sharpness";
const char QCameraParameters::KEY_QC_SHARPNESS_STEP[] = "sharpness-step";
const char QCameraParameters::KEY_QC_CONTRAST[] = "contrast";
const char QCameraParameters::KEY_QC_MIN_CONTRAST[] = "min-contrast";
const char QCameraParameters::KEY_QC_MAX_CONTRAST[] = "max-contrast";
const char QCameraParameters::KEY_QC_CONTRAST_STEP[] = "contrast-step";
const char QCameraParameters::KEY_QC_SATURATION[] = "saturation";
const char QCameraParameters::KEY_QC_MIN_SATURATION[] = "min-saturation";
const char QCameraParameters::KEY_QC_MAX_SATURATION[] = "max-saturation";
const char QCameraParameters::KEY_QC_SATURATION_STEP[] = "saturation-step";
const char QCameraParameters::KEY_QC_BRIGHTNESS[] = "luma-adaptation";
const char QCameraParameters::KEY_QC_MIN_BRIGHTNESS[] = "min-brightness";
const char QCameraParameters::KEY_QC_MAX_BRIGHTNESS[] = "max-brightness";
const char QCameraParameters::KEY_QC_BRIGHTNESS_STEP[] = "brightness-step";
const char QCameraParameters::KEY_QC_SCE_FACTOR[] = "skinToneEnhancement";
const char QCameraParameters::KEY_QC_MIN_SCE_FACTOR[] = "min-sce-factor";
const char QCameraParameters::KEY_QC_MAX_SCE_FACTOR[] = "max-sce-factor";
const char QCameraParameters::KEY_QC_SCE_FACTOR_STEP[] = "sce-factor-step";
const char QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES[] = "qc-max-num-requested-faces";
//Values for DENOISE
const char QCameraParameters::DENOISE_OFF[] = "denoise-off";
const char QCameraParameters::DENOISE_ON[] = "denoise-on";
// Values for selectable zone af Settings
const char QCameraParameters::FOCUS_ALGO_AUTO[] = "auto";
const char QCameraParameters::FOCUS_ALGO_SPOT_METERING[] = "spot-metering";
const char QCameraParameters::FOCUS_ALGO_CENTER_WEIGHTED[] = "center-weighted";
const char QCameraParameters::FOCUS_ALGO_FRAME_AVERAGE[] = "frame-average";
// Values for HFR settings.
const char QCameraParameters::VIDEO_HFR_OFF[] = "off";
const char QCameraParameters::VIDEO_HFR_2X[] = "60";
const char QCameraParameters::VIDEO_HFR_3X[] = "90";
const char QCameraParameters::VIDEO_HFR_4X[] = "120";
const char QCameraParameters::VIDEO_HFR_5X[] = "150";
const char QCameraParameters::VIDEO_HFR_6X[] = "180";
const char QCameraParameters::VIDEO_HFR_7X[] = "210";
const char QCameraParameters::VIDEO_HFR_8X[] = "240";
const char QCameraParameters::VIDEO_HFR_9X[] = "480";
// Values for HDR Bracketing settings.
const char QCameraParameters::AE_BRACKET_OFF[] = "Off";
const char QCameraParameters::AE_BRACKET[] = "AE-Bracket";
// Values for AF Bracketing setting.
const char QCameraParameters::AF_BRACKET_OFF[] = "af-bracket-off";
const char QCameraParameters::AF_BRACKET_ON[] = "af-bracket-on";
// Values for Refocus setting.
const char QCameraParameters::RE_FOCUS_OFF[] = "re-focus-off";
const char QCameraParameters::RE_FOCUS_ON[] = "re-focus-on";
// Values for Chroma Flash setting.
const char QCameraParameters::CHROMA_FLASH_OFF[] = "chroma-flash-off";
const char QCameraParameters::CHROMA_FLASH_ON[] = "chroma-flash-on";
// Values for Opti Zoom setting.
const char QCameraParameters::OPTI_ZOOM_OFF[] = "opti-zoom-off";
const char QCameraParameters::OPTI_ZOOM_ON[] = "opti-zoom-on";
// Values for Still More setting.
const char QCameraParameters::STILL_MORE_OFF[] = "still-more-off";
const char QCameraParameters::STILL_MORE_ON[] = "still-more-on";
// Values for HDR mode setting.
const char QCameraParameters::HDR_MODE_SENSOR[] = "hdr-mode-sensor";
const char QCameraParameters::HDR_MODE_MULTI_FRAME[] = "hdr-mode-multiframe";
// Values for True Portrait setting.
const char QCameraParameters::TRUE_PORTRAIT_OFF[] = "true-portrait-off";
const char QCameraParameters::TRUE_PORTRAIT_ON[] = "true-portrait-on";
// Values for FLIP settings.
const char QCameraParameters::FLIP_MODE_OFF[] = "off";
const char QCameraParameters::FLIP_MODE_V[] = "flip-v";
const char QCameraParameters::FLIP_MODE_H[] = "flip-h";
const char QCameraParameters::FLIP_MODE_VH[] = "flip-vh";
const char QCameraParameters::CDS_MODE_OFF[] = "off";
const char QCameraParameters::CDS_MODE_ON[] = "on";
const char QCameraParameters::CDS_MODE_AUTO[] = "auto";
// Values for video rotation settings.
const char QCameraParameters::VIDEO_ROTATION_0[] = "0";
const char QCameraParameters::VIDEO_ROTATION_90[] = "90";
const char QCameraParameters::VIDEO_ROTATION_180[] = "180";
const char QCameraParameters::VIDEO_ROTATION_270[] = "270";
const char QCameraParameters::KEY_QC_SUPPORTED_MANUAL_FOCUS_MODES[] = "manual-focus-modes";
const char QCameraParameters::KEY_QC_SUPPORTED_MANUAL_EXPOSURE_MODES[] = "manual-exposure-modes";
const char QCameraParameters::KEY_QC_SUPPORTED_MANUAL_WB_MODES[] = "manual-wb-modes";
const char QCameraParameters::KEY_QC_FOCUS_SCALE_MODE[] = "scale-mode";
const char QCameraParameters::KEY_QC_FOCUS_DIOPTER_MODE[] = "diopter-mode";
const char QCameraParameters::KEY_QC_ISO_PRIORITY[] = "iso-priority";
const char QCameraParameters::KEY_QC_EXP_TIME_PRIORITY[] = "exp-time-priority";
const char QCameraParameters::KEY_QC_USER_SETTING[] = "user-setting";
const char QCameraParameters::KEY_QC_WB_CCT_MODE[] = "color-temperature";
const char QCameraParameters::KEY_QC_WB_GAIN_MODE[] = "rbgb-gains";
const char QCameraParameters::KEY_QC_NOISE_REDUCTION_MODE[] = "noise-reduction-mode";
const char QCameraParameters::KEY_QC_NOISE_REDUCTION_MODE_VALUES[] = "noise-reduction-mode-values";
#ifdef TARGET_TS_MAKEUP
const char QCameraParameters::KEY_TS_MAKEUP[] = "tsmakeup";
const char QCameraParameters::KEY_TS_MAKEUP_WHITEN[] = "tsmakeup_whiten";
const char QCameraParameters::KEY_TS_MAKEUP_CLEAN[] = "tsmakeup_clean";
#endif
//KEY to share HFR batch size with video encoder.
const char QCameraParameters::KEY_QC_VIDEO_BATCH_SIZE[] = "video-batch-size";
static const char* portrait = "portrait";
static const char* landscape = "landscape";
const cam_dimension_t QCameraParameters::THUMBNAIL_SIZES_MAP[] = {
{ 256, 154 }, //1.66233
{ 240, 160 }, //1.5
{ 320, 320 }, //1.0
{ 320, 240 }, //1.33333
{ 256, 144 }, //1.777778
{ 240, 144 }, //1.666667
{ 176, 144 }, //1.222222
/*Thumbnail sizes to match portrait picture size aspect ratio*/
{ 240, 320 }, //to match 480X640 & 240X320 picture size
{ 144, 176 }, //to match 144X176 picture size
{ 0, 0 } // required by Android SDK
};
const QCameraParameters::QCameraMap<cam_auto_exposure_mode_type>
QCameraParameters::AUTO_EXPOSURE_MAP[] = {
{ AUTO_EXPOSURE_FRAME_AVG, CAM_AEC_MODE_FRAME_AVERAGE },
{ AUTO_EXPOSURE_CENTER_WEIGHTED, CAM_AEC_MODE_CENTER_WEIGHTED },
{ AUTO_EXPOSURE_SPOT_METERING, CAM_AEC_MODE_SPOT_METERING },
{ AUTO_EXPOSURE_SMART_METERING, CAM_AEC_MODE_SMART_METERING },
{ AUTO_EXPOSURE_USER_METERING, CAM_AEC_MODE_USER_METERING },
{ AUTO_EXPOSURE_SPOT_METERING_ADV, CAM_AEC_MODE_SPOT_METERING_ADV },
{ AUTO_EXPOSURE_CENTER_WEIGHTED_ADV, CAM_AEC_MODE_CENTER_WEIGHTED_ADV },
};
const QCameraParameters::QCameraMap<cam_aec_convergence_type>
QCameraParameters::INSTANT_AEC_MODES_MAP[] = {
{ KEY_QC_INSTANT_AEC_DISABLE, CAM_AEC_NORMAL_CONVERGENCE },
{ KEY_QC_INSTANT_AEC_AGGRESSIVE_AEC, CAM_AEC_AGGRESSIVE_CONVERGENCE },
{ KEY_QC_INSTANT_AEC_FAST_AEC, CAM_AEC_FAST_CONVERGENCE },
};
const QCameraParameters::QCameraMap<cam_aec_convergence_type>
QCameraParameters::INSTANT_CAPTURE_MODES_MAP[] = {
{ KEY_QC_INSTANT_CAPTURE_DISABLE, CAM_AEC_NORMAL_CONVERGENCE },
{ KEY_QC_INSTANT_CAPTURE_AGGRESSIVE_AEC, CAM_AEC_AGGRESSIVE_CONVERGENCE },
{ KEY_QC_INSTANT_CAPTURE_FAST_AEC, CAM_AEC_FAST_CONVERGENCE },
};
const QCameraParameters::QCameraMap<cam_format_t>
QCameraParameters::PREVIEW_FORMATS_MAP[] = {
{PIXEL_FORMAT_YUV420SP, CAM_FORMAT_YUV_420_NV21},
{PIXEL_FORMAT_YUV420P, CAM_FORMAT_YUV_420_YV12},
{PIXEL_FORMAT_YUV420SP_ADRENO, CAM_FORMAT_YUV_420_NV21_ADRENO},
{PIXEL_FORMAT_YV12, CAM_FORMAT_YUV_420_YV12},
{PIXEL_FORMAT_NV12, CAM_FORMAT_YUV_420_NV12},
{QC_PIXEL_FORMAT_NV12_VENUS, CAM_FORMAT_YUV_420_NV12_VENUS}
};
const QCameraParameters::QCameraMap<cam_format_t>
QCameraParameters::PICTURE_TYPES_MAP[] = {
{PIXEL_FORMAT_JPEG, CAM_FORMAT_JPEG},
{PIXEL_FORMAT_YUV420SP, CAM_FORMAT_YUV_420_NV21},
{PIXEL_FORMAT_YUV422SP, CAM_FORMAT_YUV_422_NV16},
{QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV, CAM_FORMAT_YUV_RAW_8BIT_YUYV},
{QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU, CAM_FORMAT_YUV_RAW_8BIT_YVYU},
{QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY, CAM_FORMAT_YUV_RAW_8BIT_UYVY},
{QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY, CAM_FORMAT_YUV_RAW_8BIT_VYUY},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR, CAM_FORMAT_BAYER_QCOM_RAW_8BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR, CAM_FORMAT_BAYER_QCOM_RAW_10BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR, CAM_FORMAT_BAYER_QCOM_RAW_12BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_14GBRG, CAM_FORMAT_BAYER_QCOM_RAW_14BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_14GRBG, CAM_FORMAT_BAYER_QCOM_RAW_14BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_14RGGB, CAM_FORMAT_BAYER_QCOM_RAW_14BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_QCOM_RAW_14BGGR, CAM_FORMAT_BAYER_QCOM_RAW_14BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR, CAM_FORMAT_BAYER_MIPI_RAW_8BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR, CAM_FORMAT_BAYER_MIPI_RAW_10BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR, CAM_FORMAT_BAYER_MIPI_RAW_12BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_14GBRG, CAM_FORMAT_BAYER_MIPI_RAW_14BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_14GRBG, CAM_FORMAT_BAYER_MIPI_RAW_14BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_14RGGB, CAM_FORMAT_BAYER_MIPI_RAW_14BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_MIPI_RAW_14BGGR, CAM_FORMAT_BAYER_MIPI_RAW_14BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_14GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_14BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_14GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_14BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_14RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_14BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_14BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_14BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_14GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_14BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_14GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_14BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_14RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_14BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_14BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_14BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_BGGR},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_14GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_14BPP_GBRG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_14GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_14BPP_GRBG},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_14RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_14BPP_RGGB},
{QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_14BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_14BPP_BGGR}
};
const QCameraParameters::QCameraMap<cam_focus_mode_type>
QCameraParameters::FOCUS_MODES_MAP[] = {
{ FOCUS_MODE_AUTO, CAM_FOCUS_MODE_AUTO },
{ FOCUS_MODE_INFINITY, CAM_FOCUS_MODE_INFINITY },
{ FOCUS_MODE_MACRO, CAM_FOCUS_MODE_MACRO },
{ FOCUS_MODE_FIXED, CAM_FOCUS_MODE_FIXED },
{ FOCUS_MODE_EDOF, CAM_FOCUS_MODE_EDOF },
{ FOCUS_MODE_CONTINUOUS_PICTURE, CAM_FOCUS_MODE_CONTINOUS_PICTURE },
{ FOCUS_MODE_CONTINUOUS_VIDEO, CAM_FOCUS_MODE_CONTINOUS_VIDEO },
{ FOCUS_MODE_MANUAL_POSITION, CAM_FOCUS_MODE_MANUAL},
};
const QCameraParameters::QCameraMap<cam_effect_mode_type>
QCameraParameters::EFFECT_MODES_MAP[] = {
{ EFFECT_NONE, CAM_EFFECT_MODE_OFF },
{ EFFECT_MONO, CAM_EFFECT_MODE_MONO },
{ EFFECT_NEGATIVE, CAM_EFFECT_MODE_NEGATIVE },
{ EFFECT_SOLARIZE, CAM_EFFECT_MODE_SOLARIZE },
{ EFFECT_SEPIA, CAM_EFFECT_MODE_SEPIA },
{ EFFECT_POSTERIZE, CAM_EFFECT_MODE_POSTERIZE },
{ EFFECT_WHITEBOARD, CAM_EFFECT_MODE_WHITEBOARD },
{ EFFECT_BLACKBOARD, CAM_EFFECT_MODE_BLACKBOARD },
{ EFFECT_AQUA, CAM_EFFECT_MODE_AQUA },
{ EFFECT_EMBOSS, CAM_EFFECT_MODE_EMBOSS },
{ EFFECT_SKETCH, CAM_EFFECT_MODE_SKETCH },
{ EFFECT_NEON, CAM_EFFECT_MODE_NEON },
{ EFFECT_BEAUTY, CAM_EFFECT_MODE_BEAUTY }
};
const QCameraParameters::QCameraMap<cam_scene_mode_type>
QCameraParameters::SCENE_MODES_MAP[] = {
{ SCENE_MODE_AUTO, CAM_SCENE_MODE_OFF },
{ SCENE_MODE_ACTION, CAM_SCENE_MODE_ACTION },
{ SCENE_MODE_PORTRAIT, CAM_SCENE_MODE_PORTRAIT },
{ SCENE_MODE_LANDSCAPE, CAM_SCENE_MODE_LANDSCAPE },
{ SCENE_MODE_NIGHT, CAM_SCENE_MODE_NIGHT },
{ SCENE_MODE_NIGHT_PORTRAIT, CAM_SCENE_MODE_NIGHT_PORTRAIT },
{ SCENE_MODE_THEATRE, CAM_SCENE_MODE_THEATRE },
{ SCENE_MODE_BEACH, CAM_SCENE_MODE_BEACH },
{ SCENE_MODE_SNOW, CAM_SCENE_MODE_SNOW },
{ SCENE_MODE_SUNSET, CAM_SCENE_MODE_SUNSET },
{ SCENE_MODE_STEADYPHOTO, CAM_SCENE_MODE_ANTISHAKE },
{ SCENE_MODE_FIREWORKS , CAM_SCENE_MODE_FIREWORKS },
{ SCENE_MODE_SPORTS , CAM_SCENE_MODE_SPORTS },
{ SCENE_MODE_PARTY, CAM_SCENE_MODE_PARTY },
{ SCENE_MODE_CANDLELIGHT, CAM_SCENE_MODE_CANDLELIGHT },
{ SCENE_MODE_ASD, CAM_SCENE_MODE_AUTO },
{ SCENE_MODE_BACKLIGHT, CAM_SCENE_MODE_BACKLIGHT },
{ SCENE_MODE_FLOWERS, CAM_SCENE_MODE_FLOWERS },
{ SCENE_MODE_AR, CAM_SCENE_MODE_AR },
{ SCENE_MODE_HDR, CAM_SCENE_MODE_HDR },
};
const QCameraParameters::QCameraMap<cam_flash_mode_t>
QCameraParameters::FLASH_MODES_MAP[] = {
{ FLASH_MODE_OFF, CAM_FLASH_MODE_OFF },
{ FLASH_MODE_AUTO, CAM_FLASH_MODE_AUTO },
{ FLASH_MODE_ON, CAM_FLASH_MODE_ON },
{ FLASH_MODE_TORCH, CAM_FLASH_MODE_TORCH }
};
const QCameraParameters::QCameraMap<cam_focus_algorithm_type>
QCameraParameters::FOCUS_ALGO_MAP[] = {
{ FOCUS_ALGO_AUTO, CAM_FOCUS_ALGO_AUTO },
{ FOCUS_ALGO_SPOT_METERING, CAM_FOCUS_ALGO_SPOT },
{ FOCUS_ALGO_CENTER_WEIGHTED, CAM_FOCUS_ALGO_CENTER_WEIGHTED },
{ FOCUS_ALGO_FRAME_AVERAGE, CAM_FOCUS_ALGO_AVERAGE }
};
const QCameraParameters::QCameraMap<cam_wb_mode_type>
QCameraParameters::WHITE_BALANCE_MODES_MAP[] = {
{ WHITE_BALANCE_AUTO, CAM_WB_MODE_AUTO },
{ WHITE_BALANCE_INCANDESCENT, CAM_WB_MODE_INCANDESCENT },
{ WHITE_BALANCE_FLUORESCENT, CAM_WB_MODE_FLUORESCENT },
{ WHITE_BALANCE_WARM_FLUORESCENT,CAM_WB_MODE_WARM_FLUORESCENT},
{ WHITE_BALANCE_DAYLIGHT, CAM_WB_MODE_DAYLIGHT },
{ WHITE_BALANCE_CLOUDY_DAYLIGHT, CAM_WB_MODE_CLOUDY_DAYLIGHT },
{ WHITE_BALANCE_TWILIGHT, CAM_WB_MODE_TWILIGHT },
{ WHITE_BALANCE_SHADE, CAM_WB_MODE_SHADE },
{ WHITE_BALANCE_MANUAL, CAM_WB_MODE_MANUAL},
};
const QCameraParameters::QCameraMap<cam_antibanding_mode_type>
QCameraParameters::ANTIBANDING_MODES_MAP[] = {
{ ANTIBANDING_OFF, CAM_ANTIBANDING_MODE_OFF },
{ ANTIBANDING_50HZ, CAM_ANTIBANDING_MODE_50HZ },
{ ANTIBANDING_60HZ, CAM_ANTIBANDING_MODE_60HZ },
{ ANTIBANDING_AUTO, CAM_ANTIBANDING_MODE_AUTO }
};
const QCameraParameters::QCameraMap<cam_iso_mode_type>
QCameraParameters::ISO_MODES_MAP[] = {
{ ISO_AUTO, CAM_ISO_MODE_AUTO },
{ ISO_HJR, CAM_ISO_MODE_DEBLUR },
{ ISO_100, CAM_ISO_MODE_100 },
{ ISO_200, CAM_ISO_MODE_200 },
{ ISO_400, CAM_ISO_MODE_400 },
{ ISO_800, CAM_ISO_MODE_800 },
{ ISO_1600, CAM_ISO_MODE_1600 },
{ ISO_3200, CAM_ISO_MODE_3200 }
};
const QCameraParameters::QCameraMap<cam_hfr_mode_t>
QCameraParameters::HFR_MODES_MAP[] = {
{ VIDEO_HFR_OFF, CAM_HFR_MODE_OFF },
{ VIDEO_HFR_2X, CAM_HFR_MODE_60FPS },
{ VIDEO_HFR_3X, CAM_HFR_MODE_90FPS },
{ VIDEO_HFR_4X, CAM_HFR_MODE_120FPS },
{ VIDEO_HFR_5X, CAM_HFR_MODE_150FPS },
{ VIDEO_HFR_6X, CAM_HFR_MODE_180FPS },
{ VIDEO_HFR_7X, CAM_HFR_MODE_210FPS },
{ VIDEO_HFR_8X, CAM_HFR_MODE_240FPS },
{ VIDEO_HFR_9X, CAM_HFR_MODE_480FPS }
};
const QCameraParameters::QCameraMap<cam_bracket_mode>
QCameraParameters::BRACKETING_MODES_MAP[] = {
{ AE_BRACKET_OFF, CAM_EXP_BRACKETING_OFF },
{ AE_BRACKET, CAM_EXP_BRACKETING_ON }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::ON_OFF_MODES_MAP[] = {
{ VALUE_OFF, 0 },
{ VALUE_ON, 1 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::TOUCH_AF_AEC_MODES_MAP[] = {
{ QCameraParameters::TOUCH_AF_AEC_OFF, 0 },
{ QCameraParameters::TOUCH_AF_AEC_ON, 1 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::ENABLE_DISABLE_MODES_MAP[] = {
{ VALUE_ENABLE, 1 },
{ VALUE_DISABLE, 0 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::DENOISE_ON_OFF_MODES_MAP[] = {
{ DENOISE_OFF, 0 },
{ DENOISE_ON, 1 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::TRUE_FALSE_MODES_MAP[] = {
{ VALUE_FALSE, 0},
{ VALUE_TRUE, 1}
};
const QCameraParameters::QCameraMap<cam_flip_t>
QCameraParameters::FLIP_MODES_MAP[] = {
{FLIP_MODE_OFF, FLIP_NONE},
{FLIP_MODE_V, FLIP_V},
{FLIP_MODE_H, FLIP_H},
{FLIP_MODE_VH, FLIP_V_H}
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::AF_BRACKETING_MODES_MAP[] = {
{ AF_BRACKET_OFF, 0 },
{ AF_BRACKET_ON, 1 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::RE_FOCUS_MODES_MAP[] = {
{ RE_FOCUS_OFF, 0 },
{ RE_FOCUS_ON, 1 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::CHROMA_FLASH_MODES_MAP[] = {
{ CHROMA_FLASH_OFF, 0 },
{ CHROMA_FLASH_ON, 1 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::OPTI_ZOOM_MODES_MAP[] = {
{ OPTI_ZOOM_OFF, 0 },
{ OPTI_ZOOM_ON, 1 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::TRUE_PORTRAIT_MODES_MAP[] = {
{ TRUE_PORTRAIT_OFF, 0 },
{ TRUE_PORTRAIT_ON, 1 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::STILL_MORE_MODES_MAP[] = {
{ STILL_MORE_OFF, 0 },
{ STILL_MORE_ON, 1 }
};
const QCameraParameters::QCameraMap<cam_cds_mode_type_t>
QCameraParameters::CDS_MODES_MAP[] = {
{ CDS_MODE_OFF, CAM_CDS_MODE_OFF },
{ CDS_MODE_ON, CAM_CDS_MODE_ON },
{ CDS_MODE_AUTO, CAM_CDS_MODE_AUTO}
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::HDR_MODES_MAP[] = {
{ HDR_MODE_SENSOR, 0 },
{ HDR_MODE_MULTI_FRAME, 1 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::VIDEO_ROTATION_MODES_MAP[] = {
{ VIDEO_ROTATION_0, 0 },
{ VIDEO_ROTATION_90, 90 },
{ VIDEO_ROTATION_180, 180 },
{ VIDEO_ROTATION_270, 270 }
};
const QCameraParameters::QCameraMap<int>
QCameraParameters::NOISE_REDUCTION_MODES_MAP[] = {
{ VALUE_OFF, 0 },
{ VALUE_FAST, 1 },
{ VALUE_HIGH_QUALITY, 2 }
};
#define DEFAULT_CAMERA_AREA "(0, 0, 0, 0, 0)"
#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
#define TOTAL_RAM_SIZE_512MB 536870912
#define PARAM_MAP_SIZE(MAP) (sizeof(MAP)/sizeof(MAP[0]))
/*===========================================================================
* FUNCTION : isOEMFeat1PropEnabled
*
* DESCRIPTION: inline function to check from property if custom feature
* is enabled
*
* PARAMETERS : none
*
* RETURN : boolean true/false
*==========================================================================*/
static inline bool isOEMFeat1PropEnabled()
{
char value[PROPERTY_VALUE_MAX];
property_get("persist.camera.imglib.oemfeat1", value, "0");
return atoi(value) > 0 ? true : false;
}
/*===========================================================================
* FUNCTION : QCameraParameters
*
* DESCRIPTION: default constructor of QCameraParameters
*
* PARAMETERS : none
*
* RETURN : None
*==========================================================================*/
QCameraParameters::QCameraParameters()
: CameraParameters(),
m_reprocScaleParam(),
mCommon(),
m_pCapability(NULL),
m_pCamOpsTbl(NULL),
m_pParamHeap(NULL),
m_pParamBuf(NULL),
m_pRelCamSyncHeap(NULL),
m_pRelCamSyncBuf(NULL),
m_bFrameSyncEnabled(false),
mIsType(IS_TYPE_NONE),
m_bZslMode(false),
m_bZslMode_new(false),
m_bForceZslMode(false),
m_bRecordingHint(false),
m_bRecordingHint_new(false),
m_bHistogramEnabled(false),
m_bLongshotEnabled(false),
m_nFaceProcMask(0),
m_bFaceDetectionOn(0),
m_bDebugFps(false),
mFocusMode(CAM_FOCUS_MODE_MAX),
mPreviewFormat(CAM_FORMAT_YUV_420_NV21),
mAppPreviewFormat(CAM_FORMAT_YUV_420_NV21),
mPictureFormat(CAM_FORMAT_JPEG),
m_bNeedRestart(false),
m_bNoDisplayMode(false),
m_bWNROn(false),
m_bTNRPreviewOn(false),
m_bTNRVideoOn(false),
m_bTNRSnapshotOn(false),
m_bInited(false),
m_nRetroBurstNum(0),
m_nBurstLEDOnPeriod(100),
m_bUpdateEffects(false),
m_bSceneTransitionAuto(false),
m_bPreviewFlipChanged(false),
m_bVideoFlipChanged(false),
m_bSnapshotFlipChanged(false),
m_bFixedFrameRateSet(false),
m_bHDREnabled(false),
m_bLocalHDREnabled(false),
m_bAVTimerEnabled(false),
m_bDISEnabled(false),
m_MobiMask(0),
m_AdjustFPS(NULL),
m_bHDR1xFrameEnabled(false),
m_HDRSceneEnabled(false),
m_bHDRThumbnailProcessNeeded(false),
m_bHDR1xExtraBufferNeeded(true),
m_bHDROutputCropEnabled(false),
m_tempMap(),
m_bAFBracketingOn(false),
m_bReFocusOn(false),
m_bChromaFlashOn(false),
m_bOptiZoomOn(false),
m_bSceneSelection(false),
m_SelectedScene(CAM_SCENE_MODE_MAX),
m_bSeeMoreOn(false),
m_bStillMoreOn(false),
m_bHighQualityNoiseReductionMode(false),
m_bHfrMode(false),
m_bSensorHDREnabled(false),
m_bRdiMode(false),
m_bSecureMode(false),
m_bAeBracketingEnabled(false),
mFlashValue(CAM_FLASH_MODE_OFF),
mFlashDaemonValue(CAM_FLASH_MODE_OFF),
mHfrMode(CAM_HFR_MODE_OFF),
m_bHDRModeSensor(true),
mOfflineRAW(false),
m_bTruePortraitOn(false),
m_bIsLowMemoryDevice(false),
mCds_mode(CAM_CDS_MODE_OFF),
m_LLCaptureEnabled(FALSE),
m_LowLightLevel(CAM_LOW_LIGHT_OFF),
m_bLtmForSeeMoreEnabled(false),
m_expTime(0),
m_isoValue(0),
m_ManualCaptureMode(CAM_MANUAL_CAPTURE_TYPE_OFF),
m_dualLedCalibration(0),
m_bInstantAEC(false),
m_bInstantCapture(false),
mAecFrameBound(0),
mAecSkipDisplayFrameBound(0)
{
char value[PROPERTY_VALUE_MAX];
// TODO: may move to parameter instead of sysprop
property_get("persist.debug.sf.showfps", value, "0");
m_bDebugFps = atoi(value) > 0 ? true : false;
// For thermal mode, it should be set as system property
// because system property applies to all applications, while
// parameters only apply to specific app.
property_get("persist.camera.thermal.mode", value, "fps");
if (!strcmp(value, "frameskip")) {
m_ThermalMode = QCAMERA_THERMAL_ADJUST_FRAMESKIP;
} else {
if (strcmp(value, "fps"))
LOGW("Invalid camera thermal mode %s", value);
m_ThermalMode = QCAMERA_THERMAL_ADJUST_FPS;
}
memset(value, 0, sizeof(value));
// As per Power/Quality evaluation, LTM is enabled by default in SeeMore/StillMore usecase
// to improve the quality as there is no much impact to power
property_get("persist.camera.ltmforseemore", value, "1");
m_bLtmForSeeMoreEnabled = atoi(value);
memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize));
memset(&m_default_fps_range, 0, sizeof(m_default_fps_range));
memset(&m_hfrFpsRange, 0, sizeof(m_hfrFpsRange));
memset(&m_stillmore_config, 0, sizeof(cam_still_more_t));
memset(&m_captureFrameConfig, 0, sizeof(cam_capture_frame_config_t));
memset(&m_relCamSyncInfo, 0, sizeof(cam_sync_related_sensors_event_info_t));
mTotalPPCount = 1;
mZoomLevel = 0;
mParmZoomLevel = 0;
mCurPPCount = 0;
mBufBatchCnt = 0;
mRotation = 0;
mJpegRotation = 0;
mVideoBatchSize = 0;
m_bOEMFeatEnabled = isOEMFeat1PropEnabled();
}
/*===========================================================================
* FUNCTION : QCameraParameters
*
* DESCRIPTION: constructor of QCameraParameters
*
* PARAMETERS :
* @params : parameters in string
*
* RETURN : None
*==========================================================================*/
QCameraParameters::QCameraParameters(const String8 ¶ms)
: CameraParameters(params),
m_reprocScaleParam(),
m_pCapability(NULL),
m_pCamOpsTbl(NULL),
m_pParamHeap(NULL),
m_pParamBuf(NULL),
m_pRelCamSyncHeap(NULL),
m_pRelCamSyncBuf(NULL),
m_bFrameSyncEnabled(false),
m_bZslMode(false),
m_bZslMode_new(false),
m_bForceZslMode(false),
m_bRecordingHint(false),
m_bRecordingHint_new(false),
m_bHistogramEnabled(false),
m_bLongshotEnabled(false),
m_nFaceProcMask(0),
m_bDebugFps(false),
mFocusMode(CAM_FOCUS_MODE_MAX),
mPreviewFormat(CAM_FORMAT_YUV_420_NV21),
mAppPreviewFormat(CAM_FORMAT_YUV_420_NV21),
mPictureFormat(CAM_FORMAT_JPEG),
m_bNeedRestart(false),
m_bNoDisplayMode(false),
m_bWNROn(false),
m_bTNRPreviewOn(false),
m_bTNRVideoOn(false),
m_bTNRSnapshotOn(false),
m_bInited(false),
m_nRetroBurstNum(0),
m_nBurstLEDOnPeriod(100),
m_bPreviewFlipChanged(false),
m_bVideoFlipChanged(false),
m_bSnapshotFlipChanged(false),
m_bFixedFrameRateSet(false),
m_bHDREnabled(false),
m_bLocalHDREnabled(false),
m_bAVTimerEnabled(false),
m_AdjustFPS(NULL),
m_bHDR1xFrameEnabled(false),
m_HDRSceneEnabled(false),
m_bHDRThumbnailProcessNeeded(false),
m_bHDR1xExtraBufferNeeded(true),
m_bHDROutputCropEnabled(false),
m_tempMap(),
m_bAFBracketingOn(false),
m_bReFocusOn(false),
m_bChromaFlashOn(false),
m_bOptiZoomOn(false),
m_bSceneSelection(false),
m_SelectedScene(CAM_SCENE_MODE_MAX),
m_bSeeMoreOn(false),
m_bStillMoreOn(false),
m_bHighQualityNoiseReductionMode(false),
m_bHfrMode(false),
m_bSensorHDREnabled(false),
m_bRdiMode(false),
m_bSecureMode(false),
m_bAeBracketingEnabled(false),
mFlashValue(CAM_FLASH_MODE_OFF),
mFlashDaemonValue(CAM_FLASH_MODE_OFF),
mHfrMode(CAM_HFR_MODE_OFF),
m_bHDRModeSensor(true),
mOfflineRAW(false),
m_bTruePortraitOn(false),
m_bIsLowMemoryDevice(false),
mCds_mode(CAM_CDS_MODE_OFF),
mParmEffect(CAM_EFFECT_MODE_OFF),
m_LLCaptureEnabled(FALSE),
m_LowLightLevel(CAM_LOW_LIGHT_OFF),
m_bLtmForSeeMoreEnabled(false),
m_expTime(0),
m_isoValue(0),
m_ManualCaptureMode(CAM_MANUAL_CAPTURE_TYPE_OFF),
m_dualLedCalibration(0),
m_bInstantAEC(false),
m_bInstantCapture(false),
mAecFrameBound(0),
mAecSkipDisplayFrameBound(0)
{
memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize));
memset(&m_default_fps_range, 0, sizeof(m_default_fps_range));
memset(&m_hfrFpsRange, 0, sizeof(m_hfrFpsRange));
memset(&m_stillmore_config, 0, sizeof(cam_still_more_t));
memset(&m_relCamSyncInfo, 0, sizeof(cam_sync_related_sensors_event_info_t));
mTotalPPCount = 0;
mZoomLevel = 0;
mParmZoomLevel = 0;
mCurPPCount = 0;
mRotation = 0;
mJpegRotation = 0;
mBufBatchCnt = 0;
mVideoBatchSize = 0;
m_bOEMFeatEnabled = isOEMFeat1PropEnabled();
}
/*===========================================================================
* FUNCTION : ~QCameraParameters
*
* DESCRIPTION: deconstructor of QCameraParameters
*
* PARAMETERS : none
*
* RETURN : None
*==========================================================================*/
QCameraParameters::~QCameraParameters()
{
deinit();
}
/*===========================================================================
* FUNCTION : createSizesString
*
* DESCRIPTION: create string obj contains array of dimensions
*
* PARAMETERS :
* @sizes : array of dimensions
* @len : size of dimension array
*
* RETURN : string obj
*==========================================================================*/
String8 QCameraParameters::createSizesString(const cam_dimension_t *sizes, size_t len)
{
String8 str;
char buffer[32];
if (len > 0) {
snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height);
str.append(buffer);
}
for (size_t i = 1; i < len; i++) {
snprintf(buffer, sizeof(buffer), ",%dx%d",
sizes[i].width, sizes[i].height);
str.append(buffer);
}
return str;
}
/*===========================================================================
* FUNCTION : createValuesString
*
* DESCRIPTION: create string obj contains array of values from map when matched
* from input values array
*
* PARAMETERS :
* @values : array of values
* @len : size of values array
* @map : map contains the mapping between values and enums
* @map_len : size of the map
*
* RETURN : string obj
*==========================================================================*/
template <typename valuesType, class mapType> String8 createValuesString(
const valuesType *values, size_t len, const mapType *map, size_t map_len)
{
String8 str;
int count = 0;
for (size_t i = 0; i < len; i++ ) {
for (size_t j = 0; j < map_len; j ++)
if (map[j].val == values[i]) {
if (NULL != map[j].desc) {
if (count > 0) {
str.append(",");
}
str.append(map[j].desc);
count++;
break; //loop j
}
}
}
return str;
}
/*===========================================================================
* FUNCTION : createValuesStringFromMap
*
* DESCRIPTION: create string obj contains array of values directly from map
*
* PARAMETERS :
* @map : map contains the mapping between values and enums
* @map_len : size of the map
*
* RETURN : string obj
*==========================================================================*/
template <class mapType> String8 createValuesStringFromMap(
const mapType *map, size_t map_len)
{
String8 str;
for (size_t i = 0; i < map_len; i++) {
if (NULL != map[i].desc) {
if (i > 0) {
str.append(",");
}
str.append(map[i].desc);
}
}
return str;
}
/*===========================================================================
* FUNCTION : createZoomRatioValuesString
*
* DESCRIPTION: create string obj contains array of zoom ratio values
*
* PARAMETERS :
* @zoomRaios : array of zoom ratios
* @length : size of the array
*
* RETURN : string obj
*==========================================================================*/
String8 QCameraParameters::createZoomRatioValuesString(uint32_t *zoomRatios,
size_t length)
{
String8 str;
char buffer[32] = {0};
if(length > 0){
snprintf(buffer, sizeof(buffer), "%d", zoomRatios[0]);
str.append(buffer);
}
for (size_t i = 1; i < length; i++) {
memset(buffer, 0, sizeof(buffer));
snprintf(buffer, sizeof(buffer), ",%d", zoomRatios[i]);
str.append(buffer);
}
return str;
}
/*===========================================================================
* FUNCTION : createHfrValuesString
*
* DESCRIPTION: create string obj contains array of hfr values from map when
* matched from input hfr values
*
* PARAMETERS :
* @values : array of hfr info
* @len : size of the array
* @map : map of hfr string value and enum
* map_len : size of map
*
* RETURN : string obj
*==========================================================================*/
String8 QCameraParameters::createHfrValuesString(const cam_hfr_info_t *values,
size_t len, const QCameraMap<cam_hfr_mode_t> *map, size_t map_len)
{
String8 str;
int count = 0;
char value[PROPERTY_VALUE_MAX];
int8_t batch_count = 0;
property_get("persist.camera.batchcount", value, "0");
batch_count = atoi(value);
for (size_t i = 0; i < len; i++ ) {
for (size_t j = 0; j < map_len; j ++) {
if ((batch_count < CAMERA_MIN_BATCH_COUNT)
&& (map[j].val > CAM_HFR_MODE_120FPS)) {
/*TODO: Work around. Need to revert when we have
complete 240fps support*/
break;
}
if (map[j].val == (int)values[i].mode) {
if (NULL != map[j].desc) {
if (count > 0) {
str.append(",");
}
str.append(map[j].desc);
count++;
break; //loop j
}
}
}
}
if (count > 0) {
str.append(",");
}
str.append(VIDEO_HFR_OFF);
return str;
}
/*===========================================================================
* FUNCTION : createHfrSizesString
*
* DESCRIPTION: create string obj contains array of hfr sizes
*
* PARAMETERS :
* @values : array of hfr info
* @len : size of the array
*
* RETURN : string obj
*==========================================================================*/
String8 QCameraParameters::createHfrSizesString(const cam_hfr_info_t *values, size_t len)
{
String8 str;
char buffer[32];
if (len > 0) {
snprintf(buffer, sizeof(buffer), "%dx%d",
values[0].dim[0].width, values[0].dim[0].height);
str.append(buffer);
}
for (size_t i = 1; i < len; i++) {
snprintf(buffer, sizeof(buffer), ",%dx%d",
values[i].dim[0].width, values[i].dim[0].height);
str.append(buffer);
}
return str;
}
/*===========================================================================
* FUNCTION : createFpsString
*
* DESCRIPTION: create string obj contains array of FPS rates
*
* PARAMETERS :
* @fps : default fps range
*
* RETURN : string obj
*==========================================================================*/
String8 QCameraParameters::createFpsString(cam_fps_range_t &fps)
{
char buffer[32];
String8 fpsValues;
int min_fps = int(fps.min_fps);
int max_fps = int(fps.max_fps);
if (min_fps < fps.min_fps){
min_fps++;
}
if (max_fps > fps.max_fps) {
max_fps--;
}
if (min_fps <= max_fps) {
snprintf(buffer, sizeof(buffer), "%d", min_fps);
fpsValues.append(buffer);
}
for (int i = min_fps+1; i <= max_fps; i++) {
snprintf(buffer, sizeof(buffer), ",%d", i);
fpsValues.append(buffer);
}
return fpsValues;
}
/*===========================================================================
* FUNCTION : createFpsRangeString
*
* DESCRIPTION: create string obj contains array of FPS ranges
*
* PARAMETERS :
* @fps : array of fps ranges
* @len : size of the array
* @default_fps_index : reference to index of default fps range
*
* RETURN : string obj
*==========================================================================*/
String8 QCameraParameters::createFpsRangeString(const cam_fps_range_t* fps,
size_t len, int &default_fps_index)
{
String8 str;
char buffer[32];
int max_range = 0;
int min_fps, max_fps;
if (len > 0) {
min_fps = int(fps[0].min_fps * 1000);
max_fps = int(fps[0].max_fps * 1000);
max_range = max_fps - min_fps;
default_fps_index = 0;
snprintf(buffer, sizeof(buffer), "(%d,%d)", min_fps, max_fps);
str.append(buffer);
}
for (size_t i = 1; i < len; i++) {
min_fps = int(fps[i].min_fps * 1000);
max_fps = int(fps[i].max_fps * 1000);
if (max_range < (max_fps - min_fps)) {
max_range = max_fps - min_fps;
default_fps_index = (int)i;
}
snprintf(buffer, sizeof(buffer), ",(%d,%d)", min_fps, max_fps);
str.append(buffer);
}
return str;
}
/*===========================================================================
* FUNCTION : lookupAttr
*
* DESCRIPTION: lookup a value by its name
*
* PARAMETERS :
* @attr : map contains <name, value>
* @len : size of the map
* @name : name to be looked up
*
* RETURN : valid value if found
* NAME_NOT_FOUND if not found
*==========================================================================*/
template <class mapType> int lookupAttr(const mapType *arr,
size_t len, const char *name)
{
if (name) {
for (size_t i = 0; i < len; i++) {
if (!strcmp(arr[i].desc, name))
return arr[i].val;
}
}
return NAME_NOT_FOUND;
}
/*===========================================================================
* FUNCTION : lookupNameByValue
*
* DESCRIPTION: lookup a name by its value
*
* PARAMETERS :
* @attr : map contains <name, value>
* @len : size of the map
* @value : value to be looked up
*
* RETURN : name str or NULL if not found
*==========================================================================*/
template <class mapType> const char *lookupNameByValue(const mapType *arr,
size_t len, int value)
{
for (size_t i = 0; i < len; i++) {
if (arr[i].val == value) {
return arr[i].desc;
}
}
return NULL;
}
/*===========================================================================
* FUNCTION : setPreviewSize
*
* DESCRIPTION: set preview size from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setPreviewSize(const QCameraParameters& params)
{
int width = 0, height = 0;
int old_width = 0, old_height = 0;
params.getPreviewSize(&width, &height);
CameraParameters::getPreviewSize(&old_width, &old_height);
// Validate the preview size
for (size_t i = 0; i < m_pCapability->preview_sizes_tbl_cnt; ++i) {
if (width == m_pCapability->preview_sizes_tbl[i].width
&& height == m_pCapability->preview_sizes_tbl[i].height) {
// check if need to restart preview in case of preview size change
if (width != old_width || height != old_height) {
LOGI("Requested preview size %d x %d", width, height);
m_bNeedRestart = true;
}
// set the new value
CameraParameters::setPreviewSize(width, height);
return NO_ERROR;
}
}
if (m_relCamSyncInfo.mode == CAM_MODE_SECONDARY) {
char prop[PROPERTY_VALUE_MAX];
// set prop to configure aux preview size
property_get("persist.camera.aux.preview.size", prop, "0");
parse_pair(prop, &width, &height, 'x', NULL);
bool foundMatch = false;
for (size_t i = 0; i < m_pCapability->preview_sizes_tbl_cnt; ++i) {
if (width == m_pCapability->preview_sizes_tbl[i].width &&
height == m_pCapability->preview_sizes_tbl[i].height) {
foundMatch = true;
}
}
if (!foundMatch) {
width = m_pCapability->preview_sizes_tbl[0].width;
height = m_pCapability->preview_sizes_tbl[0].height;
}
// check if need to restart preview in case of preview size change
if (width != old_width || height != old_height) {
m_bNeedRestart = true;
}
CameraParameters::setPreviewSize(width, height);
LOGH("Secondary Camera: preview size %d x %d", width, height);
return NO_ERROR;
}
LOGE("Invalid preview size requested: %dx%d", width, height);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setPictureSize
*
* DESCRIPTION: set picture size from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setPictureSize(const QCameraParameters& params)
{
int width, height;
params.getPictureSize(&width, &height);
int old_width, old_height;
CameraParameters::getPictureSize(&old_width, &old_height);
// Validate the picture size
if(!m_reprocScaleParam.isScaleEnabled()){
for (size_t i = 0; i < m_pCapability->picture_sizes_tbl_cnt; ++i) {
if (width == m_pCapability->picture_sizes_tbl[i].width
&& height == m_pCapability->picture_sizes_tbl[i].height) {
// check if need to restart preview in case of picture size change
if ((m_bZslMode || m_bRecordingHint) &&
(width != old_width || height != old_height)) {
LOGI("Requested picture size %d x %d", width, height);
m_bNeedRestart = true;
}
// set the new value
CameraParameters::setPictureSize(width, height);
// Update View angles based on Picture Aspect ratio
updateViewAngles();
return NO_ERROR;
}
}
}else{
//should use scaled picture size table to validate
if(m_reprocScaleParam.setValidatePicSize(width, height) == NO_ERROR){
// check if need to restart preview in case of picture size change
if ((m_bZslMode || m_bRecordingHint) &&
(width != old_width || height != old_height)) {
m_bNeedRestart = true;
}
// set the new value
char val[32];
snprintf(val, sizeof(val), "%dx%d", width, height);
updateParamEntry(KEY_PICTURE_SIZE, val);
LOGH("%s", val);
// Update View angles based on Picture Aspect ratio
updateViewAngles();
return NO_ERROR;
}
}
if (m_relCamSyncInfo.mode == CAM_MODE_SECONDARY) {
char prop[PROPERTY_VALUE_MAX];
// set prop to configure aux preview size
property_get("persist.camera.aux.picture.size", prop, "0");
parse_pair(prop, &width, &height, 'x', NULL);
bool foundMatch = false;
for (size_t i = 0; i < m_pCapability->picture_sizes_tbl_cnt; ++i) {
if (width == m_pCapability->picture_sizes_tbl[i].width &&
height == m_pCapability->picture_sizes_tbl[i].height) {
foundMatch = true;
}
}
if (!foundMatch) {
width = m_pCapability->picture_sizes_tbl[0].width;
height = m_pCapability->picture_sizes_tbl[0].height;
}
// check if need to restart preview in case of preview size change
if (width != old_width || height != old_height) {
m_bNeedRestart = true;
}
char val[32];
snprintf(val, sizeof(val), "%dx%d", width, height);
set(KEY_PICTURE_SIZE, val);
LOGH("Secondary Camera: picture size %s", val);
return NO_ERROR;
}
LOGE("Invalid picture size requested: %dx%d", width, height);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : updateViewAngles
*
* DESCRIPTION: Update the Horizontal & Vertical based on the Aspect ratio of Preview and
* Picture aspect ratio
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void QCameraParameters::updateViewAngles()
{
double stillAspectRatio, maxPictureAspectRatio;
int stillWidth, stillHeight, maxWidth, maxHeight;
// The crop factors from the full sensor array to the still picture crop region
double horizCropFactor = 1.f,vertCropFactor = 1.f;
float horizViewAngle, vertViewAngle, maxHfov, maxVfov;
// Get current Picture & max Snapshot sizes
getPictureSize(&stillWidth, &stillHeight);
maxWidth = m_pCapability->picture_sizes_tbl[0].width;
maxHeight = m_pCapability->picture_sizes_tbl[0].height;
// Get default maximum FOV from corresponding sensor driver
maxHfov = m_pCapability->hor_view_angle;
maxVfov = m_pCapability->ver_view_angle;
stillAspectRatio = (double)stillWidth/stillHeight;
maxPictureAspectRatio = (double)maxWidth/maxHeight;
LOGD("Stillwidth: %d, height: %d", stillWidth, stillHeight);
LOGD("Max width: %d, height: %d", maxWidth, maxHeight);
LOGD("still aspect: %f, Max Pic Aspect: %f",
stillAspectRatio, maxPictureAspectRatio);
// crop as per the Maximum Snapshot aspect ratio
if (stillAspectRatio < maxPictureAspectRatio)
horizCropFactor = stillAspectRatio/maxPictureAspectRatio;
else
vertCropFactor = maxPictureAspectRatio/stillAspectRatio;
LOGD("horizCropFactor %f, vertCropFactor %f",
horizCropFactor, vertCropFactor);
// Now derive the final FOV's based on field of view formula is i.e,
// angle of view = 2 * arctangent ( d / 2f )
// where d is the physical sensor dimension of interest, and f is
// the focal length. This only applies to rectilinear sensors, for focusing
// at distances >> f, etc.
// Here d/2f is nothing but the Maximum Horizontal or Veritical FOV
horizViewAngle = (180/PI)*2*atan(horizCropFactor*tan((maxHfov/2)*(PI/180)));
vertViewAngle = (180/PI)*2*atan(horizCropFactor*tan((maxVfov/2)*(PI/180)));
setFloat(QCameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizViewAngle);
setFloat(QCameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertViewAngle);
LOGH("Final horizViewAngle %f, vertViewAngle %f",
horizViewAngle, vertViewAngle);
}
/*===========================================================================
* FUNCTION : setVideoSize
*
* DESCRIPTION: set video size from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setVideoSize(const QCameraParameters& params)
{
const char *str= NULL;
int width, height;
str = params.get(KEY_VIDEO_SIZE);
int old_width, old_height;
CameraParameters::getVideoSize(&old_width, &old_height);
if(!str) {
//If application didn't set this parameter string, use the values from
//getPreviewSize() as video dimensions.
params.getPreviewSize(&width, &height);
LOGW("No Record Size requested, use the preview dimensions");
} else {
params.getVideoSize(&width, &height);
}
// Validate the video size
for (size_t i = 0; i < m_pCapability->video_sizes_tbl_cnt; ++i) {
if (width == m_pCapability->video_sizes_tbl[i].width
&& height == m_pCapability->video_sizes_tbl[i].height) {
// check if need to restart preview in case of video size change
if (m_bRecordingHint &&
(width != old_width || height != old_height)) {
m_bNeedRestart = true;
}
// set the new value
LOGH("Requested video size %d x %d", width, height);
CameraParameters::setVideoSize(width, height);
return NO_ERROR;
}
}
if (m_relCamSyncInfo.mode == CAM_MODE_SECONDARY) {
// Set the default preview size for secondary camera
width = m_pCapability->video_sizes_tbl[0].width;
height = m_pCapability->video_sizes_tbl[0].height;
// check if need to restart preview in case of preview size change
if (width != old_width || height != old_height) {
m_bNeedRestart = true;
}
CameraParameters::setVideoSize(width, height);
LOGH("Secondary Camera: video size %d x %d",
width, height);
return NO_ERROR;
}
LOGE("Error !! Invalid video size requested: %dx%d", width, height);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : getLiveSnapshotSize
*
* DESCRIPTION: get live snapshot size
*
* PARAMETERS : dim - Update dim with the liveshot size
*
*==========================================================================*/
void QCameraParameters::getLiveSnapshotSize(cam_dimension_t &dim)
{
if(is4k2kVideoResolution()) {
// We support maximum 8M liveshot @4K2K video resolution
cam_dimension_t resolution = {0, 0};
CameraParameters::getVideoSize(&resolution.width, &resolution.height);
if((m_LiveSnapshotSize.width > resolution.width) ||
(m_LiveSnapshotSize.height > resolution.height)) {
m_LiveSnapshotSize.width = resolution.width;
m_LiveSnapshotSize.height = resolution.height;
}
}
dim = m_LiveSnapshotSize;
LOGH("w x h: %d x %d", dim.width, dim.height);
}
/*===========================================================================
* FUNCTION : setLiveSnapshotSize
*
* DESCRIPTION: set live snapshot size
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setLiveSnapshotSize(const QCameraParameters& params)
{
char value[PROPERTY_VALUE_MAX];
property_get("persist.camera.opt.livepic", value, "1");
bool useOptimal = atoi(value) > 0 ? true : false;
bool vHdrOn;
int32_t liveSnapWidth = 0, liveSnapHeight = 0;
// use picture size from user setting
params.getPictureSize(&m_LiveSnapshotSize.width, &m_LiveSnapshotSize.height);
size_t livesnapshot_sizes_tbl_cnt =
m_pCapability->livesnapshot_sizes_tbl_cnt;
cam_dimension_t *livesnapshot_sizes_tbl =
&m_pCapability->livesnapshot_sizes_tbl[0];
if(is4k2kVideoResolution()) {
// We support maximum 8M liveshot @4K2K video resolution
cam_dimension_t resolution = {0, 0};
CameraParameters::getVideoSize(&resolution.width, &resolution.height);
if((m_LiveSnapshotSize.width > resolution.width) ||
(m_LiveSnapshotSize.height > resolution.height)) {
m_LiveSnapshotSize.width = resolution.width;
m_LiveSnapshotSize.height = resolution.height;
}
}
// check if HFR is enabled
const char *hfrStr = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE);
cam_hfr_mode_t hfrMode = CAM_HFR_MODE_OFF;
const char *hsrStr = params.get(KEY_QC_VIDEO_HIGH_SPEED_RECORDING);
const char *vhdrStr = params.get(KEY_QC_VIDEO_HDR);
vHdrOn = (vhdrStr != NULL && (0 == strcmp(vhdrStr,"on"))) ? true : false;
if (vHdrOn) {
livesnapshot_sizes_tbl_cnt = m_pCapability->vhdr_livesnapshot_sizes_tbl_cnt;
livesnapshot_sizes_tbl = &m_pCapability->vhdr_livesnapshot_sizes_tbl[0];
}
if ((hsrStr != NULL) && strcmp(hsrStr, "off")) {
int32_t hsr = lookupAttr(HFR_MODES_MAP, PARAM_MAP_SIZE(HFR_MODES_MAP), hsrStr);
if ((hsr != NAME_NOT_FOUND) && (hsr > CAM_HFR_MODE_OFF)) {
// if HSR is enabled, change live snapshot size
for (size_t i = 0; i < m_pCapability->hfr_tbl_cnt; i++) {
if (m_pCapability->hfr_tbl[i].mode == hsr) {
livesnapshot_sizes_tbl_cnt =
m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl_cnt;
livesnapshot_sizes_tbl =
&m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl[0];
hfrMode = m_pCapability->hfr_tbl[i].mode;
break;
}
}
}
} else if ((hfrStr != NULL) && strcmp(hfrStr, "off")) {
int32_t hfr = lookupAttr(HFR_MODES_MAP, PARAM_MAP_SIZE(HFR_MODES_MAP), hfrStr);
if ((hfr != NAME_NOT_FOUND) && (hfr > CAM_HFR_MODE_OFF)) {
// if HFR is enabled, change live snapshot size
for (size_t i = 0; i < m_pCapability->hfr_tbl_cnt; i++) {
if (m_pCapability->hfr_tbl[i].mode == hfr) {
livesnapshot_sizes_tbl_cnt =
m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl_cnt;
livesnapshot_sizes_tbl =
&m_pCapability->hfr_tbl[i].livesnapshot_sizes_tbl[0];
hfrMode = m_pCapability->hfr_tbl[i].mode;
break;
}
}
}
}
if (useOptimal || hfrMode != CAM_HFR_MODE_OFF || vHdrOn) {
bool found = false;
// first check if picture size is within the list of supported sizes
for (size_t i = 0; i < livesnapshot_sizes_tbl_cnt; ++i) {
if (m_LiveSnapshotSize.width == livesnapshot_sizes_tbl[i].width &&
m_LiveSnapshotSize.height == livesnapshot_sizes_tbl[i].height) {
found = true;
break;
}
}
if (!found) {
// use optimal live snapshot size from supported list,
// that has same preview aspect ratio
int width = 0, height = 0;
params.getPreviewSize(&width, &height);
double previewAspectRatio = (double)width / height;
for (size_t i = 0; i < livesnapshot_sizes_tbl_cnt; ++i) {
double ratio = (double)livesnapshot_sizes_tbl[i].width /
livesnapshot_sizes_tbl[i].height;
if (fabs(previewAspectRatio - ratio) <= ASPECT_TOLERANCE) {
m_LiveSnapshotSize = livesnapshot_sizes_tbl[i];
found = true;
break;
}
}
if (!found && ((hfrMode != CAM_HFR_MODE_OFF) || vHdrOn)) {
// Cannot find matching aspect ration from supported live snapshot list
// choose the max dim from preview and video size
LOGD("Cannot find matching aspect ratio, choose max of preview or video size");
params.getVideoSize(&m_LiveSnapshotSize.width, &m_LiveSnapshotSize.height);
if (m_LiveSnapshotSize.width < width && m_LiveSnapshotSize.height < height) {
m_LiveSnapshotSize.width = width;
m_LiveSnapshotSize.height = height;
}
}
}
}
//To read liveshot resolution from setprop instead of matching aspect ratio.
//The setprop resolution format should be WxH.
//e.g: adb shell setprop persist.camera.liveshot.size 1280x720
memset(value, 0, PROPERTY_VALUE_MAX);
property_get("persist.camera.liveshot.size", value, "");
if (strlen(value) > 0) {
char *saveptr = NULL;
char *token = strtok_r(value, "x", &saveptr);
if (token != NULL) {
liveSnapWidth = atoi(token);
}
token = strtok_r(NULL, "x", &saveptr);
if (token != NULL) {
liveSnapHeight = atoi(token);
}
if ((liveSnapWidth!=0) && (liveSnapHeight!=0)) {
for (size_t i = 0; i < m_pCapability->picture_sizes_tbl_cnt; ++i) {
if (liveSnapWidth == m_pCapability->picture_sizes_tbl[i].width
&& liveSnapHeight == m_pCapability->picture_sizes_tbl[i].height) {
m_LiveSnapshotSize.width = liveSnapWidth;
m_LiveSnapshotSize.height = liveSnapHeight;
break;
}
}
}
}
LOGH("live snapshot size %d x %d",
m_LiveSnapshotSize.width, m_LiveSnapshotSize.height);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setRawSize
*
* DESCRIPTION: set live snapshot size
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setRawSize(cam_dimension_t &dim)
{
m_rawSize = dim;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setPreviewFormat
*
* DESCRIPTION: set preview format from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setPreviewFormat(const QCameraParameters& params)
{
const char *str = params.getPreviewFormat();
int32_t previewFormat = lookupAttr(PREVIEW_FORMATS_MAP,
PARAM_MAP_SIZE(PREVIEW_FORMATS_MAP), str);
if (previewFormat != NAME_NOT_FOUND) {
if (isUBWCEnabled()) {
char prop[PROPERTY_VALUE_MAX];
int pFormat;
memset(prop, 0, sizeof(prop));
property_get("persist.camera.preview.ubwc", prop, "1");
pFormat = atoi(prop);
if (pFormat == 1) {
mPreviewFormat = CAM_FORMAT_YUV_420_NV12_UBWC;
mAppPreviewFormat = (cam_format_t)previewFormat;
} else {
mPreviewFormat = (cam_format_t)previewFormat;
mAppPreviewFormat = (cam_format_t)previewFormat;
}
} else {
mPreviewFormat = (cam_format_t)previewFormat;
mAppPreviewFormat = (cam_format_t)previewFormat;
}
CameraParameters::setPreviewFormat(str);
LOGH("format %d\n", mPreviewFormat);
return NO_ERROR;
}
LOGE("Invalid preview format value: %s", (str == NULL) ? "NULL" : str);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setPictureFormat
*
* DESCRIPTION: set picture format from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setPictureFormat(const QCameraParameters& params)
{
const char *str = params.getPictureFormat();
int32_t pictureFormat = lookupAttr(PICTURE_TYPES_MAP, PARAM_MAP_SIZE(PICTURE_TYPES_MAP), str);
if (pictureFormat != NAME_NOT_FOUND) {
mPictureFormat = pictureFormat;
CameraParameters::setPictureFormat(str);
LOGH("format %d\n", mPictureFormat);
return NO_ERROR;
}
LOGE("Invalid picture format value: %s", (str == NULL) ? "NULL" : str);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setJpegThumbnailSize
*
* DESCRIPTION: set jpeg thumbnail size from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setJpegThumbnailSize(const QCameraParameters& params)
{
int width = params.getInt(KEY_JPEG_THUMBNAIL_WIDTH);
int height = params.getInt(KEY_JPEG_THUMBNAIL_HEIGHT);
LOGD("requested jpeg thumbnail size %d x %d", width, height);
int sizes_cnt = sizeof(THUMBNAIL_SIZES_MAP) / sizeof(cam_dimension_t);
// Validate thumbnail size
for (int i = 0; i < sizes_cnt; i++) {
if (width == THUMBNAIL_SIZES_MAP[i].width &&
height == THUMBNAIL_SIZES_MAP[i].height) {
set(KEY_JPEG_THUMBNAIL_WIDTH, width);
set(KEY_JPEG_THUMBNAIL_HEIGHT, height);
return NO_ERROR;
}
}
LOGE("error: setting jpeg thumbnail size (%d, %d)", width, height);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setBurstLEDOnPeriod
*
* DESCRIPTION: set burst LED on period
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setBurstLEDOnPeriod(const QCameraParameters& params)
{
int nBurstLEDOnPeriod = params.getInt(KEY_QC_SNAPSHOT_BURST_LED_ON_PERIOD);
//Check if the LED ON period is within limits
if ((nBurstLEDOnPeriod <= 0) || (nBurstLEDOnPeriod > 800)) {
// if burst led on period is not set in parameters,
// read from sys prop
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.led.on.period", prop, "0");
nBurstLEDOnPeriod = atoi(prop);
if (nBurstLEDOnPeriod <= 0) {
nBurstLEDOnPeriod = 300;
}
}
set(KEY_QC_SNAPSHOT_BURST_LED_ON_PERIOD, nBurstLEDOnPeriod);
m_nBurstLEDOnPeriod = nBurstLEDOnPeriod;
LOGH("Burst LED on period %u", m_nBurstLEDOnPeriod);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_BURST_LED_ON_PERIOD,
(uint32_t)nBurstLEDOnPeriod)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setRetroActiveBurstNum
*
* DESCRIPTION: set retro active burst num
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setRetroActiveBurstNum(
const QCameraParameters& params)
{
int32_t nBurstNum = params.getInt(KEY_QC_NUM_RETRO_BURST_PER_SHUTTER);
LOGH("m_nRetroBurstNum = %d", m_nRetroBurstNum);
if (nBurstNum <= 0) {
// if burst number is not set in parameters,
// read from sys prop
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.retro.number", prop, "0");
nBurstNum = atoi(prop);
if (nBurstNum < 0) {
nBurstNum = 0;
}
}
set(KEY_QC_NUM_RETRO_BURST_PER_SHUTTER, nBurstNum);
m_nRetroBurstNum = nBurstNum;
LOGH("m_nRetroBurstNum = %d", m_nRetroBurstNum);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setJpegQuality
*
* DESCRIPTION: set jpeg encpding quality from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setJpegQuality(const QCameraParameters& params)
{
int32_t rc = NO_ERROR;
int quality = params.getInt(KEY_JPEG_QUALITY);
if (quality >= 0 && quality <= 100) {
set(KEY_JPEG_QUALITY, quality);
} else {
LOGE("Invalid jpeg quality=%d", quality);
rc = BAD_VALUE;
}
quality = params.getInt(KEY_JPEG_THUMBNAIL_QUALITY);
if (quality >= 0 && quality <= 100) {
set(KEY_JPEG_THUMBNAIL_QUALITY, quality);
} else {
LOGE("Invalid jpeg thumbnail quality=%d", quality);
rc = BAD_VALUE;
}
return rc;
}
/*===========================================================================
* FUNCTION : setOrientaion
*
* DESCRIPTION: set orientaion from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setOrientation(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_ORIENTATION);
if (str != NULL) {
if (strcmp(str, portrait) == 0 || strcmp(str, landscape) == 0) {
// Camera service needs this to decide if the preview frames and raw
// pictures should be rotated.
set(KEY_QC_ORIENTATION, str);
} else {
LOGE("Invalid orientation value: %s", str);
return BAD_VALUE;
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setAutoExposure
*
* DESCRIPTION: set auto exposure value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAutoExposure(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_AUTO_EXPOSURE);
const char *prev_str = get(KEY_QC_AUTO_EXPOSURE);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setAutoExposure(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setPreviewFpsRange
*
* DESCRIPTION: set preview FPS range from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setPreviewFpsRange(const QCameraParameters& params)
{
int minFps,maxFps;
int prevMinFps, prevMaxFps, vidMinFps, vidMaxFps;
int rc = NO_ERROR;
bool found = false, updateNeeded = false;
CameraParameters::getPreviewFpsRange(&prevMinFps, &prevMaxFps);
params.getPreviewFpsRange(&minFps, &maxFps);
LOGH("FpsRange Values:(%d, %d)", prevMinFps, prevMaxFps);
LOGH("Requested FpsRange Values:(%d, %d)", minFps, maxFps);
//first check if we need to change fps because of HFR mode change
updateNeeded = UpdateHFRFrameRate(params);
if (updateNeeded) {
m_bNeedRestart = true;
rc = setHighFrameRate(mHfrMode);
if (rc != NO_ERROR) goto end;
}
LOGH("UpdateHFRFrameRate %d", updateNeeded);
vidMinFps = (int)m_hfrFpsRange.video_min_fps;
vidMaxFps = (int)m_hfrFpsRange.video_max_fps;
if(minFps == prevMinFps && maxFps == prevMaxFps) {
if ( m_bFixedFrameRateSet ) {
minFps = params.getPreviewFrameRate() * 1000;
maxFps = params.getPreviewFrameRate() * 1000;
m_bFixedFrameRateSet = false;
} else if (!updateNeeded) {
LOGH("No change in FpsRange");
rc = NO_ERROR;
goto end;
}
}
for(size_t i = 0; i < m_pCapability->fps_ranges_tbl_cnt; i++) {
// if the value is in the supported list
if (minFps >= m_pCapability->fps_ranges_tbl[i].min_fps * 1000 &&
maxFps <= m_pCapability->fps_ranges_tbl[i].max_fps * 1000) {
found = true;
LOGH("FPS i=%d : minFps = %d, maxFps = %d"
" vidMinFps = %d, vidMaxFps = %d",
i, minFps, maxFps,
(int)m_hfrFpsRange.video_min_fps,
(int)m_hfrFpsRange.video_max_fps);
if ((0.0f >= m_hfrFpsRange.video_min_fps) ||
(0.0f >= m_hfrFpsRange.video_max_fps)) {
vidMinFps = minFps;
vidMaxFps = maxFps;
}
else {
vidMinFps = (int)m_hfrFpsRange.video_min_fps;
vidMaxFps = (int)m_hfrFpsRange.video_max_fps;
}
setPreviewFpsRange(minFps, maxFps, vidMinFps, vidMaxFps);
break;
}
}
if(found == false){
LOGE("error: FPS range value not supported");
rc = BAD_VALUE;
}
end:
return rc;
}
/*===========================================================================
* FUNCTION : UpdateHFRFrameRate
*
* DESCRIPTION: set preview FPS range based on HFR setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : bool true/false
* true -if HAL needs to overwrite FPS range set by app, false otherwise.
*==========================================================================*/
bool QCameraParameters::UpdateHFRFrameRate(const QCameraParameters& params)
{
bool updateNeeded = false;
int min_fps, max_fps;
int32_t hfrMode = CAM_HFR_MODE_OFF;
int32_t newHfrMode = CAM_HFR_MODE_OFF;
int parm_minfps,parm_maxfps;
int prevMinFps, prevMaxFps;
CameraParameters::getPreviewFpsRange(&prevMinFps, &prevMaxFps);
params.getPreviewFpsRange(&parm_minfps, &parm_maxfps);
LOGH("CameraParameters - : minFps = %d, maxFps = %d ",
prevMinFps, prevMaxFps);
LOGH("Requested params - : minFps = %d, maxFps = %d ",
parm_minfps, parm_maxfps);
const char *hfrStr = params.get(KEY_QC_VIDEO_HIGH_FRAME_RATE);
const char *hsrStr = params.get(KEY_QC_VIDEO_HIGH_SPEED_RECORDING);
const char *prev_hfrStr = CameraParameters::get(KEY_QC_VIDEO_HIGH_FRAME_RATE);
const char *prev_hsrStr = CameraParameters::get(KEY_QC_VIDEO_HIGH_SPEED_RECORDING);
if ((hfrStr != NULL) && (prev_hfrStr != NULL) && strcmp(hfrStr, prev_hfrStr)) {
updateParamEntry(KEY_QC_VIDEO_HIGH_FRAME_RATE, hfrStr);
}
if ((hsrStr != NULL) && (prev_hsrStr != NULL) && strcmp(hsrStr, prev_hsrStr)) {
updateParamEntry(KEY_QC_VIDEO_HIGH_SPEED_RECORDING, hsrStr);
}
// check if HFR is enabled
if ((hfrStr != NULL) && strcmp(hfrStr, "off")) {
hfrMode = lookupAttr(HFR_MODES_MAP, PARAM_MAP_SIZE(HFR_MODES_MAP), hfrStr);
if (NAME_NOT_FOUND != hfrMode) newHfrMode = hfrMode;
}
// check if HSR is enabled
else if ((hsrStr != NULL) && strcmp(hsrStr, "off")) {
hfrMode = lookupAttr(HFR_MODES_MAP, PARAM_MAP_SIZE(HFR_MODES_MAP), hsrStr);
if (NAME_NOT_FOUND != hfrMode) newHfrMode = hfrMode;
}
LOGH("prevHfrMode - %d, currentHfrMode = %d ",
mHfrMode, newHfrMode);
if (mHfrMode != newHfrMode) {
updateNeeded = true;
mHfrMode = newHfrMode;
switch (mHfrMode) {
case CAM_HFR_MODE_60FPS:
min_fps = 60000;
max_fps = 60000;
break;
case CAM_HFR_MODE_90FPS:
min_fps = 90000;
max_fps = 90000;
break;
case CAM_HFR_MODE_120FPS:
min_fps = 120000;
max_fps = 120000;
break;
case CAM_HFR_MODE_150FPS:
min_fps = 150000;
max_fps = 150000;
break;
case CAM_HFR_MODE_180FPS:
min_fps = 180000;
max_fps = 180000;
break;
case CAM_HFR_MODE_210FPS:
min_fps = 210000;
max_fps = 210000;
break;
case CAM_HFR_MODE_240FPS:
min_fps = 240000;
max_fps = 240000;
break;
case CAM_HFR_MODE_480FPS:
min_fps = 480000;
max_fps = 480000;
break;
case CAM_HFR_MODE_OFF:
default:
// Set Video Fps to zero
min_fps = 0;
max_fps = 0;
break;
}
m_hfrFpsRange.video_min_fps = (float)min_fps;
m_hfrFpsRange.video_max_fps = (float)max_fps;
LOGH("HFR mode (%d) Set video FPS : minFps = %d, maxFps = %d ",
mHfrMode, min_fps, max_fps);
}
// Remember if HFR mode is ON
if ((mHfrMode > CAM_HFR_MODE_OFF) && (mHfrMode < CAM_HFR_MODE_MAX)) {
LOGH("HFR mode is ON");
m_bHfrMode = true;
} else {
m_hfrFpsRange.video_min_fps = 0;
m_hfrFpsRange.video_max_fps = 0;
m_bHfrMode = false;
LOGH("HFR mode is OFF");
}
m_hfrFpsRange.min_fps = (float)parm_minfps;
m_hfrFpsRange.max_fps = (float)parm_maxfps;
if (m_bHfrMode && (mHfrMode > CAM_HFR_MODE_120FPS)
&& (parm_maxfps != 0)) {
//Configure buffer batch count to use batch mode for higher fps
setBufBatchCount((int8_t)(m_hfrFpsRange.video_max_fps / parm_maxfps));
} else {
//Reset batch count and update KEY for encoder
setBufBatchCount(0);
}
return updateNeeded;
}
/*===========================================================================
* FUNCTION : setPreviewFrameRate
*
* DESCRIPTION: set preview frame rate from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setPreviewFrameRate(const QCameraParameters& params)
{
const char *str = params.get(KEY_PREVIEW_FRAME_RATE);
const char *prev_str = get(KEY_PREVIEW_FRAME_RATE);
if ( str ) {
if ( prev_str &&
strcmp(str, prev_str)) {
LOGD("Requested Fixed Frame Rate %s", str);
updateParamEntry(KEY_PREVIEW_FRAME_RATE, str);
m_bFixedFrameRateSet = true;
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setEffect
*
* DESCRIPTION: set effect value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setEffect(const QCameraParameters& params)
{
const char *str = params.get(KEY_EFFECT);
const char *prev_str = get(KEY_EFFECT);
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.effect", prop, "none");
if (strcmp(prop, "none")) {
if ((prev_str == NULL) ||
(strcmp(prop, prev_str) != 0) ||
(m_bUpdateEffects == true)) {
m_bUpdateEffects = false;
return setEffect(prop);
}
} else if (str != NULL) {
if ((prev_str == NULL) ||
(strcmp(str, prev_str) != 0) ||
(m_bUpdateEffects == true)) {
m_bUpdateEffects = false;
return setEffect(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setFocusMode
*
* DESCRIPTION: set focus mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFocusMode(const QCameraParameters& params)
{
const char *str = params.get(KEY_FOCUS_MODE);
const char *prev_str = get(KEY_FOCUS_MODE);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setFocusMode(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setFocusPosition
*
* DESCRIPTION: set focus position from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFocusPosition(const QCameraParameters& params)
{
const char *focus_str = params.get(KEY_FOCUS_MODE);
const char *prev_focus_str = get(KEY_FOCUS_MODE);
if (NULL == focus_str) {
return NO_ERROR;
}
LOGD("current focus mode: %s", focus_str);
if (strcmp(focus_str, FOCUS_MODE_MANUAL_POSITION)) {
LOGH(", dont set focus pos to back-end!");
return NO_ERROR;
}
const char *pos = params.get(KEY_QC_MANUAL_FOCUS_POSITION);
const char *prev_pos = get(KEY_QC_MANUAL_FOCUS_POSITION);
const char *type = params.get(KEY_QC_MANUAL_FOCUS_POS_TYPE);
const char *prev_type = get(KEY_QC_MANUAL_FOCUS_POS_TYPE);
if ((pos != NULL) && (type != NULL) && (focus_str != NULL)) {
if (prev_pos == NULL || (strcmp(pos, prev_pos) != 0) ||
prev_type == NULL || (strcmp(type, prev_type) != 0) ||
prev_focus_str == NULL || (strcmp(focus_str, prev_focus_str) != 0)) {
return setFocusPosition(type, pos);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setBrightness
*
* DESCRIPTION: set brightness control value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setBrightness(const QCameraParameters& params)
{
int currentBrightness = getInt(KEY_QC_BRIGHTNESS);
int brightness = params.getInt(KEY_QC_BRIGHTNESS);
if(params.get(KEY_QC_BRIGHTNESS) == NULL) {
LOGH("Brigtness not set by App ");
return NO_ERROR;
}
if (currentBrightness != brightness) {
if (brightness >= m_pCapability->brightness_ctrl.min_value &&
brightness <= m_pCapability->brightness_ctrl.max_value) {
LOGD("new brightness value : %d ", brightness);
return setBrightness(brightness);
} else {
LOGE("invalid value %d out of (%d, %d)",
brightness,
m_pCapability->brightness_ctrl.min_value,
m_pCapability->brightness_ctrl.max_value);
return BAD_VALUE;
}
} else {
LOGD("No brightness value changed.");
return NO_ERROR;
}
}
/*===========================================================================
* FUNCTION : getBrightness
*
* DESCRIPTION: get brightness control value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCameraParameters::getBrightness()
{
return getInt(KEY_QC_BRIGHTNESS);
}
/*===========================================================================
* FUNCTION : setSharpness
*
* DESCRIPTION: set sharpness control value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSharpness(const QCameraParameters& params)
{
int shaprness = params.getInt(KEY_QC_SHARPNESS);
int prev_sharp = getInt(KEY_QC_SHARPNESS);
if(params.get(KEY_QC_SHARPNESS) == NULL) {
LOGH("Sharpness not set by App ");
return NO_ERROR;
}
if (prev_sharp != shaprness) {
if((shaprness >= m_pCapability->sharpness_ctrl.min_value) &&
(shaprness <= m_pCapability->sharpness_ctrl.max_value)) {
LOGD("new sharpness value : %d ", shaprness);
return setSharpness(shaprness);
} else {
LOGE("invalid value %d out of (%d, %d)",
shaprness,
m_pCapability->sharpness_ctrl.min_value,
m_pCapability->sharpness_ctrl.max_value);
return BAD_VALUE;
}
} else {
LOGD("No value change in shaprness");
return NO_ERROR;
}
}
/*===========================================================================
* FUNCTION : setSkintoneEnahancement
*
* DESCRIPTION: set skin tone enhancement factor from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSkinToneEnhancement(const QCameraParameters& params)
{
int sceFactor = params.getInt(KEY_QC_SCE_FACTOR);
int prev_sceFactor = getInt(KEY_QC_SCE_FACTOR);
if(params.get(KEY_QC_SCE_FACTOR) == NULL) {
LOGH("Skintone enhancement not set by App ");
return NO_ERROR;
}
if (prev_sceFactor != sceFactor) {
if((sceFactor >= m_pCapability->sce_ctrl.min_value) &&
(sceFactor <= m_pCapability->sce_ctrl.max_value)) {
LOGD("new Skintone Enhancement value : %d ", sceFactor);
return setSkinToneEnhancement(sceFactor);
} else {
LOGE("invalid value %d out of (%d, %d)",
sceFactor,
m_pCapability->sce_ctrl.min_value,
m_pCapability->sce_ctrl.max_value);
return BAD_VALUE;
}
} else {
LOGD("No value change in skintone enhancement factor");
return NO_ERROR;
}
}
/*===========================================================================
* FUNCTION : setSaturation
*
* DESCRIPTION: set saturation control value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSaturation(const QCameraParameters& params)
{
int saturation = params.getInt(KEY_QC_SATURATION);
int prev_sat = getInt(KEY_QC_SATURATION);
if(params.get(KEY_QC_SATURATION) == NULL) {
LOGH("Saturation not set by App ");
return NO_ERROR;
}
if (prev_sat != saturation) {
if((saturation >= m_pCapability->saturation_ctrl.min_value) &&
(saturation <= m_pCapability->saturation_ctrl.max_value)) {
LOGD("new saturation value : %d ", saturation);
return setSaturation(saturation);
} else {
LOGE("invalid value %d out of (%d, %d)",
saturation,
m_pCapability->saturation_ctrl.min_value,
m_pCapability->saturation_ctrl.max_value);
return BAD_VALUE;
}
} else {
LOGD("No value change in saturation factor");
return NO_ERROR;
}
}
/*===========================================================================
* FUNCTION : setContrast
*
* DESCRIPTION: set contrast control value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setContrast(const QCameraParameters& params)
{
int contrast = params.getInt(KEY_QC_CONTRAST);
int prev_contrast = getInt(KEY_QC_CONTRAST);
if(params.get(KEY_QC_CONTRAST) == NULL) {
LOGH("Contrast not set by App ");
return NO_ERROR;
}
if (prev_contrast != contrast) {
if((contrast >= m_pCapability->contrast_ctrl.min_value) &&
(contrast <= m_pCapability->contrast_ctrl.max_value)) {
LOGD("new contrast value : %d ", contrast);
int32_t rc = setContrast(contrast);
return rc;
} else {
LOGE("invalid value %d out of (%d, %d)",
contrast,
m_pCapability->contrast_ctrl.min_value,
m_pCapability->contrast_ctrl.max_value);
return BAD_VALUE;
}
} else {
LOGD("No value change in contrast");
return NO_ERROR;
}
}
/*===========================================================================
* FUNCTION : setExposureCompensation
*
* DESCRIPTION: set exposure compensation value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setExposureCompensation(const QCameraParameters & params)
{
int expComp = params.getInt(KEY_EXPOSURE_COMPENSATION);
int prev_expComp = getInt(KEY_EXPOSURE_COMPENSATION);
if(params.get(KEY_EXPOSURE_COMPENSATION) == NULL) {
LOGH("Exposure compensation not set by App ");
return NO_ERROR;
}
if (prev_expComp != expComp) {
if((expComp >= m_pCapability->exposure_compensation_min) &&
(expComp <= m_pCapability->exposure_compensation_max)) {
LOGD("new Exposure Compensation value : %d ", expComp);
return setExposureCompensation(expComp);
} else {
LOGE("invalid value %d out of (%d, %d)",
expComp,
m_pCapability->exposure_compensation_min,
m_pCapability->exposure_compensation_max);
return BAD_VALUE;
}
} else {
LOGD("No value change in Exposure Compensation");
return NO_ERROR;
}
}
/*===========================================================================
* FUNCTION : setWhiteBalance
*
* DESCRIPTION: set white balance value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setWhiteBalance(const QCameraParameters& params)
{
const char *str = params.get(KEY_WHITE_BALANCE);
const char *prev_str = get(KEY_WHITE_BALANCE);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setWhiteBalance(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setManualWhiteBalance
*
* DESCRIPTION: set manual white balance from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setManualWhiteBalance(const QCameraParameters& params)
{
int32_t rc = NO_ERROR;
const char *wb_str = params.get(KEY_WHITE_BALANCE);
const char *prev_wb_str = get(KEY_WHITE_BALANCE);
LOGD("current wb mode: %s", wb_str);
if (wb_str != NULL) {
if (strcmp(wb_str, WHITE_BALANCE_MANUAL)) {
LOGD("dont set cct to back-end.");
return NO_ERROR;
}
}
const char *value = params.get(KEY_QC_MANUAL_WB_VALUE);
const char *prev_value = get(KEY_QC_MANUAL_WB_VALUE);
const char *type = params.get(KEY_QC_MANUAL_WB_TYPE);
const char *prev_type = get(KEY_QC_MANUAL_WB_TYPE);
if ((value != NULL) && (type != NULL) && (wb_str != NULL)) {
if (prev_value == NULL || (strcmp(value, prev_value) != 0) ||
prev_type == NULL || (strcmp(type, prev_type) != 0) ||
prev_wb_str == NULL || (strcmp(wb_str, prev_wb_str) != 0)) {
updateParamEntry(KEY_QC_MANUAL_WB_TYPE, type);
updateParamEntry(KEY_QC_MANUAL_WB_VALUE, value);
int32_t wb_type = atoi(type);
if (wb_type == CAM_MANUAL_WB_MODE_CCT) {
rc = setWBManualCCT(value);
} else if (wb_type == CAM_MANUAL_WB_MODE_GAIN) {
rc = setManualWBGains(value);
} else {
rc = BAD_VALUE;
}
}
}
return rc;
}
/*===========================================================================
* FUNCTION : setAntibanding
*
* DESCRIPTION: set antibanding value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAntibanding(const QCameraParameters& params)
{
const char *str = params.get(KEY_ANTIBANDING);
const char *prev_str = get(KEY_ANTIBANDING);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setAntibanding(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setStatsDebugMask
*
* DESCRIPTION: get the value from persist file in Stats module that will
* control funtionality in the module
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setStatsDebugMask()
{
uint32_t mask = 0;
char value[PROPERTY_VALUE_MAX];
property_get("persist.camera.stats.debug.mask", value, "0");
mask = (uint32_t)atoi(value);
LOGH("ctrl mask :%d", mask);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_STATS_DEBUG_MASK, mask)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setPAAF
*
* DESCRIPTION: get the value from persist file in Stats module that will
* control the preview assisted AF in the module
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setPAAF()
{
uint32_t paaf = 0;
char value[PROPERTY_VALUE_MAX];
property_get("persist.camera.stats.af.paaf", value, "1");
paaf = (uint32_t)atoi(value);
LOGH("PAAF is: %s", paaf ? "ON": "OFF");
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_STATS_AF_PAAF, paaf)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setSceneDetect
*
* DESCRIPTION: set scenen detect value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSceneDetect(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_SCENE_DETECT);
const char *prev_str = get(KEY_QC_SCENE_DETECT);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setSceneDetect(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setVideoHDR
*
* DESCRIPTION: set video HDR value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setVideoHDR(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_VIDEO_HDR);
const char *prev_str = get(KEY_QC_VIDEO_HDR);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setVideoHDR(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setVtEnable
*
* DESCRIPTION: set vt Time Stamp enable from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setVtEnable(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_VT_ENABLE);
const char *prev_str = get(KEY_QC_VT_ENABLE);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setVtEnable(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setFaceRecognition
*
* DESCRIPTION: set face recognition mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFaceRecognition(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_FACE_RECOGNITION);
const char *prev_str = get(KEY_QC_FACE_RECOGNITION);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
uint32_t maxFaces = (uint32_t)params.getInt(KEY_QC_MAX_NUM_REQUESTED_FACES);
return setFaceRecognition(str, maxFaces);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setZoom
*
* DESCRIPTION: set zoom value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setZoom(const QCameraParameters& params)
{
if ((m_pCapability->zoom_supported == 0 ||
m_pCapability->zoom_ratio_tbl_cnt == 0)) {
LOGH("no zoom support");
return NO_ERROR;
}
int zoomLevel = params.getInt(KEY_ZOOM);
mParmZoomLevel = zoomLevel;
if ((zoomLevel < 0) || (zoomLevel >= (int)m_pCapability->zoom_ratio_tbl_cnt)) {
LOGE("invalid value %d out of (%d, %d)",
zoomLevel,
0, m_pCapability->zoom_ratio_tbl_cnt-1);
return BAD_VALUE;
}
int prevZoomLevel = getInt(KEY_ZOOM);
if (prevZoomLevel == zoomLevel) {
LOGD("No value change in zoom %d %d", prevZoomLevel, zoomLevel);
return NO_ERROR;
}
return setZoom(zoomLevel);
}
/*===========================================================================
* FUNCTION : setISOValue
*
* DESCRIPTION: set ISO value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setISOValue(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_ISO_MODE);
const char *prev_str = get(KEY_QC_ISO_MODE);
if(getManualCaptureMode()) {
char iso_val[PROPERTY_VALUE_MAX];
property_get("persist.camera.iso", iso_val, "");
if (strlen(iso_val) > 0) {
if (prev_str == NULL ||
strcmp(iso_val, prev_str) != 0) {
return setISOValue(iso_val);
}
}
} else if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setISOValue(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setContinuousISO
*
* DESCRIPTION: set ISO value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setContinuousISO(const char *isoValue)
{
char iso[PROPERTY_VALUE_MAX];
int32_t continous_iso = 0;
// Check if continuous ISO is set through setproperty
property_get("persist.camera.continuous.iso", iso, "");
if (strlen(iso) > 0) {
continous_iso = atoi(iso);
} else {
continous_iso = atoi(isoValue);
}
if ((continous_iso >= 0) &&
(continous_iso <= m_pCapability->sensitivity_range.max_sensitivity)) {
LOGH("Setting continuous ISO value %d", continous_iso);
updateParamEntry(KEY_QC_CONTINUOUS_ISO, isoValue);
cam_intf_parm_manual_3a_t iso_settings;
memset(&iso_settings, 0, sizeof(cam_intf_parm_manual_3a_t));
iso_settings.previewOnly = FALSE;
iso_settings.value = continous_iso;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_ISO, iso_settings)) {
return BAD_VALUE;
}
return NO_ERROR;
}
LOGE("Invalid iso value: %d", continous_iso);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setExposureTime
*
* DESCRIPTION: set exposure time from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setExposureTime(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_EXPOSURE_TIME);
const char *prev_str = get(KEY_QC_EXPOSURE_TIME);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setExposureTime(str);
}
} else if(getManualCaptureMode()) {
char expTime[PROPERTY_VALUE_MAX];
property_get("persist.camera.exposure.time", expTime, "");
if (strlen(expTime) > 0) {
if (prev_str == NULL ||
strcmp(expTime, prev_str) != 0) {
return setExposureTime(expTime);
}
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setVideoRotation
*
* DESCRIPTION: set rotation value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setVideoRotation(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_VIDEO_ROTATION);
if(str != NULL) {
int value = lookupAttr(VIDEO_ROTATION_MODES_MAP,
PARAM_MAP_SIZE(VIDEO_ROTATION_MODES_MAP), str);
if (value != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_VIDEO_ROTATION, str);
LOGL("setVideoRotation: %d: ", str, value);
} else {
LOGE("Invalid rotation value: %d", value);
return BAD_VALUE;
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setRotation
*
* DESCRIPTION: set rotation value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setRotation(const QCameraParameters& params)
{
int32_t rotation = params.getInt(KEY_ROTATION);
if (rotation != -1) {
if (rotation == 0 || rotation == 90 ||
rotation == 180 || rotation == 270) {
set(KEY_ROTATION, rotation);
ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_META_JPEG_ORIENTATION,
rotation);
mRotation = rotation;
} else {
LOGE("Invalid rotation value: %d", rotation);
return BAD_VALUE;
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setFlash
*
* DESCRIPTION: set flash mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFlash(const QCameraParameters& params)
{
const char *str = params.get(KEY_FLASH_MODE);
const char *prev_str = get(KEY_FLASH_MODE);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setFlash(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setAecLock
*
* DESCRIPTION: set AEC lock value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAecLock(const QCameraParameters& params)
{
const char *str = params.get(KEY_AUTO_EXPOSURE_LOCK);
const char *prev_str = get(KEY_AUTO_EXPOSURE_LOCK);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setAecLock(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setAwbLock
*
* DESCRIPTION: set AWB lock from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAwbLock(const QCameraParameters& params)
{
const char *str = params.get(KEY_AUTO_WHITEBALANCE_LOCK);
const char *prev_str = get(KEY_AUTO_WHITEBALANCE_LOCK);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setAwbLock(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setAutoHDR
*
* DESCRIPTION: Enable/disable auto HDR
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAutoHDR(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_AUTO_HDR_ENABLE);
const char *prev_str = get(KEY_QC_AUTO_HDR_ENABLE);
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.auto.hdr.enable", prop, VALUE_DISABLE);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
LOGH("Auto HDR set to: %s", str);
return updateParamEntry(KEY_QC_AUTO_HDR_ENABLE, str);
}
} else {
if (prev_str == NULL ||
strcmp(prev_str, prop) != 0 ) {
LOGH("Auto HDR set to: %s", prop);
updateParamEntry(KEY_QC_AUTO_HDR_ENABLE, prop);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : isAutoHDREnabled
*
* DESCRIPTION: Query auto HDR status
*
* PARAMETERS : None
*
* RETURN : bool true/false
*==========================================================================*/
bool QCameraParameters::isAutoHDREnabled()
{
const char *str = get(KEY_QC_AUTO_HDR_ENABLE);
if (str != NULL) {
int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), str);
if (value == NAME_NOT_FOUND) {
LOGE("Invalid Auto HDR value %s", str);
return false;
}
LOGH("Auto HDR status is: %d", value);
return value ? true : false;
}
LOGH("Auto HDR status not set!");
return false;
}
/*===========================================================================
* FUNCTION : setMCEValue
*
* DESCRIPTION: set memory color enhancement value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setMCEValue(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_MEMORY_COLOR_ENHANCEMENT);
const char *prev_str = get(KEY_QC_MEMORY_COLOR_ENHANCEMENT);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setMCEValue(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setDISValue
*
* DESCRIPTION: enable/disable DIS from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setDISValue(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_DIS);
const char *prev_str = get(KEY_QC_DIS);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setDISValue(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setLensShadeValue
*
* DESCRIPTION: set lens shade value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setLensShadeValue(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_LENSSHADE);
const char *prev_str = get(KEY_QC_LENSSHADE);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setLensShadeValue(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setFocusAreas
*
* DESCRIPTION: set focus areas from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFocusAreas(const QCameraParameters& params)
{
const char *str = params.get(KEY_FOCUS_AREAS);
if (getRelatedCamSyncInfo()->mode == CAM_MODE_SECONDARY) {
// Ignore focus areas for secondary camera
LOGH("Ignore focus areas for secondary camera!! ");
return NO_ERROR;
}
if (str != NULL) {
int max_num_af_areas = getInt(KEY_MAX_NUM_FOCUS_AREAS);
if(max_num_af_areas == 0) {
LOGE("max num of AF area is 0, cannot set focus areas");
return BAD_VALUE;
}
const char *prev_str = get(KEY_FOCUS_AREAS);
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setFocusAreas(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setMeteringAreas
*
* DESCRIPTION: set metering areas from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setMeteringAreas(const QCameraParameters& params)
{
const char *str = params.get(KEY_METERING_AREAS);
if (str != NULL) {
int max_num_mtr_areas = getInt(KEY_MAX_NUM_METERING_AREAS);
if(max_num_mtr_areas == 0) {
LOGE("max num of metering areas is 0, cannot set focus areas");
return BAD_VALUE;
}
const char *prev_str = get(KEY_METERING_AREAS);
if (prev_str == NULL ||
strcmp(str, prev_str) != 0 ||
(m_bNeedRestart == true)) {
return setMeteringAreas(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setSceneMode
*
* DESCRIPTION: set scenen mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSceneMode(const QCameraParameters& params)
{
const char *str = params.get(KEY_SCENE_MODE);
const char *prev_str = get(KEY_SCENE_MODE);
LOGH("str - %s, prev_str - %s", str, prev_str);
// HDR & Recording are mutually exclusive and so disable HDR if recording hint is set
if (m_bRecordingHint_new && m_bHDREnabled) {
LOGH("Disable the HDR and set it to Auto");
str = SCENE_MODE_AUTO;
m_bLocalHDREnabled = true;
} else if (!m_bRecordingHint_new && m_bLocalHDREnabled) {
LOGH("Restore the HDR from Auto scene mode");
str = SCENE_MODE_HDR;
m_bLocalHDREnabled = false;
}
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
if(strcmp(str, SCENE_MODE_AUTO) == 0) {
m_bSceneTransitionAuto = true;
}
if (strcmp(str, SCENE_MODE_HDR) == 0) {
// If HDR is set from client and the feature is not enabled in the backend, ignore it.
if (m_bHDRModeSensor && isSupportedSensorHdrSize(params)) {
m_bSensorHDREnabled = true;
LOGH("Sensor HDR mode Enabled");
} else {
m_bHDREnabled = true;
LOGH("S/W HDR Enabled");
}
} else {
m_bHDREnabled = false;
if (m_bSensorHDREnabled) {
m_bSensorHDREnabled = false;
m_bNeedRestart = true;
setSensorSnapshotHDR("off");
}
}
if (m_bSensorHDREnabled) {
setSensorSnapshotHDR("on");
m_bNeedRestart = true;
} else if ((m_bHDREnabled) ||
((prev_str != NULL) && (strcmp(prev_str, SCENE_MODE_HDR) == 0))) {
LOGH("scene mode changed between HDR and non-HDR, need restart");
m_bNeedRestart = true;
}
return setSceneMode(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setSelectableZoneAf
*
* DESCRIPTION: set selectable zone auto focus value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSelectableZoneAf(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_SELECTABLE_ZONE_AF);
const char *prev_str = get(KEY_QC_SELECTABLE_ZONE_AF);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setSelectableZoneAf(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setAEBracket
*
* DESCRIPTION: set AE bracket from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAEBracket(const QCameraParameters& params)
{
if (isHDREnabled()) {
LOGH("scene mode is HDR, overwrite AE bracket setting to off");
return setAEBracket(AE_BRACKET_OFF);
}
const char *expStr = params.get(KEY_QC_CAPTURE_BURST_EXPOSURE);
if (NULL != expStr && strlen(expStr) > 0) {
set(KEY_QC_CAPTURE_BURST_EXPOSURE, expStr);
} else {
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.capture.burst.exposures", prop, "");
if (strlen(prop) > 0) {
set(KEY_QC_CAPTURE_BURST_EXPOSURE, prop);
} else {
remove(KEY_QC_CAPTURE_BURST_EXPOSURE);
}
}
const char *str = params.get(KEY_QC_AE_BRACKET_HDR);
const char *prev_str = get(KEY_QC_AE_BRACKET_HDR);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setAEBracket(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setAFBracket
*
* DESCRIPTION: set AF bracket from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAFBracket(const QCameraParameters& params)
{
if ((m_pCapability->qcom_supported_feature_mask &
(CAM_QCOM_FEATURE_REFOCUS | CAM_QCOM_FEATURE_UBIFOCUS)) == 0) {
LOGH("AF Bracketing is not supported");
return NO_ERROR;
}
const char *str = params.get(KEY_QC_AF_BRACKET);
const char *prev_str = get(KEY_QC_AF_BRACKET);
LOGH("str =%s & prev_str =%s", str, prev_str);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
m_bNeedRestart = true;
return setAFBracket(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setReFocus
*
* DESCRIPTION: set refocus from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setReFocus(const QCameraParameters& params)
{
if ((m_pCapability->qcom_supported_feature_mask &
(CAM_QCOM_FEATURE_REFOCUS | CAM_QCOM_FEATURE_UBIFOCUS)) == 0) {
LOGD("AF Bracketing is not supported");
return NO_ERROR;
}
const char *str = params.get(KEY_QC_RE_FOCUS);
const char *prev_str = get(KEY_QC_RE_FOCUS);
LOGH("str =%s & prev_str =%s", str, prev_str);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
m_bNeedRestart = true;
return setReFocus(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setChromaFlash
*
* DESCRIPTION: set chroma flash from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setChromaFlash(const QCameraParameters& params)
{
if ((m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_CHROMA_FLASH) == 0) {
LOGH("Chroma Flash is not supported");
return NO_ERROR;
}
const char *str = params.get(KEY_QC_CHROMA_FLASH);
const char *prev_str = get(KEY_QC_CHROMA_FLASH);
LOGH("str =%s & prev_str =%s", str, prev_str);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
m_bNeedRestart = true;
return setChromaFlash(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setOptiZoom
*
* DESCRIPTION: set opti zoom from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setOptiZoom(const QCameraParameters& params)
{
if ((m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_OPTIZOOM) == 0){
LOGH("Opti Zoom is not supported");
return NO_ERROR;
}
const char *str = params.get(KEY_QC_OPTI_ZOOM);
const char *prev_str = get(KEY_QC_OPTI_ZOOM);
LOGH("str =%s & prev_str =%s", str, prev_str);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
m_bNeedRestart = true;
return setOptiZoom(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setTruePortrait
*
* DESCRIPTION: set true portrait from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setTruePortrait(const QCameraParameters& params)
{
if ((m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_TRUEPORTRAIT) == 0) {
LOGD("True Portrait is not supported");
return NO_ERROR;
}
const char *str = params.get(KEY_QC_TRUE_PORTRAIT);
const char *prev_str = get(KEY_QC_TRUE_PORTRAIT);
LOGH("str =%s & prev_str =%s", str, prev_str);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setTruePortrait(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setHDRMode
*
* DESCRIPTION: set HDR mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setHDRMode(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_HDR_MODE);
const char *prev_str = get(KEY_QC_HDR_MODE);
uint32_t supported_hdr_modes = m_pCapability->qcom_supported_feature_mask &
(CAM_QCOM_FEATURE_SENSOR_HDR | CAM_QCOM_FEATURE_HDR);
LOGH("str =%s & prev_str =%s", str, prev_str);
if (str != NULL) {
if ((CAM_QCOM_FEATURE_SENSOR_HDR == supported_hdr_modes) &&
(strncmp(str, HDR_MODE_SENSOR, strlen(HDR_MODE_SENSOR)))) {
LOGH("Only sensor HDR is supported");
return NO_ERROR;
} else if ((CAM_QCOM_FEATURE_HDR == supported_hdr_modes) &&
(strncmp(str, HDR_MODE_SENSOR, strlen(HDR_MODE_MULTI_FRAME)))) {
LOGH("Only multi frame HDR is supported");
return NO_ERROR;
} else if (!supported_hdr_modes) {
LOGH("HDR is not supported");
return NO_ERROR;
}
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setHDRMode(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setHDRNeed1x
*
* DESCRIPTION: set HDR need 1x from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setHDRNeed1x(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_HDR_NEED_1X);
const char *prev_str = get(KEY_QC_HDR_NEED_1X);
LOGH("str =%s & prev_str =%s", str, prev_str);
if (str != NULL) {
if (m_bHDRModeSensor) {
LOGH("Only multi frame HDR supports 1x frame");
return NO_ERROR;
}
if ((prev_str == NULL) || (strcmp(str, prev_str) != 0)) {
return setHDRNeed1x(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setSeeMore
*
* DESCRIPTION: set see more (llvd) from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSeeMore(const QCameraParameters& params)
{
if ((m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_LLVD) == 0) {
LOGD("See more is not supported");
return NO_ERROR;
}
const char *str = params.get(KEY_QC_SEE_MORE);
const char *prev_str = get(KEY_QC_SEE_MORE);
LOGH("str =%s & prev_str =%s", str, prev_str);
if (str != NULL) {
if (prev_str == NULL || strcmp(str, prev_str) != 0) {
m_bNeedRestart = true;
return setSeeMore(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setNoiseReductionMode
*
* DESCRIPTION: set noise reduction mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setNoiseReductionMode(const QCameraParameters& params)
{
if ((m_pCapability->qcom_supported_feature_mask & CAM_QTI_FEATURE_SW_TNR) == 0) {
LOGD("SW TNR is not supported");
return NO_ERROR;
}
const char *str = params.get(KEY_QC_NOISE_REDUCTION_MODE);
const char *prev_str = get(KEY_QC_NOISE_REDUCTION_MODE);
LOGH("str =%s & prev_str =%s", str, prev_str);
if (str != NULL) {
if (prev_str == NULL || strcmp(str, prev_str) != 0) {
m_bNeedRestart = true;
return setNoiseReductionMode(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setStillMore
*
* DESCRIPTION: set stillmore from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setStillMore(const QCameraParameters& params)
{
if ((m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_STILLMORE) == 0) {
LOGD("Stillmore is not supported");
return NO_ERROR;
}
const char *str = params.get(KEY_QC_STILL_MORE);
const char *prev_str = get(KEY_QC_STILL_MORE);
LOGH("str =%s & prev_str =%s", str, prev_str);
if (str != NULL) {
if (prev_str == NULL || strcmp(str, prev_str) != 0) {
m_bNeedRestart = true;
return setStillMore(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setRedeyeReduction
*
* DESCRIPTION: set red eye reduction setting from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setRedeyeReduction(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_REDEYE_REDUCTION);
const char *prev_str = get(KEY_QC_REDEYE_REDUCTION);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setRedeyeReduction(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setGpsLocation
*
* DESCRIPTION: set GPS location information from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setGpsLocation(const QCameraParameters& params)
{
const char *method = params.get(KEY_GPS_PROCESSING_METHOD);
if (method) {
set(KEY_GPS_PROCESSING_METHOD, method);
}else {
remove(KEY_GPS_PROCESSING_METHOD);
}
const char *latitude = params.get(KEY_GPS_LATITUDE);
if (latitude) {
set(KEY_GPS_LATITUDE, latitude);
}else {
remove(KEY_GPS_LATITUDE);
}
const char *latitudeRef = params.get(KEY_QC_GPS_LATITUDE_REF);
if (latitudeRef) {
set(KEY_QC_GPS_LATITUDE_REF, latitudeRef);
}else {
remove(KEY_QC_GPS_LATITUDE_REF);
}
const char *longitude = params.get(KEY_GPS_LONGITUDE);
if (longitude) {
set(KEY_GPS_LONGITUDE, longitude);
}else {
remove(KEY_GPS_LONGITUDE);
}
const char *longitudeRef = params.get(KEY_QC_GPS_LONGITUDE_REF);
if (longitudeRef) {
set(KEY_QC_GPS_LONGITUDE_REF, longitudeRef);
}else {
remove(KEY_QC_GPS_LONGITUDE_REF);
}
const char *altitudeRef = params.get(KEY_QC_GPS_ALTITUDE_REF);
if (altitudeRef) {
set(KEY_QC_GPS_ALTITUDE_REF, altitudeRef);
}else {
remove(KEY_QC_GPS_ALTITUDE_REF);
}
const char *altitude = params.get(KEY_GPS_ALTITUDE);
if (altitude) {
set(KEY_GPS_ALTITUDE, altitude);
}else {
remove(KEY_GPS_ALTITUDE);
}
const char *status = params.get(KEY_QC_GPS_STATUS);
if (status) {
set(KEY_QC_GPS_STATUS, status);
} else {
remove(KEY_QC_GPS_STATUS);
}
const char *timestamp = params.get(KEY_GPS_TIMESTAMP);
if (timestamp) {
set(KEY_GPS_TIMESTAMP, timestamp);
}else {
remove(KEY_GPS_TIMESTAMP);
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setNumOfSnapshot
*
* DESCRIPTION: set number of snapshot per shutter from user setting
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setNumOfSnapshot()
{
int nBurstNum = 1;
int nExpnum = 0;
const char *bracket_str = get(KEY_QC_AE_BRACKET_HDR);
if (bracket_str != NULL && strlen(bracket_str) > 0) {
int value = lookupAttr(BRACKETING_MODES_MAP, PARAM_MAP_SIZE(BRACKETING_MODES_MAP),
bracket_str);
switch (value) {
case CAM_EXP_BRACKETING_ON:
{
nExpnum = 0;
const char *str_val = get(KEY_QC_CAPTURE_BURST_EXPOSURE);
if ((str_val != NULL) && (strlen(str_val) > 0)) {
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
strlcpy(prop, str_val, PROPERTY_VALUE_MAX);
char *saveptr = NULL;
char *token = strtok_r(prop, ",", &saveptr);
while (token != NULL) {
token = strtok_r(NULL, ",", &saveptr);
nExpnum++;
}
}
if (nExpnum == 0) {
nExpnum = 1;
}
}
break;
default:
nExpnum = 1 + getNumOfExtraHDROutBufsIfNeeded();
break;
}
}
if (isUbiRefocus()) {
nBurstNum = m_pCapability->refocus_af_bracketing_need.output_count + 1;
}
LOGH("nBurstNum = %d, nExpnum = %d", nBurstNum, nExpnum);
set(KEY_QC_NUM_SNAPSHOT_PER_SHUTTER, nBurstNum * nExpnum);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setRecordingHint
*
* DESCRIPTION: set recording hint value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setRecordingHint(const QCameraParameters& params)
{
const char * str = params.get(KEY_RECORDING_HINT);
const char *prev_str = get(KEY_RECORDING_HINT);
if (str != NULL) {
if (prev_str == NULL || strcmp(str, prev_str) != 0) {
int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP, PARAM_MAP_SIZE(TRUE_FALSE_MODES_MAP),
str);
if(value != NAME_NOT_FOUND){
updateParamEntry(KEY_RECORDING_HINT, str);
setRecordingHintValue(value);
if (getFaceDetectionOption() == true) {
if (!fdModeInVideo()) {
setFaceDetection(value > 0 ? false : true, false);
} else {
setFaceDetection(true, false);
}
}
if (m_bDISEnabled) {
LOGH("Setting DIS value again");
setDISValue(VALUE_ENABLE);
}
return NO_ERROR;
} else {
LOGE("Invalid recording hint value: %s", str);
return BAD_VALUE;
}
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setNoDisplayMode
*
* DESCRIPTION: set no display mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setNoDisplayMode(const QCameraParameters& params)
{
const char *str_val = params.get(KEY_QC_NO_DISPLAY_MODE);
const char *prev_str = get(KEY_QC_NO_DISPLAY_MODE);
char prop[PROPERTY_VALUE_MAX];
LOGD("str_val: %s, prev_str: %s", str_val, prev_str);
// Aux Camera Mode, set no display mode
if (m_relCamSyncInfo.mode == CAM_MODE_SECONDARY) {
if (!m_bNoDisplayMode) {
set(KEY_QC_NO_DISPLAY_MODE, 1);
m_bNoDisplayMode = true;
m_bNeedRestart = true;
}
return NO_ERROR;
}
if(str_val && strlen(str_val) > 0) {
if (prev_str == NULL || strcmp(str_val, prev_str) != 0) {
m_bNoDisplayMode = atoi(str_val);
set(KEY_QC_NO_DISPLAY_MODE, str_val);
m_bNeedRestart = true;
}
} else {
memset(prop, 0, sizeof(prop));
property_get("persist.camera.no-display", prop, "0");
m_bNoDisplayMode = atoi(prop);
}
LOGH("Param m_bNoDisplayMode = %d", m_bNoDisplayMode);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setZslMode
*
* DESCRIPTION: set ZSL mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setZslMode(const QCameraParameters& params)
{
const char *str_val = params.get(KEY_QC_ZSL);
const char *prev_val = get(KEY_QC_ZSL);
int32_t rc = NO_ERROR;
if(m_bForceZslMode) {
if (!m_bZslMode) {
// Force ZSL mode to ON
set(KEY_QC_ZSL, VALUE_ON);
setZslMode(TRUE);
LOGH("ZSL Mode forced to be enabled");
}
} else if (str_val != NULL) {
if (prev_val == NULL || strcmp(str_val, prev_val) != 0) {
int32_t value = lookupAttr(ON_OFF_MODES_MAP, PARAM_MAP_SIZE(ON_OFF_MODES_MAP),
str_val);
if (value != NAME_NOT_FOUND) {
set(KEY_QC_ZSL, str_val);
rc = setZslMode(value);
// ZSL mode changed, need restart preview
m_bNeedRestart = true;
} else {
LOGE("Invalid ZSL mode value: %s", str_val);
rc = BAD_VALUE;
}
}
}
return rc;
}
/*===========================================================================
* FUNCTION : setZslMode
*
* DESCRIPTION: set ZSL mode from user setting
*
* PARAMETERS :
* @value : ZSL mode value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setZslMode(bool value)
{
int32_t rc = NO_ERROR;
if(m_bForceZslMode) {
if (!m_bZslMode) {
// Force ZSL mode to ON
set(KEY_QC_ZSL, VALUE_ON);
m_bZslMode_new = true;
m_bZslMode = true;
m_bNeedRestart = true;
int32_t value = m_bForceZslMode;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_ZSL_MODE, value)) {
rc = BAD_VALUE;
}
LOGI("ZSL Mode forced to be enabled");
}
} else {
LOGI("ZSL Mode -> %s", m_bZslMode_new ? "Enabled" : "Disabled");
m_bZslMode_new = (value > 0)? true : false;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_ZSL_MODE, value)) {
rc = BAD_VALUE;
}
}
LOGH("enabled: %d rc = %d", m_bZslMode_new, rc);
return rc;
}
/*===========================================================================
* FUNCTION : updateZSLModeValue
*
* DESCRIPTION: update zsl mode value locally and to daemon
*
* PARAMETERS :
* @value : zsl mode value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::updateZSLModeValue(bool value)
{
int32_t rc = NO_ERROR;
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
rc = setZslMode(value);
if (rc != NO_ERROR) {
LOGE("Failed to ZSL value");
return rc;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to update recording hint");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : setWaveletDenoise
*
* DESCRIPTION: set wavelet denoise value from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setWaveletDenoise(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_DENOISE);
const char *prev_str = get(KEY_QC_DENOISE);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setWaveletDenoise(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setTemporalDenoise
*
* DESCRIPTION: set temporal denoise value from properties
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setTemporalDenoise(const QCameraParameters& params)
{
if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_CPP_TNR) == 0) {
LOGH("TNR is not supported");
return NO_ERROR;
}
const char *str = params.get(KEY_QC_TNR_MODE);
const char *prev_str = get(KEY_QC_TNR_MODE);
const char *video_str = params.get(KEY_QC_VIDEO_TNR_MODE);
const char *video_prev_str = get(KEY_QC_VIDEO_TNR_MODE);
char video_value[PROPERTY_VALUE_MAX];
char preview_value[PROPERTY_VALUE_MAX];
bool prev_video_tnr = m_bTNRVideoOn;
bool prev_preview_tnr = m_bTNRPreviewOn;
bool prev_snap_tnr = m_bTNRSnapshotOn;
char value[PROPERTY_VALUE_MAX];
memset(value, 0, sizeof(value));
property_get("persist.camera.tnr_cds", value, "0");
uint8_t tnr_cds = (uint8_t)atoi(value);
if (m_bRecordingHint_new == true) {
if (video_str) {
if ((video_prev_str == NULL) || (strcmp(video_str, video_prev_str) != 0)) {
if (!strcmp(video_str, VALUE_ON)) {
m_bTNRVideoOn = true;
m_bTNRPreviewOn = true;
} else {
m_bTNRVideoOn = false;
m_bTNRPreviewOn = false;
}
updateParamEntry(KEY_QC_VIDEO_TNR_MODE, video_str);
} else {
return NO_ERROR;
}
}
} else {
if (str) {
if ((prev_str == NULL) || (strcmp(str, prev_str) != 0)) {
if (!strcmp(str, VALUE_ON)) {
m_bTNRPreviewOn = true;
} else {
m_bTNRPreviewOn = false;
}
updateParamEntry(KEY_QC_TNR_MODE, str);
} else {
return NO_ERROR;
}
}
}
//Read setprops only if UI is not present or disabled.
if ((m_bRecordingHint_new == true)
&& ((video_str == NULL)
|| (strcmp(video_str, VALUE_ON)))) {
memset(video_value, 0, sizeof(video_value));
property_get("persist.camera.tnr.video", video_value, VALUE_OFF);
if (!strcmp(video_value, VALUE_ON)) {
m_bTNRVideoOn = true;
} else {
m_bTNRVideoOn = false;
}
updateParamEntry(KEY_QC_VIDEO_TNR_MODE, video_value);
memset(preview_value, 0, sizeof(preview_value));
property_get("persist.camera.tnr.preview", preview_value, VALUE_OFF);
if (!strcmp(preview_value, VALUE_ON)) {
m_bTNRPreviewOn = true;
} else {
m_bTNRPreviewOn = false;
}
updateParamEntry(KEY_QC_TNR_MODE, preview_value);
} else if ((m_bRecordingHint_new != true)
&& ((str == NULL) || (strcmp(str, VALUE_ON)))) {
memset(preview_value, 0, sizeof(preview_value));
property_get("persist.camera.tnr.preview", preview_value, VALUE_OFF);
if (!strcmp(preview_value, VALUE_ON)) {
m_bTNRPreviewOn = true;
} else {
m_bTNRPreviewOn = false;
}
updateParamEntry(KEY_QC_TNR_MODE, preview_value);
}
memset(value, 0, sizeof(value));
property_get("persist.camera.tnr.snapshot", value, VALUE_OFF);
if (!strcmp(value, VALUE_ON)) {
m_bTNRSnapshotOn = true;
LOGD("TNR enabled for SNAPSHOT stream");
} else {
m_bTNRSnapshotOn = false;
}
cam_denoise_param_t temp;
memset(&temp, 0, sizeof(temp));
if (m_bTNRVideoOn || m_bTNRPreviewOn || m_bTNRSnapshotOn) {
temp.denoise_enable = 1;
temp.process_plates = getDenoiseProcessPlate(
CAM_INTF_PARM_TEMPORAL_DENOISE);
if (!tnr_cds) {
int32_t cds_mode = lookupAttr(CDS_MODES_MAP,
PARAM_MAP_SIZE(CDS_MODES_MAP), CDS_MODE_OFF);
if (cds_mode != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_VIDEO_CDS_MODE, CDS_MODE_OFF);
if (m_bTNRPreviewOn) {
updateParamEntry(KEY_QC_CDS_MODE, CDS_MODE_OFF);
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_CDS_MODE, cds_mode)) {
LOGE("Failed CDS MODE to update table");
return BAD_VALUE;
}
LOGD("CDS is set to = %s when TNR is enabled",
CDS_MODE_OFF);
mCds_mode = cds_mode;
} else {
LOGE("Invalid argument for video CDS MODE %d",
cds_mode);
}
} else {
LOGH("Enabled TNR with CDS");
}
}
if ((m_bTNRVideoOn != prev_video_tnr)
|| (m_bTNRPreviewOn != prev_preview_tnr)
|| (prev_snap_tnr != m_bTNRSnapshotOn)) {
LOGD("TNR enabled = %d, plates = %d",
temp.denoise_enable, temp.process_plates);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_TEMPORAL_DENOISE, temp)) {
return BAD_VALUE;
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setCameraMode
*
* DESCRIPTION: set camera mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setCameraMode(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_CAMERA_MODE);
if (str != NULL) {
set(KEY_QC_CAMERA_MODE, str);
} else {
remove(KEY_QC_CAMERA_MODE);
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setSceneSelectionMode
*
* DESCRIPTION: set scene selection mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSceneSelectionMode(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_SCENE_SELECTION);
const char *prev_str = get(KEY_QC_SCENE_SELECTION);
if (NULL != str) {
if ((NULL == prev_str) || (strcmp(str, prev_str) != 0)) {
int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), str);
if (value != NAME_NOT_FOUND) {
LOGD("Setting selection value %s", str);
if (value && m_bZslMode_new) {
updateParamEntry(KEY_QC_SCENE_SELECTION, str);
m_bNeedRestart = true;
m_bSceneSelection = true;
} else if (!value) {
updateParamEntry(KEY_QC_SCENE_SELECTION, str);
m_bNeedRestart = true;
m_bSceneSelection = false;
} else {
LOGE("Trying to enable scene selection in non ZSL mode!!!");
return BAD_VALUE;
}
} else {
LOGE("Trying to configure invalid scene selection value: %s",
str);
return BAD_VALUE;
}
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setSelectedScene
*
* DESCRIPTION: select specific scene
*
* PARAMETERS :
* @scene : scene mode
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSelectedScene(cam_scene_mode_type scene)
{
Mutex::Autolock l(m_SceneSelectLock);
m_SelectedScene = scene;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getSelectedScene
*
* DESCRIPTION: get selected scene
*
* PARAMETERS :
*
* RETURN : currently selected scene
*==========================================================================*/
cam_scene_mode_type QCameraParameters::getSelectedScene()
{
Mutex::Autolock l(m_SceneSelectLock);
return m_SelectedScene;
}
/*==========================================================
* FUNCTION : setRdiMode
*
* DESCRIPTION: set Rdi mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*===========================================================*/
int32_t QCameraParameters::setRdiMode(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_RDI_MODE);
const char *prev_str = get(KEY_QC_RDI_MODE);
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.rdi.mode", prop, VALUE_DISABLE);
if ((str != NULL) && (prev_str == NULL || strcmp(str, prev_str) != 0)) {
LOGD("RDI mode set to %s", str);
setRdiMode(str);
} else if (prev_str == NULL || strcmp(prev_str, prop) != 0 ) {
LOGD("RDI mode set to prop: %s", prop);
setRdiMode(prop);
}
return NO_ERROR;
}
/*==========================================================
* FUNCTION : setSecureMode
*
* DESCRIPTION: set secure mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*===========================================================*/
int32_t QCameraParameters::setSecureMode(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_SECURE_MODE);
const char *prev_str = get(KEY_QC_SECURE_MODE);
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.secure.mode", prop, VALUE_DISABLE);
if ((str != NULL) && (prev_str == NULL || strcmp(str, prev_str) != 0)) {
LOGD("Secure mode set to KEY: %s", str);
setSecureMode(str);
} else if (prev_str == NULL || strcmp(prev_str, prop) != 0 ) {
LOGD("Secure mode set to prop: %s", prop);
setSecureMode(prop);
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setZslAttributes
*
* DESCRIPTION: set ZSL related attributes from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setZslAttributes(const QCameraParameters& params)
{
// TODO: may switch to pure param instead of sysprop
char prop[PROPERTY_VALUE_MAX];
const char *str = params.get(KEY_QC_ZSL_BURST_INTERVAL);
if (str != NULL) {
set(KEY_QC_ZSL_BURST_INTERVAL, str);
} else {
memset(prop, 0, sizeof(prop));
property_get("persist.camera.zsl.interval", prop, "1");
set(KEY_QC_ZSL_BURST_INTERVAL, prop);
LOGH("burst interval: %s", prop);
}
str = params.get(KEY_QC_ZSL_BURST_LOOKBACK);
if (str != NULL) {
set(KEY_QC_ZSL_BURST_LOOKBACK, str);
} else {
memset(prop, 0, sizeof(prop));
property_get("persist.camera.zsl.backlookcnt", prop, "2");
uint32_t look_back_cnt = atoi(prop);
if (m_bFrameSyncEnabled) {
look_back_cnt += EXTRA_FRAME_SYNC_BUFFERS;
}
set(KEY_QC_ZSL_BURST_LOOKBACK, look_back_cnt);
LOGH("look back count: %s", prop);
}
str = params.get(KEY_QC_ZSL_QUEUE_DEPTH);
if (str != NULL) {
set(KEY_QC_ZSL_QUEUE_DEPTH, str);
} else {
memset(prop, 0, sizeof(prop));
property_get("persist.camera.zsl.queuedepth", prop, "2");
uint32_t queue_depth = atoi(prop);
if (m_bFrameSyncEnabled) {
queue_depth += EXTRA_FRAME_SYNC_BUFFERS;
}
set(KEY_QC_ZSL_QUEUE_DEPTH, queue_depth);
LOGH("queue depth: %s", prop);
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setFlip
*
* DESCRIPTION: set preview/ video/ picture flip mode from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFlip(const QCameraParameters& params)
{
if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_FLIP) == 0) {
LOGH("flip is not supported.");
return NO_ERROR;
}
//check preview flip setting
const char *str = params.get(KEY_QC_PREVIEW_FLIP);
const char *prev_val = get(KEY_QC_PREVIEW_FLIP);
if(str != NULL){
if (prev_val == NULL || strcmp(str, prev_val) != 0) {
int32_t value = lookupAttr(FLIP_MODES_MAP, PARAM_MAP_SIZE(FLIP_MODES_MAP), str);
if(value != NAME_NOT_FOUND){
set(KEY_QC_PREVIEW_FLIP, str);
m_bPreviewFlipChanged = true;
}
}
}
// check video filp setting
str = params.get(KEY_QC_VIDEO_FLIP);
prev_val = get(KEY_QC_VIDEO_FLIP);
if(str != NULL){
if (prev_val == NULL || strcmp(str, prev_val) != 0) {
int32_t value = lookupAttr(FLIP_MODES_MAP, PARAM_MAP_SIZE(FLIP_MODES_MAP), str);
if(value != NAME_NOT_FOUND){
set(KEY_QC_VIDEO_FLIP, str);
m_bVideoFlipChanged = true;
}
}
}
// check picture filp setting
str = params.get(KEY_QC_SNAPSHOT_PICTURE_FLIP);
prev_val = get(KEY_QC_SNAPSHOT_PICTURE_FLIP);
if(str != NULL){
if (prev_val == NULL || strcmp(str, prev_val) != 0) {
int32_t value = lookupAttr(FLIP_MODES_MAP, PARAM_MAP_SIZE(FLIP_MODES_MAP), str);
if(value != NAME_NOT_FOUND){
set(KEY_QC_SNAPSHOT_PICTURE_FLIP, str);
m_bSnapshotFlipChanged = true;
}
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setSnapshotFDReq
*
* DESCRIPTION: set requirement of Face Detection Metadata in Snapshot mode.
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSnapshotFDReq(const QCameraParameters& params)
{
char prop[PROPERTY_VALUE_MAX];
const char *str = params.get(KEY_QC_SNAPSHOT_FD_DATA);
if(str != NULL){
set(KEY_QC_SNAPSHOT_FD_DATA, str);
}else{
memset(prop, 0, sizeof(prop));
property_get("persist.camera.snapshot.fd", prop, "0");
set(KEY_QC_SNAPSHOT_FD_DATA, prop);
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setMobicat
*
* DESCRIPTION: set Mobicat on/off.
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setMobicat(const QCameraParameters& )
{
char value [PROPERTY_VALUE_MAX];
property_get("persist.camera.mobicat", value, "0");
int32_t ret = NO_ERROR;
uint8_t enableMobi = (uint8_t)atoi(value);
if (enableMobi) {
tune_cmd_t tune_cmd;
tune_cmd.type = 2;
tune_cmd.module = 0;
tune_cmd.value = 1;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_SET_VFE_COMMAND, tune_cmd)) {
return BAD_VALUE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_SET_PP_COMMAND, tune_cmd)) {
ret = BAD_VALUE;
}
}
m_MobiMask = enableMobi;
return ret;
}
/*===========================================================================
* FUNCTION : setLongshotParam
*
* DESCRIPTION: set Longshot on/off.
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setLongshotParam(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_LONG_SHOT);
const char *prev_str = get(KEY_QC_LONG_SHOT);
if (str != NULL) {
if (prev_str == NULL || strcmp(str, prev_str) != 0) {
set(KEY_QC_LONG_SHOT, str);
if (prev_str && !strcmp(str, "off") && !strcmp(prev_str, "on")) {
// We restart here, to reset the FPS and no
// of buffers as per the requirement of single snapshot usecase.
// Here restart happens when continuous shot is changed to off from on.
// In case of continuous shot on, restart is taken care when actual
// longshot command is triggered through sendCommand.
m_bNeedRestart = true;
}
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : checkFeatureConcurrency
*
* DESCRIPTION: check if there is a feature concurrency issue with advanced
* camera features
*
* PARAMETERS : None
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::checkFeatureConcurrency()
{
int32_t rc = NO_ERROR;
uint32_t advancedFeatEnableBit = 0;
if (isStillMoreEnabled()) {
advancedFeatEnableBit |= CAM_QCOM_FEATURE_STILLMORE;
}
if (isHDREnabled()) {
advancedFeatEnableBit |= CAM_QCOM_FEATURE_HDR;
}
if (isChromaFlashEnabled()) {
advancedFeatEnableBit |= CAM_QCOM_FEATURE_CHROMA_FLASH;
}
if (isUbiFocusEnabled()) {
advancedFeatEnableBit |= CAM_QCOM_FEATURE_UBIFOCUS;
}
if (isTruePortraitEnabled()) {
advancedFeatEnableBit |= CAM_QCOM_FEATURE_TRUEPORTRAIT;
}
if (isOptiZoomEnabled()) {
advancedFeatEnableBit |= CAM_QCOM_FEATURE_OPTIZOOM;
}
if (isUbiRefocus()) {
advancedFeatEnableBit |= CAM_QCOM_FEATURE_REFOCUS;
}
if (m_bLongshotEnabled && advancedFeatEnableBit) {
LOGE("Failed Longshot mode bit 0x%x",
advancedFeatEnableBit);
rc = BAD_TYPE;
return rc;
}
if(m_bRecordingHint_new) {
advancedFeatEnableBit &= ~CAM_QCOM_FEATURE_STILLMORE;
if (advancedFeatEnableBit) {
LOGE("Failed recording mode bit 0x%x",
advancedFeatEnableBit);
rc = BAD_TYPE;
}
} else if (m_bZslMode_new) {
/* ZSL mode check if 2 bits are set */
if (advancedFeatEnableBit & (advancedFeatEnableBit - 1)) {
LOGE("Failed ZSL mode bit 0x%x", advancedFeatEnableBit);
rc = BAD_TYPE;
}
} else { /* non-ZSL mode */
advancedFeatEnableBit &= ~CAM_QCOM_FEATURE_HDR;
/* non-ZSL mode check if 1 bit is set */
if (advancedFeatEnableBit) {
LOGE("Failed non-ZSL mode bit 0x%x", advancedFeatEnableBit);
rc = BAD_TYPE;
}
}
LOGI("Advance feature enabled 0x%x", advancedFeatEnableBit);
return rc;
}
/*===========================================================================
* FUNCTION : updateParameters
*
* DESCRIPTION: update parameters from user setting
*
* PARAMETERS :
* @params : user setting parameters
* @needRestart : [output] if preview need restart upon setting changes
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::updateParameters(const String8& p,
bool &needRestart)
{
int32_t final_rc = NO_ERROR;
int32_t rc;
m_bNeedRestart = false;
QCameraParameters params(p);
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
rc = BAD_TYPE;
goto UPDATE_PARAM_DONE;
}
if ((rc = setPreviewSize(params))) final_rc = rc;
if ((rc = setVideoSize(params))) final_rc = rc;
if ((rc = setPictureSize(params))) final_rc = rc;
if ((rc = setPreviewFormat(params))) final_rc = rc;
if ((rc = setPictureFormat(params))) final_rc = rc;
if ((rc = setJpegQuality(params))) final_rc = rc;
if ((rc = setOrientation(params))) final_rc = rc;
if ((rc = setRotation(params))) final_rc = rc;
if ((rc = setVideoRotation(params))) final_rc = rc;
if ((rc = setNoDisplayMode(params))) final_rc = rc;
if ((rc = setZslMode(params))) final_rc = rc;
if ((rc = setZslAttributes(params))) final_rc = rc;
if ((rc = setCameraMode(params))) final_rc = rc;
if ((rc = setSceneSelectionMode(params))) final_rc = rc;
if ((rc = setRecordingHint(params))) final_rc = rc;
if ((rc = setRdiMode(params))) final_rc = rc;
if ((rc = setSecureMode(params))) final_rc = rc;
if ((rc = setPreviewFrameRate(params))) final_rc = rc;
if ((rc = setPreviewFpsRange(params))) final_rc = rc;
if ((rc = setAutoExposure(params))) final_rc = rc;
if ((rc = setEffect(params))) final_rc = rc;
if ((rc = setBrightness(params))) final_rc = rc;
if ((rc = setZoom(params))) final_rc = rc;
if ((rc = setSharpness(params))) final_rc = rc;
if ((rc = setSaturation(params))) final_rc = rc;
if ((rc = setContrast(params))) final_rc = rc;
if ((rc = setFocusMode(params))) final_rc = rc;
if ((rc = setISOValue(params))) final_rc = rc;
if ((rc = setContinuousISO(params))) final_rc = rc;
if ((rc = setExposureTime(params))) final_rc = rc;
if ((rc = setSkinToneEnhancement(params))) final_rc = rc;
if ((rc = setFlash(params))) final_rc = rc;
if ((rc = setAecLock(params))) final_rc = rc;
if ((rc = setAwbLock(params))) final_rc = rc;
if ((rc = setLensShadeValue(params))) final_rc = rc;
if ((rc = setMCEValue(params))) final_rc = rc;
if ((rc = setDISValue(params))) final_rc = rc;
if ((rc = setAntibanding(params))) final_rc = rc;
if ((rc = setExposureCompensation(params))) final_rc = rc;
if ((rc = setWhiteBalance(params))) final_rc = rc;
if ((rc = setHDRMode(params))) final_rc = rc;
if ((rc = setHDRNeed1x(params))) final_rc = rc;
if ((rc = setManualWhiteBalance(params))) final_rc = rc;
if ((rc = setSceneMode(params))) final_rc = rc;
if ((rc = setFocusAreas(params))) final_rc = rc;
if ((rc = setFocusPosition(params))) final_rc = rc;
if ((rc = setMeteringAreas(params))) final_rc = rc;
if ((rc = setSelectableZoneAf(params))) final_rc = rc;
if ((rc = setRedeyeReduction(params))) final_rc = rc;
if ((rc = setAEBracket(params))) final_rc = rc;
if ((rc = setAutoHDR(params))) final_rc = rc;
if ((rc = setGpsLocation(params))) final_rc = rc;
if ((rc = setWaveletDenoise(params))) final_rc = rc;
if ((rc = setFaceRecognition(params))) final_rc = rc;
if ((rc = setFlip(params))) final_rc = rc;
if ((rc = setVideoHDR(params))) final_rc = rc;
if ((rc = setVtEnable(params))) final_rc = rc;
if ((rc = setAFBracket(params))) final_rc = rc;
if ((rc = setReFocus(params))) final_rc = rc;
if ((rc = setChromaFlash(params))) final_rc = rc;
if ((rc = setTruePortrait(params))) final_rc = rc;
if ((rc = setOptiZoom(params))) final_rc = rc;
if ((rc = setBurstLEDOnPeriod(params))) final_rc = rc;
if ((rc = setRetroActiveBurstNum(params))) final_rc = rc;
if ((rc = setSnapshotFDReq(params))) final_rc = rc;
if ((rc = setTintlessValue(params))) final_rc = rc;
if ((rc = setCDSMode(params))) final_rc = rc;
if ((rc = setTemporalDenoise(params))) final_rc = rc;
if ((rc = setCacheVideoBuffers(params))) final_rc = rc;
if ((rc = setInitialExposureIndex(params))) final_rc = rc;
if ((rc = setInstantCapture(params))) final_rc = rc;
if ((rc = setInstantAEC(params))) final_rc = rc;
// update live snapshot size after all other parameters are set
if ((rc = setLiveSnapshotSize(params))) final_rc = rc;
if ((rc = setJpegThumbnailSize(params))) final_rc = rc;
if ((rc = setStatsDebugMask())) final_rc = rc;
if ((rc = setPAAF())) final_rc = rc;
if ((rc = setMobicat(params))) final_rc = rc;
if ((rc = setSeeMore(params))) final_rc = rc;
if ((rc = setStillMore(params))) final_rc = rc;
if ((rc = setCustomParams(params))) final_rc = rc;
if ((rc = setNoiseReductionMode(params))) final_rc = rc;
if ((rc = setLongshotParam(params))) final_rc = rc;
if ((rc = setDualLedCalibration(params))) final_rc = rc;
setVideoBatchSize();
setLowLightCapture();
if ((rc = updateFlash(false))) final_rc = rc;
#ifdef TARGET_TS_MAKEUP
if (params.get(KEY_TS_MAKEUP) != NULL) {
set(KEY_TS_MAKEUP,params.get(KEY_TS_MAKEUP));
final_rc = rc;
}
if (params.get(KEY_TS_MAKEUP_WHITEN) != NULL) {
set(KEY_TS_MAKEUP_WHITEN,params.get(KEY_TS_MAKEUP_WHITEN));
final_rc = rc;
}
if (params.get(KEY_TS_MAKEUP_CLEAN) != NULL) {
set(KEY_TS_MAKEUP_CLEAN,params.get(KEY_TS_MAKEUP_CLEAN));
final_rc = rc;
}
#endif
if ((rc = setAdvancedCaptureMode())) final_rc = rc;
UPDATE_PARAM_DONE:
needRestart = m_bNeedRestart;
return final_rc;
}
/*===========================================================================
* FUNCTION : commitParameters
*
* DESCRIPTION: commit parameter changes to backend
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::commitParameters()
{
return commitSetBatch();
}
/*===========================================================================
* FUNCTION : initDefaultParameters
*
* DESCRIPTION: initialize default parameters for the first time
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::initDefaultParameters()
{
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
int32_t hal_version = CAM_HAL_V1;
ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_HAL_VERSION, hal_version);
/*************************Initialize Values******************************/
// Set read only parameters from camera capability
set(KEY_SMOOTH_ZOOM_SUPPORTED,
m_pCapability->smooth_zoom_supported? VALUE_TRUE : VALUE_FALSE);
set(KEY_ZOOM_SUPPORTED,
m_pCapability->zoom_supported? VALUE_TRUE : VALUE_FALSE);
set(KEY_VIDEO_SNAPSHOT_SUPPORTED,
m_pCapability->video_snapshot_supported? VALUE_TRUE : VALUE_FALSE);
set(KEY_VIDEO_STABILIZATION_SUPPORTED,
m_pCapability->video_stablization_supported? VALUE_TRUE : VALUE_FALSE);
set(KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
m_pCapability->auto_exposure_lock_supported? VALUE_TRUE : VALUE_FALSE);
set(KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
m_pCapability->auto_wb_lock_supported? VALUE_TRUE : VALUE_FALSE);
set(KEY_MAX_NUM_DETECTED_FACES_HW, m_pCapability->max_num_roi);
set(KEY_MAX_NUM_DETECTED_FACES_SW, m_pCapability->max_num_roi);
set(KEY_QC_MAX_NUM_REQUESTED_FACES, m_pCapability->max_num_roi);
// Set focal length, horizontal view angle, and vertical view angle
setFloat(KEY_FOCAL_LENGTH, m_pCapability->focal_length);
setFloat(KEY_HORIZONTAL_VIEW_ANGLE, m_pCapability->hor_view_angle);
setFloat(KEY_VERTICAL_VIEW_ANGLE, m_pCapability->ver_view_angle);
set(QCameraParameters::KEY_FOCUS_DISTANCES, "Infinity,Infinity,Infinity");
set(KEY_QC_AUTO_HDR_SUPPORTED,
(m_pCapability->auto_hdr_supported)? VALUE_TRUE : VALUE_FALSE);
// Set supported preview sizes
if (m_pCapability->preview_sizes_tbl_cnt > 0 &&
m_pCapability->preview_sizes_tbl_cnt <= MAX_SIZES_CNT) {
String8 previewSizeValues = createSizesString(
m_pCapability->preview_sizes_tbl, m_pCapability->preview_sizes_tbl_cnt);
set(KEY_SUPPORTED_PREVIEW_SIZES, previewSizeValues.string());
LOGH("supported preview sizes: %s", previewSizeValues.string());
// Set default preview size
CameraParameters::setPreviewSize(m_pCapability->preview_sizes_tbl[0].width,
m_pCapability->preview_sizes_tbl[0].height);
} else {
LOGW("supported preview sizes cnt is 0 or exceeds max!!!");
}
// Set supported video sizes
if (m_pCapability->video_sizes_tbl_cnt > 0 &&
m_pCapability->video_sizes_tbl_cnt <= MAX_SIZES_CNT) {
String8 videoSizeValues = createSizesString(
m_pCapability->video_sizes_tbl, m_pCapability->video_sizes_tbl_cnt);
set(KEY_SUPPORTED_VIDEO_SIZES, videoSizeValues.string());
LOGH("supported video sizes: %s", videoSizeValues.string());
// Set default video size
CameraParameters::setVideoSize(m_pCapability->video_sizes_tbl[0].width,
m_pCapability->video_sizes_tbl[0].height);
//Set preferred Preview size for video
String8 vSize = createSizesString(&m_pCapability->preview_sizes_tbl[0], 1);
set(KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, vSize.string());
} else {
LOGW("supported video sizes cnt is 0 or exceeds max!!!");
}
// Set supported picture sizes
if (m_pCapability->picture_sizes_tbl_cnt > 0 &&
m_pCapability->picture_sizes_tbl_cnt <= MAX_SIZES_CNT) {
String8 pictureSizeValues = createSizesString(
m_pCapability->picture_sizes_tbl, m_pCapability->picture_sizes_tbl_cnt);
set(KEY_SUPPORTED_PICTURE_SIZES, pictureSizeValues.string());
LOGH("supported pic sizes: %s", pictureSizeValues.string());
// Set default picture size to the smallest resolution
CameraParameters::setPictureSize(
m_pCapability->picture_sizes_tbl[m_pCapability->picture_sizes_tbl_cnt-1].width,
m_pCapability->picture_sizes_tbl[m_pCapability->picture_sizes_tbl_cnt-1].height);
} else {
LOGW("supported picture sizes cnt is 0 or exceeds max!!!");
}
// Need check if scale should be enabled
if (m_pCapability->scale_picture_sizes_cnt > 0 &&
m_pCapability->scale_picture_sizes_cnt <= MAX_SCALE_SIZES_CNT){
//get scale size, enable scaling. And re-set picture size table with scale sizes
m_reprocScaleParam.setScaleEnable(true);
int rc_s = m_reprocScaleParam.setScaleSizeTbl(
m_pCapability->scale_picture_sizes_cnt, m_pCapability->scale_picture_sizes,
m_pCapability->picture_sizes_tbl_cnt, m_pCapability->picture_sizes_tbl);
if(rc_s == NO_ERROR){
cam_dimension_t *totalSizeTbl = m_reprocScaleParam.getTotalSizeTbl();
size_t totalSizeCnt = m_reprocScaleParam.getTotalSizeTblCnt();
String8 pictureSizeValues = createSizesString(totalSizeTbl, totalSizeCnt);
set(KEY_SUPPORTED_PICTURE_SIZES, pictureSizeValues.string());
LOGH("scaled supported pic sizes: %s", pictureSizeValues.string());
}else{
m_reprocScaleParam.setScaleEnable(false);
LOGW("reset scaled picture size table failed.");
}
}else{
m_reprocScaleParam.setScaleEnable(false);
}
// Set supported thumbnail sizes
String8 thumbnailSizeValues = createSizesString(
THUMBNAIL_SIZES_MAP,
PARAM_MAP_SIZE(THUMBNAIL_SIZES_MAP));
set(KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, thumbnailSizeValues.string());
// Set default thumnail size
set(KEY_JPEG_THUMBNAIL_WIDTH, THUMBNAIL_SIZES_MAP[0].width);
set(KEY_JPEG_THUMBNAIL_HEIGHT, THUMBNAIL_SIZES_MAP[0].height);
// Set supported livesnapshot sizes
if (m_pCapability->livesnapshot_sizes_tbl_cnt > 0 &&
m_pCapability->livesnapshot_sizes_tbl_cnt <= MAX_SIZES_CNT) {
String8 liveSnpashotSizeValues = createSizesString(
m_pCapability->livesnapshot_sizes_tbl,
m_pCapability->livesnapshot_sizes_tbl_cnt);
set(KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES, liveSnpashotSizeValues.string());
LOGD("supported live snapshot sizes: %s", liveSnpashotSizeValues.string());
m_LiveSnapshotSize =
m_pCapability->livesnapshot_sizes_tbl[m_pCapability->livesnapshot_sizes_tbl_cnt-1];
}
// Set supported preview formats
String8 previewFormatValues = createValuesString(
m_pCapability->supported_preview_fmts,
m_pCapability->supported_preview_fmt_cnt,
PREVIEW_FORMATS_MAP,
PARAM_MAP_SIZE(PREVIEW_FORMATS_MAP));
set(KEY_SUPPORTED_PREVIEW_FORMATS, previewFormatValues.string());
// Set default preview format
CameraParameters::setPreviewFormat(PIXEL_FORMAT_YUV420SP);
// Set default Video Format as OPAQUE
// Internally both Video and Camera subsystems use NV21_VENUS
set(KEY_VIDEO_FRAME_FORMAT, PIXEL_FORMAT_ANDROID_OPAQUE);
// Set supported picture formats
String8 pictureTypeValues(PIXEL_FORMAT_JPEG);
String8 str = createValuesString(
m_pCapability->supported_raw_fmts,
m_pCapability->supported_raw_fmt_cnt,
PICTURE_TYPES_MAP,
PARAM_MAP_SIZE(PICTURE_TYPES_MAP));
if (str.string() != NULL) {
pictureTypeValues.append(",");
pictureTypeValues.append(str);
}
set(KEY_SUPPORTED_PICTURE_FORMATS, pictureTypeValues.string());
// Set default picture Format
CameraParameters::setPictureFormat(PIXEL_FORMAT_JPEG);
// Set raw image size
char raw_size_str[32];
snprintf(raw_size_str, sizeof(raw_size_str), "%dx%d",
m_pCapability->raw_dim[0].width, m_pCapability->raw_dim[0].height);
set(KEY_QC_RAW_PICUTRE_SIZE, raw_size_str);
LOGD("KEY_QC_RAW_PICUTRE_SIZE: w: %d, h: %d ",
m_pCapability->raw_dim[0].width, m_pCapability->raw_dim[0].height);
//set default jpeg quality and thumbnail quality
set(KEY_JPEG_QUALITY, 85);
set(KEY_JPEG_THUMBNAIL_QUALITY, 85);
// Set FPS ranges
if (m_pCapability->fps_ranges_tbl_cnt > 0 &&
m_pCapability->fps_ranges_tbl_cnt <= MAX_SIZES_CNT) {
int default_fps_index = 0;
String8 fpsRangeValues = createFpsRangeString(m_pCapability->fps_ranges_tbl,
m_pCapability->fps_ranges_tbl_cnt,
default_fps_index);
set(KEY_SUPPORTED_PREVIEW_FPS_RANGE, fpsRangeValues.string());
int min_fps =
int(m_pCapability->fps_ranges_tbl[default_fps_index].min_fps * 1000);
int max_fps =
int(m_pCapability->fps_ranges_tbl[default_fps_index].max_fps * 1000);
m_default_fps_range = m_pCapability->fps_ranges_tbl[default_fps_index];
//Set video fps same as preview fps
setPreviewFpsRange(min_fps, max_fps, min_fps, max_fps);
// Set legacy preview fps
String8 fpsValues = createFpsString(m_pCapability->fps_ranges_tbl[default_fps_index]);
set(KEY_SUPPORTED_PREVIEW_FRAME_RATES, fpsValues.string());
LOGH("supported fps rates: %s", fpsValues.string());
CameraParameters::setPreviewFrameRate(int(m_pCapability->fps_ranges_tbl[default_fps_index].max_fps));
} else {
LOGW("supported fps ranges cnt is 0 or exceeds max!!!");
}
// Set supported focus modes
if (m_pCapability->supported_focus_modes_cnt > 0) {
String8 focusModeValues = createValuesString(
m_pCapability->supported_focus_modes,
m_pCapability->supported_focus_modes_cnt,
FOCUS_MODES_MAP,
PARAM_MAP_SIZE(FOCUS_MODES_MAP));
set(KEY_SUPPORTED_FOCUS_MODES, focusModeValues);
// Set default focus mode and update corresponding parameter buf
const char *focusMode = lookupNameByValue(FOCUS_MODES_MAP,
PARAM_MAP_SIZE(FOCUS_MODES_MAP),
m_pCapability->supported_focus_modes[0]);
if (focusMode != NULL) {
setFocusMode(focusMode);
} else {
setFocusMode(FOCUS_MODE_FIXED);
}
} else {
LOGW("supported focus modes cnt is 0!!!");
}
// Set focus areas
if (m_pCapability->max_num_focus_areas > MAX_ROI) {
m_pCapability->max_num_focus_areas = MAX_ROI;
}
set(KEY_MAX_NUM_FOCUS_AREAS, m_pCapability->max_num_focus_areas);
if (m_pCapability->max_num_focus_areas > 0) {
setFocusAreas(DEFAULT_CAMERA_AREA);
}
// Set metering areas
if (m_pCapability->max_num_metering_areas > MAX_ROI) {
m_pCapability->max_num_metering_areas = MAX_ROI;
}
set(KEY_MAX_NUM_METERING_AREAS, m_pCapability->max_num_metering_areas);
if (m_pCapability->max_num_metering_areas > 0) {
setMeteringAreas(DEFAULT_CAMERA_AREA);
}
// set focus position, we should get them from m_pCapability
m_pCapability->min_focus_pos[CAM_MANUAL_FOCUS_MODE_INDEX] = 0;
m_pCapability->max_focus_pos[CAM_MANUAL_FOCUS_MODE_INDEX] = 1023;
set(KEY_QC_MIN_FOCUS_POS_INDEX,
(int) m_pCapability->min_focus_pos[CAM_MANUAL_FOCUS_MODE_INDEX]);
set(KEY_QC_MAX_FOCUS_POS_INDEX,
(int) m_pCapability->max_focus_pos[CAM_MANUAL_FOCUS_MODE_INDEX]);
m_pCapability->min_focus_pos[CAM_MANUAL_FOCUS_MODE_DAC_CODE] = 0;
m_pCapability->max_focus_pos[CAM_MANUAL_FOCUS_MODE_DAC_CODE] = 1023;
set(KEY_QC_MIN_FOCUS_POS_DAC,
(int) m_pCapability->min_focus_pos[CAM_MANUAL_FOCUS_MODE_DAC_CODE]);
set(KEY_QC_MAX_FOCUS_POS_DAC,
(int) m_pCapability->max_focus_pos[CAM_MANUAL_FOCUS_MODE_DAC_CODE]);
m_pCapability->min_focus_pos[CAM_MANUAL_FOCUS_MODE_RATIO] = 0;
m_pCapability->max_focus_pos[CAM_MANUAL_FOCUS_MODE_RATIO] = 100;
set(KEY_QC_MIN_FOCUS_POS_RATIO,
(int) m_pCapability->min_focus_pos[CAM_MANUAL_FOCUS_MODE_RATIO]);
set(KEY_QC_MAX_FOCUS_POS_RATIO,
(int) m_pCapability->max_focus_pos[CAM_MANUAL_FOCUS_MODE_RATIO]);
m_pCapability->min_focus_pos[CAM_MANUAL_FOCUS_MODE_DIOPTER] = 0;
if (m_pCapability->min_focus_distance > 0) {
m_pCapability->max_focus_pos[CAM_MANUAL_FOCUS_MODE_DIOPTER] =
m_pCapability->min_focus_distance;
} else {
m_pCapability->max_focus_pos[CAM_MANUAL_FOCUS_MODE_DIOPTER] = 0;
}
setFloat(KEY_QC_MIN_FOCUS_POS_DIOPTER,
m_pCapability->min_focus_pos[CAM_MANUAL_FOCUS_MODE_DIOPTER]);
setFloat(KEY_QC_MAX_FOCUS_POS_DIOPTER,
m_pCapability->max_focus_pos[CAM_MANUAL_FOCUS_MODE_DIOPTER]);
//set supported manual focus modes
String8 manualFocusModes(VALUE_OFF);
if (m_pCapability->supported_focus_modes_cnt > 1 &&
m_pCapability->min_focus_distance > 0) {
manualFocusModes.append(",");
manualFocusModes.append(KEY_QC_FOCUS_SCALE_MODE);
manualFocusModes.append(",");
manualFocusModes.append(KEY_QC_FOCUS_DIOPTER_MODE);
}
set(KEY_QC_SUPPORTED_MANUAL_FOCUS_MODES, manualFocusModes.string());
// Set Saturation
set(KEY_QC_MIN_SATURATION, m_pCapability->saturation_ctrl.min_value);
set(KEY_QC_MAX_SATURATION, m_pCapability->saturation_ctrl.max_value);
set(KEY_QC_SATURATION_STEP, m_pCapability->saturation_ctrl.step);
setSaturation(m_pCapability->saturation_ctrl.def_value);
// Set Sharpness
set(KEY_QC_MIN_SHARPNESS, m_pCapability->sharpness_ctrl.min_value);
set(KEY_QC_MAX_SHARPNESS, m_pCapability->sharpness_ctrl.max_value);
set(KEY_QC_SHARPNESS_STEP, m_pCapability->sharpness_ctrl.step);
setSharpness(m_pCapability->sharpness_ctrl.def_value);
// Set Contrast
set(KEY_QC_MIN_CONTRAST, m_pCapability->contrast_ctrl.min_value);
set(KEY_QC_MAX_CONTRAST, m_pCapability->contrast_ctrl.max_value);
set(KEY_QC_CONTRAST_STEP, m_pCapability->contrast_ctrl.step);
setContrast(m_pCapability->contrast_ctrl.def_value);
// Set SCE factor
set(KEY_QC_MIN_SCE_FACTOR, m_pCapability->sce_ctrl.min_value); // -100
set(KEY_QC_MAX_SCE_FACTOR, m_pCapability->sce_ctrl.max_value); // 100
set(KEY_QC_SCE_FACTOR_STEP, m_pCapability->sce_ctrl.step); // 10
setSkinToneEnhancement(m_pCapability->sce_ctrl.def_value); // 0
// Set Brightness
set(KEY_QC_MIN_BRIGHTNESS, m_pCapability->brightness_ctrl.min_value); // 0
set(KEY_QC_MAX_BRIGHTNESS, m_pCapability->brightness_ctrl.max_value); // 6
set(KEY_QC_BRIGHTNESS_STEP, m_pCapability->brightness_ctrl.step); // 1
setBrightness(m_pCapability->brightness_ctrl.def_value);
// Set Auto exposure
String8 autoExposureValues = createValuesString(
m_pCapability->supported_aec_modes,
m_pCapability->supported_aec_modes_cnt,
AUTO_EXPOSURE_MAP,
PARAM_MAP_SIZE(AUTO_EXPOSURE_MAP));
set(KEY_QC_SUPPORTED_AUTO_EXPOSURE, autoExposureValues.string());
setAutoExposure(AUTO_EXPOSURE_FRAME_AVG);
// Set Exposure Compensation
set(KEY_MAX_EXPOSURE_COMPENSATION, m_pCapability->exposure_compensation_max); // 12
set(KEY_MIN_EXPOSURE_COMPENSATION, m_pCapability->exposure_compensation_min); // -12
setFloat(KEY_EXPOSURE_COMPENSATION_STEP, m_pCapability->exposure_compensation_step); // 1/6
setExposureCompensation(m_pCapability->exposure_compensation_default); // 0
// Set Instant AEC modes
String8 instantAECModes = createValuesString(
m_pCapability->supported_instant_aec_modes,
m_pCapability->supported_instant_aec_modes_cnt,
INSTANT_AEC_MODES_MAP,
PARAM_MAP_SIZE(INSTANT_AEC_MODES_MAP));
set(KEY_QC_INSTANT_AEC_SUPPORTED_MODES, instantAECModes.string());
// Set Instant Capture modes
String8 instantCaptureModes = createValuesString(
m_pCapability->supported_instant_aec_modes,
m_pCapability->supported_instant_aec_modes_cnt,
INSTANT_CAPTURE_MODES_MAP,
PARAM_MAP_SIZE(INSTANT_CAPTURE_MODES_MAP));
set(KEY_QC_INSTANT_CAPTURE_SUPPORTED_MODES, instantCaptureModes.string());
// Set Antibanding
String8 antibandingValues = createValuesString(
m_pCapability->supported_antibandings,
m_pCapability->supported_antibandings_cnt,
ANTIBANDING_MODES_MAP,
PARAM_MAP_SIZE(ANTIBANDING_MODES_MAP));
set(KEY_SUPPORTED_ANTIBANDING, antibandingValues);
setAntibanding(ANTIBANDING_OFF);
// Set Effect
String8 effectValues = createValuesString(
m_pCapability->supported_effects,
m_pCapability->supported_effects_cnt,
EFFECT_MODES_MAP,
PARAM_MAP_SIZE(EFFECT_MODES_MAP));
if (m_pCapability->supported_effects_cnt > 0) {
set(KEY_SUPPORTED_EFFECTS, effectValues);
} else {
LOGW("Color effects are not available");
set(KEY_SUPPORTED_EFFECTS, EFFECT_NONE);
}
setEffect(EFFECT_NONE);
// Set WhiteBalance
String8 whitebalanceValues = createValuesString(
m_pCapability->supported_white_balances,
m_pCapability->supported_white_balances_cnt,
WHITE_BALANCE_MODES_MAP,
PARAM_MAP_SIZE(WHITE_BALANCE_MODES_MAP));
set(KEY_SUPPORTED_WHITE_BALANCE, whitebalanceValues);
setWhiteBalance(WHITE_BALANCE_AUTO);
// set supported wb cct, we should get them from m_pCapability
m_pCapability->min_wb_cct = 2000;
m_pCapability->max_wb_cct = 8000;
set(KEY_QC_MIN_WB_CCT, m_pCapability->min_wb_cct);
set(KEY_QC_MAX_WB_CCT, m_pCapability->max_wb_cct);
// set supported wb rgb gains, ideally we should get them from m_pCapability
//but for now hardcode.
m_pCapability->min_wb_gain = 1.0;
m_pCapability->max_wb_gain = 4.0;
setFloat(KEY_QC_MIN_WB_GAIN, m_pCapability->min_wb_gain);
setFloat(KEY_QC_MAX_WB_GAIN, m_pCapability->max_wb_gain);
//set supported manual wb modes
String8 manualWBModes(VALUE_OFF);
if(m_pCapability->sensor_type.sens_type != CAM_SENSOR_YUV) {
manualWBModes.append(",");
manualWBModes.append(KEY_QC_WB_CCT_MODE);
manualWBModes.append(",");
manualWBModes.append(KEY_QC_WB_GAIN_MODE);
}
set(KEY_QC_SUPPORTED_MANUAL_WB_MODES, manualWBModes.string());
// Set Flash mode
if(m_pCapability->supported_flash_modes_cnt > 0) {
String8 flashValues = createValuesString(
m_pCapability->supported_flash_modes,
m_pCapability->supported_flash_modes_cnt,
FLASH_MODES_MAP,
PARAM_MAP_SIZE(FLASH_MODES_MAP));
set(KEY_SUPPORTED_FLASH_MODES, flashValues);
setFlash(FLASH_MODE_OFF);
} else {
LOGW("supported flash modes cnt is 0!!!");
}
// Set Scene Mode
String8 sceneModeValues = createValuesString(
m_pCapability->supported_scene_modes,
m_pCapability->supported_scene_modes_cnt,
SCENE_MODES_MAP,
PARAM_MAP_SIZE(SCENE_MODES_MAP));
set(KEY_SUPPORTED_SCENE_MODES, sceneModeValues);
setSceneMode(SCENE_MODE_AUTO);
// Set CDS Mode
String8 cdsModeValues = createValuesStringFromMap(
CDS_MODES_MAP,
PARAM_MAP_SIZE(CDS_MODES_MAP));
set(KEY_QC_SUPPORTED_CDS_MODES, cdsModeValues);
// Set video CDS Mode
String8 videoCdsModeValues = createValuesStringFromMap(
CDS_MODES_MAP,
PARAM_MAP_SIZE(CDS_MODES_MAP));
set(KEY_QC_SUPPORTED_VIDEO_CDS_MODES, videoCdsModeValues);
// Set TNR Mode
String8 tnrModeValues = createValuesStringFromMap(
ON_OFF_MODES_MAP,
PARAM_MAP_SIZE(ON_OFF_MODES_MAP));
set(KEY_QC_SUPPORTED_TNR_MODES, tnrModeValues);
// Set video TNR Mode
String8 videoTnrModeValues = createValuesStringFromMap(
ON_OFF_MODES_MAP,
PARAM_MAP_SIZE(ON_OFF_MODES_MAP));
set(KEY_QC_SUPPORTED_VIDEO_TNR_MODES, videoTnrModeValues);
// Set ISO Mode
String8 isoValues = createValuesString(
m_pCapability->supported_iso_modes,
m_pCapability->supported_iso_modes_cnt,
ISO_MODES_MAP,
PARAM_MAP_SIZE(ISO_MODES_MAP));
set(KEY_QC_SUPPORTED_ISO_MODES, isoValues);
setISOValue(ISO_AUTO);
// Set exposure time
String8 manualExpModes(VALUE_OFF);
bool expTimeSupported = false;
bool manualISOSupported = false;
//capability values are in nano sec, convert to milli sec for upper layers
char expTimeStr[20];
double min_exp_time = (double) m_pCapability->exposure_time_range[0] / 1000000.0;
double max_exp_time = (double) m_pCapability->exposure_time_range[1] / 1000000.0;
snprintf(expTimeStr, sizeof(expTimeStr), "%f", min_exp_time);
set(KEY_QC_MIN_EXPOSURE_TIME, expTimeStr);
snprintf(expTimeStr, sizeof(expTimeStr), "%f", max_exp_time);
set(KEY_QC_MAX_EXPOSURE_TIME, expTimeStr);
if ((min_exp_time > 0) && (max_exp_time > min_exp_time)) {
manualExpModes.append(",");
manualExpModes.append(KEY_QC_EXP_TIME_PRIORITY);
expTimeSupported = true;
}
LOGH(", Exposure time min %f ms, max %f ms",
min_exp_time, max_exp_time);
// Set iso
set(KEY_QC_MIN_ISO, m_pCapability->sensitivity_range.min_sensitivity);
set(KEY_QC_MAX_ISO, m_pCapability->sensitivity_range.max_sensitivity);
LOGH(", ISO min %d, max %d",
m_pCapability->sensitivity_range.min_sensitivity,
m_pCapability->sensitivity_range.max_sensitivity);
if ((m_pCapability->sensitivity_range.min_sensitivity > 0) &&
(m_pCapability->sensitivity_range.max_sensitivity >
m_pCapability->sensitivity_range.min_sensitivity)) {
manualExpModes.append(",");
manualExpModes.append(KEY_QC_ISO_PRIORITY);
manualISOSupported = true;
}
if (expTimeSupported && manualISOSupported) {
manualExpModes.append(",");
manualExpModes.append(KEY_QC_USER_SETTING);
}
//finally set supported manual exposure modes
set(KEY_QC_SUPPORTED_MANUAL_EXPOSURE_MODES, manualExpModes.string());
// Set HFR
String8 hfrValues = createHfrValuesString(
m_pCapability->hfr_tbl,
m_pCapability->hfr_tbl_cnt,
HFR_MODES_MAP,
PARAM_MAP_SIZE(HFR_MODES_MAP));
set(KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES, hfrValues.string());
set(KEY_QC_VIDEO_HIGH_SPEED_RECORDING, "off");
set(KEY_QC_VIDEO_HIGH_FRAME_RATE, "off");
String8 hfrSizeValues = createHfrSizesString(
m_pCapability->hfr_tbl,
m_pCapability->hfr_tbl_cnt);
set(KEY_QC_SUPPORTED_HFR_SIZES, hfrSizeValues.string());
LOGD("HFR values = %s HFR Sizes = %s", hfrValues.string(), hfrSizeValues.string());
setHighFrameRate(CAM_HFR_MODE_OFF);
// Set Focus algorithms
String8 focusAlgoValues = createValuesString(
m_pCapability->supported_focus_algos,
m_pCapability->supported_focus_algos_cnt,
FOCUS_ALGO_MAP,
PARAM_MAP_SIZE(FOCUS_ALGO_MAP));
set(KEY_QC_SUPPORTED_FOCUS_ALGOS, focusAlgoValues);
setSelectableZoneAf(FOCUS_ALGO_AUTO);
// Set Zoom Ratios
if (m_pCapability->zoom_supported > 0) {
String8 zoomRatioValues = createZoomRatioValuesString(
m_pCapability->zoom_ratio_tbl,
m_pCapability->zoom_ratio_tbl_cnt);
set(KEY_ZOOM_RATIOS, zoomRatioValues);
set(KEY_MAX_ZOOM, (int)(m_pCapability->zoom_ratio_tbl_cnt - 1));
setZoom(0);
}
// Set Bracketing/HDR
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.capture.burst.exposures", prop, "");
if (strlen(prop) > 0) {
set(KEY_QC_CAPTURE_BURST_EXPOSURE, prop);
}
String8 bracketingValues = createValuesStringFromMap(
BRACKETING_MODES_MAP,
PARAM_MAP_SIZE(BRACKETING_MODES_MAP));
set(KEY_QC_SUPPORTED_AE_BRACKET_MODES, bracketingValues);
setAEBracket(AE_BRACKET_OFF);
//Set AF Bracketing.
for (size_t i = 0; i < m_pCapability->supported_focus_modes_cnt; i++) {
if ((CAM_FOCUS_MODE_AUTO == m_pCapability->supported_focus_modes[i]) &&
((m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_UBIFOCUS) > 0)) {
String8 afBracketingValues = createValuesStringFromMap(
AF_BRACKETING_MODES_MAP,
PARAM_MAP_SIZE(AF_BRACKETING_MODES_MAP));
set(KEY_QC_SUPPORTED_AF_BRACKET_MODES, afBracketingValues);
setAFBracket(AF_BRACKET_OFF);
break;
}
}
//Set Refocus.
//Re-use ubifocus flag for now.
for (size_t i = 0; i < m_pCapability->supported_focus_modes_cnt; i++) {
if ((CAM_FOCUS_MODE_AUTO == m_pCapability->supported_focus_modes[i]) &&
(m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_REFOCUS) > 0) {
String8 reFocusValues = createValuesStringFromMap(
RE_FOCUS_MODES_MAP,
PARAM_MAP_SIZE(RE_FOCUS_MODES_MAP));
set(KEY_QC_SUPPORTED_RE_FOCUS_MODES, reFocusValues);
setReFocus(RE_FOCUS_OFF);
}
}
//Set Chroma Flash.
if ((m_pCapability->supported_flash_modes_cnt > 0) &&
(m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_CHROMA_FLASH) > 0) {
String8 chromaFlashValues = createValuesStringFromMap(
CHROMA_FLASH_MODES_MAP,
PARAM_MAP_SIZE(CHROMA_FLASH_MODES_MAP));
set(KEY_QC_SUPPORTED_CHROMA_FLASH_MODES, chromaFlashValues);
setChromaFlash(CHROMA_FLASH_OFF);
}
//Set Opti Zoom.
if (m_pCapability->zoom_supported &&
(m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_OPTIZOOM) > 0){
String8 optiZoomValues = createValuesStringFromMap(
OPTI_ZOOM_MODES_MAP,
PARAM_MAP_SIZE(OPTI_ZOOM_MODES_MAP));
set(KEY_QC_SUPPORTED_OPTI_ZOOM_MODES, optiZoomValues);
setOptiZoom(OPTI_ZOOM_OFF);
}
//Set HDR Type
uint32_t supported_hdr_modes = m_pCapability->qcom_supported_feature_mask &
(CAM_QCOM_FEATURE_SENSOR_HDR | CAM_QCOM_FEATURE_HDR);
if (supported_hdr_modes) {
if (CAM_QCOM_FEATURE_SENSOR_HDR == supported_hdr_modes) {
String8 hdrModeValues;
hdrModeValues.append(HDR_MODE_SENSOR);
set(KEY_QC_SUPPORTED_KEY_QC_HDR_MODES, hdrModeValues);
setHDRMode(HDR_MODE_SENSOR);
} else if (CAM_QCOM_FEATURE_HDR == supported_hdr_modes) {
String8 hdrModeValues;
hdrModeValues.append(HDR_MODE_MULTI_FRAME);
set(KEY_QC_SUPPORTED_KEY_QC_HDR_MODES, hdrModeValues);
setHDRMode(HDR_MODE_MULTI_FRAME);
} else {
String8 hdrModeValues = createValuesStringFromMap(
HDR_MODES_MAP,
PARAM_MAP_SIZE(HDR_MODES_MAP));
set(KEY_QC_SUPPORTED_KEY_QC_HDR_MODES, hdrModeValues);
setHDRMode(HDR_MODE_MULTI_FRAME);
}
}
//Set HDR need 1x
String8 hdrNeed1xValues;
if (!m_bHDRModeSensor) {
hdrNeed1xValues = createValuesStringFromMap(TRUE_FALSE_MODES_MAP,
PARAM_MAP_SIZE(TRUE_FALSE_MODES_MAP));
} else {
hdrNeed1xValues.append(VALUE_FALSE);
}
setHDRNeed1x(VALUE_FALSE);
set(KEY_QC_SUPPORTED_HDR_NEED_1X, hdrNeed1xValues);
//Set True Portrait
if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_TRUEPORTRAIT) > 0) {
String8 truePortraitValues = createValuesStringFromMap(
TRUE_PORTRAIT_MODES_MAP,
PARAM_MAP_SIZE(TRUE_PORTRAIT_MODES_MAP));
set(KEY_QC_SUPPORTED_TRUE_PORTRAIT_MODES, truePortraitValues);
}
// Set Denoise
if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_DENOISE2D) > 0){
String8 denoiseValues = createValuesStringFromMap(
DENOISE_ON_OFF_MODES_MAP, PARAM_MAP_SIZE(DENOISE_ON_OFF_MODES_MAP));
set(KEY_QC_SUPPORTED_DENOISE, denoiseValues.string());
#ifdef DEFAULT_DENOISE_MODE_ON
setWaveletDenoise(DENOISE_ON);
#else
setWaveletDenoise(DENOISE_OFF);
#endif
}
// Set feature enable/disable
String8 enableDisableValues = createValuesStringFromMap(
ENABLE_DISABLE_MODES_MAP, PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP));
// Set Lens Shading
set(KEY_QC_SUPPORTED_LENSSHADE_MODES, enableDisableValues);
setLensShadeValue(VALUE_ENABLE);
// Set MCE
set(KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES, enableDisableValues);
setMCEValue(VALUE_ENABLE);
// Set DIS
set(KEY_QC_SUPPORTED_DIS_MODES, enableDisableValues);
setDISValue(VALUE_DISABLE);
// Set Histogram
set(KEY_QC_SUPPORTED_HISTOGRAM_MODES,
m_pCapability->histogram_supported ? enableDisableValues : "");
set(KEY_QC_HISTOGRAM, VALUE_DISABLE);
//Set Red Eye Reduction
set(KEY_QC_SUPPORTED_REDEYE_REDUCTION, enableDisableValues);
setRedeyeReduction(VALUE_DISABLE);
//Set SkinTone Enhancement
set(KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES, enableDisableValues);
// Enable LTM by default and disable it in HDR & SeeMore usecases
setToneMapMode(true, false);
// Set feature on/off
String8 onOffValues = createValuesStringFromMap(
ON_OFF_MODES_MAP, PARAM_MAP_SIZE(ON_OFF_MODES_MAP));
//Set See more (LLVD)
if (m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_LLVD) {
set(KEY_QC_SUPPORTED_SEE_MORE_MODES, onOffValues);
setSeeMore(VALUE_OFF);
}
//Set Still more
if (m_pCapability->qcom_supported_feature_mask &
CAM_QCOM_FEATURE_STILLMORE) {
String8 stillMoreValues = createValuesStringFromMap(
STILL_MORE_MODES_MAP,
PARAM_MAP_SIZE(STILL_MORE_MODES_MAP));
set(KEY_QC_SUPPORTED_STILL_MORE_MODES, stillMoreValues);
setStillMore(STILL_MORE_OFF);
}
//Set Noise Reduction mode
if (m_pCapability->qcom_supported_feature_mask &
CAM_QTI_FEATURE_SW_TNR) {
String8 noiseReductionModesValues = createValuesStringFromMap(
NOISE_REDUCTION_MODES_MAP, PARAM_MAP_SIZE(NOISE_REDUCTION_MODES_MAP));
set(KEY_QC_NOISE_REDUCTION_MODE_VALUES, noiseReductionModesValues);
setNoiseReductionMode(VALUE_OFF);
}
//Set Scene Detection
set(KEY_QC_SUPPORTED_SCENE_DETECT, onOffValues);
setSceneDetect(VALUE_OFF);
m_bHDREnabled = false;
m_bHDR1xFrameEnabled = false;
m_bHDRThumbnailProcessNeeded = false;
m_bHDR1xExtraBufferNeeded = true;
for (uint32_t i=0; i<m_pCapability->hdr_bracketing_setting.num_frames; i++) {
if (0 == m_pCapability->hdr_bracketing_setting.exp_val.values[i]) {
m_bHDR1xExtraBufferNeeded = false;
break;
}
}
// Set HDR output scaling
char value[PROPERTY_VALUE_MAX];
property_get("persist.camera.hdr.outcrop", value, VALUE_DISABLE);
if (strncmp(VALUE_ENABLE, value, sizeof(VALUE_ENABLE))) {
m_bHDROutputCropEnabled = false;
} else {
m_bHDROutputCropEnabled = true;
}
//Set Face Detection
set(KEY_QC_SUPPORTED_FACE_DETECTION, onOffValues);
set(KEY_QC_FACE_DETECTION, VALUE_OFF);
//Set Face Recognition
//set(KEY_QC_SUPPORTED_FACE_RECOGNITION, onOffValues);
//set(KEY_QC_FACE_RECOGNITION, VALUE_OFF);
//Set ZSL
set(KEY_QC_SUPPORTED_ZSL_MODES, onOffValues);
#ifdef DEFAULT_ZSL_MODE_ON
set(KEY_QC_ZSL, VALUE_ON);
m_bZslMode = true;
#else
set(KEY_QC_ZSL, VALUE_OFF);
m_bZslMode = false;
#endif
// Check if zsl mode property is enabled.
// If yes, force the camera to be in zsl mode
// and force zsl mode to be enabled in dual camera mode.
memset(value, 0x0, PROPERTY_VALUE_MAX);
property_get("persist.camera.zsl.mode", value, "0");
int32_t zsl_mode = atoi(value);
if((zsl_mode == 1) ||
(m_bZslMode == true) ||
(m_relCamSyncInfo.sync_control == CAM_SYNC_RELATED_SENSORS_ON)) {
LOGH("%d: Forcing Camera to ZSL mode enabled");
set(KEY_QC_ZSL, VALUE_ON);
m_bForceZslMode = true;
m_bZslMode = true;
int32_t value = m_bForceZslMode;
ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_ZSL_MODE, value);
}
m_bZslMode_new = m_bZslMode;
set(KEY_QC_SCENE_SELECTION, VALUE_DISABLE);
// Rdi mode
set(KEY_QC_SUPPORTED_RDI_MODES, enableDisableValues);
setRdiMode(VALUE_DISABLE);
// Secure mode
set(KEY_QC_SUPPORTED_SECURE_MODES, enableDisableValues);
setSecureMode(VALUE_DISABLE);
//Set video HDR
if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_VIDEO_HDR) > 0) {
set(KEY_QC_SUPPORTED_VIDEO_HDR_MODES, onOffValues);
set(KEY_QC_VIDEO_HDR, VALUE_OFF);
}
//Set HW Sensor Snapshot HDR
if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_SENSOR_HDR)> 0) {
set(KEY_QC_SUPPORTED_SENSOR_HDR_MODES, onOffValues);
set(KEY_QC_SENSOR_HDR, VALUE_OFF);
m_bSensorHDREnabled = false;
}
// Set VT TimeStamp
set(KEY_QC_VT_ENABLE, VALUE_DISABLE);
//Set Touch AF/AEC
String8 touchValues = createValuesStringFromMap(
TOUCH_AF_AEC_MODES_MAP, PARAM_MAP_SIZE(TOUCH_AF_AEC_MODES_MAP));
set(KEY_QC_SUPPORTED_TOUCH_AF_AEC, touchValues);
set(KEY_QC_TOUCH_AF_AEC, TOUCH_AF_AEC_OFF);
//set flip mode
if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_FLIP) > 0) {
String8 flipModes = createValuesStringFromMap(
FLIP_MODES_MAP, PARAM_MAP_SIZE(FLIP_MODES_MAP));
set(KEY_QC_SUPPORTED_FLIP_MODES, flipModes);
set(KEY_QC_PREVIEW_FLIP, FLIP_MODE_OFF);
set(KEY_QC_VIDEO_FLIP, FLIP_MODE_OFF);
set(KEY_QC_SNAPSHOT_PICTURE_FLIP, FLIP_MODE_OFF);
}
// Set default Auto Exposure lock value
setAecLock(VALUE_FALSE);
// Set default AWB_LOCK lock value
setAwbLock(VALUE_FALSE);
// Set default Camera mode
set(KEY_QC_CAMERA_MODE, 0);
// Add support for internal preview restart
set(KEY_INTERNAL_PERVIEW_RESTART, VALUE_TRUE);
// Set default burst number
set(KEY_QC_SNAPSHOT_BURST_NUM, 0);
set(KEY_QC_NUM_RETRO_BURST_PER_SHUTTER, 0);
//Get RAM size and disable features which are memory rich
struct sysinfo info;
sysinfo(&info);
LOGH("totalram = %ld, freeram = %ld ", info.totalram,
info.freeram);
if (info.totalram > TOTAL_RAM_SIZE_512MB) {
set(KEY_QC_ZSL_HDR_SUPPORTED, VALUE_TRUE);
} else {
m_bIsLowMemoryDevice = true;
set(KEY_QC_ZSL_HDR_SUPPORTED, VALUE_FALSE);
}
setOfflineRAW();
memset(mStreamPpMask, 0, sizeof(cam_feature_mask_t)*CAM_STREAM_TYPE_MAX);
//Set video buffers as uncached by default
set(KEY_QC_CACHE_VIDEO_BUFFERS, VALUE_DISABLE);
// Set default longshot mode
set(KEY_QC_LONG_SHOT, "off");
//Enable longshot by default
set(KEY_QC_LONGSHOT_SUPPORTED, VALUE_TRUE);
int32_t rc = commitParameters();
if (rc == NO_ERROR) {
rc = setNumOfSnapshot();
}
//Set Video Rotation
String8 videoRotationValues = createValuesStringFromMap(VIDEO_ROTATION_MODES_MAP,
PARAM_MAP_SIZE(VIDEO_ROTATION_MODES_MAP));
set(KEY_QC_SUPPORTED_VIDEO_ROTATION_VALUES, videoRotationValues.string());
set(KEY_QC_VIDEO_ROTATION, VIDEO_ROTATION_0);
//Check for EZTune
setEztune();
//Default set for video batch size
set(KEY_QC_VIDEO_BATCH_SIZE, 0);
//Setup dual-camera
setDcrf();
// For Aux Camera of dual camera Mode,
// by default set no display mode
if (m_relCamSyncInfo.mode == CAM_MODE_SECONDARY) {
set(KEY_QC_NO_DISPLAY_MODE, 1);
m_bNoDisplayMode = true;
}
cam_dimension_t pic_dim;
pic_dim.width = 0;
pic_dim.height = 0;
for(uint32_t i = 0;
i < (m_pCapability->picture_sizes_tbl_cnt - 1);
i++) {
if ((pic_dim.width * pic_dim.height) <
(int32_t)(m_pCapability->picture_sizes_tbl[i].width *
m_pCapability->picture_sizes_tbl[i].height)) {
pic_dim.width =
m_pCapability->picture_sizes_tbl[i].width;
pic_dim.height =
m_pCapability->picture_sizes_tbl[i].height;
}
}
LOGD("max pic size = %d %d", pic_dim.width,
pic_dim.height);
setMaxPicSize(pic_dim);
setManualCaptureMode(CAM_MANUAL_CAPTURE_TYPE_OFF);
return rc;
}
/*===========================================================================
* FUNCTION : allocate
*
* DESCRIPTION: Allocate buffer memory for parameter obj (if necessary)
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::allocate()
{
int32_t rc = NO_ERROR;
if (m_pParamHeap != NULL) {
return rc;
}
//Allocate Set Param Buffer
m_pParamHeap = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
if (m_pParamHeap == NULL) {
return NO_MEMORY;
}
rc = m_pParamHeap->allocate(1, sizeof(parm_buffer_t), NON_SECURE);
if(rc != OK) {
rc = NO_MEMORY;
LOGE("Error!! Param buffers have not been allocated");
delete m_pParamHeap;
m_pParamHeap = NULL;
}
return rc;
}
/*===========================================================================
* FUNCTION : init
*
* DESCRIPTION: initialize parameter obj
*
* PARAMETERS :
* @capabilities : ptr to camera capabilities
* @mmops : ptr to memory ops table for mapping/unmapping
* @adjustFPS : object reference for additional (possibly thermal)
* framerate adjustment
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::init(cam_capability_t *capabilities,
mm_camera_vtbl_t *mmOps, QCameraAdjustFPS *adjustFPS)
{
int32_t rc = NO_ERROR;
m_pCapability = capabilities;
m_pCamOpsTbl = mmOps;
m_AdjustFPS = adjustFPS;
if (m_pParamHeap == NULL) {
LOGE("Parameter buffers have not been allocated");
rc = UNKNOWN_ERROR;
goto TRANS_INIT_ERROR1;
}
//Map memory for parameters buffer
cam_buf_map_type_list bufMapList;
rc = QCameraBufferMaps::makeSingletonBufMapList(
CAM_MAPPING_BUF_TYPE_PARM_BUF, 0 /*stream id*/,
0 /*buffer index*/, -1 /*plane index*/, 0 /*cookie*/,
m_pParamHeap->getFd(0), sizeof(parm_buffer_t), bufMapList,
m_pParamHeap->getPtr(0));
if (rc == NO_ERROR) {
rc = m_pCamOpsTbl->ops->map_bufs(m_pCamOpsTbl->camera_handle,
&bufMapList);
}
if(rc < 0) {
LOGE("failed to map SETPARM buffer");
rc = FAILED_TRANSACTION;
goto TRANS_INIT_ERROR2;
}
m_pParamBuf = (parm_buffer_t*) DATA_PTR(m_pParamHeap,0);
// Check if it is dual camera mode
if(m_relCamSyncInfo.sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
//Allocate related cam sync buffer
//this is needed for the payload that goes along with bundling cmd for related
//camera use cases
m_pRelCamSyncHeap = new QCameraHeapMemory(QCAMERA_ION_USE_CACHE);
rc = m_pRelCamSyncHeap->allocate(1,
sizeof(cam_sync_related_sensors_event_info_t), NON_SECURE);
if(rc != OK) {
rc = NO_MEMORY;
LOGE("Failed to allocate Related cam sync Heap memory");
goto TRANS_INIT_ERROR3;
}
//Map memory for related cam sync buffer
rc = m_pCamOpsTbl->ops->map_buf(m_pCamOpsTbl->camera_handle,
CAM_MAPPING_BUF_TYPE_SYNC_RELATED_SENSORS_BUF,
m_pRelCamSyncHeap->getFd(0),
sizeof(cam_sync_related_sensors_event_info_t),
(cam_sync_related_sensors_event_info_t*)DATA_PTR(m_pRelCamSyncHeap,0));
if(rc < 0) {
LOGE("failed to map Related cam sync buffer");
rc = FAILED_TRANSACTION;
goto TRANS_INIT_ERROR4;
}
m_pRelCamSyncBuf =
(cam_sync_related_sensors_event_info_t*) DATA_PTR(m_pRelCamSyncHeap,0);
}
initDefaultParameters();
mCommon.init(capabilities);
m_bInited = true;
goto TRANS_INIT_DONE;
TRANS_INIT_ERROR4:
m_pRelCamSyncHeap->deallocate();
TRANS_INIT_ERROR3:
delete m_pRelCamSyncHeap;
m_pRelCamSyncHeap = NULL;
TRANS_INIT_ERROR2:
m_pParamHeap->deallocate();
delete m_pParamHeap;
m_pParamHeap = NULL;
TRANS_INIT_ERROR1:
m_pCapability = NULL;
m_pCamOpsTbl = NULL;
m_AdjustFPS = NULL;
TRANS_INIT_DONE:
return rc;
}
/*===========================================================================
* FUNCTION : deinit
*
* DESCRIPTION: deinitialize
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
void QCameraParameters::deinit()
{
if (!m_bInited) {
return;
}
//clear all entries in the map
String8 emptyStr;
QCameraParameters::unflatten(emptyStr);
if ((NULL != m_pCamOpsTbl) && (m_pCamOpsTbl->ops != NULL)) {
m_pCamOpsTbl->ops->unmap_buf(
m_pCamOpsTbl->camera_handle,
CAM_MAPPING_BUF_TYPE_PARM_BUF);
if (m_relCamSyncInfo.sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
m_pCamOpsTbl->ops->unmap_buf(
m_pCamOpsTbl->camera_handle,
CAM_MAPPING_BUF_TYPE_SYNC_RELATED_SENSORS_BUF);
}
}
m_pCapability = NULL;
if (NULL != m_pParamHeap) {
m_pParamHeap->deallocate();
delete m_pParamHeap;
m_pParamHeap = NULL;
m_pParamBuf = NULL;
}
if (NULL != m_pRelCamSyncHeap) {
m_pRelCamSyncHeap->deallocate();
delete m_pRelCamSyncHeap;
m_pRelCamSyncHeap = NULL;
m_pRelCamSyncBuf = NULL;
}
m_AdjustFPS = NULL;
m_tempMap.clear();
m_pCamOpsTbl = NULL;
m_AdjustFPS = NULL;
m_bInited = false;
}
/*===========================================================================
* FUNCTION : parse_pair
*
* DESCRIPTION: helper function to parse string like "640x480" or "10000,20000"
*
* PARAMETERS :
* @str : input string to be parse
* @first : [output] first value of the pair
* @second : [output] second value of the pair
* @delim : [input] delimeter to seperate the pair
* @endptr : [output] ptr to the end of the pair string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::parse_pair(const char *str,
int *first,
int *second,
char delim,
char **endptr = NULL)
{
// Find the first integer.
char *end;
int w = (int)strtol(str, &end, 10);
// If a delimeter does not immediately follow, give up.
if (*end != delim) {
LOGE("Cannot find delimeter (%c) in str=%s", delim, str);
return BAD_VALUE;
}
// Find the second integer, immediately after the delimeter.
int h = (int)strtol(end+1, &end, 10);
*first = w;
*second = h;
if (endptr) {
*endptr = end;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : parseSizesList
*
* DESCRIPTION: helper function to parse string containing sizes
*
* PARAMETERS :
* @sizesStr: [input] input string to be parse
* @sizes : [output] reference to store parsed sizes
*
* RETURN : none
*==========================================================================*/
void QCameraParameters::parseSizesList(const char *sizesStr, Vector<Size> &sizes)
{
if (sizesStr == 0) {
return;
}
char *sizeStartPtr = (char *)sizesStr;
while (true) {
int width, height;
int success = parse_pair(sizeStartPtr, &width, &height, 'x',
&sizeStartPtr);
if (success == -1 || (*sizeStartPtr != ',' && *sizeStartPtr != '\0')) {
LOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
return;
}
sizes.push(Size(width, height));
if (*sizeStartPtr == '\0') {
return;
}
sizeStartPtr++;
}
}
/*===========================================================================
* FUNCTION : adjustPreviewFpsRange
*
* DESCRIPTION: adjust preview FPS ranges
* according to external events
*
* PARAMETERS :
* @minFPS : min FPS value
* @maxFPS : max FPS value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::adjustPreviewFpsRange(cam_fps_range_t *fpsRange)
{
if ( fpsRange == NULL ) {
return BAD_VALUE;
}
if ( m_pParamBuf == NULL ) {
return NO_INIT;
}
int32_t rc = initBatchUpdate(m_pParamBuf);
if ( rc != NO_ERROR ) {
LOGE("Failed to initialize group update table");
return rc;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_FPS_RANGE, *fpsRange)) {
LOGE("Parameters batch failed");
return BAD_VALUE;
}
rc = commitSetBatch();
if ( rc != NO_ERROR ) {
LOGE("Failed to commit batch parameters");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : setPreviewFpsRanges
*
* DESCRIPTION: set preview FPS ranges
*
* PARAMETERS :
* @minFPS : min FPS value
* @maxFPS : max FPS value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setPreviewFpsRange(int min_fps,
int max_fps, int vid_min_fps,int vid_max_fps)
{
char str[32];
char value[PROPERTY_VALUE_MAX];
int fixedFpsValue;
/*This property get value should be the fps that user needs*/
property_get("persist.debug.set.fixedfps", value, "0");
fixedFpsValue = atoi(value);
LOGD("E minFps = %d, maxFps = %d , vid minFps = %d, vid maxFps = %d",
min_fps, max_fps, vid_min_fps, vid_max_fps);
if(fixedFpsValue != 0) {
min_fps = max_fps = fixedFpsValue*1000;
if (!isHfrMode()) {
vid_min_fps = vid_max_fps = fixedFpsValue*1000;
}
}
snprintf(str, sizeof(str), "%d,%d", min_fps, max_fps);
LOGH("Setting preview fps range %s", str);
updateParamEntry(KEY_PREVIEW_FPS_RANGE, str);
cam_fps_range_t fps_range;
memset(&fps_range, 0x00, sizeof(cam_fps_range_t));
fps_range.min_fps = (float)min_fps / 1000.0f;
fps_range.max_fps = (float)max_fps / 1000.0f;
fps_range.video_min_fps = (float)vid_min_fps / 1000.0f;
fps_range.video_max_fps = (float)vid_max_fps / 1000.0f;
LOGH("Updated: minFps = %d, maxFps = %d ,"
" vid minFps = %d, vid maxFps = %d",
min_fps, max_fps, vid_min_fps, vid_max_fps);
if ( NULL != m_AdjustFPS ) {
if (m_ThermalMode == QCAMERA_THERMAL_ADJUST_FPS &&
!m_bRecordingHint) {
float minVideoFps = min_fps, maxVideoFps = max_fps;
if (isHfrMode()) {
minVideoFps = m_hfrFpsRange.video_min_fps;
maxVideoFps = m_hfrFpsRange.video_max_fps;
}
m_AdjustFPS->recalcFPSRange(min_fps, max_fps, minVideoFps, maxVideoFps, fps_range);
LOGH("Thermal adjusted Preview fps range %3.2f,%3.2f, %3.2f, %3.2f",
fps_range.min_fps, fps_range.max_fps,
fps_range.video_min_fps, fps_range.video_max_fps);
}
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_FPS_RANGE, fps_range)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setAutoExposure
*
* DESCRIPTION: set auto exposure
*
* PARAMETERS :
* @autoExp : auto exposure value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAutoExposure(const char *autoExp)
{
if (autoExp != NULL) {
int32_t value = lookupAttr(AUTO_EXPOSURE_MAP, PARAM_MAP_SIZE(AUTO_EXPOSURE_MAP), autoExp);
if (value != NAME_NOT_FOUND) {
LOGH("Setting auto exposure %s", autoExp);
updateParamEntry(KEY_QC_AUTO_EXPOSURE, autoExp);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_AEC_ALGO_TYPE, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid auto exposure value: %s", (autoExp == NULL) ? "NULL" : autoExp);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setEffect
*
* DESCRIPTION: set effect
*
* PARAMETERS :
* @effect : effect value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setEffect(const char *effect)
{
if (effect != NULL) {
int32_t value = lookupAttr(EFFECT_MODES_MAP, PARAM_MAP_SIZE(EFFECT_MODES_MAP), effect);
if (value != NAME_NOT_FOUND) {
LOGH("Setting effect %s", effect);
updateParamEntry(KEY_EFFECT, effect);
uint8_t prmEffect = static_cast<uint8_t>(value);
mParmEffect = prmEffect;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_EFFECT, prmEffect)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid effect value: %s", (effect == NULL) ? "NULL" : effect);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setBrightness
*
* DESCRIPTION: set brightness control value
*
* PARAMETERS :
* @brightness : brightness control value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setBrightness(int brightness)
{
char val[16];
snprintf(val, sizeof(val), "%d", brightness);
updateParamEntry(KEY_QC_BRIGHTNESS, val);
LOGH("Setting brightness %s", val);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_BRIGHTNESS, brightness)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setFocusMode
*
* DESCRIPTION: set focus mode
*
* PARAMETERS :
* @focusMode : focus mode value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFocusMode(const char *focusMode)
{
if (focusMode != NULL) {
int32_t value = lookupAttr(FOCUS_MODES_MAP, PARAM_MAP_SIZE(FOCUS_MODES_MAP), focusMode);
if (value != NAME_NOT_FOUND) {
int32_t rc = NO_ERROR;
LOGH("Setting focus mode %s", focusMode);
mFocusMode = (cam_focus_mode_type)value;
updateParamEntry(KEY_FOCUS_MODE, focusMode);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_FOCUS_MODE, (uint8_t)value)) {
rc = BAD_VALUE;
}
if (strcmp(focusMode,"infinity")==0){
set(QCameraParameters::KEY_FOCUS_DISTANCES, "Infinity,Infinity,Infinity");
}
return rc;
}
}
LOGE("Invalid focus mode value: %s", (focusMode == NULL) ? "NULL" : focusMode);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setFocusPosition
*
* DESCRIPTION: set focus position
*
* PARAMETERS :
* @typeStr : focus position type, index or dac_code
* @posStr : focus positon.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFocusPosition(const char *typeStr, const char *posStr)
{
LOGH(", type:%s, pos: %s", typeStr, posStr);
int32_t type = atoi(typeStr);
float pos = (float) atof(posStr);
if ((type >= CAM_MANUAL_FOCUS_MODE_INDEX) &&
(type < CAM_MANUAL_FOCUS_MODE_MAX)) {
// get max and min focus position from m_pCapability
float minFocusPos = m_pCapability->min_focus_pos[type];
float maxFocusPos = m_pCapability->max_focus_pos[type];
LOGH(", focusPos min: %f, max: %f", minFocusPos, maxFocusPos);
if (pos >= minFocusPos && pos <= maxFocusPos) {
updateParamEntry(KEY_QC_MANUAL_FOCUS_POS_TYPE, typeStr);
updateParamEntry(KEY_QC_MANUAL_FOCUS_POSITION, posStr);
cam_manual_focus_parm_t manual_focus;
manual_focus.flag = (cam_manual_focus_mode_type)type;
if (manual_focus.flag == CAM_MANUAL_FOCUS_MODE_DIOPTER) {
manual_focus.af_manual_diopter = pos;
} else if (manual_focus.flag == CAM_MANUAL_FOCUS_MODE_RATIO) {
manual_focus.af_manual_lens_position_ratio = (int32_t) pos;
} else if (manual_focus.flag == CAM_MANUAL_FOCUS_MODE_INDEX) {
manual_focus.af_manual_lens_position_index = (int32_t) pos;
} else {
manual_focus.af_manual_lens_position_dac = (int32_t) pos;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_MANUAL_FOCUS_POS,
manual_focus)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("invalid params, type:%d, pos: %f", type, pos);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : updateAEInfo
*
* DESCRIPTION: update exposure information from metadata callback
*
* PARAMETERS :
* @ae_params : auto exposure params
*
* RETURN : void
*==========================================================================*/
void QCameraParameters::updateAEInfo(cam_3a_params_t &ae_params)
{
const char *prevExpTime = get(KEY_QC_CURRENT_EXPOSURE_TIME);
char newExpTime[15];
snprintf(newExpTime, sizeof(newExpTime), "%f", ae_params.exp_time*1000.0);
if (prevExpTime == NULL || strcmp(prevExpTime, newExpTime)) {
LOGD("update exposure time: old: %s, new: %s", prevExpTime, newExpTime);
set(KEY_QC_CURRENT_EXPOSURE_TIME, newExpTime);
}
int32_t prevISO = getInt(KEY_QC_CURRENT_ISO);
int32_t newISO = ae_params.iso_value;
if (prevISO != newISO) {
LOGD("update iso: old:%d, new:%d", prevISO, newISO);
set(KEY_QC_CURRENT_ISO, newISO);
}
}
/*===========================================================================
* FUNCTION : updateCurrentFocusPosition
*
* DESCRIPTION: update current focus position from metadata callback
*
* PARAMETERS :
* @pos : current focus position
*
* RETURN : void
*==========================================================================*/
void QCameraParameters::updateCurrentFocusPosition(cam_focus_pos_info_t &cur_pos_info)
{
int prevScalePos = getInt(KEY_QC_FOCUS_POSITION_SCALE);
int newScalePos = (int) cur_pos_info.scale;
if (prevScalePos != newScalePos) {
LOGD("update focus scale: old:%d, new:%d", prevScalePos, newScalePos);
set(KEY_QC_FOCUS_POSITION_SCALE, newScalePos);
}
float prevDiopterPos = getFloat(KEY_QC_FOCUS_POSITION_DIOPTER);
float newDiopterPos = cur_pos_info.diopter;
if (prevDiopterPos != newDiopterPos) {
LOGD("update focus diopter: old:%f, new:%f", prevDiopterPos, newDiopterPos);
setFloat(KEY_QC_FOCUS_POSITION_DIOPTER, newDiopterPos);
}
}
/*===========================================================================
* FUNCTION : setSharpness
*
* DESCRIPTION: set sharpness control value
*
* PARAMETERS :
* @sharpness : sharpness control value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSharpness(int sharpness)
{
char val[16];
snprintf(val, sizeof(val), "%d", sharpness);
updateParamEntry(KEY_QC_SHARPNESS, val);
LOGH("Setting sharpness %s", val);
m_nSharpness = sharpness;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_SHARPNESS, m_nSharpness)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setSkinToneEnhancement
*
* DESCRIPTION: set skin tone enhancement value
*
* PARAMETERS :
* @sceFactore : skin tone enhancement factor value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSkinToneEnhancement(int sceFactor)
{
char val[16];
snprintf(val, sizeof(val), "%d", sceFactor);
updateParamEntry(KEY_QC_SCE_FACTOR, val);
LOGH("Setting skintone enhancement %s", val);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_SCE_FACTOR, sceFactor)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setSaturation
*
* DESCRIPTION: set saturation control value
*
* PARAMETERS :
* @saturation : saturation control value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSaturation(int saturation)
{
char val[16];
snprintf(val, sizeof(val), "%d", saturation);
updateParamEntry(KEY_QC_SATURATION, val);
LOGH("Setting saturation %s", val);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_SATURATION, saturation)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setContrast
*
* DESCRIPTION: set contrast control value
*
* PARAMETERS :
* @contrast : contrast control value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setContrast(int contrast)
{
char val[16];
snprintf(val, sizeof(val), "%d", contrast);
updateParamEntry(KEY_QC_CONTRAST, val);
LOGH("Setting contrast %s", val);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_CONTRAST, contrast)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setSceneDetect
*
* DESCRIPTION: set scenen detect value
*
* PARAMETERS :
* @sceneDetect : scene detect value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSceneDetect(const char *sceneDetect)
{
if (sceneDetect != NULL) {
int32_t value = lookupAttr(ON_OFF_MODES_MAP, PARAM_MAP_SIZE(ON_OFF_MODES_MAP),
sceneDetect);
if (value != NAME_NOT_FOUND) {
LOGH("Setting Scene Detect %s", sceneDetect);
updateParamEntry(KEY_QC_SCENE_DETECT, sceneDetect);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_ASD_ENABLE, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid Scene Detect value: %s",
(sceneDetect == NULL) ? "NULL" : sceneDetect);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setSensorSnapshotHDR
*
* DESCRIPTION: set snapshot HDR value
*
* PARAMETERS :
* @snapshotHDR : snapshot HDR value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSensorSnapshotHDR(const char *snapshotHDR)
{
if (snapshotHDR != NULL) {
int32_t value = (cam_sensor_hdr_type_t) lookupAttr(ON_OFF_MODES_MAP,
PARAM_MAP_SIZE(ON_OFF_MODES_MAP), snapshotHDR);
if (value != NAME_NOT_FOUND) {
LOGH("Setting Sensor Snapshot HDR %s", snapshotHDR);
updateParamEntry(KEY_QC_SENSOR_HDR, snapshotHDR);
char zz_prop[PROPERTY_VALUE_MAX];
memset(zz_prop, 0, sizeof(zz_prop));
property_get("persist.camera.zzhdr.enable", zz_prop, "0");
uint8_t zzhdr_enable = (uint8_t)atoi(zz_prop);
if (zzhdr_enable && (value != CAM_SENSOR_HDR_OFF)) {
value = CAM_SENSOR_HDR_ZIGZAG;
LOGH("%s: Overriding to ZZ HDR Mode", __func__);
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_SENSOR_HDR, (cam_sensor_hdr_type_t)value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid Snapshot HDR value: %s",
(snapshotHDR == NULL) ? "NULL" : snapshotHDR);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setVideoHDR
*
* DESCRIPTION: set video HDR value
*
* PARAMETERS :
* @videoHDR : svideo HDR value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setVideoHDR(const char *videoHDR)
{
if (videoHDR != NULL) {
int32_t value = lookupAttr(ON_OFF_MODES_MAP, PARAM_MAP_SIZE(ON_OFF_MODES_MAP), videoHDR);
if (value != NAME_NOT_FOUND) {
char zz_prop[PROPERTY_VALUE_MAX];
memset(zz_prop, 0, sizeof(zz_prop));
property_get("persist.camera.zzhdr.video", zz_prop, "0");
uint8_t use_zzhdr_video = (uint8_t)atoi(zz_prop);
if (use_zzhdr_video) {
LOGH("%s: Using ZZ HDR for video mode", __func__);
if (value)
value = CAM_SENSOR_HDR_ZIGZAG;
else
value = CAM_SENSOR_HDR_OFF;
LOGH("%s: Overriding to sensor HDR Mode to:%d", __func__, value);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_SENSOR_HDR, (cam_sensor_hdr_type_t) value)) {
LOGE("%s: Override to sensor HDR mode for video HDR failed", __func__);
return BAD_VALUE;
}
updateParamEntry(KEY_QC_VIDEO_HDR, videoHDR);
} else {
LOGH("%s: Setting Video HDR %s", __func__, videoHDR);
updateParamEntry(KEY_QC_VIDEO_HDR, videoHDR);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_VIDEO_HDR, value)) {
return BAD_VALUE;
}
}
return NO_ERROR;
}
}
LOGE("Invalid Video HDR value: %s",
(videoHDR == NULL) ? "NULL" : videoHDR);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setVtEnable
*
* DESCRIPTION: set vt Enable value
*
* PARAMETERS :
* @videoHDR : svtEnable value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setVtEnable(const char *vtEnable)
{
if (vtEnable != NULL) {
int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), vtEnable);
if (value != NAME_NOT_FOUND) {
LOGH("Setting Vt Enable %s", vtEnable);
m_bAVTimerEnabled = true;
updateParamEntry(KEY_QC_VT_ENABLE, vtEnable);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_VT, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid Vt Enable value: %s",
(vtEnable == NULL) ? "NULL" : vtEnable);
m_bAVTimerEnabled = false;
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setFaceRecognition
*
* DESCRIPTION: set face recognition value
*
* PARAMETERS :
* @faceRecog : face recognition value string
* @maxFaces : number of max faces to be detected/recognized
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFaceRecognition(const char *faceRecog,
uint32_t maxFaces)
{
if (faceRecog != NULL) {
int32_t value = lookupAttr(ON_OFF_MODES_MAP, PARAM_MAP_SIZE(ON_OFF_MODES_MAP), faceRecog);
if (value != NAME_NOT_FOUND) {
LOGH("Setting face recognition %s", faceRecog);
updateParamEntry(KEY_QC_FACE_RECOGNITION, faceRecog);
uint32_t faceProcMask = m_nFaceProcMask;
if (value > 0) {
faceProcMask |= CAM_FACE_PROCESS_MASK_RECOGNITION;
} else {
faceProcMask &= (uint32_t)(~CAM_FACE_PROCESS_MASK_RECOGNITION);
}
if(m_nFaceProcMask == faceProcMask) {
LOGH("face process mask not changed, no ops here");
return NO_ERROR;
}
m_nFaceProcMask = faceProcMask;
LOGH("FaceProcMask -> %d", m_nFaceProcMask);
// set parm for face process
cam_fd_set_parm_t fd_set_parm;
memset(&fd_set_parm, 0, sizeof(cam_fd_set_parm_t));
fd_set_parm.fd_mode = m_nFaceProcMask;
fd_set_parm.num_fd = maxFaces;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_FD, fd_set_parm)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid face recognition value: %s", (faceRecog == NULL) ? "NULL" : faceRecog);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setZoom
*
* DESCRIPTION: set zoom level
*
* PARAMETERS :
* @zoom_level : zoom level
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setZoom(int zoom_level)
{
char val[16];
snprintf(val, sizeof(val), "%d", zoom_level);
updateParamEntry(KEY_ZOOM, val);
LOGH("zoom level: %d", zoom_level);
mZoomLevel = zoom_level;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_ZOOM, zoom_level)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setISOValue
*
* DESCRIPTION: set ISO value
*
* PARAMETERS :
* @isoValue : ISO value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setISOValue(const char *isoValue)
{
if (isoValue != NULL) {
if (!strcmp(isoValue, ISO_MANUAL)) {
LOGD("iso manual mode - use continuous iso");
updateParamEntry(KEY_QC_ISO_MODE, isoValue);
return NO_ERROR;
}
int32_t value = lookupAttr(ISO_MODES_MAP, PARAM_MAP_SIZE(ISO_MODES_MAP), isoValue);
if (value != NAME_NOT_FOUND) {
LOGH("Setting ISO value %s", isoValue);
updateParamEntry(KEY_QC_ISO_MODE, isoValue);
cam_intf_parm_manual_3a_t iso_settings;
memset(&iso_settings, 0, sizeof(cam_intf_parm_manual_3a_t));
iso_settings.previewOnly = FALSE;
iso_settings.value = value;
if (getManualCaptureMode() != CAM_MANUAL_CAPTURE_TYPE_OFF) {
iso_settings.previewOnly = TRUE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_ISO, iso_settings)) {
return BAD_VALUE;
}
m_isoValue = value;
return NO_ERROR;
}
}
LOGE("Invalid ISO value: %s",
(isoValue == NULL) ? "NULL" : isoValue);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setContinuousISO
*
* DESCRIPTION: set continuous ISO value
*
* PARAMETERS :
* @params : ISO value parameter
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setContinuousISO(const QCameraParameters& params)
{
const char *iso = params.get(KEY_QC_ISO_MODE);
LOGD("current iso mode: %s", iso);
if (iso != NULL) {
if (strcmp(iso, ISO_MANUAL)) {
LOGD("dont set iso to back-end.");
return NO_ERROR;
}
}
const char *str = params.get(KEY_QC_CONTINUOUS_ISO);
const char *prev_str = get(KEY_QC_CONTINUOUS_ISO);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setContinuousISO(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setExposureTime
*
* DESCRIPTION: set exposure time
*
* PARAMETERS :
* @expTimeStr : string of exposure time in ms
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setExposureTime(const char *expTimeStr)
{
if (expTimeStr != NULL) {
double expTimeMs = atof(expTimeStr);
//input is in milli seconds. Convert to nano sec for backend
int64_t expTimeNs = (int64_t)(expTimeMs*1000000L);
// expTime == 0 means not to use manual exposure time.
if ((0 <= expTimeNs) &&
((expTimeNs == 0) ||
((expTimeNs >= m_pCapability->exposure_time_range[0]) &&
(expTimeNs <= m_pCapability->exposure_time_range[1])))) {
LOGH(", exposure time: %f ms", expTimeMs);
updateParamEntry(KEY_QC_EXPOSURE_TIME, expTimeStr);
cam_intf_parm_manual_3a_t exp_settings;
memset(&exp_settings, 0, sizeof(cam_intf_parm_manual_3a_t));
if (getManualCaptureMode() != CAM_MANUAL_CAPTURE_TYPE_OFF) {
exp_settings.previewOnly = TRUE;
if (expTimeMs < QCAMERA_MAX_EXP_TIME_LEVEL1) {
exp_settings.value = expTimeNs;
} else {
exp_settings.value =
(int64_t)(QCAMERA_MAX_EXP_TIME_LEVEL1*1000000L);
}
} else {
exp_settings.previewOnly = FALSE;
exp_settings.value = expTimeNs;
}
//Based on exposure values we can decide the capture type here
if (getManualCaptureMode() != CAM_MANUAL_CAPTURE_TYPE_OFF) {
if (expTimeMs < QCAMERA_MAX_EXP_TIME_LEVEL1) {
setManualCaptureMode(CAM_MANUAL_CAPTURE_TYPE_1);
} else if (expTimeMs < QCAMERA_MAX_EXP_TIME_LEVEL2) {
setManualCaptureMode(CAM_MANUAL_CAPTURE_TYPE_2);
} else if (expTimeMs < QCAMERA_MAX_EXP_TIME_LEVEL4) {
setManualCaptureMode(CAM_MANUAL_CAPTURE_TYPE_3);
} else {
setManualCaptureMode(CAM_MANUAL_CAPTURE_TYPE_OFF);
}
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_EXPOSURE_TIME,
exp_settings)) {
return BAD_VALUE;
}
m_expTime = expTimeNs;
return NO_ERROR;
}
}
LOGE("Invalid exposure time, value: %s",
(expTimeStr == NULL) ? "NULL" : expTimeStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setLongshotEnable
*
* DESCRIPTION: set a flag indicating longshot mode
*
* PARAMETERS :
* @enable : true - Longshot enabled
* false - Longshot disabled
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setLongshotEnable(bool enable)
{
int32_t rc = NO_ERROR;
int8_t value = enable ? 1 : 0;
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_LONGSHOT_ENABLE, value)) {
LOGE("Failed to update table");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to parameter changes");
return rc;
}
m_bLongshotEnabled = enable;
return rc;
}
/*===========================================================================
* FUNCTION : setFlash
*
* DESCRIPTION: set flash mode
*
* PARAMETERS :
* @flashStr : LED flash mode value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFlash(const char *flashStr)
{
if (flashStr != NULL) {
int32_t value = lookupAttr(FLASH_MODES_MAP, PARAM_MAP_SIZE(FLASH_MODES_MAP), flashStr);
if (value != NAME_NOT_FOUND) {
LOGH("Setting Flash value %s", flashStr);
updateParamEntry(KEY_FLASH_MODE, flashStr);
mFlashValue = value;
return NO_ERROR;
}
}
LOGE("Invalid flash value: %s", (flashStr == NULL) ? "NULL" : flashStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : updateFlashMode
*
* DESCRIPTION: update flash mode
*
* PARAMETERS :
* @flashStr : LED flash mode value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::updateFlashMode(cam_flash_mode_t flash_mode)
{
int32_t rc = NO_ERROR;
if (flash_mode >= CAM_FLASH_MODE_MAX) {
LOGH("Error!! Invalid flash mode (%d)", flash_mode);
return BAD_VALUE;
}
LOGH("Setting Flash mode from EZTune %d", flash_mode);
const char *flash_mode_str = lookupNameByValue(FLASH_MODES_MAP,
PARAM_MAP_SIZE(FLASH_MODES_MAP), flash_mode);
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
rc = setFlash(flash_mode_str);
if (rc != NO_ERROR) {
LOGE("Failed to update Flash mode");
return rc;
}
LOGH("Setting Flash mode %d", mFlashValue);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_LED_MODE, mFlashValue)) {
LOGE("Failed to set led mode");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to commit parameters");
return rc;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : configureFlash
*
* DESCRIPTION: configure Flash Bracketing.
*
* PARAMETERS :
* @frame_config : output configuration structure to fill in.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::configureFlash(cam_capture_frame_config_t &frame_config)
{
LOGH("E");
int32_t rc = NO_ERROR;
uint32_t i = 0;
if (isChromaFlashEnabled()) {
rc = setToneMapMode(false, false);
if (rc != NO_ERROR) {
LOGE("Failed to configure tone map");
return rc;
}
rc = setCDSMode(CAM_CDS_MODE_OFF, false);
if (rc != NO_ERROR) {
LOGE("Failed to configure csd mode");
return rc;
}
LOGH("Enable Chroma Flash capture");
cam_flash_mode_t flash_mode = CAM_FLASH_MODE_OFF;
frame_config.num_batch =
m_pCapability->chroma_flash_settings_need.burst_count;
if (frame_config.num_batch > CAM_MAX_FLASH_BRACKETING) {
frame_config.num_batch = CAM_MAX_FLASH_BRACKETING;
}
for (i = 0; i < frame_config.num_batch; i++) {
flash_mode = (m_pCapability->chroma_flash_settings_need.flash_bracketing[i]) ?
CAM_FLASH_MODE_ON:CAM_FLASH_MODE_OFF;
frame_config.configs[i].num_frames = 1;
frame_config.configs[i].type = CAM_CAPTURE_FLASH;
frame_config.configs[i].flash_mode = flash_mode;
}
} else if (mFlashValue != CAM_FLASH_MODE_OFF) {
frame_config.num_batch = 1;
for (i = 0; i < frame_config.num_batch; i++) {
frame_config.configs[i].num_frames = getNumOfSnapshots();
frame_config.configs[i].type = CAM_CAPTURE_FLASH;
frame_config.configs[i].flash_mode =(cam_flash_mode_t)mFlashValue;
}
}
LOGD("Flash frame batch cnt = %d",frame_config.num_batch);
return rc;
}
/*===========================================================================
* FUNCTION : configureHDRBracketing
*
* DESCRIPTION: configure HDR Bracketing.
*
* PARAMETERS :
* @frame_config : output configuration structure to fill in.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::configureHDRBracketing(cam_capture_frame_config_t &frame_config)
{
LOGH("E");
int32_t rc = NO_ERROR;
uint32_t i = 0;
uint32_t hdrFrameCount = m_pCapability->hdr_bracketing_setting.num_frames;
LOGH("HDR values %d, %d frame count: %u",
(int8_t) m_pCapability->hdr_bracketing_setting.exp_val.values[0],
(int8_t) m_pCapability->hdr_bracketing_setting.exp_val.values[1],
hdrFrameCount);
frame_config.num_batch = hdrFrameCount;
cam_bracket_mode mode =
m_pCapability->hdr_bracketing_setting.exp_val.mode;
if (mode == CAM_EXP_BRACKETING_ON) {
rc = setToneMapMode(false, true);
if (rc != NO_ERROR) {
LOGW("Failed to disable tone map during HDR");
}
}
for (i = 0; i < frame_config.num_batch; i++) {
frame_config.configs[i].num_frames = 1;
frame_config.configs[i].type = CAM_CAPTURE_BRACKETING;
frame_config.configs[i].hdr_mode.mode = mode;
frame_config.configs[i].hdr_mode.values =
m_pCapability->hdr_bracketing_setting.exp_val.values[i];
LOGD("exp values %d",
(int)frame_config.configs[i].hdr_mode.values);
}
return rc;
}
/*===========================================================================
* FUNCTION : configureAEBracketing
*
* DESCRIPTION: configure AE Bracketing.
*
* PARAMETERS :
* @frame_config : output configuration structure to fill in.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::configureAEBracketing(cam_capture_frame_config_t &frame_config)
{
LOGH("E");
int32_t rc = NO_ERROR;
uint32_t i = 0;
char exp_value[MAX_EXP_BRACKETING_LENGTH];
rc = setToneMapMode(false, true);
if (rc != NO_ERROR) {
LOGH("Failed to disable tone map during AEBracketing");
}
uint32_t burstCount = 0;
const char *str_val = m_AEBracketingClient.values;
if ((str_val != NULL) && (strlen(str_val) > 0)) {
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
strlcpy(prop, str_val, PROPERTY_VALUE_MAX);
char *saveptr = NULL;
char *token = strtok_r(prop, ",", &saveptr);
if (token != NULL) {
exp_value[burstCount++] = (char)atoi(token);
while (token != NULL) {
token = strtok_r(NULL, ",", &saveptr);
if (token != NULL) {
exp_value[burstCount++] = (char)atoi(token);
}
}
}
}
frame_config.num_batch = burstCount;
cam_bracket_mode mode = m_AEBracketingClient.mode;
for (i = 0; i < frame_config.num_batch; i++) {
frame_config.configs[i].num_frames = 1;
frame_config.configs[i].type = CAM_CAPTURE_BRACKETING;
frame_config.configs[i].hdr_mode.mode = mode;
frame_config.configs[i].hdr_mode.values =
m_AEBracketingClient.values[i];
LOGD("exp values %d", (int)m_AEBracketingClient.values[i]);
}
LOGH("num_frame = %d X", burstCount);
return rc;
}
/*===========================================================================
* FUNCTION : configureLowLight
*
* DESCRIPTION: configure low light frame capture use case.
*
* PARAMETERS :
* @frame_config : output configuration structure to fill in.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::configureLowLight(cam_capture_frame_config_t &frame_config)
{
int32_t rc = NO_ERROR;
frame_config.num_batch = 1;
frame_config.configs[0].num_frames = getNumOfSnapshots();
frame_config.configs[0].type = CAM_CAPTURE_LOW_LIGHT;
frame_config.configs[0].low_light_mode = CAM_LOW_LIGHT_ON;
LOGH("Snapshot Count: %d", frame_config.configs[0].num_frames);
return rc;
}
/*===========================================================================
* FUNCTION : configureManualCapture
*
* DESCRIPTION: configure manual capture.
*
* PARAMETERS :
* @frame_config : output configaration structure to fill in.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::configureManualCapture(cam_capture_frame_config_t &frame_config)
{
int32_t rc = NO_ERROR;
uint32_t i = 0;
LOGD("E");
if (getManualCaptureMode()) {
frame_config.num_batch = 1;
for (i = 0; i < frame_config.num_batch; i++) {
frame_config.configs[i].num_frames = getNumOfSnapshots();
frame_config.configs[i].type = CAM_CAPTURE_MANUAL_3A;
if (m_expTime != 0) {
frame_config.configs[i].manual_3A_mode.exp_mode = CAM_SETTINGS_TYPE_ON;
frame_config.configs[i].manual_3A_mode.exp_time = m_expTime;
} else {
frame_config.configs[i].manual_3A_mode.exp_mode = CAM_SETTINGS_TYPE_AUTO;
frame_config.configs[i].manual_3A_mode.exp_time = 0;
}
if (m_isoValue != 0) {
frame_config.configs[i].manual_3A_mode.iso_mode = CAM_SETTINGS_TYPE_ON;
frame_config.configs[i].manual_3A_mode.iso_value = m_isoValue;
} else {
frame_config.configs[i].manual_3A_mode.iso_mode = CAM_SETTINGS_TYPE_AUTO;
frame_config.configs[i].manual_3A_mode.iso_value = 0;
}
}
}
LOGD("X: batch cnt = %d", frame_config.num_batch);
return rc;
}
/*===========================================================================
* FUNCTION : configFrameCapture
*
* DESCRIPTION: configuration for ZSL special captures (FLASH/HDR etc)
*
* PARAMETERS :
* @commitSettings : flag to enable or disable commit this this settings
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::configFrameCapture(bool commitSettings)
{
int32_t rc = NO_ERROR;
int32_t value;
memset(&m_captureFrameConfig, 0, sizeof(cam_capture_frame_config_t));
if (commitSettings) {
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
}
if (isHDREnabled() || m_bAeBracketingEnabled || m_bAFBracketingOn ||
m_bOptiZoomOn || m_bReFocusOn || m_LowLightLevel
|| getManualCaptureMode()) {
value = CAM_FLASH_MODE_OFF;
} else if (isChromaFlashEnabled()) {
value = CAM_FLASH_MODE_ON;
} else {
value = mFlashValue;
}
if (value != CAM_FLASH_MODE_OFF) {
configureFlash(m_captureFrameConfig);
} else if(isHDREnabled()) {
configureHDRBracketing (m_captureFrameConfig);
} else if(isAEBracketEnabled()) {
configureAEBracketing (m_captureFrameConfig);
} else if (m_LowLightLevel) {
configureLowLight (m_captureFrameConfig);
//Added reset capture type as a last batch for back-end to restore settings.
int32_t batch_count = m_captureFrameConfig.num_batch;
m_captureFrameConfig.configs[batch_count].type = CAM_CAPTURE_RESET;
m_captureFrameConfig.configs[batch_count].num_frames = 0;
m_captureFrameConfig.num_batch++;
} else if (getManualCaptureMode() >= CAM_MANUAL_CAPTURE_TYPE_2){
rc = configureManualCapture (m_captureFrameConfig);
//Added reset capture type as a last batch for back-end to restore settings.
int32_t batch_count = m_captureFrameConfig.num_batch;
m_captureFrameConfig.configs[batch_count].type = CAM_CAPTURE_RESET;
m_captureFrameConfig.configs[batch_count].num_frames = 0;
m_captureFrameConfig.num_batch++;
}
rc = ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_CAPTURE_FRAME_CONFIG,
(cam_capture_frame_config_t)m_captureFrameConfig);
if (rc != NO_ERROR) {
rc = BAD_VALUE;
LOGE("Failed to set capture settings");
return rc;
}
if (commitSettings) {
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to commit parameters");
return rc;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : resetFrameCapture
*
* DESCRIPTION: reset special captures settings(FLASH/HDR etc)
*
* PARAMETERS :
* @commitSettings : flag to enable or disable commit this this settings
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::resetFrameCapture(bool commitSettings)
{
int32_t rc = NO_ERROR;
memset(&m_captureFrameConfig, 0, sizeof(cam_capture_frame_config_t));
if (commitSettings) {
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
}
if (isHDREnabled() || isAEBracketEnabled()) {
rc = setToneMapMode(true, true);
if (rc != NO_ERROR) {
LOGH("Failed to enable tone map during HDR/AEBracketing");
}
rc = stopAEBracket();
} else if ((isChromaFlashEnabled()) || (mFlashValue != CAM_FLASH_MODE_OFF)
|| (getLowLightLevel() != CAM_LOW_LIGHT_OFF)) {
rc = setToneMapMode(true, false);
if (rc != NO_ERROR) {
LOGH("Failed to enable tone map during chroma flash");
}
rc = setCDSMode(mCds_mode, false);
if (rc != NO_ERROR) {
LOGE("Failed to configure csd mode");
return rc;
}
}
rc = ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_CAPTURE_FRAME_CONFIG,
(cam_capture_frame_config_t)m_captureFrameConfig);
if (rc != NO_ERROR) {
rc = BAD_VALUE;
LOGE("Failed to set capture settings");
return rc;
}
if (commitSettings) {
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to commit parameters");
return rc;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : setAecLock
*
* DESCRIPTION: set AEC lock value
*
* PARAMETERS :
* @aecLockStr : AEC lock value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAecLock(const char *aecLockStr)
{
if (aecLockStr != NULL) {
int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP, PARAM_MAP_SIZE(TRUE_FALSE_MODES_MAP),
aecLockStr);
if (value != NAME_NOT_FOUND) {
LOGH("Setting AECLock value %s", aecLockStr);
updateParamEntry(KEY_AUTO_EXPOSURE_LOCK, aecLockStr);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_AEC_LOCK, (uint32_t)value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid AECLock value: %s",
(aecLockStr == NULL) ? "NULL" : aecLockStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setAwbLock
*
* DESCRIPTION: set AWB lock value
*
* PARAMETERS :
* @awbLockStr : AWB lock value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAwbLock(const char *awbLockStr)
{
if (awbLockStr != NULL) {
int32_t value = lookupAttr(TRUE_FALSE_MODES_MAP, PARAM_MAP_SIZE(TRUE_FALSE_MODES_MAP),
awbLockStr);
if (value != NAME_NOT_FOUND) {
LOGH("Setting AWBLock value %s", awbLockStr);
updateParamEntry(KEY_AUTO_WHITEBALANCE_LOCK, awbLockStr);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_AWB_LOCK, (uint32_t)value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid AWBLock value: %s", (awbLockStr == NULL) ? "NULL" : awbLockStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setMCEValue
*
* DESCRIPTION: set memory color enhancement value
*
* PARAMETERS :
* @mceStr : MCE value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setMCEValue(const char *mceStr)
{
if (mceStr != NULL) {
int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), mceStr);
if (value != NAME_NOT_FOUND) {
LOGH("Setting AWBLock value %s", mceStr);
updateParamEntry(KEY_QC_MEMORY_COLOR_ENHANCEMENT, mceStr);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_MCE, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid MCE value: %s", (mceStr == NULL) ? "NULL" : mceStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setTintlessValue
*
* DESCRIPTION: enable/disable tintless from user setting
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setTintlessValue(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_TINTLESS_ENABLE);
const char *prev_str = get(KEY_QC_TINTLESS_ENABLE);
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.tintless", prop, VALUE_ENABLE);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setTintlessValue(str);
}
} else {
if (prev_str == NULL ||
strcmp(prev_str, prop) != 0 ) {
setTintlessValue(prop);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setTintless
*
* DESCRIPTION: set tintless mode
*
* PARAMETERS :
* @enable : 1 = enable, 0 = disable
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
void QCameraParameters::setTintless(bool enable)
{
if (enable) {
setTintlessValue(VALUE_ENABLE);
} else {
setTintlessValue(VALUE_DISABLE);
}
}
/*===========================================================================
* FUNCTION : setTintlessValue
*
* DESCRIPTION: set tintless value
*
* PARAMETERS :
* @tintStr : Tintless value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setTintlessValue(const char *tintStr)
{
if (tintStr != NULL) {
int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), tintStr);
if (value != NAME_NOT_FOUND) {
LOGH("Setting Tintless value %s", tintStr);
updateParamEntry(KEY_QC_TINTLESS_ENABLE, tintStr);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_TINTLESS, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid Tintless value: %s", (tintStr == NULL) ? "NULL" : tintStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setCDSMode
*
* DESCRIPTION: Set CDS mode
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setCDSMode(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_CDS_MODE);
const char *prev_str = get(KEY_QC_CDS_MODE);
const char *video_str = params.get(KEY_QC_VIDEO_CDS_MODE);
const char *video_prev_str = get(KEY_QC_VIDEO_CDS_MODE);
int32_t rc = NO_ERROR;
if (m_bRecordingHint_new == true) {
if (video_str) {
if ((video_prev_str == NULL) || (strcmp(video_str, video_prev_str) != 0)) {
int32_t cds_mode = lookupAttr(CDS_MODES_MAP, PARAM_MAP_SIZE(CDS_MODES_MAP),
video_str);
if (cds_mode != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_VIDEO_CDS_MODE, video_str);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_CDS_MODE, cds_mode)) {
LOGE("Failed CDS MODE to update table");
rc = BAD_VALUE;
} else {
LOGD("Set CDS in video mode = %d", cds_mode);
mCds_mode = cds_mode;
m_bNeedRestart = true;
}
} else {
LOGE("Invalid argument for video CDS MODE %d", cds_mode);
rc = BAD_VALUE;
}
}
} else {
char video_prop[PROPERTY_VALUE_MAX];
memset(video_prop, 0, sizeof(video_prop));
property_get("persist.camera.video.CDS", video_prop, CDS_MODE_ON);
int32_t cds_mode = lookupAttr(CDS_MODES_MAP, PARAM_MAP_SIZE(CDS_MODES_MAP),
video_prop);
if (cds_mode != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_VIDEO_CDS_MODE, video_prop);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_CDS_MODE, cds_mode)) {
LOGE("Failed CDS MODE to update table");
rc = BAD_VALUE;
} else {
LOGD("Set CDS in video mode from setprop = %d", cds_mode);
mCds_mode = cds_mode;
}
} else {
LOGE("Invalid prop for video CDS MODE %d", cds_mode);
rc = BAD_VALUE;
}
}
} else {
if (str) {
if ((prev_str == NULL) || (strcmp(str, prev_str) != 0)) {
int32_t cds_mode = lookupAttr(CDS_MODES_MAP, PARAM_MAP_SIZE(CDS_MODES_MAP),
str);
if (cds_mode != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_CDS_MODE, str);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_CDS_MODE, cds_mode)) {
LOGE("Failed CDS MODE to update table");
rc = BAD_VALUE;
} else {
LOGD("Set CDS in capture mode = %d", cds_mode);
mCds_mode = cds_mode;
m_bNeedRestart = true;
}
} else {
LOGE("Invalid argument for snapshot CDS MODE %d", cds_mode);
rc = BAD_VALUE;
}
}
} else {
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.CDS", prop, CDS_MODE_ON);
int32_t cds_mode = lookupAttr(CDS_MODES_MAP, PARAM_MAP_SIZE(CDS_MODES_MAP),
prop);
if (cds_mode != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_CDS_MODE, prop);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_CDS_MODE, cds_mode)) {
LOGE("Failed CDS MODE to update table");
rc = BAD_VALUE;
} else {
LOGD("Set CDS in snapshot mode from setprop = %d", cds_mode);
mCds_mode = cds_mode;
}
} else {
LOGE("Invalid prop for snapshot CDS MODE %d", cds_mode);
rc = BAD_VALUE;
}
}
}
return rc;
}
/*===========================================================================
* FUNCTION : setInitialExposureIndex
*
* DESCRIPTION: Set initial exposure index value
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setInitialExposureIndex(const QCameraParameters& params)
{
int32_t rc = NO_ERROR;
int value = -1;
const char *str = params.get(KEY_QC_INITIAL_EXPOSURE_INDEX);
const char *prev_str = get(KEY_QC_INITIAL_EXPOSURE_INDEX);
if (str) {
if ((prev_str == NULL) || (strcmp(str, prev_str) != 0)) {
value = atoi(str);
LOGD("Set initial exposure index value from param = %d", value);
if (value >= 0) {
updateParamEntry(KEY_QC_INITIAL_EXPOSURE_INDEX, str);
}
}
} else {
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.initial.exp.val", prop, "");
if ((strlen(prop) > 0) &&
( (prev_str == NULL) || (strcmp(prop, prev_str) != 0))) {
value = atoi(prop);
LOGD("Set initial exposure index value from setprop = %d", value);
if (value >= 0) {
updateParamEntry(KEY_QC_INITIAL_EXPOSURE_INDEX, prop);
}
}
}
if (value >= 0) {
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_INITIAL_EXPOSURE_INDEX, (uint32_t)value)) {
LOGE("Failed to update initial exposure index value");
rc = BAD_VALUE;
}
} else {
LOGD("Invalid value for initial exposure index value %d", value);
}
return rc;
}
/*===========================================================================
* FUNCTION : setInstantCapture
*
* DESCRIPTION: Set Instant Capture related params
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setInstantCapture(const QCameraParameters& params)
{
int32_t rc = NO_ERROR;
int value = -1;
// Check for instant capture, this will enable instant AEC as well.
// This param will trigger the instant AEC param to backend
// And also will be useful for instant capture.
const char *str = params.get(KEY_QC_INSTANT_CAPTURE);
const char *prev_str = get(KEY_QC_INSTANT_CAPTURE);
if (str) {
if ((prev_str == NULL) || (strcmp(str, prev_str) != 0)) {
value = lookupAttr(INSTANT_CAPTURE_MODES_MAP,
PARAM_MAP_SIZE(INSTANT_CAPTURE_MODES_MAP), str);
LOGD("Set instant Capture from param = %d", value);
if(value != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_INSTANT_CAPTURE, str);
}
}
} else {
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.instant.capture", prop, KEY_QC_INSTANT_CAPTURE_DISABLE);
if ((prev_str == NULL) || (strcmp(prop, prev_str) != 0)) {
value = lookupAttr(INSTANT_CAPTURE_MODES_MAP,
PARAM_MAP_SIZE(INSTANT_CAPTURE_MODES_MAP), prop);
LOGD("Set instant capture from setprop = %d", value);
if (value != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_INSTANT_CAPTURE, prop);
}
}
}
// Set instant AEC param to the backend for either instant capture or instant AEC
// 0 - disbale (normal AEC)
// 1 - Aggressive AEC (algo used in backend)
// 2 - Fast AEC (algo used in backend)
if (value != NAME_NOT_FOUND && value != -1) {
m_bInstantCapture = (value > 0)? true : false;
setInstantAEC((uint8_t)value, false);
}
// get frame aec bound value from setprop.
// This value indicates the number of frames, camera interface
// will wait for getting the instant capture frame.
// Default value set to 7.
// This value also indicates the number of frames, that HAL
// will not display and will not send preview frames to app
// This will be applicable only if instant capture is set.
if (m_bInstantCapture) {
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.ae.capture.bound", prop, "7");
int32_t frame_bound = atoi(prop);
if (frame_bound >= 0) {
mAecFrameBound = (uint8_t)frame_bound;
} else {
LOGE("Invalid prop for aec frame bound %d", frame_bound);
rc = BAD_VALUE;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : setInstantAEC
*
* DESCRIPTION: Set Instant AEC related params
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setInstantAEC(const QCameraParameters& params)
{
int32_t rc = NO_ERROR;
int value = -1;
// Check for instant AEC only when instant capture is not enabled.
// Instant capture already takes care of the instant AEC as well.
if (!m_bInstantCapture) {
// Check for instant AEC. Instant AEC will only enable fast AEC.
// It will not enable instant capture.
// This param will trigger the instant AEC param to backend
const char *str = params.get(KEY_QC_INSTANT_AEC);
const char *prev_str = get(KEY_QC_INSTANT_AEC);
if (str) {
if ((prev_str == NULL) || (strcmp(str, prev_str) != 0)) {
value = lookupAttr(INSTANT_AEC_MODES_MAP,
PARAM_MAP_SIZE(INSTANT_AEC_MODES_MAP), str);
LOGD("Set instant AEC from param = %d", value);
}
} else {
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.instant.aec", prop, KEY_QC_INSTANT_AEC_DISABLE);
if ((prev_str == NULL) || (strcmp(prop, prev_str) != 0)) {
value = lookupAttr(INSTANT_AEC_MODES_MAP,
PARAM_MAP_SIZE(INSTANT_AEC_MODES_MAP), prop);
LOGD("Set instant AEC from setprop = %d", value);
}
}
// Set instant AEC param to the backend for either instant capture or instant AEC
// 0 - disbale (normal AEC)
// 1 - Aggressive AEC (algo used in backend)
// 2 - Fast AEC (algo used in backend)
if (value != NAME_NOT_FOUND && value != -1) {
setInstantAEC((uint8_t)value, false);
}
}
// get frame aec preview skip count from setprop.
// This value indicates the number of frames, that HAL
// will not display and will not send preview frames to app
// Default value set to 7.
// This will be applicable only if instant aec is set.
if (m_bInstantAEC) {
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.ae.instant.bound", prop, "7");
int32_t aec_frame_skip_cnt = atoi(prop);
if (aec_frame_skip_cnt >= 0) {
mAecSkipDisplayFrameBound = (uint8_t)aec_frame_skip_cnt;
} else {
LOGE("Invalid prop for aec frame bound %d", aec_frame_skip_cnt);
rc = BAD_VALUE;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : setDISValue
*
* DESCRIPTION: set DIS value
*
* PARAMETERS :
* @disStr : DIS value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setDISValue(const char *disStr)
{
if (disStr != NULL) {
int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), disStr);
if (value != NAME_NOT_FOUND) {
//For some IS types (like EIS 2.0), when DIS value is changed, we need to restart
//preview because of topology change in backend. But, for now, restart preview
//for all IS types.
m_bNeedRestart = true;
LOGH("Setting DIS value %s", disStr);
updateParamEntry(KEY_QC_DIS, disStr);
if (!(strcmp(disStr,"enable"))) {
m_bDISEnabled = true;
} else {
m_bDISEnabled = false;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_DIS_ENABLE, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid DIS value: %s", (disStr == NULL) ? "NULL" : disStr);
m_bDISEnabled = false;
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : updateOisValue
*
* DESCRIPTION: update OIS value
*
* PARAMETERS :
* @oisValue : OIS value TRUE/FALSE
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::updateOisValue(bool oisValue)
{
uint8_t enable = 0;
int32_t rc = NO_ERROR;
// Check for OIS disable
char ois_prop[PROPERTY_VALUE_MAX];
memset(ois_prop, 0, sizeof(ois_prop));
property_get("persist.camera.ois.disable", ois_prop, "0");
uint8_t ois_disable = (uint8_t)atoi(ois_prop);
//Enable OIS if it is camera mode or Camcoder 4K mode
if (!m_bRecordingHint || (is4k2kVideoResolution() && m_bRecordingHint)) {
enable = 1;
LOGH("Valid OIS mode!! ");
}
// Disable OIS if setprop is set
if (ois_disable || !oisValue) {
//Disable OIS
enable = 0;
LOGH("Disable OIS mode!! ois_disable(%d) oisValue(%d)",
ois_disable, oisValue);
}
m_bOISEnabled = enable;
if (m_bOISEnabled) {
updateParamEntry(KEY_QC_OIS, VALUE_ENABLE);
} else {
updateParamEntry(KEY_QC_OIS, VALUE_DISABLE);
}
if (initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
LOGH("Sending OIS mode (%d)", enable);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_META_LENS_OPT_STAB_MODE, enable)) {
LOGE("Failed to update table");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to parameter changes");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : setHighFrameRate
*
* DESCRIPTION: set high frame rate
*
* PARAMETERS :
* @hfrMode : HFR mode
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setHighFrameRate(const int32_t hfrMode)
{
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_HFR, hfrMode)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setLensShadeValue
*
* DESCRIPTION: set lens shade value
*
* PARAMETERS :
* @lensSahdeStr : lens shade value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setLensShadeValue(const char *lensShadeStr)
{
if (lensShadeStr != NULL) {
int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), lensShadeStr);
if (value != NAME_NOT_FOUND) {
LOGH("Setting LensShade value %s", lensShadeStr);
updateParamEntry(KEY_QC_LENSSHADE, lensShadeStr);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_ROLLOFF, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid LensShade value: %s",
(lensShadeStr == NULL) ? "NULL" : lensShadeStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setExposureCompensation
*
* DESCRIPTION: set exposure compensation value
*
* PARAMETERS :
* @expComp : exposure compensation value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setExposureCompensation(int expComp)
{
char val[16];
snprintf(val, sizeof(val), "%d", expComp);
updateParamEntry(KEY_EXPOSURE_COMPENSATION, val);
// Don't need to pass step as part of setParameter because
// camera daemon is already aware of it.
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_EXPOSURE_COMPENSATION, expComp)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setWhiteBalance
*
* DESCRIPTION: set white balance mode
*
* PARAMETERS :
* @wbStr : white balance mode value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setWhiteBalance(const char *wbStr)
{
if (wbStr != NULL) {
int32_t value = lookupAttr(WHITE_BALANCE_MODES_MAP,
PARAM_MAP_SIZE(WHITE_BALANCE_MODES_MAP), wbStr);
if (value != NAME_NOT_FOUND) {
LOGH("Setting WhiteBalance value %s", wbStr);
updateParamEntry(KEY_WHITE_BALANCE, wbStr);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_WHITE_BALANCE, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid WhiteBalance value: %s", (wbStr == NULL) ? "NULL" : wbStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setWBManualCCT
*
* DESCRIPTION: set setWBManualCCT time
*
* PARAMETERS :
* @cctStr : string of wb cct, range (2000, 8000) in K.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setWBManualCCT(const char *cctStr)
{
if (cctStr != NULL) {
int32_t cctVal = atoi(cctStr);
int32_t minCct = m_pCapability->min_wb_cct; /* 2000K */
int32_t maxCct = m_pCapability->max_wb_cct; /* 8000K */
if (cctVal >= minCct && cctVal <= maxCct) {
LOGH(", cct value: %d", cctVal);
updateParamEntry(KEY_QC_WB_MANUAL_CCT, cctStr);
cam_manual_wb_parm_t manual_wb;
manual_wb.type = CAM_MANUAL_WB_MODE_CCT;
manual_wb.cct = cctVal;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_WB_MANUAL, manual_wb)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid cct, value: %s",
(cctStr == NULL) ? "NULL" : cctStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : updateAWBParams
*
* DESCRIPTION: update CCT parameters key
*
* PARAMETERS :
* @awb_params : WB parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::updateAWBParams(cam_awb_params_t &awb_params)
{
//check and update CCT
int32_t prev_cct = getInt(KEY_QC_WB_MANUAL_CCT);
if (prev_cct != awb_params.cct_value) {
LOGD("update current cct value. old:%d, now:%d",
prev_cct, awb_params.cct_value);
set(KEY_QC_WB_MANUAL_CCT, awb_params.cct_value);
}
//check and update WB gains
const char *prev_gains = get(KEY_QC_MANUAL_WB_GAINS);
char gainStr[30];
snprintf(gainStr, sizeof(gainStr), "%f,%f,%f", awb_params.rgb_gains.r_gain,
awb_params.rgb_gains.g_gain, awb_params.rgb_gains.b_gain);
if (prev_gains == NULL || strcmp(prev_gains, gainStr)) {
set(KEY_QC_MANUAL_WB_GAINS, gainStr);
LOGD("update currernt RGB gains: old %s new %s", prev_gains, gainStr);
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : parseGains
*
* DESCRIPTION: parse WB gains
*
* PARAMETERS :
* @gainStr : WB result string
* @r_gain : WB red gain
* @g_gain : WB green gain
* @b_gain : WB blue gain
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::parseGains(const char *gainStr, double &r_gain,
double &g_gain, double &b_gain)
{
int32_t rc = NO_ERROR;
char *saveptr = NULL;
size_t gains_size = strlen(gainStr) + 1;
char* gains = (char*) calloc(1, gains_size);
if (NULL == gains) {
LOGE("No memory for gains");
return NO_MEMORY;
}
strlcpy(gains, gainStr, gains_size);
char *token = strtok_r(gains, ",", &saveptr);
if (NULL != token) {
r_gain = (float) atof(token);
token = strtok_r(NULL, ",", &saveptr);
}
if (NULL != token) {
g_gain = (float) atof(token);
token = strtok_r(NULL, ",", &saveptr);
}
if (NULL != token) {
b_gain = (float) atof(token);
} else {
LOGE("Malformed string for gains");
rc = BAD_VALUE;
}
free(gains);
return rc;
}
/*===========================================================================
* FUNCTION : setManualWBGains
*
* DESCRIPTION: set manual wb gains for r,g,b
*
* PARAMETERS :
* @cctStr : string of wb gains, range (1.0, 4.0).
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setManualWBGains(const char *gainStr)
{
int32_t rc = NO_ERROR;
if (gainStr != NULL) {
double r_gain,g_gain,b_gain;
rc = parseGains(gainStr, r_gain, g_gain, b_gain);
if (rc != NO_ERROR) {
return rc;
}
double minGain = m_pCapability->min_wb_gain;
double maxGain = m_pCapability->max_wb_gain;
if (r_gain >= minGain && r_gain <= maxGain &&
g_gain >= minGain && g_gain <= maxGain &&
b_gain >= minGain && b_gain <= maxGain) {
LOGH(", setting rgb gains: r = %lf g = %lf b = %lf",
r_gain, g_gain, b_gain);
updateParamEntry(KEY_QC_MANUAL_WB_GAINS, gainStr);
cam_manual_wb_parm_t manual_wb;
manual_wb.type = CAM_MANUAL_WB_MODE_GAIN;
manual_wb.gains.r_gain = r_gain;
manual_wb.gains.g_gain = g_gain;
manual_wb.gains.b_gain = b_gain;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_WB_MANUAL, manual_wb)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGH("Invalid manual wb gains: %s",
(gainStr == NULL) ? "NULL" : gainStr);
return BAD_VALUE;
}
int QCameraParameters::getAutoFlickerMode()
{
/* Enable Advanced Auto Antibanding where we can set
any of the following option
ie. CAM_ANTIBANDING_MODE_AUTO
CAM_ANTIBANDING_MODE_AUTO_50HZ
CAM_ANTIBANDING_MODE_AUTO_60HZ
Currently setting it to default */
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.set.afd", prop, "3");
return atoi(prop);
}
/*===========================================================================
* FUNCTION : setAntibanding
*
* DESCRIPTION: set antibanding value
*
* PARAMETERS :
* @antiBandingStr : antibanding value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAntibanding(const char *antiBandingStr)
{
if (antiBandingStr != NULL) {
int32_t value = lookupAttr(ANTIBANDING_MODES_MAP, PARAM_MAP_SIZE(ANTIBANDING_MODES_MAP),
antiBandingStr);
if (value != NAME_NOT_FOUND) {
LOGH("Setting AntiBanding value %s", antiBandingStr);
updateParamEntry(KEY_ANTIBANDING, antiBandingStr);
if(value == CAM_ANTIBANDING_MODE_AUTO) {
value = getAutoFlickerMode();
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_ANTIBANDING, (uint32_t)value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid AntiBanding value: %s",
(antiBandingStr == NULL) ? "NULL" : antiBandingStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setFocusAreas
*
* DESCRIPTION: set focus areas
*
* PARAMETERS :
* @focusAreasStr : focus areas value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFocusAreas(const char *focusAreasStr)
{
if (m_pCapability->max_num_focus_areas == 0 ||
focusAreasStr == NULL) {
LOGD("Parameter string is null");
return NO_ERROR;
}
cam_area_t *areas = (cam_area_t *)malloc(sizeof(cam_area_t) * m_pCapability->max_num_focus_areas);
if (NULL == areas) {
LOGE("No memory for areas");
return NO_MEMORY;
}
memset(areas, 0, sizeof(cam_area_t) * m_pCapability->max_num_focus_areas);
int num_areas_found = 0;
if (parseCameraAreaString(focusAreasStr,
m_pCapability->max_num_focus_areas,
areas,
num_areas_found) != NO_ERROR) {
LOGE("Failed to parse the string: %s", focusAreasStr);
free(areas);
return BAD_VALUE;
}
if (validateCameraAreas(areas, num_areas_found) == false) {
LOGE("invalid areas specified : %s", focusAreasStr);
free(areas);
return BAD_VALUE;
}
updateParamEntry(KEY_FOCUS_AREAS, focusAreasStr);
//for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
//so no action is takenby the lower layer
if (num_areas_found == 1 &&
areas[0].rect.left == 0 &&
areas[0].rect.top == 0 &&
areas[0].rect.width == 0 &&
areas[0].rect.height == 0 &&
areas[0].weight == 0) {
num_areas_found = 0;
}
int previewWidth, previewHeight;
getPreviewSize(&previewWidth, &previewHeight);
cam_roi_info_t af_roi_value;
memset(&af_roi_value, 0, sizeof(cam_roi_info_t));
af_roi_value.num_roi = (uint8_t)num_areas_found;
for (int i = 0; i < num_areas_found; i++) {
LOGH("FocusArea[%d] = (%d, %d, %d, %d)",
i, (areas[i].rect.top), (areas[i].rect.left),
(areas[i].rect.width), (areas[i].rect.height));
// Transform the coords from (-1000, 1000)
// to (0, previewWidth or previewHeight).
af_roi_value.roi[i].left =
(int32_t)(((double)areas[i].rect.left + 1000.0) *
((double)previewWidth / 2000.0));
af_roi_value.roi[i].top =
(int32_t)(((double)areas[i].rect.top + 1000.0) *
((double)previewHeight / 2000.0));
af_roi_value.roi[i].width =
(int32_t)((double)areas[i].rect.width *
(double)previewWidth / 2000.0);
af_roi_value.roi[i].height =
(int32_t)((double)areas[i].rect.height *
(double)previewHeight / 2000.0);
af_roi_value.weight[i] = areas[i].weight;
}
free(areas);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_AF_ROI, af_roi_value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setMeteringAreas
*
* DESCRIPTION: set metering areas value
*
* PARAMETERS :
* @meteringAreasStr : metering areas value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setMeteringAreas(const char *meteringAreasStr)
{
if (m_pCapability->max_num_metering_areas == 0 ||
meteringAreasStr == NULL) {
LOGD("Parameter string is null");
return NO_ERROR;
}
cam_area_t *areas = (cam_area_t *)malloc(sizeof(cam_area_t) * m_pCapability->max_num_metering_areas);
if (NULL == areas) {
LOGE("No memory for areas");
return NO_MEMORY;
}
memset(areas, 0, sizeof(cam_area_t) * m_pCapability->max_num_metering_areas);
int num_areas_found = 0;
if (parseCameraAreaString(meteringAreasStr,
m_pCapability->max_num_metering_areas,
areas,
num_areas_found) < 0) {
LOGE("Failed to parse the string: %s", meteringAreasStr);
free(areas);
return BAD_VALUE;
}
if (validateCameraAreas(areas, num_areas_found) == false) {
LOGE("invalid areas specified : %s", meteringAreasStr);
free(areas);
return BAD_VALUE;
}
updateParamEntry(KEY_METERING_AREAS, meteringAreasStr);
//for special area string (0, 0, 0, 0, 0), set the num_areas_found to 0,
//so no action is takenby the lower layer
if (num_areas_found == 1 &&
areas[0].rect.left == 0 &&
areas[0].rect.top == 0 &&
areas[0].rect.width == 0 &&
areas[0].rect.height == 0 &&
areas[0].weight == 0) {
num_areas_found = 0;
}
cam_set_aec_roi_t aec_roi_value;
int previewWidth, previewHeight;
getPreviewSize(&previewWidth, &previewHeight);
memset(&aec_roi_value, 0, sizeof(cam_set_aec_roi_t));
if (num_areas_found > 0) {
aec_roi_value.aec_roi_enable = CAM_AEC_ROI_ON;
aec_roi_value.aec_roi_type = CAM_AEC_ROI_BY_COORDINATE;
for (int i = 0; i < num_areas_found; i++) {
LOGH("MeteringArea[%d] = (%d, %d, %d, %d)",
i, (areas[i].rect.top), (areas[i].rect.left),
(areas[i].rect.width), (areas[i].rect.height));
// Transform the coords from (-1000, 1000) to
// (0, previewWidth or previewHeight).
aec_roi_value.cam_aec_roi_position.coordinate[i].x =
(uint32_t)((((double)areas[i].rect.left +
(double)areas[i].rect.width / 2.0) + 1000.0) *
(double)previewWidth / 2000.0);
aec_roi_value.cam_aec_roi_position.coordinate[i].y =
(uint32_t)((((double)areas[i].rect.top +
(double)areas[i].rect.height / 2.0) + 1000.0) *
(double)previewHeight / 2000.0);
}
} else {
aec_roi_value.aec_roi_enable = CAM_AEC_ROI_OFF;
}
free(areas);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_AEC_ROI, aec_roi_value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : isSupportedSensorHdrSize
*
* DESCRIPTION: Checks if the requested snapshot size is compatible with currently
* configured HDR mode, currently primary target for validation is
* zzhdr however this function can be extended in the future to vet
* all sensor based HDR configs
*
* PARAMETERS :
* @params : CameraParameters object
*
* RETURN : boolean type
* True -- indicates supported config
* False -- indicated unsupported config should fallback to other
* available HDR modes
*==========================================================================*/
bool QCameraParameters::isSupportedSensorHdrSize(const QCameraParameters& params)
{
char value[PROPERTY_VALUE_MAX];
memset(value, 0, sizeof(value));
property_get("persist.camera.zzhdr.enable", value, "0");
uint8_t zzhdr_enable = (uint8_t)atoi(value);
if (zzhdr_enable) {
int req_w, req_h;
params.getPictureSize(&req_w, &req_h);
// Check if requested w x h is in zzhdr supported list
for (size_t i = 0; i< m_pCapability->zzhdr_sizes_tbl_cnt; ++i) {
if (req_w == m_pCapability->zzhdr_sizes_tbl[i].width &&
req_h == m_pCapability->zzhdr_sizes_tbl[i].height) {
LOGD("%s: Found match for %d x %d", __func__, req_w, req_h);
return true;
}
}
LOGH("%s: %d x %d is not supported for zzhdr mode", __func__, req_w, req_h);
return false;
}
return true;
}
/*===========================================================================
* FUNCTION : setSceneMode
*
* DESCRIPTION: set scene mode
*
* PARAMETERS :
* @sceneModeStr : scene mode value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSceneMode(const char *sceneModeStr)
{
if (sceneModeStr != NULL) {
int32_t value = lookupAttr(SCENE_MODES_MAP, PARAM_MAP_SIZE(SCENE_MODES_MAP), sceneModeStr);
if (value != NAME_NOT_FOUND) {
LOGD("Setting SceneMode %s", sceneModeStr);
updateParamEntry(KEY_SCENE_MODE, sceneModeStr);
if (m_bSensorHDREnabled) {
// Incase of HW HDR mode, we do not update the same as Best shot mode.
LOGH("H/W HDR mode enabled. Do not set Best Shot Mode");
return NO_ERROR;
}
if (m_bSceneSelection) {
setSelectedScene((cam_scene_mode_type) value);
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_BESTSHOT_MODE,
(uint32_t)value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid Secene Mode: %s",
(sceneModeStr == NULL) ? "NULL" : sceneModeStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setSelectableZoneAf
*
* DESCRIPTION: set selectable zone AF algorithm
*
* PARAMETERS :
* @selZoneAFStr : selectable zone AF algorithm value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSelectableZoneAf(const char *selZoneAFStr)
{
if (selZoneAFStr != NULL) {
int32_t value = lookupAttr(FOCUS_ALGO_MAP, PARAM_MAP_SIZE(FOCUS_ALGO_MAP), selZoneAFStr);
if (value != NAME_NOT_FOUND) {
LOGD("Setting Selectable Zone AF value %s", selZoneAFStr);
updateParamEntry(KEY_QC_SELECTABLE_ZONE_AF, selZoneAFStr);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_FOCUS_ALGO_TYPE, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid selectable zone af value: %s",
(selZoneAFStr == NULL) ? "NULL" : selZoneAFStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : isAEBracketEnabled
*
* DESCRIPTION: checks if AE bracketing is enabled
*
* PARAMETERS :
*
* RETURN : TRUE/FALSE
*==========================================================================*/
bool QCameraParameters::isAEBracketEnabled()
{
const char *str = get(KEY_QC_AE_BRACKET_HDR);
if (str != NULL) {
if (strcmp(str, AE_BRACKET_OFF) != 0) {
return true;
}
}
return false;
}
/*===========================================================================
* FUNCTION : setAEBracket
*
* DESCRIPTION: set AE bracket value
*
* PARAMETERS :
* @aecBracketStr : AE bracket value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAEBracket(const char *aecBracketStr)
{
if (aecBracketStr == NULL) {
LOGD("setAEBracket with NULL value");
return NO_ERROR;
}
cam_exp_bracketing_t expBracket;
memset(&expBracket, 0, sizeof(expBracket));
int value = lookupAttr(BRACKETING_MODES_MAP, PARAM_MAP_SIZE(BRACKETING_MODES_MAP),
aecBracketStr);
switch (value) {
case CAM_EXP_BRACKETING_ON:
{
LOGD("EXP_BRACKETING_ON");
const char *str_val = get(KEY_QC_CAPTURE_BURST_EXPOSURE);
if ((str_val != NULL) && (strlen(str_val)>0)) {
expBracket.mode = CAM_EXP_BRACKETING_ON;
m_bAeBracketingEnabled = true;
strlcpy(expBracket.values, str_val, MAX_EXP_BRACKETING_LENGTH);
LOGD("setting Exposure Bracketing value of %s",
expBracket.values);
}
else {
/* Apps not set capture-burst-exposures, error case fall into bracketing off mode */
LOGD("capture-burst-exposures not set, back to HDR OFF mode");
m_bAeBracketingEnabled = false;
expBracket.mode = CAM_EXP_BRACKETING_OFF;
}
}
break;
default:
{
m_bAeBracketingEnabled = false;
LOGH(", EXP_BRACKETING_OFF");
expBracket.mode = CAM_EXP_BRACKETING_OFF;
}
break;
}
// Cache client AE bracketing configuration
memcpy(&m_AEBracketingClient, &expBracket, sizeof(cam_exp_bracketing_t));
/* save the value*/
updateParamEntry(KEY_QC_AE_BRACKET_HDR, aecBracketStr);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : set3ALock
*
* DESCRIPTION: enable/disable 3A lock.
*
* PARAMETERS :
* @lock3A : lock or unlock
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::set3ALock(bool lock3A)
{
int32_t rc = NO_ERROR;
LOGH("Setting Lock %d", lock3A);
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
uint32_t focus_mode = CAM_FOCUS_MODE_AUTO;
if (lock3A) {
if (isUbiFocusEnabled() || isUbiRefocus()) {
//For Ubi focus move focus to infinity.
focus_mode = CAM_FOCUS_MODE_INFINITY;
} else if (isOptiZoomEnabled() || isStillMoreEnabled()) {
//For optizoom and stillmore, set focus as fixed.
focus_mode = CAM_FOCUS_MODE_FIXED;
}
} else {
// retrieve previous focus value.
const char *focus = get(KEY_FOCUS_MODE);
int val = lookupAttr(FOCUS_MODES_MAP, PARAM_MAP_SIZE(FOCUS_MODES_MAP), focus);
if (val != NAME_NOT_FOUND) {
focus_mode = (uint32_t) val;
LOGD("focus mode %s", focus);
}
}
//Lock AWB
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_AWB_LOCK, (uint32_t)lock3A)) {
return BAD_VALUE;
}
//Lock AEC
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_AEC_LOCK, (uint32_t)lock3A)) {
return BAD_VALUE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_FOCUS_MODE, focus_mode)) {
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to commit batch");
}
return rc;
}
/*===========================================================================
* FUNCTION : setAndCommitZoom
*
* DESCRIPTION: set zoom.
*
* PARAMETERS :
* @zoom_level : zoom level to set.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAndCommitZoom(int zoom_level)
{
LOGH("E");
int32_t rc = NO_ERROR;
if (initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_ZOOM, zoom_level)) {
LOGE("Failed to update table");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to set Flash value");
}
mZoomLevel = zoom_level;
LOGH("X");
return rc;
}
/*===========================================================================
* FUNCTION : isOptiZoomEnabled
*
* DESCRIPTION: checks whether optizoom is enabled
*
* PARAMETERS :
*
* RETURN : true - enabled, false - disabled
*
*==========================================================================*/
bool QCameraParameters::isOptiZoomEnabled()
{
if (m_bOptiZoomOn && (0 <= mParmZoomLevel)) {
uint32_t zoom_level = (uint32_t) mParmZoomLevel;
cam_opti_zoom_t *opti_zoom_settings_need =
&(m_pCapability->opti_zoom_settings_need);
uint32_t zoom_threshold = (uint32_t) opti_zoom_settings_need->zoom_threshold;
LOGH("current zoom level =%u & zoom_threshold =%u",
zoom_level, zoom_threshold);
if (zoom_level >= zoom_threshold) {
return true;
}
}
return false;
}
/*===========================================================================
* FUNCTION : setNoiseReductionMode
*
* DESCRIPTION: set noise reduction mode
*
* PARAMETERS :
* @noiseReductionModeStr : noise reduction mode
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setNoiseReductionMode(const char *noiseReductionModeStr)
{
LOGH("noiseReductionModeStr = %s", noiseReductionModeStr);
if (noiseReductionModeStr != NULL) {
int value = lookupAttr(NOISE_REDUCTION_MODES_MAP, PARAM_MAP_SIZE(NOISE_REDUCTION_MODES_MAP),
noiseReductionModeStr);
if (value != NAME_NOT_FOUND) {
m_bHighQualityNoiseReductionMode =
!strncmp(VALUE_HIGH_QUALITY, noiseReductionModeStr, strlen(VALUE_HIGH_QUALITY));
updateParamEntry(KEY_QC_NOISE_REDUCTION_MODE, noiseReductionModeStr);
return NO_ERROR;
}
}
LOGE("Invalid noise reduction mode value: %s",
(noiseReductionModeStr == NULL) ? "NULL" : noiseReductionModeStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : commitAFBracket
*
* DESCRIPTION: commit AF Bracket.
*
* PARAMETERS :
* @AFBracket : AF bracketing configuration
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::commitAFBracket(cam_af_bracketing_t afBracket)
{
int32_t rc = NO_ERROR;
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_FOCUS_BRACKETING, afBracket)) {
LOGE("Failed to update table");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to commit batch");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : setAFBracket
*
* DESCRIPTION: set AF bracket value
*
* PARAMETERS :
* @afBracketStr : AF bracket value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAFBracket(const char *afBracketStr)
{
LOGH("afBracketStr =%s",afBracketStr);
if(afBracketStr != NULL) {
int value = lookupAttr(AF_BRACKETING_MODES_MAP, PARAM_MAP_SIZE(AF_BRACKETING_MODES_MAP),
afBracketStr);
if (value != NAME_NOT_FOUND) {
m_bAFBracketingOn = (value != 0);
updateParamEntry(KEY_QC_AF_BRACKET, afBracketStr);
return NO_ERROR;
}
}
LOGE("Invalid af bracket value: %s",
(afBracketStr == NULL) ? "NULL" : afBracketStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setReFocus
*
* DESCRIPTION: set refocus value
*
* PARAMETERS :
* @afBracketStr : refocus value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setReFocus(const char *reFocusStr)
{
LOGH("reFocusStr =%s",reFocusStr);
if (reFocusStr != NULL) {
int value = lookupAttr(RE_FOCUS_MODES_MAP, PARAM_MAP_SIZE(RE_FOCUS_MODES_MAP),
reFocusStr);
if (value != NAME_NOT_FOUND) {
m_bReFocusOn = (value != 0);
updateParamEntry(KEY_QC_RE_FOCUS, reFocusStr);
return NO_ERROR;
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setChromaFlash
*
* DESCRIPTION: set chroma flash value
*
* PARAMETERS :
* @aecBracketStr : chroma flash value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setChromaFlash(const char *chromaFlashStr)
{
LOGH("chromaFlashStr =%s",chromaFlashStr);
if(chromaFlashStr != NULL) {
int value = lookupAttr(CHROMA_FLASH_MODES_MAP, PARAM_MAP_SIZE(CHROMA_FLASH_MODES_MAP),
chromaFlashStr);
if(value != NAME_NOT_FOUND) {
m_bChromaFlashOn = (value != 0);
updateParamEntry(KEY_QC_CHROMA_FLASH, chromaFlashStr);
return NO_ERROR;
}
}
LOGE("Invalid chroma flash value: %s",
(chromaFlashStr == NULL) ? "NULL" : chromaFlashStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setOptiZoom
*
* DESCRIPTION: set opti zoom value
*
* PARAMETERS :
* @optiZoomStr : opti zoom value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setOptiZoom(const char *optiZoomStr)
{
LOGH("optiZoomStr =%s",optiZoomStr);
if(optiZoomStr != NULL) {
int value = lookupAttr(OPTI_ZOOM_MODES_MAP, PARAM_MAP_SIZE(OPTI_ZOOM_MODES_MAP),
optiZoomStr);
if(value != NAME_NOT_FOUND) {
m_bOptiZoomOn = (value != 0);
updateParamEntry(KEY_QC_OPTI_ZOOM, optiZoomStr);
return NO_ERROR;
}
}
LOGE("Invalid opti zoom value: %s",
(optiZoomStr == NULL) ? "NULL" : optiZoomStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setTruePortrait
*
* DESCRIPTION: set true portrait value
*
* PARAMETERS :
* @optiZoomStr : true portrait value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setTruePortrait(const char *truePortraitStr)
{
LOGH("truePortraitStr =%s", truePortraitStr);
if (truePortraitStr != NULL) {
int value = lookupAttr(TRUE_PORTRAIT_MODES_MAP,
PARAM_MAP_SIZE(TRUE_PORTRAIT_MODES_MAP),
truePortraitStr);
if (value != NAME_NOT_FOUND) {
m_bTruePortraitOn = (value != 0);
updateParamEntry(KEY_QC_TRUE_PORTRAIT, truePortraitStr);
setFaceDetection(m_bFaceDetectionOn, false);
return NO_ERROR;
}
}
LOGH("Invalid true portrait value: %s",
(truePortraitStr == NULL) ? "NULL" : truePortraitStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setHDRMode
*
* DESCRIPTION: set hdr mode value
*
* PARAMETERS :
* @hdrModeStr : hdr mode value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setHDRMode(const char *hdrModeStr)
{
LOGH("hdrModeStr =%s", hdrModeStr);
if (hdrModeStr != NULL) {
int value = lookupAttr(HDR_MODES_MAP, PARAM_MAP_SIZE(HDR_MODES_MAP), hdrModeStr);
if (value != NAME_NOT_FOUND) {
const char *str = get(KEY_SCENE_MODE);
m_bHDRModeSensor = !strncmp(hdrModeStr, HDR_MODE_SENSOR, strlen(HDR_MODE_SENSOR));
updateParamEntry(KEY_QC_HDR_MODE, hdrModeStr);
// If hdr is already selected, need to deselect it in local cache
// So the new hdr mode will be applied
if (str && !strncmp(str, SCENE_MODE_HDR, strlen(SCENE_MODE_HDR))) {
updateParamEntry(KEY_SCENE_MODE, SCENE_MODE_AUTO);
m_bNeedRestart = true;
}
return NO_ERROR;
}
}
LOGH("Invalid hdr mode value: %s",
(hdrModeStr == NULL) ? "NULL" : hdrModeStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setSeeMore
*
* DESCRIPTION: set see more value
*
* PARAMETERS :
* @seeMoreStr : see more value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSeeMore(const char *seeMoreStr)
{
int32_t rc = NO_ERROR;
LOGH("seeMoreStr =%s", seeMoreStr);
if (seeMoreStr != NULL) {
int value = lookupAttr(ON_OFF_MODES_MAP,
PARAM_MAP_SIZE(ON_OFF_MODES_MAP),
seeMoreStr);
if (value != NAME_NOT_FOUND) {
m_bSeeMoreOn = (value != 0);
// If SeeMore is enabled, enable StillMore for live snapshot
// and disable tone map
if (m_bSeeMoreOn) {
m_bStillMoreOn = TRUE;
if (!m_bLtmForSeeMoreEnabled) {
rc = setToneMapMode(false, false);
}
if (rc != NO_ERROR) {
LOGH("Failed to disable tone map during SeeMore");
}
} else {
m_bStillMoreOn = FALSE;
if (!m_bLtmForSeeMoreEnabled) {
rc = setToneMapMode(true, false);
}
if (rc != NO_ERROR) {
LOGH("Failed to enable tone map during SeeMore");
}
}
updateParamEntry(KEY_QC_SEE_MORE, seeMoreStr);
return NO_ERROR;
}
}
LOGE("Invalid see more value: %s",
(seeMoreStr == NULL) ? "NULL" : seeMoreStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setStillMore
*
* DESCRIPTION: set still more value
*
* PARAMETERS :
* @seeMoreStr : still more value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setStillMore(const char *stillMoreStr)
{
LOGH("stillMoreStr =%s", stillMoreStr);
if (stillMoreStr != NULL) {
int value = lookupAttr(STILL_MORE_MODES_MAP, PARAM_MAP_SIZE(STILL_MORE_MODES_MAP),
stillMoreStr);
if (value != NAME_NOT_FOUND) {
m_bStillMoreOn = (value != 0);
updateParamEntry(KEY_QC_STILL_MORE, stillMoreStr);
return NO_ERROR;
}
}
LOGE("Invalid still more value: %s",
(stillMoreStr == NULL) ? "NULL" : stillMoreStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setHDRNeed1x
*
* DESCRIPTION: set hdr need 1x value
*
* PARAMETERS :
* @hdrModeStr : hdr need 1x value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setHDRNeed1x(const char *hdrNeed1xStr)
{
LOGH("hdrNeed1xStr =%s", hdrNeed1xStr);
if (hdrNeed1xStr != NULL) {
int value = lookupAttr(TRUE_FALSE_MODES_MAP, PARAM_MAP_SIZE(TRUE_FALSE_MODES_MAP),
hdrNeed1xStr);
if (value != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_HDR_NEED_1X, hdrNeed1xStr);
m_bHDR1xFrameEnabled = !strncmp(hdrNeed1xStr, VALUE_TRUE, strlen(VALUE_TRUE));
m_bNeedRestart = true;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_HDR_NEED_1X,
m_bHDR1xFrameEnabled)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGH("Invalid hdr need 1x value: %s",
(hdrNeed1xStr == NULL) ? "NULL" : hdrNeed1xStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setAEBracketing
*
* DESCRIPTION: enables AE bracketing
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAEBracketing()
{
int32_t rc = NO_ERROR;
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_HDR, m_AEBracketingClient)) {
LOGE("Failed to update AE bracketing");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to configure AE bracketing");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : setHDRAEBracket
*
* DESCRIPTION: enables AE bracketing for HDR
*
* PARAMETERS :
* @hdrBracket : HDR bracketing configuration
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setHDRAEBracket(cam_exp_bracketing_t hdrBracket)
{
int32_t rc = NO_ERROR;
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_HDR, hdrBracket)) {
LOGE("Failed to update table");
return BAD_TYPE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to configure HDR bracketing");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : setCacheVideoBuffers
*
* DESCRIPTION: set cache video buffers value
*
* PARAMETERS :
* @cacheVideoStr : cache video buffer value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setCacheVideoBuffers(const char *cacheVideoBufStr)
{
if (cacheVideoBufStr != NULL) {
int8_t cacheVideoBuf = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), cacheVideoBufStr);
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.mem.usecache", prop, "");
if (strlen(prop) > 0) {
cacheVideoBuf = atoi(prop);
}
if (cacheVideoBuf != NAME_NOT_FOUND) {
const char *cacheStr = (strlen(prop)>0) ? prop : cacheVideoBufStr;
LOGD("Setting video buffer %s",
(cacheVideoBuf == 0) ? "UnCached" : "Cached");
return updateParamEntry(KEY_QC_CACHE_VIDEO_BUFFERS, cacheStr);
}
LOGE("Cache video buffers not set correctly");
}
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setCacheVideoBuffers
*
* DESCRIPTION: Set buffers as Cache/Uncache Memory
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setCacheVideoBuffers(const QCameraParameters& params)
{
const char *str = params.get(KEY_QC_CACHE_VIDEO_BUFFERS);;
const char *prev_str = get(KEY_QC_CACHE_VIDEO_BUFFERS);
if (str != NULL) {
if (prev_str == NULL ||
strcmp(str, prev_str) != 0) {
return setCacheVideoBuffers(str);
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : restoreAEBracket
*
* DESCRIPTION: restores client AE bracketing configuration after HDR is done
*
* PARAMETERS :
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::stopAEBracket()
{
cam_exp_bracketing_t bracketing;
bracketing.mode = CAM_EXP_BRACKETING_OFF;
return setHDRAEBracket(bracketing);
}
/*===========================================================================
* FUNCTION : updateFlash
*
* DESCRIPTION: restores client flash configuration or disables flash
*
* PARAMETERS :
* @commitSettings : flag indicating whether settings need to be commited
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::updateFlash(bool commitSettings)
{
int32_t rc = NO_ERROR;
int32_t value;
if (commitSettings) {
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
}
if (isHDREnabled() || m_bAeBracketingEnabled || m_bAFBracketingOn ||
m_bOptiZoomOn || m_bReFocusOn || m_LowLightLevel) {
value = CAM_FLASH_MODE_OFF;
} else if (m_bChromaFlashOn) {
value = CAM_FLASH_MODE_ON;
} else {
value = mFlashValue;
}
if (value != mFlashDaemonValue) {
LOGD("Setting Flash value %d", value);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_LED_MODE, value)) {
LOGE("Failed to set led mode");
return BAD_VALUE;
}
mFlashDaemonValue = value;
} else {
rc = NO_ERROR;
}
if (commitSettings) {
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to configure HDR bracketing");
return rc;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : setRedeyeReduction
*
* DESCRIPTION: set red eye reduction value
*
* PARAMETERS :
* @redeyeStr : red eye reduction value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setRedeyeReduction(const char *redeyeStr)
{
if (redeyeStr != NULL) {
int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), redeyeStr);
if (value != NAME_NOT_FOUND) {
LOGD("Setting RedEye Reduce value %s", redeyeStr);
updateParamEntry(KEY_QC_REDEYE_REDUCTION, redeyeStr);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_REDEYE_REDUCTION, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid RedEye Reduce value: %s",
(redeyeStr == NULL) ? "NULL" : redeyeStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : getDenoiseProcessPlate
*
* DESCRIPTION: query denoise process plate
*
* PARAMETERS : None
*
* RETURN : NR process plate vlaue
*==========================================================================*/
cam_denoise_process_type_t
QCameraParameters::getDenoiseProcessPlate(cam_intf_parm_type_t type)
{
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
cam_denoise_process_type_t processPlate = CAM_WAVELET_DENOISE_CBCR_ONLY;
if (CAM_INTF_PARM_WAVELET_DENOISE == type) {
property_get("persist.denoise.process.plates", prop, "");
} else if (CAM_INTF_PARM_TEMPORAL_DENOISE == type) {
property_get("persist.tnr.process.plates", prop, "");
} else {
LOGW("Type not supported");
prop[0] = '\0';
}
if (strlen(prop) > 0) {
switch(atoi(prop)) {
case 0:
processPlate = CAM_WAVELET_DENOISE_YCBCR_PLANE;
break;
case 1:
processPlate = CAM_WAVELET_DENOISE_CBCR_ONLY;
break;
case 2:
processPlate = CAM_WAVELET_DENOISE_STREAMLINE_YCBCR;
break;
case 3:
processPlate = CAM_WAVELET_DENOISE_STREAMLINED_CBCR;
break;
default:
processPlate = CAM_WAVELET_DENOISE_CBCR_ONLY;
break;
}
}
return processPlate;
}
/*===========================================================================
* FUNCTION : setWaveletDenoise
*
* DESCRIPTION: set wavelet denoise value
*
* PARAMETERS :
* @wnrStr : wavelet denoise value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setWaveletDenoise(const char *wnrStr)
{
if ((m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_DENOISE2D) == 0){
LOGH("WNR is not supported");
return NO_ERROR;
}
if (wnrStr != NULL) {
int value = lookupAttr(DENOISE_ON_OFF_MODES_MAP,
PARAM_MAP_SIZE(DENOISE_ON_OFF_MODES_MAP), wnrStr);
if (value != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_DENOISE, wnrStr);
cam_denoise_param_t temp;
memset(&temp, 0, sizeof(temp));
temp.denoise_enable = (uint8_t)value;
m_bWNROn = (value != 0);
if (m_bWNROn) {
temp.process_plates = getDenoiseProcessPlate(CAM_INTF_PARM_WAVELET_DENOISE);
}
LOGD("Denoise enable=%d, plates=%d",
temp.denoise_enable, temp.process_plates);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_WAVELET_DENOISE, temp)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid Denoise value: %s", (wnrStr == NULL) ? "NULL" : wnrStr);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setRdiMode
*
* DESCRIPTION: set rdi mode value
*
* PARAMETERS :
* @str : rdi mode value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setRdiMode(const char *str)
{
LOGD("RDI_DEBUG rdi mode value: %s", str);
if (str != NULL) {
int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), str);
if (value != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_RDI_MODE, str);
m_bRdiMode = (value == 0) ? false : true;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_RDI_MODE, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
}
LOGE("Invalid rdi mode value: %s", (str == NULL) ? "NULL" : str);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : setSecureMode
*
* DESCRIPTION: set secure mode value
*
* PARAMETERS :
* @str : secure mode value string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setSecureMode(const char *str)
{
LOGD("Secure mode value: %s", str);
if (str != NULL) {
int32_t value = lookupAttr(ENABLE_DISABLE_MODES_MAP,
PARAM_MAP_SIZE(ENABLE_DISABLE_MODES_MAP), str);
if (value != NAME_NOT_FOUND) {
updateParamEntry(KEY_QC_SECURE_MODE, str);
m_bSecureMode = (value == 0)? false : true;
return NO_ERROR;
}
}
LOGE("Invalid Secure mode value: %s",
(str == NULL) ? "NULL" : str);
return BAD_VALUE;
}
/*===========================================================================
* FUNCTION : getStreamRotation
*
* DESCRIPTION: get stream rotation by its type
*
* PARAMETERS :
* @streamType : stream type
* @featureConfig : stream feature config structure
* @dim : stream dimension
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getStreamRotation(cam_stream_type_t streamType,
cam_pp_feature_config_t &featureConfig,
cam_dimension_t &dim)
{
int32_t ret = NO_ERROR;
const char *str = get(KEY_QC_VIDEO_ROTATION);
int rotationParam = lookupAttr(VIDEO_ROTATION_MODES_MAP,
PARAM_MAP_SIZE(VIDEO_ROTATION_MODES_MAP), str);
featureConfig.rotation = ROTATE_0;
int swapDim = 0;
switch (streamType) {
case CAM_STREAM_TYPE_VIDEO:
switch(rotationParam) {
case 90:
featureConfig.feature_mask |= CAM_QCOM_FEATURE_ROTATION;
featureConfig.rotation = ROTATE_90;
swapDim = 1;
break;
case 180:
featureConfig.feature_mask |= CAM_QCOM_FEATURE_ROTATION;
featureConfig.rotation = ROTATE_180;
break;
case 270:
featureConfig.feature_mask |= CAM_QCOM_FEATURE_ROTATION;
featureConfig.rotation = ROTATE_270;
swapDim = 1;
break;
default:
featureConfig.rotation = ROTATE_0;
}
break;
case CAM_STREAM_TYPE_PREVIEW:
case CAM_STREAM_TYPE_POSTVIEW:
case CAM_STREAM_TYPE_SNAPSHOT:
case CAM_STREAM_TYPE_RAW:
case CAM_STREAM_TYPE_METADATA:
case CAM_STREAM_TYPE_OFFLINE_PROC:
case CAM_STREAM_TYPE_DEFAULT:
default:
break;
}
if (swapDim > 0) {
int w = 0;
w = dim.width;
dim.width = dim.height;
dim.height = w;
}
return ret;
}
/*===========================================================================
* FUNCTION : getStreamFormat
*
* DESCRIPTION: get stream format by its type
*
* PARAMETERS :
* @streamType : [input] stream type
* @format : [output] stream format
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getStreamFormat(cam_stream_type_t streamType,
cam_format_t &format)
{
int32_t ret = NO_ERROR;
format = CAM_FORMAT_MAX;
switch (streamType) {
case CAM_STREAM_TYPE_PREVIEW:
if (!isUBWCEnabled()) {
#if VENUS_PRESENT
cam_dimension_t preview;
cam_dimension_t video;
getStreamDimension(CAM_STREAM_TYPE_VIDEO , video);
getStreamDimension(CAM_STREAM_TYPE_PREVIEW, preview);
if (getRecordingHintValue() == true &&
video.width == preview.width &&
video.height == preview.height &&
mPreviewFormat == CAM_FORMAT_YUV_420_NV21) {
format = CAM_FORMAT_YUV_420_NV21_VENUS;
} else
#endif
format = mPreviewFormat;
} else {
format = mPreviewFormat;
}
break;
case CAM_STREAM_TYPE_POSTVIEW:
case CAM_STREAM_TYPE_CALLBACK:
format = mAppPreviewFormat;
break;
case CAM_STREAM_TYPE_ANALYSIS:
cam_analysis_info_t analysisInfo;
cam_feature_mask_t featureMask;
featureMask = 0;
getStreamPpMask(CAM_STREAM_TYPE_ANALYSIS, featureMask);
ret = getAnalysisInfo(
((getRecordingHintValue() == true) && fdModeInVideo()),
FALSE,
featureMask,
&analysisInfo);
if (ret != NO_ERROR) {
LOGE("getAnalysisInfo failed, ret = %d", ret);
return ret;
}
if (analysisInfo.hw_analysis_supported &&
analysisInfo.analysis_format == CAM_FORMAT_Y_ONLY) {
format = analysisInfo.analysis_format;
} else {
if (analysisInfo.hw_analysis_supported) {
LOGW("Invalid analysis_format %d\n",
analysisInfo.analysis_format);
}
format = mAppPreviewFormat;
}
break;
case CAM_STREAM_TYPE_SNAPSHOT:
if ( mPictureFormat == CAM_FORMAT_YUV_422_NV16 ) {
format = CAM_FORMAT_YUV_422_NV16;
} else {
char prop[PROPERTY_VALUE_MAX];
int snapshotFormat;
memset(prop, 0, sizeof(prop));
property_get("persist.camera.snap.format", prop, "0");
snapshotFormat = atoi(prop);
if(snapshotFormat == 1) {
format = CAM_FORMAT_YUV_422_NV61;
} else {
format = CAM_FORMAT_YUV_420_NV21;
}
}
break;
case CAM_STREAM_TYPE_VIDEO:
if (isUBWCEnabled()) {
char prop[PROPERTY_VALUE_MAX];
int pFormat;
memset(prop, 0, sizeof(prop));
property_get("persist.camera.video.ubwc", prop, "1");
pFormat = atoi(prop);
if (pFormat == 1) {
format = CAM_FORMAT_YUV_420_NV12_UBWC;
} else {
format = CAM_FORMAT_YUV_420_NV21_VENUS;
}
} else {
#if VENUS_PRESENT
format = CAM_FORMAT_YUV_420_NV21_VENUS;
#else
format = CAM_FORMAT_YUV_420_NV21;
#endif
}
break;
case CAM_STREAM_TYPE_RAW:
if ((isRdiMode()) || (getofflineRAW())) {
format = m_pCapability->rdi_mode_stream_fmt;
} else if (mPictureFormat >= CAM_FORMAT_YUV_RAW_8BIT_YUYV) {
format = (cam_format_t)mPictureFormat;
} else {
char raw_format[PROPERTY_VALUE_MAX];
int rawFormat;
memset(raw_format, 0, sizeof(raw_format));
/*Default value is CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GBRG*/
property_get("persist.camera.raw.format", raw_format, "17");
rawFormat = atoi(raw_format);
format = (cam_format_t)rawFormat;
LOGH("Raw stream format %d bundled with snapshot",
format);
}
break;
case CAM_STREAM_TYPE_METADATA:
case CAM_STREAM_TYPE_OFFLINE_PROC:
case CAM_STREAM_TYPE_DEFAULT:
default:
break;
}
LOGD("Stream type = %d Stream Format = %d", streamType, format);
return ret;
}
/*===========================================================================
* FUNCTION : getFlipMode
*
* DESCRIPTION: get flip mode
*
* PARAMETERS :
* @cam_intf_parm_type_t : [input] stream type
*
* RETURN : int type of flip mode
* 0 - no filp
* 1 - FLIP_H
* 2 - FLIP_V
* 3 - FLIP_H | FLIP_V
*==========================================================================*/
int QCameraParameters::getFlipMode(cam_stream_type_t type)
{
const char *str = NULL;
int flipMode = 0; // no flip
switch(type){
case CAM_STREAM_TYPE_PREVIEW:
if (!isRdiMode()) {
str = get(KEY_QC_PREVIEW_FLIP);
}
break;
case CAM_STREAM_TYPE_VIDEO:
str = get(KEY_QC_VIDEO_FLIP);
break;
case CAM_STREAM_TYPE_SNAPSHOT:
case CAM_STREAM_TYPE_POSTVIEW:
str = get(KEY_QC_SNAPSHOT_PICTURE_FLIP);
break;
default:
LOGD("No flip mode for stream type %d", type);
break;
}
if(str != NULL){
//Need give corresponding filp value based on flip mode strings
int value = lookupAttr(FLIP_MODES_MAP, PARAM_MAP_SIZE(FLIP_MODES_MAP), str);
if(value != NAME_NOT_FOUND)
flipMode = value;
}
LOGH("the filp mode of stream type %d is %d .", type, flipMode);
return flipMode;
}
/*===========================================================================
* FUNCTION : isSnapshotFDNeeded
*
* DESCRIPTION: check whether Face Detection Metadata is needed
*
* PARAMETERS : none
*
* RETURN : bool type of status
* 0 - need
* 1 - not need
*==========================================================================*/
bool QCameraParameters::isSnapshotFDNeeded()
{
return getInt(KEY_QC_SNAPSHOT_FD_DATA);
}
/*===========================================================================
* FUNCTION : getStreamDimension
*
* DESCRIPTION: get stream dimension by its type
*
* PARAMETERS :
* @streamType : [input] stream type
* @dim : [output] stream dimension
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getStreamDimension(cam_stream_type_t streamType,
cam_dimension_t &dim)
{
int32_t ret = NO_ERROR;
memset(&dim, 0, sizeof(cam_dimension_t));
switch (streamType) {
case CAM_STREAM_TYPE_PREVIEW:
case CAM_STREAM_TYPE_CALLBACK:
getPreviewSize(&dim.width, &dim.height);
break;
case CAM_STREAM_TYPE_POSTVIEW:
getPreviewSize(&dim.width, &dim.height);
break;
case CAM_STREAM_TYPE_SNAPSHOT:
if (isPostProcScaling()) {
getMaxPicSize(dim);
} else if (getRecordingHintValue()) {
// live snapshot
getLiveSnapshotSize(dim);
} else {
getPictureSize(&dim.width, &dim.height);
}
break;
case CAM_STREAM_TYPE_VIDEO:
getVideoSize(&dim.width, &dim.height);
break;
case CAM_STREAM_TYPE_RAW:
//dim = m_pCapability->raw_dim;
getRawSize(dim);
break;
case CAM_STREAM_TYPE_METADATA:
dim.width = (int32_t)sizeof(metadata_buffer_t);
dim.height = 1;
break;
case CAM_STREAM_TYPE_OFFLINE_PROC:
if (isPostProcScaling()) {
if (getRecordingHintValue()) {
// live snapshot
getLiveSnapshotSize(dim);
} else {
getPictureSize(&dim.width, &dim.height);
}
}
break;
case CAM_STREAM_TYPE_ANALYSIS:
cam_dimension_t prv_dim, max_dim;
/* Analysis stream need aspect ratio as preview stream */
getPreviewSize(&prv_dim.width, &prv_dim.height);
cam_analysis_info_t analysisInfo;
cam_feature_mask_t featureMask;
featureMask = 0;
getStreamPpMask(CAM_STREAM_TYPE_ANALYSIS, featureMask);
ret = getAnalysisInfo(
((getRecordingHintValue() == true) && fdModeInVideo()),
FALSE,
featureMask,
&analysisInfo);
if (ret != NO_ERROR) {
LOGE("getAnalysisInfo failed, ret = %d", ret);
return ret;
}
max_dim.width = analysisInfo.analysis_max_res.width;
max_dim.height = analysisInfo.analysis_max_res.height;
if (prv_dim.width > max_dim.width || prv_dim.height > max_dim.height) {
double max_ratio, requested_ratio;
max_ratio = (double)max_dim.width / (double)max_dim.height;
requested_ratio = (double)prv_dim.width / (double)prv_dim.height;
if (max_ratio < requested_ratio) {
dim.width = max_dim.width;
dim.height = (int32_t)((double)dim.width / requested_ratio);
} else {
dim.height = max_dim.height;
dim.width = (int32_t)((double)max_dim.height * requested_ratio);
}
dim.width &= ~0x1;
dim.height &= ~0x1;
} else {
dim.width = prv_dim.width;
dim.height = prv_dim.height;
}
break;
case CAM_STREAM_TYPE_DEFAULT:
default:
LOGE("no dimension for unsupported stream type %d",
streamType);
ret = BAD_VALUE;
break;
}
LOGD("Stream type = %d Stream Dimension = %d X %d",
streamType, dim.width, dim.height);
return ret;
}
/*===========================================================================
* FUNCTION : getParameters
*
* DESCRIPTION: Return a C string containing the parameters
*
* PARAMETERS : none
*
* RETURN : a string containing parameter pairs
*==========================================================================*/
char* QCameraParameters::getParameters()
{
char* strParams = NULL;
String8 str;
int cur_width, cur_height;
//Need take care Scale picture size
if(m_reprocScaleParam.isScaleEnabled() &&
m_reprocScaleParam.isUnderScaling()){
int scale_width, scale_height;
m_reprocScaleParam.getPicSizeFromAPK(scale_width,scale_height);
getPictureSize(&cur_width, &cur_height);
String8 pic_size;
char buffer[32];
snprintf(buffer, sizeof(buffer), "%dx%d", scale_width, scale_height);
pic_size.append(buffer);
set(CameraParameters::KEY_PICTURE_SIZE, pic_size);
}
str = flatten();
strParams = (char *)malloc(sizeof(char)*(str.length()+1));
if(strParams != NULL){
memset(strParams, 0, sizeof(char)*(str.length()+1));
strlcpy(strParams, str.string(), str.length()+1);
strParams[str.length()] = 0;
}
if(m_reprocScaleParam.isScaleEnabled() &&
m_reprocScaleParam.isUnderScaling()){
//need set back picture size
String8 pic_size;
char buffer[32];
snprintf(buffer, sizeof(buffer), "%dx%d", cur_width, cur_height);
pic_size.append(buffer);
set(CameraParameters::KEY_PICTURE_SIZE, pic_size);
}
return strParams;
}
#ifdef TARGET_TS_MAKEUP
/*===========================================================================
* FUNCTION : getTsMakeupInfo
*
* DESCRIPTION: get TsMakeup info
*
* PARAMETERS :
* @whiteLevel : [output] white level
* @cleanLevel : [output] clean level
* RETURN : Whether makeup is enabled or not
*==========================================================================*/
bool QCameraParameters::getTsMakeupInfo(int &whiteLevel, int &cleanLevel) const
{
const char* pch_makeup_enable = get(QCameraParameters::KEY_TS_MAKEUP);
if (pch_makeup_enable == NULL) {
LOGH("pch_makeup_enable = null");
return false;
}
bool enableMakeup =
(strcmp(pch_makeup_enable,"On") == 0);
if (enableMakeup) {
whiteLevel = getInt(QCameraParameters::KEY_TS_MAKEUP_WHITEN);
cleanLevel = getInt(QCameraParameters::KEY_TS_MAKEUP_CLEAN);
}
return enableMakeup;
}
#endif
/*===========================================================================
* FUNCTION : getPreviewHalPixelFormat
*
* DESCRIPTION: get preview HAL pixel format
*
* PARAMETERS : none
*
* RETURN : HAL pixel format
*==========================================================================*/
int QCameraParameters::getPreviewHalPixelFormat()
{
int32_t halPixelFormat;
cam_format_t fmt;
getStreamFormat(CAM_STREAM_TYPE_PREVIEW,fmt);
switch (fmt) {
case CAM_FORMAT_YUV_420_NV12:
halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP;
break;
case CAM_FORMAT_YUV_420_NV21:
halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
break;
case CAM_FORMAT_YUV_420_NV21_ADRENO:
halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO;
break;
case CAM_FORMAT_YUV_420_YV12:
halPixelFormat = HAL_PIXEL_FORMAT_YV12;
break;
case CAM_FORMAT_YUV_420_NV12_VENUS:
halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;
break;
case CAM_FORMAT_YUV_420_NV21_VENUS:
halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS;
break;
case CAM_FORMAT_YUV_420_NV12_UBWC:
halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
break;
case CAM_FORMAT_YUV_422_NV16:
case CAM_FORMAT_YUV_422_NV61:
default:
halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
break;
}
LOGH("format %d\n", halPixelFormat);
return halPixelFormat;
}
/*===========================================================================
* FUNCTION : getthumbnailSize
*
* DESCRIPTION: get thumbnail size
*
* PARAMETERS :
* @width, height : [output] thumbnail width and height
*
* RETURN : none
*==========================================================================*/
void QCameraParameters::getThumbnailSize(int *width, int *height) const
{
*width = getInt(KEY_JPEG_THUMBNAIL_WIDTH);
*height = getInt(KEY_JPEG_THUMBNAIL_HEIGHT);
}
/*===========================================================================
* FUNCTION : getZSLBurstInterval
*
* DESCRIPTION: get ZSL burst interval setting
*
* PARAMETERS : none
*
* RETURN : ZSL burst interval value
*==========================================================================*/
uint8_t QCameraParameters::getZSLBurstInterval()
{
int interval = getInt(KEY_QC_ZSL_BURST_INTERVAL);
if (interval < 0) {
interval = 1;
}
return (uint8_t)interval;
}
/*===========================================================================
* FUNCTION : getZSLQueueDepth
*
* DESCRIPTION: get ZSL queue depth
*
* PARAMETERS : none
*
* RETURN : ZSL queue depth value
*==========================================================================*/
uint8_t QCameraParameters::getZSLQueueDepth()
{
int qdepth = getInt(KEY_QC_ZSL_QUEUE_DEPTH);
if (qdepth < 0) {
qdepth = 2;
}
if (isLowMemoryDevice()) {
qdepth = 1;
}
return (uint8_t)qdepth;
}
/*===========================================================================
* FUNCTION : getZSLBackLookCount
*
* DESCRIPTION: get ZSL backlook count setting
*
* PARAMETERS : none
*
* RETURN : ZSL backlook count value
*==========================================================================*/
uint8_t QCameraParameters::getZSLBackLookCount()
{
int look_back = getInt(KEY_QC_ZSL_BURST_LOOKBACK);
if (look_back < 0) {
look_back = 2;
}
if (isLowMemoryDevice()) {
look_back = 1;
}
return (uint8_t)look_back;
}
/*===========================================================================
* FUNCTION : isVideoBuffersCached
*
* DESCRIPTION: Query buffers are cached /un cached
*
* PARAMETERS : None
*
* RETURN : buffers are cached /un cached
*==========================================================================*/
bool QCameraParameters::isVideoBuffersCached()
{
const char *cached_mem = get(KEY_QC_CACHE_VIDEO_BUFFERS);
if (cached_mem != NULL) {
if (strcmp(cached_mem, VALUE_DISABLE) != 0) {
return true;
}
}
return false;
}
/*===========================================================================
* FUNCTION : getZSLMaxUnmatchedFrames
*
* DESCRIPTION: get allowed ZSL max unmatched frames number
*
* PARAMETERS : none
*
* RETURN : ZSL backlook count value
*==========================================================================*/
uint8_t QCameraParameters::getMaxUnmatchedFramesInQueue()
{
return (uint8_t)(m_pCapability->min_num_pp_bufs);
}
/*===========================================================================
* FUNCTION : setRecordingHintValue
*
* DESCRIPTION: set recording hint
*
* PARAMETERS :
* @value : video hint value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCameraParameters::setRecordingHintValue(int32_t value)
{
LOGH("VideoHint = %d", value);
bool newValue = (value > 0)? true : false;
if ( m_bRecordingHint != newValue ) {
m_bNeedRestart = true;
m_bRecordingHint_new = newValue;
} else {
m_bRecordingHint_new = m_bRecordingHint;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_RECORDING_HINT, value)) {
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getNumOfSnapshots
*
* DESCRIPTION: get number of snapshot per shutter
*
* PARAMETERS : none
*
* RETURN : number of snapshot per shutter
*==========================================================================*/
uint8_t QCameraParameters::getNumOfSnapshots()
{
uint8_t numOfSnapshot = 1;
int val = getInt(KEY_QC_NUM_SNAPSHOT_PER_SHUTTER);
if (0 < val) {
numOfSnapshot = (uint8_t)val;
}
return (uint8_t)numOfSnapshot;
}
/*===========================================================================
* FUNCTION : getBurstCountForAdvancedCapture
*
* DESCRIPTION: get burst count for advanced capture.
*
* PARAMETERS : none
*
* RETURN : number of snapshot required for advanced capture.
*==========================================================================*/
uint8_t QCameraParameters::getBurstCountForAdvancedCapture()
{
uint32_t burstCount = 0;
if (isUbiFocusEnabled()) {
//number of snapshots required for Ubi Focus.
burstCount = m_pCapability->ubifocus_af_bracketing_need.burst_count;
} else if (isUbiRefocus()) {
//number of snapshots required for Opti Zoom.
burstCount = m_pCapability->refocus_af_bracketing_need.burst_count;
} else if (isOptiZoomEnabled()) {
//number of snapshots required for Opti Zoom.
burstCount = m_pCapability->opti_zoom_settings_need.burst_count;
} else if (isChromaFlashEnabled()) {
//number of snapshots required for Chroma Flash.
burstCount = m_pCapability->chroma_flash_settings_need.burst_count;
} else if (isStillMoreEnabled()) {
//number of snapshots required for Still More.
if (isSeeMoreEnabled()) {
burstCount = 1;
} else if ((m_stillmore_config.burst_count >=
m_pCapability->stillmore_settings_need.min_burst_count) &&
(m_stillmore_config.burst_count <=
m_pCapability->stillmore_settings_need.max_burst_count)) {
burstCount = m_stillmore_config.burst_count;
} else {
burstCount = m_pCapability->stillmore_settings_need.burst_count;
}
} else if (isHDREnabled()) {
//number of snapshots required for HDR.
burstCount = m_pCapability->hdr_bracketing_setting.num_frames;
} else if (isAEBracketEnabled()) {
burstCount = 0;
const char *str_val = m_AEBracketingClient.values;
if ((str_val != NULL) && (strlen(str_val) > 0)) {
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
strlcpy(prop, str_val, PROPERTY_VALUE_MAX);
char *saveptr = NULL;
char *token = strtok_r(prop, ",", &saveptr);
while (token != NULL) {
token = strtok_r(NULL, ",", &saveptr);
burstCount++;
}
}
}
if (burstCount <= 0) {
burstCount = getNumOfSnapshots();
}
LOGH("Snapshot burst count = %d", burstCount);
return (uint8_t)burstCount;
}
/*===========================================================================
* FUNCTION : getNumOfRetroSnapshots
*
* DESCRIPTION: get number of retro active snapshots per shutter
*
* PARAMETERS : none
*
* RETURN : number of retro active snapshots per shutter
*==========================================================================*/
uint8_t QCameraParameters::getNumOfRetroSnapshots()
{
int numOfRetroSnapshots = getInt(KEY_QC_NUM_RETRO_BURST_PER_SHUTTER);
if (numOfRetroSnapshots < 0) {
numOfRetroSnapshots = 0;
}
LOGH("numOfRetroSnaps - %d", numOfRetroSnapshots);
return (uint8_t)numOfRetroSnapshots;
}
/*===========================================================================
* FUNCTION : getNumOfExtraHDRInBufsIfNeeded
*
* DESCRIPTION: get number of extra input buffers needed by HDR
*
* PARAMETERS : none
*
* RETURN : number of extra buffers needed by HDR; 0 if not HDR enabled
*==========================================================================*/
uint8_t QCameraParameters::getNumOfExtraHDRInBufsIfNeeded()
{
unsigned int numOfBufs = 0;
if (isHDREnabled()) {
numOfBufs += m_pCapability->hdr_bracketing_setting.num_frames;
if (isHDR1xFrameEnabled() && isHDR1xExtraBufferNeeded()) {
numOfBufs++;
}
numOfBufs--; // Only additional buffers need to be returned
}
return (uint8_t)(numOfBufs);
}
/*===========================================================================
* FUNCTION : getNumOfExtraHDROutBufsIfNeeded
*
* DESCRIPTION: get number of extra output buffers needed by HDR
*
* PARAMETERS : none
*
* RETURN : number of extra buffers needed by HDR; 0 if not HDR enabled
*==========================================================================*/
uint8_t QCameraParameters::getNumOfExtraHDROutBufsIfNeeded()
{
int numOfBufs = 0;
if (isHDREnabled() && isHDR1xFrameEnabled()) {
numOfBufs++;
}
return (uint8_t)(numOfBufs);
}
/*===========================================================================
* FUNCTION : getJpegQuality
*
* DESCRIPTION: get jpeg encoding quality
*
* PARAMETERS : none
*
* RETURN : jpeg encoding quality
*==========================================================================*/
uint32_t QCameraParameters::getJpegQuality()
{
int quality = getInt(KEY_JPEG_QUALITY);
if (quality < 0) {
quality = 85; // set to default quality value
}
return (uint32_t)quality;
}
/*===========================================================================
* FUNCTION : getRotation
*
* DESCRIPTION: get application configured rotation
*
* PARAMETERS : none
*
* RETURN : rotation value
*==========================================================================*/
uint32_t QCameraParameters::getRotation() {
int rotation = 0;
//If exif rotation is set, do not rotate captured image
if (!useJpegExifRotation()) {
rotation = mRotation;
if (rotation < 0) {
rotation = 0;
}
}
return (uint32_t)rotation;
}
/*===========================================================================
* FUNCTION : setJpegRotation
*
* DESCRIPTION: set jpeg rotation value configured internally
*
* PARAMETERS : none
*
* RETURN : jpeg rotation value
*==========================================================================*/
void QCameraParameters::setJpegRotation(int rotation) {
if (rotation == 0 || rotation == 90 ||
rotation == 180 || rotation == 270) {
mJpegRotation = (uint32_t)rotation;
}
}
/*===========================================================================
* FUNCTION : getDeviceRotation
*
* DESCRIPTION: get device rotation value
*
* PARAMETERS : none
*
* RETURN : device rotation value
*==========================================================================*/
uint32_t QCameraParameters::getDeviceRotation() {
int rotation = 0;
rotation = mRotation;
if (rotation < 0) {
rotation = 0;
}
return (uint32_t)rotation;
}
/*===========================================================================
* FUNCTION : getJpegExifRotation
*
* DESCRIPTION: get exif rotation value
*
* PARAMETERS : none
*
* RETURN : rotation value
*==========================================================================*/
uint32_t QCameraParameters::getJpegExifRotation() {
int rotation = 0;
if (useJpegExifRotation()) {
rotation = mRotation;
if (rotation < 0) {
rotation = 0;
}
}
return (uint32_t)rotation;
}
/*===========================================================================
* FUNCTION : useJpegExifRotation
*
* DESCRIPTION: Check if jpeg exif rotation need to be used
*
* PARAMETERS : none
*
* RETURN : true if jpeg exif rotation need to be used
*==========================================================================*/
bool QCameraParameters::useJpegExifRotation() {
char exifRotation[PROPERTY_VALUE_MAX];
property_get("persist.camera.exif.rotation", exifRotation, "off");
if (!strcmp(exifRotation, "on")) {
return true;
}
if (!(m_pCapability->qcom_supported_feature_mask & CAM_QCOM_FEATURE_ROTATION)) {
return true;
}
return false;
}
/*===========================================================================
* FUNCTION : getEffectValue
*
* DESCRIPTION: get effect value
*
* PARAMETERS : none
*
* RETURN : effect value
*==========================================================================*/
int32_t QCameraParameters::getEffectValue()
{
uint32_t cnt = 0;
const char *effect = get(KEY_EFFECT);
if (effect) {
while (NULL != EFFECT_MODES_MAP[cnt].desc) {
if (!strcmp(EFFECT_MODES_MAP[cnt].desc, effect)) {
return EFFECT_MODES_MAP[cnt].val;
}
cnt++;
}
} else {
LOGW("Missing effect value");
}
return CAM_EFFECT_MODE_OFF;
}
/*===========================================================================
* FUNCTION : parseGPSCoordinate
*
* DESCRIPTION: parse GPS coordinate string
*
* PARAMETERS :
* @coord_str : [input] coordinate string
* @coord : [output] ptr to struct to store coordinate
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int QCameraParameters::parseGPSCoordinate(const char *coord_str, rat_t* coord)
{
if(coord == NULL) {
LOGE("error, invalid argument coord == NULL");
return BAD_VALUE;
}
double degF = atof(coord_str);
if (degF < 0) {
degF = -degF;
}
double minF = (degF - (double)(int) degF) * 60.0;
double secF = (minF - (double)(int) minF) * 60.0;
getRational(&coord[0], (int)degF, 1);
getRational(&coord[1], (int)minF, 1);
getRational(&coord[2], (int)(secF * 10000.0), 10000);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getExifDateTime
*
* DESCRIPTION: query exif date time
*
* PARAMETERS :
* @dateTime : String to store exif date time.
* Should be leaved unchanged in case of error.
* @subsecTime : String to store exif time nanoseconds.
* Should be leaved unchanged in case of error.
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getExifDateTime(String8 &dateTime, String8 &subsecTime)
{
int32_t ret = NO_ERROR;
//get time and date from system
struct timeval tv;
struct tm timeinfo_data;
int res = gettimeofday(&tv, NULL);
if (0 == res) {
struct tm *timeinfo = localtime_r(&tv.tv_sec, &timeinfo_data);
if (NULL != timeinfo) {
//Write datetime according to EXIF Spec
//"YYYY:MM:DD HH:MM:SS" (20 chars including \0)
dateTime = String8::format("%04d:%02d:%02d %02d:%02d:%02d",
timeinfo->tm_year + 1900, timeinfo->tm_mon + 1,
timeinfo->tm_mday, timeinfo->tm_hour,
timeinfo->tm_min, timeinfo->tm_sec);
//Write subsec according to EXIF Sepc
subsecTime = String8::format("%06ld", tv.tv_usec);
} else {
LOGE("localtime_r() error");
ret = UNKNOWN_ERROR;
}
} else if (-1 == res) {
LOGE("gettimeofday() error: %s", strerror(errno));
ret = UNKNOWN_ERROR;
} else {
LOGE("gettimeofday() unexpected return code: %d", res);
ret = UNKNOWN_ERROR;
}
return ret;
}
/*===========================================================================
* FUNCTION : getRational
*
* DESCRIPTION: compose rational struct
*
* PARAMETERS :
* @rat : ptr to struct to store rational info
* @num :num of the rational
* @denom : denom of the rational
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getRational(rat_t *rat, int num, int denom)
{
if ((0 > num) || (0 > denom)) {
LOGE("Negative values");
return BAD_VALUE;
}
if (NULL == rat) {
LOGE("NULL rat input");
return BAD_VALUE;
}
rat->num = (uint32_t)num;
rat->denom = (uint32_t)denom;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getExifFocalLength
*
* DESCRIPTION: get exif focal lenght
*
* PARAMETERS :
* @focalLength : ptr to rational strcut to store focal lenght
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getExifFocalLength(rat_t *focalLength)
{
int focalLengthValue =
(int)(getFloat(QCameraParameters::KEY_FOCAL_LENGTH) * FOCAL_LENGTH_DECIMAL_PRECISION);
return getRational(focalLength, focalLengthValue, FOCAL_LENGTH_DECIMAL_PRECISION);
}
/*===========================================================================
* FUNCTION : getExifIsoSpeed
*
* DESCRIPTION: get exif ISO speed
*
* PARAMETERS : none
*
* RETURN : ISO speed value
*==========================================================================*/
uint16_t QCameraParameters::getExifIsoSpeed()
{
uint16_t isoSpeed = 0;
const char *iso_str = get(QCameraParameters::KEY_QC_ISO_MODE);
int iso_index = lookupAttr(ISO_MODES_MAP, PARAM_MAP_SIZE(ISO_MODES_MAP), iso_str);
switch (iso_index) {
case CAM_ISO_MODE_AUTO:
isoSpeed = 0;
break;
case CAM_ISO_MODE_DEBLUR:
isoSpeed = 1;
break;
case CAM_ISO_MODE_100:
isoSpeed = 100;
break;
case CAM_ISO_MODE_200:
isoSpeed = 200;
break;
case CAM_ISO_MODE_400:
isoSpeed = 400;
break;
case CAM_ISO_MODE_800:
isoSpeed = 800;
break;
case CAM_ISO_MODE_1600:
isoSpeed = 1600;
break;
case CAM_ISO_MODE_3200:
isoSpeed = 3200;
break;
}
return isoSpeed;
}
/*===========================================================================
* FUNCTION : getExifGpsProcessingMethod
*
* DESCRIPTION: get GPS processing method
*
* PARAMETERS :
* @gpsProcessingMethod : string to store GPS process method
* @count : lenght of the string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getExifGpsProcessingMethod(char *gpsProcessingMethod,
uint32_t &count)
{
const char *str = get(KEY_GPS_PROCESSING_METHOD);
if(str != NULL) {
memcpy(gpsProcessingMethod, ExifAsciiPrefix, EXIF_ASCII_PREFIX_SIZE);
count = EXIF_ASCII_PREFIX_SIZE;
strlcpy(gpsProcessingMethod + EXIF_ASCII_PREFIX_SIZE, str, GPS_PROCESSING_METHOD_SIZE);
count += (uint32_t)strlen(str);
gpsProcessingMethod[count++] = '\0'; // increase 1 for the last NULL char
return NO_ERROR;
} else {
return BAD_VALUE;
}
}
/*===========================================================================
* FUNCTION : getExifLatitude
*
* DESCRIPTION: get exif latitude
*
* PARAMETERS :
* @latitude : ptr to rational struct to store latitude info
* @ladRef : charater to indicate latitude reference
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getExifLatitude(rat_t *latitude,
char *latRef)
{
const char *str = get(KEY_GPS_LATITUDE);
if(str != NULL) {
parseGPSCoordinate(str, latitude);
//set Latitude Ref
float latitudeValue = getFloat(KEY_GPS_LATITUDE);
if(latitudeValue < 0.0f) {
latRef[0] = 'S';
} else {
latRef[0] = 'N';
}
latRef[1] = '\0';
return NO_ERROR;
}else{
return BAD_VALUE;
}
}
/*===========================================================================
* FUNCTION : getExifLongitude
*
* DESCRIPTION: get exif longitude
*
* PARAMETERS :
* @longitude : ptr to rational struct to store longitude info
* @lonRef : charater to indicate longitude reference
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getExifLongitude(rat_t *longitude,
char *lonRef)
{
const char *str = get(KEY_GPS_LONGITUDE);
if(str != NULL) {
parseGPSCoordinate(str, longitude);
//set Longitude Ref
float longitudeValue = getFloat(KEY_GPS_LONGITUDE);
if(longitudeValue < 0.0f) {
lonRef[0] = 'W';
} else {
lonRef[0] = 'E';
}
lonRef[1] = '\0';
return NO_ERROR;
}else{
return BAD_VALUE;
}
}
/*===========================================================================
* FUNCTION : getExifAltitude
*
* DESCRIPTION: get exif altitude
*
* PARAMETERS :
* @altitude : ptr to rational struct to store altitude info
* @altRef : charater to indicate altitude reference
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getExifAltitude(rat_t *altitude,
char *altRef)
{
const char *str = get(KEY_GPS_ALTITUDE);
if(str != NULL) {
double value = atof(str);
*altRef = 0;
if(value < 0){
*altRef = 1;
value = -value;
}
return getRational(altitude, (int)(value*1000), 1000);
}else{
return BAD_VALUE;
}
}
/*===========================================================================
* FUNCTION : getExifGpsDateTimeStamp
*
* DESCRIPTION: get exif GPS date time stamp
*
* PARAMETERS :
* @gpsDateStamp : GPS date time stamp string
* @bufLen : length of the string
* @gpsTimeStamp : ptr to rational struct to store time stamp info
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getExifGpsDateTimeStamp(char *gpsDateStamp,
uint32_t bufLen,
rat_t *gpsTimeStamp)
{
const char *str = get(KEY_GPS_TIMESTAMP);
if(str != NULL) {
time_t unixTime = (time_t)atol(str);
struct tm *UTCTimestamp = gmtime(&unixTime);
if(!UTCTimestamp) {
LOGE("UTCTimestamp is null\n");
return BAD_VALUE;
}
strftime(gpsDateStamp, bufLen, "%Y:%m:%d", UTCTimestamp);
getRational(&gpsTimeStamp[0], UTCTimestamp->tm_hour, 1);
getRational(&gpsTimeStamp[1], UTCTimestamp->tm_min, 1);
getRational(&gpsTimeStamp[2], UTCTimestamp->tm_sec, 1);
return NO_ERROR;
} else {
return BAD_VALUE;
}
}
/*===========================================================================
* FUNCTION : updateFocusDistances
*
* DESCRIPTION: update focus distances
*
* PARAMETERS :
* @focusDistances : ptr to focus distance info
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::updateFocusDistances(cam_focus_distances_info_t *focusDistances)
{
String8 str;
char buffer[32] = {0};
//set all distances to infinity if focus mode is infinity
if(mFocusMode == CAM_FOCUS_MODE_INFINITY) {
str.append("Infinity,Infinity,Infinity");
} else {
if (focusDistances->focus_distance[0] < FOCUS_PERCISION) {
str.append("Infinity");
} else {
snprintf(buffer, sizeof(buffer), "%f", 1.0/focusDistances->focus_distance[0]);
str.append(buffer);
}
if (focusDistances->focus_distance[1] < FOCUS_PERCISION) {
str.append(",Infinity");
} else {
snprintf(buffer, sizeof(buffer), ",%f", 1.0/focusDistances->focus_distance[1]);
str.append(buffer);
}
if (focusDistances->focus_distance[2] < FOCUS_PERCISION) {
str.append(",Infinity");
} else {
snprintf(buffer, sizeof(buffer), ",%f", 1.0/focusDistances->focus_distance[2]);
str.append(buffer);
}
}
LOGH("setting KEY_FOCUS_DISTANCES as %s", __FUNCTION__, str.string());
set(QCameraParameters::KEY_FOCUS_DISTANCES, str.string());
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : updateRecordingHintValue
*
* DESCRIPTION: update recording hint locally and to daemon
*
* PARAMETERS :
* @value : video hint value
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::updateRecordingHintValue(int32_t value)
{
int32_t rc = NO_ERROR;
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
rc = setRecordingHintValue(value);
if (rc != NO_ERROR) {
LOGE("Failed to update table");
return rc;
}
if(m_bDISEnabled && (value==1)) {
LOGH("%d: Setting DIS value again!!");
setDISValue(VALUE_ENABLE);
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to update recording hint");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : setHistogram
*
* DESCRIPTION: set histogram
*
* PARAMETERS :
* @enabled : if histogram is enabled
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setHistogram(bool enabled)
{
if(m_bHistogramEnabled == enabled) {
LOGH("histogram flag not changed, no ops here");
return NO_ERROR;
}
// set parm for histogram
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
int32_t value = enabled ? 1 : 0;
int32_t rc = NO_ERROR;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_HISTOGRAM, value)) {
LOGE("Failed to update table");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to set histogram");
return rc;
}
m_bHistogramEnabled = enabled;
LOGH("Histogram -> %s", m_bHistogramEnabled ? "Enabled" : "Disabled");
return rc;
}
/*===========================================================================
* FUNCTION : setIntEvent
*
* DESCRIPTION: set setIntEvent
*
* PARAMETERS :
* @params : image size and dimensions
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setIntEvent(cam_int_evt_params_t params)
{
int32_t rc = NO_ERROR;
if ( m_pParamBuf == NULL ) {
return NO_INIT;
}
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
//Sending snapshot taken notification back to Eztune"
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_INT_EVT, params)) {
LOGE("Failed to update table");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to set frameskip info parm");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : setFaceDetectionOption
*
* DESCRIPTION: set if face detection is enabled by SendCommand
*
* PARAMETERS :
* @enabled : bool flag if face detection should be enabled
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFaceDetectionOption(bool enabled)
{
m_bFaceDetectionOn = enabled;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setFaceDetection
*
* DESCRIPTION: set face detection
*
* PARAMETERS :
* @enabled : if face detection is enabled
* @initCommit : if configuration list need to be initialized and commited
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFaceDetection(bool enabled, bool initCommit)
{
uint32_t faceProcMask = m_nFaceProcMask;
// set face detection mask
if (enabled) {
faceProcMask |= CAM_FACE_PROCESS_MASK_DETECTION;
if (getRecordingHintValue() > 0) {
faceProcMask = 0;
faceProcMask |= CAM_FACE_PROCESS_MASK_FOCUS;
if (fdModeInVideo() == CAM_FACE_PROCESS_MASK_DETECTION) {
faceProcMask |= CAM_FACE_PROCESS_MASK_DETECTION;
}
} else {
faceProcMask |= CAM_FACE_PROCESS_MASK_FOCUS;
faceProcMask |= CAM_FACE_PROCESS_MASK_DETECTION;
}
if (isTruePortraitEnabled()) {
LOGL("QCameraParameters::setFaceDetection trueportrait enabled");
faceProcMask |= CAM_FACE_PROCESS_MASK_GAZE;
} else {
LOGL("QCameraParameters::setFaceDetection trueportrait disabled");
faceProcMask &= ~CAM_FACE_PROCESS_MASK_GAZE;
}
} else {
faceProcMask &= ~(CAM_FACE_PROCESS_MASK_DETECTION
| CAM_FACE_PROCESS_MASK_FOCUS
| CAM_FACE_PROCESS_MASK_GAZE);
}
if(m_nFaceProcMask == faceProcMask) {
LOGH("face process mask not changed, no ops here");
return NO_ERROR;
}
m_nFaceProcMask = faceProcMask;
// set parm for face detection
uint32_t requested_faces = (uint32_t)getInt(KEY_QC_MAX_NUM_REQUESTED_FACES);
cam_fd_set_parm_t fd_set_parm;
memset(&fd_set_parm, 0, sizeof(cam_fd_set_parm_t));
fd_set_parm.fd_mode = faceProcMask;
fd_set_parm.num_fd = requested_faces;
LOGH("[KPI Perf]: PROFILE_FACE_DETECTION_VALUE = %d num_fd = %d",
faceProcMask,requested_faces);
if (initCommit) {
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
}
int32_t rc = NO_ERROR;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_FD, fd_set_parm)) {
LOGE("Failed to update table");
return BAD_VALUE;
}
if (initCommit) {
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to set face detection parm");
return rc;
}
}
LOGH("FaceProcMask -> %d", m_nFaceProcMask);
return rc;
}
/*===========================================================================
* FUNCTION : setFrameSkip
*
* DESCRIPTION: send ISP frame skip pattern to camera daemon
*
* PARAMETERS :
* @pattern : skip pattern for ISP
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFrameSkip(enum msm_vfe_frame_skip_pattern pattern)
{
int32_t rc = NO_ERROR;
if ( m_pParamBuf == NULL ) {
return NO_INIT;
}
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_FRAMESKIP, (int32_t)pattern)) {
LOGE("Failed to update table");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to set frameskip info parm");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : updateRAW
*
* DESCRIPTION: Query sensor output size based on maximum stream dimension
*
* PARAMETERS :
* @max_dim : maximum stream dimension
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::updateRAW(cam_dimension_t max_dim)
{
int32_t rc = NO_ERROR;
cam_dimension_t raw_dim, pic_dim;
// If offline raw is enabled, check the dimensions from Picture size since snapshot
// stream is not added but final JPEG is required of snapshot size
if (getofflineRAW()) {
getStreamDimension(CAM_STREAM_TYPE_SNAPSHOT, pic_dim);
if (pic_dim.width > max_dim.width) {
max_dim.width = pic_dim.width;
}
if (pic_dim.height > max_dim.height) {
max_dim.height = pic_dim.height;
}
}
if (max_dim.width == 0 || max_dim.height == 0) {
max_dim = m_pCapability->raw_dim[0];
}
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_MAX_DIMENSION, max_dim)) {
LOGE("Failed to update table for CAM_INTF_PARM_MAX_DIMENSION ");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to set lock CAM_INTF_PARM_MAX_DIMENSION parm");
return rc;
}
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
ADD_GET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_RAW_DIMENSION);
rc = commitGetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to get commit CAM_INTF_PARM_RAW_DIMENSION");
return rc;
}
READ_PARAM_ENTRY(m_pParamBuf, CAM_INTF_PARM_RAW_DIMENSION, raw_dim);
LOGH("RAW Dimension = %d X %d",raw_dim.width,raw_dim.height);
if (raw_dim.width == 0 || raw_dim.height == 0) {
LOGW("Error getting RAW size. Setting to Capability value");
raw_dim = m_pCapability->raw_dim[0];
}
setRawSize(raw_dim);
return rc;
}
/*===========================================================================
* FUNCTION : setHDRSceneEnable
*
* DESCRIPTION: sets hdr scene deteced flag
*
* PARAMETERS :
* @bflag : hdr scene deteced
*
* RETURN : nothing
*==========================================================================*/
void QCameraParameters::setHDRSceneEnable(bool bflag)
{
bool bupdate = false;
if (m_HDRSceneEnabled != bflag) {
bupdate = true;
}
m_HDRSceneEnabled = bflag;
if (bupdate) {
updateFlash(true);
}
}
/*===========================================================================
* FUNCTION : getASDStateString
*
* DESCRIPTION: get ASD result in string format
*
* PARAMETERS :
* @scene : selected scene mode
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
const char *QCameraParameters::getASDStateString(cam_auto_scene_t scene)
{
switch (scene) {
case S_NORMAL :
return "Normal";
case S_SCENERY:
return "Scenery";
case S_PORTRAIT:
return "Portrait";
case S_PORTRAIT_BACKLIGHT:
return "Portrait-Backlight";
case S_SCENERY_BACKLIGHT:
return "Scenery-Backlight";
case S_BACKLIGHT:
return "Backlight";
default:
return "<Unknown!>";
}
}
/*===========================================================================
* FUNCTION : parseNDimVector
*
* DESCRIPTION: helper function to parse a string like "(1, 2, 3, 4, ..., N)"
* into N-dimension vector
*
* PARAMETERS :
* @str : string to be parsed
* @num : output array of size N to store vector element values
* @N : number of dimension
* @delim : delimeter to seperete string
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::parseNDimVector(const char *str, int *num, int N, char delim = ',')
{
char *start, *end;
if (num == NULL) {
LOGE("Invalid output array (num == NULL)");
return BAD_VALUE;
}
//check if string starts and ends with parantheses
if(str[0] != '(' || str[strlen(str)-1] != ')') {
LOGE("Invalid format of string %s, valid format is (n1, n2, n3, n4 ...)",
str);
return BAD_VALUE;
}
start = (char*) str;
start++;
for(int i=0; i<N; i++) {
*(num+i) = (int) strtol(start, &end, 10);
if(*end != delim && i < N-1) {
LOGE("Cannot find delimeter '%c' in string \"%s\". end = %c",
delim, str, *end);
return -1;
}
start = end+1;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : parseCameraAreaString
*
* DESCRIPTION: helper function to parse a string of camera areas like
* "(1, 2, 3, 4, 5),(1, 2, 3, 4, 5),..."
*
* PARAMETERS :
* @str : string to be parsed
* @max_num_areas : max number of areas
* @pAreas : ptr to struct to store areas
* @num_areas_found : number of areas found
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::parseCameraAreaString(const char *str,
int max_num_areas,
cam_area_t *pAreas,
int& num_areas_found)
{
char area_str[32];
const char *start, *end, *p;
start = str; end = NULL;
int values[5], index=0;
num_areas_found = 0;
memset(values, 0, sizeof(values));
while(start != NULL) {
if(*start != '(') {
LOGE("error: Ill formatted area string: %s", str);
return BAD_VALUE;
}
end = strchr(start, ')');
if(end == NULL) {
LOGE("error: Ill formatted area string: %s", str);
return BAD_VALUE;
}
int i;
for (i=0,p=start; p<=end; p++, i++) {
area_str[i] = *p;
}
area_str[i] = '\0';
if(parseNDimVector(area_str, values, 5) < 0){
LOGE("error: Failed to parse the area string: %s", area_str);
return BAD_VALUE;
}
// no more areas than max_num_areas are accepted.
if(index >= max_num_areas) {
LOGE("error: too many areas specified %s", str);
return BAD_VALUE;
}
pAreas[index].rect.left = values[0];
pAreas[index].rect.top = values[1];
pAreas[index].rect.width = values[2] - values[0];
pAreas[index].rect.height = values[3] - values[1];
pAreas[index].weight = values[4];
index++;
start = strchr(end, '('); // serach for next '('
}
num_areas_found = index;
return 0;
}
/*===========================================================================
* FUNCTION : validateCameraAreas
*
* DESCRIPTION: helper function to validate camera areas within (-1000, 1000)
*
* PARAMETERS :
* @areas : ptr to array of areas
* @num_areas : number of areas
*
* RETURN : true -- area is in valid range
* false -- not valid
*==========================================================================*/
bool QCameraParameters::validateCameraAreas(cam_area_t *areas, int num_areas)
{
// special case: default area
if (num_areas == 1 &&
areas[0].rect.left == 0 &&
areas[0].rect.top == 0 &&
areas[0].rect.width == 0 &&
areas[0].rect.height == 0 &&
areas[0].weight == 0) {
return true;
}
for(int i = 0; i < num_areas; i++) {
// left should be >= -1000
if(areas[i].rect.left < -1000) {
return false;
}
// top should be >= -1000
if(areas[i].rect.top < -1000) {
return false;
}
// width or height should be > 0
if (areas[i].rect.width <= 0 || areas[i].rect.height <= 0) {
return false;
}
// right should be <= 1000
if(areas[i].rect.left + areas[i].rect.width > 1000) {
return false;
}
// bottom should be <= 1000
if(areas[i].rect.top + areas[i].rect.height > 1000) {
return false;
}
// weight should be within (1, 1000)
if (areas[i].weight < 1 || areas[i].weight > 1000) {
return false;
}
}
return true;
}
/*===========================================================================
* FUNCTION : isYUVFrameInfoNeeded
*
* DESCRIPTION: In AE-Bracket mode, we need set yuv buffer information for up-layer
*
* PARAMETERS : none
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCameraParameters::isYUVFrameInfoNeeded()
{
//In AE-Bracket mode, we need set raw buffer information for up-layer
if(!isNV21PictureFormat() && !isNV16PictureFormat()){
return false;
}
const char *aecBracketStr = get(KEY_QC_AE_BRACKET_HDR);
int value = lookupAttr(BRACKETING_MODES_MAP, PARAM_MAP_SIZE(BRACKETING_MODES_MAP),
aecBracketStr);
LOGH("aecBracketStr=%s, value=%d.", aecBracketStr, value);
return (value == CAM_EXP_BRACKETING_ON);
}
/*===========================================================================
* FUNCTION : getFrameFmtString
*
* DESCRIPTION: get string name of frame format
*
* PARAMETERS :
* @frame : frame format
*
* RETURN : string name of frame format
*==========================================================================*/
const char *QCameraParameters::getFrameFmtString(cam_format_t fmt)
{
return lookupNameByValue(PICTURE_TYPES_MAP, PARAM_MAP_SIZE(PICTURE_TYPES_MAP), fmt);
}
/*===========================================================================
* FUNCTION : setDcrf
*
* DESCRIPTION: Enable/Disable DCRF (dual-camera-range-finding)
*
* RETURN : none
*==========================================================================*/
void QCameraParameters::setDcrf()
{
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
// Set DCRF to off by default (assuming single-camera mode)
m_bDcrfEnabled = 0;
// In dual-cam mode, get sysprop and set it to on by default
if(m_relCamSyncInfo.sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
property_get("persist.camera.dcrf.enable", prop, "1");
m_bDcrfEnabled = atoi(prop);
}
}
/*===========================================================================
* FUNCTION : setRelatedCamSyncInfo
*
* DESCRIPTION: set the related cam info parameters
* the related cam info is cached into params to make some decisions beforehand
*
* PARAMETERS :
* @info : ptr to related cam info parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setRelatedCamSyncInfo(
cam_sync_related_sensors_event_info_t* info)
{
if(info != NULL){
memcpy(&m_relCamSyncInfo, info,
sizeof(cam_sync_related_sensors_event_info_t));
return NO_ERROR;
} else {
LOGE("info buffer is null");
return UNKNOWN_ERROR;
}
}
/*===========================================================================
* FUNCTION : getRelatedCamSyncInfo
*
* DESCRIPTION:returns the related cam sync info for this HWI instance
*
* PARAMETERS :none
*
* RETURN : const pointer to cam_sync_related_sensors_event_info_t
*==========================================================================*/
const cam_sync_related_sensors_event_info_t*
QCameraParameters::getRelatedCamSyncInfo(void)
{
return &m_relCamSyncInfo;
}
/*===========================================================================
* FUNCTION : setFrameSyncEnabled
*
* DESCRIPTION: sets whether frame sync is enabled
*
* PARAMETERS :
* @enable : flag whether to enable or disable frame sync
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setFrameSyncEnabled(bool enable)
{
m_bFrameSyncEnabled = enable;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : isFrameSyncEnabled
*
* DESCRIPTION: returns whether frame sync is enabled
*
* PARAMETERS :none
*
* RETURN : bool indicating whether frame sync is enabled
*==========================================================================*/
bool QCameraParameters::isFrameSyncEnabled(void)
{
return m_bFrameSyncEnabled;
}
/*===========================================================================
* FUNCTION : bundleRelatedCameras
*
* DESCRIPTION: send trigger for bundling related camera sessions in the server
*
* PARAMETERS :
* @sync :indicates whether syncing is On or Off
* @sessionid :session id for other camera session
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::bundleRelatedCameras(bool sync,
uint32_t sessionid)
{
int32_t rc = NO_ERROR;
if (NULL == m_pCamOpsTbl) {
LOGE("Ops not initialized");
return NO_INIT;
}
LOGD("Sending Bundling cmd sync %d, SessionId %d ",
sync, sessionid);
if(m_pRelCamSyncBuf) {
if(sync) {
m_pRelCamSyncBuf->sync_control = CAM_SYNC_RELATED_SENSORS_ON;
}
else {
m_pRelCamSyncBuf->sync_control = CAM_SYNC_RELATED_SENSORS_OFF;
}
m_pRelCamSyncBuf->mode = m_relCamSyncInfo.mode;
m_pRelCamSyncBuf->type = m_relCamSyncInfo.type;
m_pRelCamSyncBuf->related_sensor_session_id = sessionid;
rc = m_pCamOpsTbl->ops->sync_related_sensors(
m_pCamOpsTbl->camera_handle, m_pRelCamSyncBuf);
} else {
LOGE("Related Cam SyncBuffer not allocated", rc);
return NO_INIT;
}
return rc;
}
/*===========================================================================
* FUNCTION : getRelatedCamCalibration
*
* DESCRIPTION: fetch the related camera subsystem calibration data
*
* PARAMETERS :
* @calib : calibration data fetched
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getRelatedCamCalibration(
cam_related_system_calibration_data_t* calib)
{
int32_t rc = NO_ERROR;
if(!calib) {
return BAD_TYPE;
}
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
ADD_GET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_RELATED_SENSORS_CALIBRATION);
rc = commitGetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to get related cam calibration info");
return rc;
}
READ_PARAM_ENTRY(m_pParamBuf,
CAM_INTF_PARM_RELATED_SENSORS_CALIBRATION, *calib);
LOGD("CALIB version %d ", calib->calibration_format_version);
LOGD("CALIB normalized_focal_length %f ",
calib->main_cam_specific_calibration.normalized_focal_length);
LOGD("CALIB native_sensor_resolution_width %d ",
calib->main_cam_specific_calibration.native_sensor_resolution_width);
LOGD("CALIB native_sensor_resolution_height %d ",
calib->main_cam_specific_calibration.native_sensor_resolution_height);
LOGD("CALIB sensor_resolution_width %d ",
calib->main_cam_specific_calibration.calibration_sensor_resolution_width);
LOGD("CALIB sensor_resolution_height %d ",
calib->main_cam_specific_calibration.calibration_sensor_resolution_height);
LOGD("CALIB focal_length_ratio %f ",
calib->main_cam_specific_calibration.focal_length_ratio);
return rc;
}
/*===========================================================================
* FUNCTION : initBatchUpdate
*
* DESCRIPTION: init camera parameters buf entries
*
* PARAMETERS :
* @p_table : ptr to parameter buffer
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::initBatchUpdate(parm_buffer_t *p_table)
{
m_tempMap.clear();
clear_metadata_buffer(p_table);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : commitSetBatch
*
* DESCRIPTION: commit all set parameters in the batch work to backend
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::commitSetBatch()
{
int32_t rc = NO_ERROR;
int32_t i = 0;
if (NULL == m_pParamBuf) {
LOGE("Params not initialized");
return NO_INIT;
}
/* Loop to check if atleast one entry is valid */
for(i = 0; i < CAM_INTF_PARM_MAX; i++){
if(m_pParamBuf->is_valid[i])
break;
}
if (NULL == m_pCamOpsTbl) {
LOGE("Ops not initialized");
return NO_INIT;
}
if (i < CAM_INTF_PARM_MAX) {
rc = m_pCamOpsTbl->ops->set_parms(m_pCamOpsTbl->camera_handle, m_pParamBuf);
}
if (rc == NO_ERROR) {
// commit change from temp storage into param map
rc = commitParamChanges();
}
return rc;
}
/*===========================================================================
* FUNCTION : commitGetBatch
*
* DESCRIPTION: commit all get parameters in the batch work to backend
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::commitGetBatch()
{
int32_t rc = NO_ERROR;
int32_t i = 0;
if (NULL == m_pParamBuf) {
LOGE("Params not initialized");
return NO_INIT;
}
/* Loop to check if atleast one entry is valid */
for(i = 0; i < CAM_INTF_PARM_MAX; i++){
if(m_pParamBuf->is_valid[i])
break;
}
if (NULL == m_pCamOpsTbl) {
LOGE("Ops not initialized");
return NO_INIT;
}
if (i < CAM_INTF_PARM_MAX) {
return m_pCamOpsTbl->ops->get_parms(m_pCamOpsTbl->camera_handle, m_pParamBuf);
} else {
return NO_ERROR;
}
return rc;
}
/*===========================================================================
* FUNCTION : updateParamEntry
*
* DESCRIPTION: update a parameter entry in the local temp map obj
*
* PARAMETERS :
* @key : key of the entry
* @value : value of the entry
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::updateParamEntry(const char *key, const char *value)
{
m_tempMap.replaceValueFor(String8(key), String8(value));
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : commitParamChanges
*
* DESCRIPTION: commit all changes in local temp map obj into parameter obj
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::commitParamChanges()
{
size_t size = m_tempMap.size();
for (size_t i = 0; i < size; i++) {
String8 k, v;
k = m_tempMap.keyAt(i);
v = m_tempMap.valueAt(i);
set(k, v);
}
m_tempMap.clear();
// update local changes
m_bRecordingHint = m_bRecordingHint_new;
m_bZslMode = m_bZslMode_new;
/* After applying scene mode auto,
Camera effects need to be reapplied */
if ( m_bSceneTransitionAuto ) {
m_bUpdateEffects = true;
m_bSceneTransitionAuto = false;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : QCameraReprocScaleParam
*
* DESCRIPTION: constructor of QCameraReprocScaleParam
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
QCameraParameters::QCameraReprocScaleParam::QCameraReprocScaleParam()
: mScaleEnabled(false),
mIsUnderScaling(false),
mNeedScaleCnt(0),
mSensorSizeTblCnt(0),
mSensorSizeTbl(NULL),
mTotalSizeTblCnt(0)
{
mPicSizeFromAPK.width = 0;
mPicSizeFromAPK.height = 0;
mPicSizeSetted.width = 0;
mPicSizeSetted.height = 0;
memset(mNeedScaledSizeTbl, 0, sizeof(mNeedScaledSizeTbl));
memset(mTotalSizeTbl, 0, sizeof(mTotalSizeTbl));
}
/*===========================================================================
* FUNCTION : ~~QCameraReprocScaleParam
*
* DESCRIPTION: destructor of QCameraReprocScaleParam
*
* PARAMETERS : none
*
* RETURN : none
*==========================================================================*/
QCameraParameters::QCameraReprocScaleParam::~QCameraReprocScaleParam()
{
//do nothing now.
}
/*===========================================================================
* FUNCTION : setScaledSizeTbl
*
* DESCRIPTION: re-set picture size table with dimensions that need scaling if Reproc Scale is enabled
*
* PARAMETERS :
* @scale_cnt : count of picture sizes that want scale
* @scale_tbl : picture size table that want scale
* @org_cnt : sensor supported picture size count
* @org_tbl : sensor supported picture size table
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::QCameraReprocScaleParam::setScaleSizeTbl(size_t scale_cnt,
cam_dimension_t *scale_tbl, size_t org_cnt, cam_dimension_t *org_tbl)
{
int32_t rc = NO_ERROR;
size_t i;
mNeedScaleCnt = 0;
if(!mScaleEnabled || scale_cnt <=0 || scale_tbl == NULL || org_cnt <=0 || org_tbl == NULL){
return BAD_VALUE; // Do not need scale, so also need not reset picture size table
}
mSensorSizeTblCnt = org_cnt;
mSensorSizeTbl = org_tbl;
mNeedScaleCnt = checkScaleSizeTable(scale_cnt, scale_tbl, org_cnt, org_tbl);
if(mNeedScaleCnt <= 0){
LOGE("do not have picture sizes need scaling.");
return BAD_VALUE;
}
if(mNeedScaleCnt + org_cnt > MAX_SIZES_CNT){
LOGE("picture size list exceed the max count.");
return BAD_VALUE;
}
//get the total picture size table
mTotalSizeTblCnt = mNeedScaleCnt + org_cnt;
if (mNeedScaleCnt > MAX_SCALE_SIZES_CNT) {
LOGE("Error!! mNeedScaleCnt (%d) is more than MAX_SCALE_SIZES_CNT",
mNeedScaleCnt);
return BAD_VALUE;
}
for(i = 0; i < mNeedScaleCnt; i++){
mTotalSizeTbl[i].width = mNeedScaledSizeTbl[i].width;
mTotalSizeTbl[i].height = mNeedScaledSizeTbl[i].height;
LOGH("scale picture size: i =%d, width=%d, height=%d.",
i, mTotalSizeTbl[i].width, mTotalSizeTbl[i].height);
}
for(; i < mTotalSizeTblCnt; i++){
mTotalSizeTbl[i].width = org_tbl[i-mNeedScaleCnt].width;
mTotalSizeTbl[i].height = org_tbl[i-mNeedScaleCnt].height;
LOGH("sensor supportted picture size: i =%d, width=%d, height=%d.",
i, mTotalSizeTbl[i].width, mTotalSizeTbl[i].height);
}
return rc;
}
/*===========================================================================
* FUNCTION : getScaledSizeTblCnt
*
* DESCRIPTION: get picture size cnt that need scale
*
* PARAMETERS : none
*
* RETURN : uint8_t type of picture size count
*==========================================================================*/
size_t QCameraParameters::QCameraReprocScaleParam::getScaleSizeTblCnt()
{
return mNeedScaleCnt;
}
/*===========================================================================
* FUNCTION : getScaledSizeTbl
*
* DESCRIPTION: get picture size table that need scale
*
* PARAMETERS : none
*
* RETURN : cam_dimension_t list of picture size table
*==========================================================================*/
cam_dimension_t *QCameraParameters::QCameraReprocScaleParam::getScaledSizeTbl()
{
if(!mScaleEnabled)
return NULL;
return mNeedScaledSizeTbl;
}
/*===========================================================================
* FUNCTION : setScaleEnable
*
* DESCRIPTION: enable or disable Reproc Scale
*
* PARAMETERS :
* @enabled : enable: 1; disable 0
*
* RETURN : none
*==========================================================================*/
void QCameraParameters::QCameraReprocScaleParam::setScaleEnable(bool enabled)
{
mScaleEnabled = enabled;
}
/*===========================================================================
* FUNCTION : isScaleEnabled
*
* DESCRIPTION: check if Reproc Scale is enabled
*
* PARAMETERS : none
*
* RETURN : bool type of status
*==========================================================================*/
bool QCameraParameters::QCameraReprocScaleParam::isScaleEnabled()
{
return mScaleEnabled;
}
/*===========================================================================
* FUNCTION : isScalePicSize
*
* DESCRIPTION: check if current picture size is from Scale Table
*
* PARAMETERS :
* @width : current picture width
* @height : current picture height
*
* RETURN : bool type of status
*==========================================================================*/
bool QCameraParameters::QCameraReprocScaleParam::isScalePicSize(int width, int height)
{
//Check if the picture size is in scale table
if(mNeedScaleCnt <= 0)
return FALSE;
for (size_t i = 0; i < mNeedScaleCnt; i++) {
if ((mNeedScaledSizeTbl[i].width == width) && (mNeedScaledSizeTbl[i].height == height)) {
//found match
return TRUE;
}
}
LOGE("Not in scale picture size table.");
return FALSE;
}
/*===========================================================================
* FUNCTION : isValidatePicSize
*
* DESCRIPTION: check if current picture size is validate
*
* PARAMETERS :
* @width : current picture width
* @height : current picture height
*
* RETURN : bool type of status
*==========================================================================*/
bool QCameraParameters::QCameraReprocScaleParam::isValidatePicSize(int width, int height)
{
size_t i = 0;
for(i = 0; i < mSensorSizeTblCnt; i++){
if(mSensorSizeTbl[i].width == width
&& mSensorSizeTbl[i].height== height){
return TRUE;
}
}
for(i = 0; i < mNeedScaleCnt; i++){
if(mNeedScaledSizeTbl[i].width == width
&& mNeedScaledSizeTbl[i].height== height){
return TRUE;
}
}
LOGE("Invalidate input picture size.");
return FALSE;
}
/*===========================================================================
* FUNCTION : setSensorSupportedPicSize
*
* DESCRIPTION: set sensor supported picture size.
* For Snapshot stream size configuration, we need use sensor supported size.
* We will use CPP to do Scaling based on output Snapshot stream.
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::QCameraReprocScaleParam::setSensorSupportedPicSize()
{
//will find a suitable picture size (here we leave a prossibility to add other scale requirement)
//Currently we only focus on upscaling, and checkScaleSizeTable() has guaranteed the dimension ratio.
if(!mIsUnderScaling || mSensorSizeTblCnt <= 0)
return BAD_VALUE;
//We just get the max sensor supported size here.
mPicSizeSetted.width = mSensorSizeTbl[0].width;
mPicSizeSetted.height = mSensorSizeTbl[0].height;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setValidatePicSize
*
* DESCRIPTION: set sensor supported size and change scale status.
*
* PARAMETERS :
* @width : input picture width
* @height : input picture height
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::QCameraReprocScaleParam::setValidatePicSize(int &width,int &height)
{
if(!mScaleEnabled)
return BAD_VALUE;
mIsUnderScaling = FALSE; //default: not under scale
if(isScalePicSize(width, height)){
// input picture size need scaling operation. Record size from APK and setted
mIsUnderScaling = TRUE;
mPicSizeFromAPK.width = width;
mPicSizeFromAPK.height = height;
if(setSensorSupportedPicSize() != NO_ERROR)
return BAD_VALUE;
//re-set picture size to sensor supported size
width = mPicSizeSetted.width;
height = mPicSizeSetted.height;
LOGH("mPicSizeFromAPK- with=%d, height=%d, mPicSizeSetted- with =%d, height=%d.",
mPicSizeFromAPK.width, mPicSizeFromAPK.height, mPicSizeSetted.width, mPicSizeSetted.height);
}else{
mIsUnderScaling = FALSE;
//no scale is needed for input picture size
if(!isValidatePicSize(width, height)){
LOGE("invalidate input picture size.");
return BAD_VALUE;
}
mPicSizeSetted.width = width;
mPicSizeSetted.height = height;
}
LOGH("X. mIsUnderScaling=%d, width=%d, height=%d.", mIsUnderScaling, width, height);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getPicSizeFromAPK
*
* DESCRIPTION: get picture size that get from APK
*
* PARAMETERS :
* @width : input width
* @height : input height
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::QCameraReprocScaleParam::getPicSizeFromAPK(int &width, int &height)
{
if(!mIsUnderScaling)
return BAD_VALUE;
width = mPicSizeFromAPK.width;
height = mPicSizeFromAPK.height;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getPicSizeSetted
*
* DESCRIPTION: get picture size that setted into mm-camera
*
* PARAMETERS :
* @width : input width
* @height : input height
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::QCameraReprocScaleParam::getPicSizeSetted(int &width, int &height)
{
width = mPicSizeSetted.width;
height = mPicSizeSetted.height;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : isUnderScaling
*
* DESCRIPTION: check if we are in Reproc Scaling requirment
*
* PARAMETERS : none
*
* RETURN : bool type of status
*==========================================================================*/
bool QCameraParameters::QCameraReprocScaleParam::isUnderScaling()
{
return mIsUnderScaling;
}
/*===========================================================================
* FUNCTION : checkScaleSizeTable
*
* DESCRIPTION: check PICTURE_SIZE_NEED_SCALE to choose
*
* PARAMETERS :
* @scale_cnt : count of picture sizes that want scale
* @scale_tbl : picture size table that want scale
* @org_cnt : sensor supported picture size count
* @org_tbl : sensor supported picture size table
*
* RETURN : bool type of status
*==========================================================================*/
size_t QCameraParameters::QCameraReprocScaleParam::checkScaleSizeTable(size_t scale_cnt,
cam_dimension_t *scale_tbl, size_t org_cnt, cam_dimension_t *org_tbl)
{
size_t stbl_cnt = 0;
size_t temp_cnt = 0;
ssize_t i = 0;
if(scale_cnt <=0 || scale_tbl == NULL || org_tbl == NULL || org_cnt <= 0)
return stbl_cnt;
//get validate scale size table. Currently we only support:
// 1. upscale. The scale size must larger than max sensor supported size
// 2. Scale dimension ratio must be same as the max sensor supported size.
temp_cnt = scale_cnt;
for (i = (ssize_t)(scale_cnt - 1); i >= 0; i--) {
if (scale_tbl[i].width > org_tbl[0].width ||
(scale_tbl[i].width == org_tbl[0].width &&
scale_tbl[i].height > org_tbl[0].height)) {
//get the smallest scale size
break;
}
temp_cnt--;
}
//check dimension ratio
double supported_ratio = (double)org_tbl[0].width / (double)org_tbl[0].height;
for (i = 0; i < (ssize_t)temp_cnt; i++) {
double cur_ratio = (double)scale_tbl[i].width / (double)scale_tbl[i].height;
if (fabs(supported_ratio - cur_ratio) > ASPECT_TOLERANCE) {
continue;
}
mNeedScaledSizeTbl[stbl_cnt].width = scale_tbl[i].width;
mNeedScaledSizeTbl[stbl_cnt].height= scale_tbl[i].height;
stbl_cnt++;
}
return stbl_cnt;
}
/*===========================================================================
* FUNCTION : getTotalSizeTblCnt
*
* DESCRIPTION: get total picture size count after adding dimensions that need scaling
*
* PARAMETERS : none
*
* RETURN : uint8_t type of picture size count
*==========================================================================*/
size_t QCameraParameters::QCameraReprocScaleParam::getTotalSizeTblCnt()
{
return mTotalSizeTblCnt;
}
/*===========================================================================
* FUNCTION : getTotalSizeTbl
*
* DESCRIPTION: get picture size table after adding dimensions that need scaling
*
* PARAMETERS : none
*
* RETURN : cam_dimension_t list of picture size table
*==========================================================================*/
cam_dimension_t *QCameraParameters::QCameraReprocScaleParam::getTotalSizeTbl()
{
if(!mScaleEnabled)
return NULL;
return mTotalSizeTbl;
}
/*===========================================================================
* FUNCTION : setEztune
*
* DESCRIPTION: Enable/Disable EZtune
*
*==========================================================================*/
int32_t QCameraParameters::setEztune()
{
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.eztune.enable", prop, "0");
m_bEztuneEnabled = atoi(prop);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : isHDREnabled
*
* DESCRIPTION: if HDR is enabled
*
* PARAMETERS : none
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCameraParameters::isHDREnabled()
{
return ((m_bHDREnabled || m_HDRSceneEnabled));
}
/*===========================================================================
* FUNCTION : isAVTimerEnabled
*
* DESCRIPTION: if AVTimer is enabled
*
* PARAMETERS : none
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCameraParameters::isAVTimerEnabled()
{
return m_bAVTimerEnabled;
}
/*===========================================================================
* FUNCTION : isDISEnabled
*
* DESCRIPTION: if DIS is enabled
*
* PARAMETERS : none
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCameraParameters::isDISEnabled()
{
return m_bDISEnabled;
}
/*===========================================================================
* FUNCTION : getISType
*
* DESCRIPTION: returns IS type
*
* PARAMETERS : none
*
* RETURN : IS type
*
*==========================================================================*/
cam_is_type_t QCameraParameters::getISType()
{
return mIsType;
}
/*===========================================================================
* FUNCTION : MobicatMask
*
* DESCRIPTION: returns mobicat mask
*
* PARAMETERS : none
*
* RETURN : mobicat mask
*
*==========================================================================*/
uint8_t QCameraParameters::getMobicatMask()
{
return m_MobiMask;
}
/*===========================================================================
* FUNCTION : sendStreamConfigInfo
*
* DESCRIPTION: send Stream config info.
*
* PARAMETERS :
* @stream_config_info: Stream config information
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
bool QCameraParameters::sendStreamConfigInfo(cam_stream_size_info_t &stream_config_info) {
int32_t rc = NO_ERROR;
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_META_STREAM_INFO, stream_config_info)) {
LOGE("Failed to update table");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to set stream info parm");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : setStreamConfigure
*
* DESCRIPTION: set stream type, stream dimension for all configured streams.
*
* PARAMETERS :
* @isCapture: Whether this configureation is for an image capture
* @previewAsPostview: Use preview as postview
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
bool QCameraParameters::setStreamConfigure(bool isCapture,
bool previewAsPostview, bool resetConfig) {
int32_t rc = NO_ERROR;
cam_stream_size_info_t stream_config_info;
char value[PROPERTY_VALUE_MAX];
bool raw_yuv = false;
bool raw_capture = false;
if ( m_pParamBuf == NULL ) {
return NO_INIT;
}
memset(&stream_config_info, 0, sizeof(stream_config_info));
stream_config_info.num_streams = 0;
if (resetConfig) {
LOGH("Reset stream config!!");
rc = sendStreamConfigInfo(stream_config_info);
LOGH("Done Resetting stream config!!");
return rc;
}
stream_config_info.hfr_mode = static_cast<cam_hfr_mode_t>(mHfrMode);
stream_config_info.buf_alignment = m_pCapability->buf_alignment;
stream_config_info.min_stride = m_pCapability->min_stride;
stream_config_info.min_scanline = m_pCapability->min_scanline;
stream_config_info.batch_size = getBufBatchCount();
property_get("persist.camera.raw_yuv", value, "0");
raw_yuv = atoi(value) > 0 ? true : false;
if (isZSLMode() && getRecordingHintValue() != true) {
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_PREVIEW;
getStreamDimension(CAM_STREAM_TYPE_PREVIEW,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_PREVIEW);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_PREVIEW];
getStreamFormat(CAM_STREAM_TYPE_PREVIEW,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_ANALYSIS;
getStreamDimension(CAM_STREAM_TYPE_ANALYSIS,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_ANALYSIS);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_ANALYSIS];
getStreamFormat(CAM_STREAM_TYPE_ANALYSIS,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_SNAPSHOT;
getStreamDimension(CAM_STREAM_TYPE_SNAPSHOT,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_SNAPSHOT);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_SNAPSHOT];
getStreamFormat(CAM_STREAM_TYPE_SNAPSHOT,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
if (isUBWCEnabled() && getRecordingHintValue() != true) {
cam_format_t fmt;
getStreamFormat(CAM_STREAM_TYPE_PREVIEW,fmt);
if (fmt == CAM_FORMAT_YUV_420_NV12_UBWC) {
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_CALLBACK;
getStreamDimension(CAM_STREAM_TYPE_CALLBACK,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_CALLBACK);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_CALLBACK];
getStreamFormat(CAM_STREAM_TYPE_CALLBACK,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
}
}
} else if (!isCapture) {
if (m_bRecordingHint) {
if (m_bDISEnabled) {
char value[PROPERTY_VALUE_MAX];
// Make default value for IS_TYPE as IS_TYPE_EIS_2_0
property_get("persist.camera.is_type", value, "4");
mIsType = static_cast<cam_is_type_t>(atoi(value));
} else {
mIsType = IS_TYPE_NONE;
}
stream_config_info.is_type = mIsType;
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_SNAPSHOT;
getStreamDimension(CAM_STREAM_TYPE_SNAPSHOT,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_SNAPSHOT);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_SNAPSHOT];
getStreamFormat(CAM_STREAM_TYPE_SNAPSHOT,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_VIDEO;
getStreamDimension(CAM_STREAM_TYPE_VIDEO,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_VIDEO);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_VIDEO];
getStreamFormat(CAM_STREAM_TYPE_VIDEO,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
}
/* Analysis stream is needed by DCRF regardless of recording hint */
if ((getDcrf() == true) ||
(getRecordingHintValue() != true) ||
(fdModeInVideo())) {
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_ANALYSIS;
getStreamDimension(CAM_STREAM_TYPE_ANALYSIS,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_ANALYSIS);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_ANALYSIS];
getStreamFormat(CAM_STREAM_TYPE_ANALYSIS,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
}
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_PREVIEW;
getStreamDimension(CAM_STREAM_TYPE_PREVIEW,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_PREVIEW);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_PREVIEW];
getStreamFormat(CAM_STREAM_TYPE_PREVIEW,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
if (isUBWCEnabled() && getRecordingHintValue() != true) {
cam_format_t fmt;
getStreamFormat(CAM_STREAM_TYPE_PREVIEW,fmt);
if (fmt == CAM_FORMAT_YUV_420_NV12_UBWC) {
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_CALLBACK;
getStreamDimension(CAM_STREAM_TYPE_CALLBACK,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_CALLBACK);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_CALLBACK];
getStreamFormat(CAM_STREAM_TYPE_CALLBACK,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
}
}
} else {
if (isJpegPictureFormat() || isNV16PictureFormat() || isNV21PictureFormat()) {
if (!getofflineRAW()) {
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_SNAPSHOT;
getStreamDimension(CAM_STREAM_TYPE_SNAPSHOT,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_SNAPSHOT);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_SNAPSHOT];
getStreamFormat(CAM_STREAM_TYPE_SNAPSHOT,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
}
if (previewAsPostview) {
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_PREVIEW;
getStreamDimension(CAM_STREAM_TYPE_PREVIEW,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_PREVIEW);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_PREVIEW];
getStreamFormat(CAM_STREAM_TYPE_PREVIEW,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
} else {
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_POSTVIEW;
getStreamDimension(CAM_STREAM_TYPE_POSTVIEW,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_POSTVIEW);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_POSTVIEW];
getStreamFormat(CAM_STREAM_TYPE_POSTVIEW,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
}
} else {
raw_capture = true;
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_RAW;
getStreamDimension(CAM_STREAM_TYPE_RAW,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_RAW);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_RAW];
getStreamFormat(CAM_STREAM_TYPE_RAW,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
}
}
if ((!raw_capture) && ((getofflineRAW() && !getRecordingHintValue())
|| (raw_yuv))) {
cam_dimension_t max_dim = {0,0};
// Find the Maximum dimension admong all the streams
for (uint32_t j = 0; j < stream_config_info.num_streams; j++) {
if (stream_config_info.stream_sizes[j].width > max_dim.width) {
max_dim.width = stream_config_info.stream_sizes[j].width;
}
if (stream_config_info.stream_sizes[j].height > max_dim.height) {
max_dim.height = stream_config_info.stream_sizes[j].height;
}
}
LOGH("Max Dimension = %d X %d", max_dim.width, max_dim.height);
updateRAW(max_dim);
stream_config_info.type[stream_config_info.num_streams] =
CAM_STREAM_TYPE_RAW;
getStreamDimension(CAM_STREAM_TYPE_RAW,
stream_config_info.stream_sizes[stream_config_info.num_streams]);
updatePpFeatureMask(CAM_STREAM_TYPE_RAW);
stream_config_info.postprocess_mask[stream_config_info.num_streams] =
mStreamPpMask[CAM_STREAM_TYPE_RAW];
getStreamFormat(CAM_STREAM_TYPE_RAW,
stream_config_info.format[stream_config_info.num_streams]);
stream_config_info.num_streams++;
}
for (uint32_t k = 0; k < stream_config_info.num_streams; k++) {
LOGI("STREAM INFO : type %d, wxh: %d x %d, pp_mask: 0x%llx Format = %d",
stream_config_info.type[k],
stream_config_info.stream_sizes[k].width,
stream_config_info.stream_sizes[k].height,
stream_config_info.postprocess_mask[k],
stream_config_info.format[k]);
}
rc = sendStreamConfigInfo(stream_config_info);
return rc;
}
/*===========================================================================
* FUNCTION : addOnlineRotation
*
* DESCRIPTION: send additional rotation information for specific stream
*
* PARAMETERS :
* @rotation: rotation
* @streamId: internal stream id
* @device_rotation: device rotation
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::addOnlineRotation(uint32_t rotation, uint32_t streamId,
int32_t device_rotation)
{
int32_t rc = NO_ERROR;
cam_rotation_info_t rotation_info;
memset(&rotation_info, 0, sizeof(cam_rotation_info_t));
/* Add jpeg rotation information */
if (rotation == 0) {
rotation_info.rotation = ROTATE_0;
} else if (rotation == 90) {
rotation_info.rotation = ROTATE_90;
} else if (rotation == 180) {
rotation_info.rotation = ROTATE_180;
} else if (rotation == 270) {
rotation_info.rotation = ROTATE_270;
} else {
rotation_info.rotation = ROTATE_0;
}
rotation_info.streamId = streamId;
/* Add device rotation information */
if (device_rotation == 0) {
rotation_info.device_rotation = ROTATE_0;
} else if (device_rotation == 90) {
rotation_info.device_rotation = ROTATE_90;
} else if (device_rotation == 180) {
rotation_info.device_rotation = ROTATE_180;
} else if (device_rotation == 270) {
rotation_info.device_rotation = ROTATE_270;
} else {
rotation_info.device_rotation = ROTATE_0;
}
if(initBatchUpdate(m_pParamBuf) < 0 ) {
LOGE("Failed to initialize group update table");
return BAD_TYPE;
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_ROTATION, rotation_info)) {
LOGE("Failed to update table");
return BAD_VALUE;
}
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to set stream info parm");
return rc;
}
return rc;
}
/*===========================================================================
* FUNCTION : needThumbnailReprocess
*
* DESCRIPTION: Check if thumbnail reprocessing is needed
*
* PARAMETERS : @pFeatureMask - feature mask
*
* RETURN : true: needed
* false: no need
*==========================================================================*/
bool QCameraParameters::needThumbnailReprocess(cam_feature_mask_t *pFeatureMask)
{
if (isUbiFocusEnabled() || isChromaFlashEnabled() ||
isOptiZoomEnabled() || isUbiRefocus() ||
isStillMoreEnabled() ||
(isHDREnabled() && !isHDRThumbnailProcessNeeded())
|| isUBWCEnabled()) {
*pFeatureMask &= ~CAM_QCOM_FEATURE_CHROMA_FLASH;
*pFeatureMask &= ~CAM_QCOM_FEATURE_UBIFOCUS;
*pFeatureMask &= ~CAM_QCOM_FEATURE_REFOCUS;
*pFeatureMask &= ~CAM_QCOM_FEATURE_OPTIZOOM;
*pFeatureMask &= ~CAM_QCOM_FEATURE_STILLMORE;
*pFeatureMask &= ~CAM_QCOM_FEATURE_HDR;
return false;
} else {
cam_dimension_t thumb_dim;
getThumbnailSize(&(thumb_dim.width), &(thumb_dim.height));
if (thumb_dim.width == 0 || thumb_dim.height == 0) {
return false;
}
else {
return true;
}
}
}
/*===========================================================================
* FUNCTION : getNumOfExtraBuffersForImageProc
*
* DESCRIPTION: get number of extra input buffers needed by image processing
*
* PARAMETERS : none
*
* RETURN : number of extra buffers needed by ImageProc;
* 0 if not ImageProc enabled
*==========================================================================*/
uint8_t QCameraParameters::getNumOfExtraBuffersForImageProc()
{
int numOfBufs = 0;
if (isUbiRefocus()) {
return (uint8_t)(m_pCapability->refocus_af_bracketing_need.burst_count - 1);
} else if (isUbiFocusEnabled()) {
numOfBufs += m_pCapability->ubifocus_af_bracketing_need.burst_count - 1;
} else if (m_bOptiZoomOn) {
numOfBufs += m_pCapability->opti_zoom_settings_need.burst_count - 1;
} else if (isChromaFlashEnabled()) {
numOfBufs += m_pCapability->chroma_flash_settings_need.burst_count - 1;
} else if (isStillMoreEnabled()) {
if (isSeeMoreEnabled()) {
m_stillmore_config.burst_count = 1;
} else if ((m_stillmore_config.burst_count >=
m_pCapability->stillmore_settings_need.min_burst_count) &&
(m_stillmore_config.burst_count <=
m_pCapability->stillmore_settings_need.max_burst_count)) {
numOfBufs += m_stillmore_config.burst_count - 1;
} else {
numOfBufs += m_pCapability->stillmore_settings_need.burst_count - 1;
}
} else if (isOEMFeatEnabled()) {
numOfBufs += 1;
}
return (uint8_t)(numOfBufs);
}
/*===========================================================================
* FUNCTION : getExifBufIndex
*
* DESCRIPTION: get index of metadata to be used for EXIF
*
* PARAMETERS : @captureIndex - index of current captured frame
*
* RETURN : index of metadata to be used for EXIF
*==========================================================================*/
uint32_t QCameraParameters::getExifBufIndex(uint32_t captureIndex)
{
uint32_t index = captureIndex;
if (isUbiRefocus()) {
if (captureIndex < m_pCapability->refocus_af_bracketing_need.burst_count) {
index = captureIndex;
} else {
index = 0;
}
} else if (isChromaFlashEnabled()) {
index = m_pCapability->chroma_flash_settings_need.metadata_index;
} else if (isHDREnabled()) {
if (isHDR1xFrameEnabled() && isHDR1xExtraBufferNeeded()) {
index = m_pCapability->hdr_bracketing_setting.num_frames;
} else {
for (index = 0; index < m_pCapability->hdr_bracketing_setting.num_frames; index++) {
if (0 == m_pCapability->hdr_bracketing_setting.exp_val.values[index]) {
break;
}
}
if (index == m_pCapability->hdr_bracketing_setting.num_frames) {
index = captureIndex;
}
}
}
return index;
}
/*===========================================================================
* FUNCTION : getNumberInBufsForSingleShot
*
* DESCRIPTION: get number of input buffers for single shot
*
* PARAMETERS : none
*
* RETURN : number of input buffers for single shot
*==========================================================================*/
uint32_t QCameraParameters::getNumberInBufsForSingleShot()
{
uint32_t numOfBufs = 1;
if (isUbiRefocus()) {
numOfBufs = m_pCapability->refocus_af_bracketing_need.burst_count;
} else if (isUbiFocusEnabled()) {
numOfBufs = m_pCapability->ubifocus_af_bracketing_need.burst_count;
} else if (m_bOptiZoomOn) {
numOfBufs = m_pCapability->opti_zoom_settings_need.burst_count;
} else if (isChromaFlashEnabled()) {
numOfBufs = m_pCapability->chroma_flash_settings_need.burst_count;
} else if (isHDREnabled()) {
numOfBufs = m_pCapability->hdr_bracketing_setting.num_frames;
if (isHDR1xFrameEnabled() && isHDR1xExtraBufferNeeded()) {
numOfBufs++;
}
} else if (isStillMoreEnabled()) {
if (isSeeMoreEnabled()) {
m_stillmore_config.burst_count = 1;
numOfBufs = m_stillmore_config.burst_count;
} else if ((m_stillmore_config.burst_count >=
m_pCapability->stillmore_settings_need.min_burst_count) &&
(m_stillmore_config.burst_count <=
m_pCapability->stillmore_settings_need.max_burst_count)) {
numOfBufs = m_stillmore_config.burst_count;
} else {
numOfBufs = m_pCapability->stillmore_settings_need.burst_count;
}
}
return numOfBufs;
}
/*===========================================================================
* FUNCTION : getNumberOutBufsForSingleShot
*
* DESCRIPTION: get number of output buffers for single shot
*
* PARAMETERS : none
*
* RETURN : number of output buffers for single shot
*==========================================================================*/
uint32_t QCameraParameters::getNumberOutBufsForSingleShot()
{
uint32_t numOfBufs = 1;
if (isUbiRefocus()) {
numOfBufs = m_pCapability->refocus_af_bracketing_need.output_count;
} else if (isHDREnabled()) {
if (isHDR1xFrameEnabled()) {
numOfBufs++;
}
}
return numOfBufs;
}
/*===========================================================================
* FUNCTION : is4k2kVideoResolution
*
* DESCRIPTION: if resolution is 4k x 2k or true 4k x 2k
*
* PARAMETERS : none
*
* RETURN : true: video resolution is 4k x 2k
* false: video resolution is not 4k x 2k
*==========================================================================*/
bool QCameraParameters::is4k2kVideoResolution()
{
bool enabled = false;
cam_dimension_t resolution;
getVideoSize(&resolution.width, &resolution.height);
if (!(resolution.width < 3840 && resolution.height < 2160)) {
enabled = true;
}
return enabled;
}
/*===========================================================================
* FUNCTION : isPreviewSeeMoreRequired
*
* DESCRIPTION: This function checks whether SeeMmore(SW TNR) needs to be applied for
* preview stream depending on video resoluion and setprop
*
* PARAMETERS : none
*
* RETURN : true: If SeeMore needs to apply
* false: No need to apply
*==========================================================================*/
bool QCameraParameters::isPreviewSeeMoreRequired()
{
cam_dimension_t dim;
char prop[PROPERTY_VALUE_MAX];
getVideoSize(&dim.width, &dim.height);
memset(prop, 0, sizeof(prop));
property_get("persist.camera.preview.seemore", prop, "0");
int enable = atoi(prop);
// Enable SeeMore for preview stream if :
// 1. Video resolution <= (1920x1080) (or)
// 2. persist.camera.preview.seemore is set
LOGD("width=%d, height=%d, enable=%d", dim.width, dim.height, enable);
return (((dim.width * dim.height) <= (1920 * 1080)) || enable);
}
/*===========================================================================
* FUNCTION : updateDebugLevel
*
* DESCRIPTION: send CAM_INTF_PARM_UPDATE_DEBUG_LEVEL to backend
*
* PARAMETERS : none
*
* RETURN : NO_ERROR --success
* int32_t type of status
*==========================================================================*/
int32_t QCameraParameters::updateDebugLevel()
{
if ( m_pParamBuf == NULL ) {
return NO_INIT;
}
int32_t rc = initBatchUpdate(m_pParamBuf);
if ( rc != NO_ERROR ) {
LOGE("Failed to initialize group update table");
return rc;
}
uint32_t dummyDebugLevel = 0;
/* The value of dummyDebugLevel is irrelavent. On
* CAM_INTF_PARM_UPDATE_DEBUG_LEVEL, read debug property */
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_UPDATE_DEBUG_LEVEL, dummyDebugLevel)) {
LOGE("Parameters batch failed");
return BAD_VALUE;
}
rc = commitSetBatch();
if ( rc != NO_ERROR ) {
LOGE("Failed to commit batch parameters");
return rc;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setOfflineRAW
*
* DESCRIPTION: Function to decide Offline RAW feature.
*
* PARAMETERS :
* @raw_value: offline raw value to set.
*
* RETURN : none
*==========================================================================*/
void QCameraParameters::setOfflineRAW(bool raw_value)
{
char value[PROPERTY_VALUE_MAX];
bool raw_yuv = false;
bool offlineRaw = false;
if (raw_value) {
mOfflineRAW = true;
LOGH("Offline Raw %d", mOfflineRAW);
return;
}
property_get("persist.camera.raw_yuv", value, "0");
raw_yuv = atoi(value) > 0 ? true : false;
property_get("persist.camera.offlineraw", value, "0");
offlineRaw = atoi(value) > 0 ? true : false;
if ((raw_yuv || isRdiMode()) && offlineRaw) {
mOfflineRAW = true;
} else {
mOfflineRAW = false;
}
LOGH("Offline Raw %d", mOfflineRAW);
}
/*===========================================================================
* FUNCTION : updatePpFeatureMask
*
* DESCRIPTION: Updates the feature mask for a particular stream depending
* on current client configuration.
*
* PARAMETERS :
* @stream_type: Camera stream type
*
* RETURN : NO_ERROR --success
* int32_t type of status
*==========================================================================*/
int32_t QCameraParameters::updatePpFeatureMask(cam_stream_type_t stream_type) {
cam_feature_mask_t feature_mask = 0;
if (stream_type >= CAM_STREAM_TYPE_MAX) {
LOGE("Error!! stream type: %d not valid", stream_type);
return -1;
}
// Update feature mask for SeeMore in video and video preview
if (isSeeMoreEnabled() && ((stream_type == CAM_STREAM_TYPE_VIDEO) ||
(stream_type == CAM_STREAM_TYPE_PREVIEW && getRecordingHintValue() &&
isPreviewSeeMoreRequired()))) {
feature_mask |= CAM_QCOM_FEATURE_LLVD;
}
if (isHighQualityNoiseReductionMode() &&
((stream_type == CAM_STREAM_TYPE_VIDEO) ||
(stream_type == CAM_STREAM_TYPE_PREVIEW && getRecordingHintValue() &&
isPreviewSeeMoreRequired()))) {
feature_mask |= CAM_QTI_FEATURE_SW_TNR;
}
// Do not enable feature mask for ZSL/non-ZSL/liveshot snapshot except for 4K2k case
if ((getRecordingHintValue() &&
(stream_type == CAM_STREAM_TYPE_SNAPSHOT) && is4k2kVideoResolution()) ||
(stream_type != CAM_STREAM_TYPE_SNAPSHOT)) {
if ((m_nMinRequiredPpMask & CAM_QCOM_FEATURE_SHARPNESS) &&
!isOptiZoomEnabled()) {
feature_mask |= CAM_QCOM_FEATURE_SHARPNESS;
}
if (m_nMinRequiredPpMask & CAM_QCOM_FEATURE_EFFECT) {
feature_mask |= CAM_QCOM_FEATURE_EFFECT;
}
if (isWNREnabled()) {
feature_mask |= CAM_QCOM_FEATURE_DENOISE2D;
}
//Set flip mode based on Stream type;
int flipMode = getFlipMode(stream_type);
if (flipMode > 0) {
feature_mask |= CAM_QCOM_FEATURE_FLIP;
}
}
if ((isTNRVideoEnabled() && (CAM_STREAM_TYPE_VIDEO == stream_type))
|| (isTNRPreviewEnabled() && (CAM_STREAM_TYPE_PREVIEW == stream_type))) {
feature_mask |= CAM_QCOM_FEATURE_CPP_TNR;
}
if (isEztuneEnabled() &&
((CAM_STREAM_TYPE_PREVIEW == stream_type) ||
(CAM_STREAM_TYPE_SNAPSHOT == stream_type))) {
feature_mask |= CAM_QCOM_FEATURE_EZTUNE;
}
if ((getCDSMode() != CAM_CDS_MODE_OFF) &&
((CAM_STREAM_TYPE_PREVIEW == stream_type) ||
(CAM_STREAM_TYPE_VIDEO == stream_type) ||
(CAM_STREAM_TYPE_CALLBACK == stream_type) ||
((CAM_STREAM_TYPE_SNAPSHOT == stream_type) &&
getRecordingHintValue() && is4k2kVideoResolution()))) {
if (m_nMinRequiredPpMask & CAM_QCOM_FEATURE_DSDN) {
feature_mask |= CAM_QCOM_FEATURE_DSDN;
} else {
feature_mask |= CAM_QCOM_FEATURE_CDS;
}
}
if (isTNRSnapshotEnabled() && (CAM_STREAM_TYPE_SNAPSHOT == stream_type)
&& (isZSLMode() || getRecordingHintValue())) {
feature_mask |= CAM_QCOM_FEATURE_CPP_TNR;
}
//Rotation could also have an effect on pp feature mask
cam_pp_feature_config_t config;
cam_dimension_t dim;
memset(&config, 0, sizeof(cam_pp_feature_config_t));
getStreamRotation(stream_type, config, dim);
feature_mask |= config.feature_mask;
// Dual Camera scenarios
// all feature masks are disabled for preview and analysis streams for aux session
// all required feature masks for aux session preview and analysis streams need
// to be enabled explicitly here
///@note When aux camera is of bayer type, keep pp mask as is or we'd run
/// into stream mapping problems. YUV sensor is marked as interleaved and has
/// preferred mapping setup so we don't see any mapping issues.
if (m_relCamSyncInfo.sync_control == CAM_SYNC_RELATED_SENSORS_ON) {
if (((CAM_STREAM_TYPE_ANALYSIS == stream_type) ||
(CAM_STREAM_TYPE_PREVIEW == stream_type)) &&
(m_relCamSyncInfo.mode == CAM_MODE_SECONDARY) &&
(m_pCapability->sensor_type.sens_type == CAM_SENSOR_YUV)) {
LOGH("Disabling all pp feature masks for aux preview and "
"analysis streams");
feature_mask = 0;
}
// all feature masks need to be enabled here
// enable DCRF feature mask on analysis stream in case of dual camera
if (m_bDcrfEnabled && (CAM_STREAM_TYPE_ANALYSIS == stream_type)) {
feature_mask |= CAM_QCOM_FEATURE_DCRF;
} else {
feature_mask &= ~CAM_QCOM_FEATURE_DCRF;
}
}
// Preview assisted autofocus needs to be supported for
// callback, preview, or video streams
switch (stream_type) {
case CAM_STREAM_TYPE_CALLBACK:
case CAM_STREAM_TYPE_PREVIEW:
case CAM_STREAM_TYPE_VIDEO:
feature_mask |= CAM_QCOM_FEATURE_PAAF;
break;
default:
break;
}
// Store stream feature mask
setStreamPpMask(stream_type, feature_mask);
LOGH("stream type: %d, pp_mask: 0x%llx", stream_type, feature_mask);
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setStreamPpMask
*
* DESCRIPTION: Stores a particular feature mask for a given camera stream
*
* PARAMETERS :
* @stream_type: Camera stream type
* @pp_mask : Feature mask
*
* RETURN : NO_ERROR --success
* int32_t type of status
*==========================================================================*/
int32_t QCameraParameters::setStreamPpMask(cam_stream_type_t stream_type,
cam_feature_mask_t pp_mask) {
if(stream_type >= CAM_STREAM_TYPE_MAX) {
return BAD_TYPE;
}
mStreamPpMask[stream_type] = pp_mask;
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getStreamPpMask
*
* DESCRIPTION: Retrieves the feature mask for a given camera stream
*
* PARAMETERS :
* @stream_type: Camera stream type
* @pp_mask : Feature mask
*
* RETURN : NO_ERROR --success
* int32_t type of status
*==========================================================================*/
int32_t QCameraParameters::getStreamPpMask(cam_stream_type_t stream_type,
cam_feature_mask_t &pp_mask) {
if(stream_type >= CAM_STREAM_TYPE_MAX) {
return BAD_TYPE;
}
pp_mask = mStreamPpMask[stream_type];
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : isMultiPassReprocessing
*
* DESCRIPTION: Read setprop to enable/disable multipass
*
* PARAMETERS : none
*
* RETURN : TRUE -- If enabled
* FALSE -- disabled
*==========================================================================*/
bool QCameraParameters::isMultiPassReprocessing()
{
char value[PROPERTY_VALUE_MAX];
int multpass = 0;
property_get("persist.camera.multi_pass", value, "0");
multpass = atoi(value);
return (multpass == 0)? FALSE : TRUE;
}
/*===========================================================================
* FUNCTION : setReprocCount
*
* DESCRIPTION: Set total reprocessing pass count
*
* PARAMETERS : none
*
* RETURN : None
*==========================================================================*/
void QCameraParameters::setReprocCount()
{
mTotalPPCount = 1; //Default reprocessing Pass count
if (getManualCaptureMode() >=
CAM_MANUAL_CAPTURE_TYPE_3) {
LOGD("Additional post processing enabled for manual capture");
mTotalPPCount++;
}
if (!isMultiPassReprocessing()) {
return;
}
if ((getZoomLevel() != 0)
&& (getBurstCountForAdvancedCapture()
== getNumOfSnapshots())) {
LOGD("2 Pass postprocessing enabled");
mTotalPPCount++;
}
}
/*===========================================================================
* FUNCTION : isUBWCEnabled
*
* DESCRIPTION: Function to get UBWC hardware support.
*
* PARAMETERS : None
*
* RETURN : TRUE -- UBWC format supported
* FALSE -- UBWC is not supported.
*==========================================================================*/
bool QCameraParameters::isUBWCEnabled()
{
#ifdef UBWC_PRESENT
char value[PROPERTY_VALUE_MAX];
int prop_value = 0;
memset(value, 0, sizeof(value));
property_get("debug.gralloc.gfx_ubwc_disable", value, "0");
prop_value = atoi(value);
if (prop_value) {
return FALSE;
}
//Disable UBWC if it is YUV sensor.
if ((m_pCapability != NULL) &&
(m_pCapability->sensor_type.sens_type == CAM_SENSOR_YUV)) {
return FALSE;
}
//Disable UBWC if Eztune is enabled
// Eztune works on CPP output and cannot understand UBWC buffer.
memset(value, 0, sizeof(value));
property_get("persist.camera.eztune.enable", value, "0");
prop_value = atoi(value);
if (prop_value) {
return FALSE;
}
return TRUE;
#else
return FALSE;
#endif
}
/*===========================================================================
* FUNCTION : isPostProcScaling
*
* DESCRIPTION: is scaling to be done by CPP?
*
* PARAMETERS : none
*
* RETURN : TRUE : If CPP scaling enabled
* FALSE : If VFE scaling enabled
*==========================================================================*/
bool QCameraParameters::isPostProcScaling()
{
char value[PROPERTY_VALUE_MAX];
bool cpp_scaling = FALSE;
if (getRecordingHintValue()) {
return FALSE;
}
property_get("persist.camera.pp_scaling", value, "0");
cpp_scaling = atoi(value) > 0 ? TRUE : FALSE;
LOGH("Post proc scaling enabled : %d",
cpp_scaling);
return cpp_scaling;
}
/*===========================================================================
* FUNCTION : isLLNoiseEnabled
*
* DESCRIPTION: Low light noise change
*
* PARAMETERS : none
*
* RETURN : TRUE : If low light noise enabled
* FALSE : If low light noise disabled
*==========================================================================*/
bool QCameraParameters::isLLNoiseEnabled()
{
char value[PROPERTY_VALUE_MAX];
bool llnoise = FALSE;
if (!isWNREnabled()) {
return FALSE;
}
property_get("persist.camera.llnoise", value, "0");
llnoise = atoi(value) > 0 ? TRUE : FALSE;
LOGH("Low light noise enabled : %d",
llnoise);
return llnoise;
}
/*===========================================================================
* FUNCTION : setBufBatchCount
*
* DESCRIPTION: Function to configure batch buffer
*
* PARAMETERS : int8_t buf_cnt
* Buffer batch count
*
* RETURN : None
*==========================================================================*/
void QCameraParameters::setBufBatchCount(int8_t buf_cnt)
{
mBufBatchCnt = 0;
char value[PROPERTY_VALUE_MAX];
int8_t count = 0;
property_get("persist.camera.batchcount", value, "0");
count = atoi(value);
if (!(count != 0 || buf_cnt > CAMERA_MIN_BATCH_COUNT)) {
LOGH("Buffer batch count = %d", mBufBatchCnt);
set(KEY_QC_VIDEO_BATCH_SIZE, mBufBatchCnt);
return;
}
while((m_pCapability->max_batch_bufs_supported != 0)
&& (m_pCapability->max_batch_bufs_supported < buf_cnt)) {
buf_cnt = buf_cnt / 2;
}
if (count > 0) {
mBufBatchCnt = count;
LOGH("Buffer batch count = %d", mBufBatchCnt);
set(KEY_QC_VIDEO_BATCH_SIZE, mBufBatchCnt);
return;
}
if (buf_cnt > CAMERA_MIN_BATCH_COUNT) {
mBufBatchCnt = buf_cnt;
LOGH("Buffer batch count = %d", mBufBatchCnt);
set(KEY_QC_VIDEO_BATCH_SIZE, mBufBatchCnt);
return;
}
}
/*===========================================================================
* FUNCTION : setVideoBatch()
*
* DESCRIPTION: Function to batching for video.
*
* PARAMETERS : none
*
* RETURN : None
*==========================================================================*/
void QCameraParameters::setVideoBatchSize()
{
char value[PROPERTY_VALUE_MAX];
int8_t minBatchcnt = 2; //Batching enabled only if batch size if greater than 2;
int32_t width = 0, height = 0;
mVideoBatchSize = 0;
if (getBufBatchCount()) {
//We don't need HAL to HAL batching if camera batching enabled.
return;
}
getVideoSize(&width, &height);
if ((width > 1920) || (height > 1080)) {
//Cannot enable batch mode for video size bigger than 1080p
return;
}
//Batch size "6" is the recommended and gives optimal power saving.
property_get("persist.camera.video.batchsize", value, "0");
mVideoBatchSize = atoi(value);
if (mVideoBatchSize > CAMERA_MAX_CONSUMER_BATCH_BUFFER_SIZE) {
mVideoBatchSize = CAMERA_MAX_CONSUMER_BATCH_BUFFER_SIZE;
} else if (mVideoBatchSize <= minBatchcnt) {
//Batching enabled only if batch size is greater than 2.
mVideoBatchSize = 0;
}
LOGD("mVideoBatchSize = %d", mVideoBatchSize);
set(KEY_QC_VIDEO_BATCH_SIZE, mVideoBatchSize);
}
/*===========================================================================
* FUNCTION : setCustomParams
*
* DESCRIPTION: Function to update OEM specific custom parameter
*
* PARAMETERS : params: Input Parameter object
*
* RETURN : error value
*==========================================================================*/
int32_t QCameraParameters::setCustomParams(__unused const QCameraParameters& params)
{
int32_t rc = NO_ERROR;
/* Application specific parameter can be read from "params" and update m_pParamBuf
We can also update internal OEM custom parameters in this funcion.
"CAM_CUSTOM_PARM_EXAMPLE" is used as a example */
/*Get the pointer of shared buffer for custom parameter*/
custom_parm_buffer_t *customParam =
(custom_parm_buffer_t *)POINTER_OF_META(CAM_INTF_PARM_CUSTOM, m_pParamBuf);
/*start updating custom parameter values*/
if (ADD_SET_PARAM_ENTRY_TO_BATCH(customParam, CAM_CUSTOM_PARM_EXAMPLE, 1)) {
LOGE("Failed to update CAM_CUSTOM_PARM_DUMMY");
return BAD_VALUE;
}
/*set custom parameter values to main parameter buffer. Update isvalid flag*/
ADD_GET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_CUSTOM);
return rc;
}
/*===========================================================================
* FUNCTION : dump
*
* DESCRIPTION: Composes a string based on current configuration
*
* PARAMETERS : none
*
* RETURN : Formatted string
*==========================================================================*/
String8 QCameraParameters::dump()
{
String8 str("\n");
char s[128];
snprintf(s, 128, "Preview Pixel Fmt: %d\n", getPreviewHalPixelFormat());
str += s;
snprintf(s, 128, "ZSL Burst Interval: %d\n", getZSLBurstInterval());
str += s;
snprintf(s, 128, "ZSL Queue Depth: %d\n", getZSLQueueDepth());
str += s;
snprintf(s, 128, "ZSL Back Look Count %d\n", getZSLBackLookCount());
str += s;
snprintf(s, 128, "Max Unmatched Frames In Queue: %d\n",
getMaxUnmatchedFramesInQueue());
str += s;
snprintf(s, 128, "Is ZSL Mode: %d\n", isZSLMode());
str += s;
snprintf(s, 128, "Is No Display Mode: %d\n", isNoDisplayMode());
str += s;
snprintf(s, 128, "Is WNR Enabled: %d\n", isWNREnabled());
str += s;
snprintf(s, 128, "isHfrMode: %d\n", isHfrMode());
str += s;
snprintf(s, 128, "getNumOfSnapshots: %d\n", getNumOfSnapshots());
str += s;
snprintf(s, 128, "getNumOfExtraHDRInBufsIfNeeded: %d\n",
getNumOfExtraHDRInBufsIfNeeded());
str += s;
snprintf(s, 128, "getNumOfExtraHDROutBufsIfNeeded: %d\n",
getNumOfExtraHDROutBufsIfNeeded());
str += s;
snprintf(s, 128, "getRecordingHintValue: %d\n", getRecordingHintValue());
str += s;
snprintf(s, 128, "getJpegQuality: %u\n", getJpegQuality());
str += s;
snprintf(s, 128, "getJpegRotation: %u\n", getJpegRotation());
str += s;
snprintf(s, 128, "isHistogramEnabled: %d\n", isHistogramEnabled());
str += s;
snprintf(s, 128, "isFaceDetectionEnabled: %d\n", isFaceDetectionEnabled());
str += s;
snprintf(s, 128, "isHDREnabled: %d\n", isHDREnabled());
str += s;
snprintf(s, 128, "isAutoHDREnabled: %d\n", isAutoHDREnabled());
str += s;
snprintf(s, 128, "isAVTimerEnabled: %d\n", isAVTimerEnabled());
str += s;
snprintf(s, 128, "getFocusMode: %d\n", getFocusMode());
str += s;
snprintf(s, 128, "isJpegPictureFormat: %d\n", isJpegPictureFormat());
str += s;
snprintf(s, 128, "isNV16PictureFormat: %d\n", isNV16PictureFormat());
str += s;
snprintf(s, 128, "isNV21PictureFormat: %d\n", isNV21PictureFormat());
str += s;
snprintf(s, 128, "isSnapshotFDNeeded: %d\n", isSnapshotFDNeeded());
str += s;
snprintf(s, 128, "isHDR1xFrameEnabled: %d\n", isHDR1xFrameEnabled());
str += s;
snprintf(s, 128, "isYUVFrameInfoNeeded: %d\n", isYUVFrameInfoNeeded());
str += s;
snprintf(s, 128, "isHDR1xExtraBufferNeeded: %d\n",
isHDR1xExtraBufferNeeded());
str += s;
snprintf(s, 128, "isHDROutputCropEnabled: %d\n", isHDROutputCropEnabled());
str += s;
snprintf(s, 128, "isPreviewFlipChanged: %d\n", isPreviewFlipChanged());
str += s;
snprintf(s, 128, "isVideoFlipChanged: %d\n", isVideoFlipChanged());
str += s;
snprintf(s, 128, "isSnapshotFlipChanged: %d\n", isSnapshotFlipChanged());
str += s;
snprintf(s, 128, "isHDRThumbnailProcessNeeded: %d\n",
isHDRThumbnailProcessNeeded());
str += s;
snprintf(s, 128, "getAutoFlickerMode: %d\n", getAutoFlickerMode());
str += s;
snprintf(s, 128, "getNumOfExtraBuffersForImageProc: %d\n",
getNumOfExtraBuffersForImageProc());
str += s;
snprintf(s, 128, "isUbiFocusEnabled: %d\n", isUbiFocusEnabled());
str += s;
snprintf(s, 128, "isChromaFlashEnabled: %d\n", isChromaFlashEnabled());
str += s;
snprintf(s, 128, "isOptiZoomEnabled: %d\n", isOptiZoomEnabled());
str += s;
snprintf(s, 128, "isStillMoreEnabled: %d\n", isStillMoreEnabled());
str += s;
snprintf(s, 128, "getBurstCountForAdvancedCapture: %d\n",
getBurstCountForAdvancedCapture());
str += s;
return str;
}
/*===========================================================================
* FUNCTION : getNumOfExtraBuffersForVideo
*
* DESCRIPTION: get number of extra buffers needed by image processing
*
* PARAMETERS : none
*
* RETURN : number of extra buffers needed by ImageProc;
* 0 if not ImageProc enabled
*==========================================================================*/
uint8_t QCameraParameters::getNumOfExtraBuffersForVideo()
{
uint8_t numOfBufs = 0;
if (isSeeMoreEnabled() || isHighQualityNoiseReductionMode()) {
numOfBufs = 1;
}
return numOfBufs;
}
/*===========================================================================
* FUNCTION : getNumOfExtraBuffersForPreview
*
* DESCRIPTION: get number of extra buffers needed by image processing
*
* PARAMETERS : none
*
* RETURN : number of extra buffers needed by ImageProc;
* 0 if not ImageProc enabled
*==========================================================================*/
uint8_t QCameraParameters::getNumOfExtraBuffersForPreview()
{
uint8_t numOfBufs = 0;
if ((isSeeMoreEnabled() || isHighQualityNoiseReductionMode())
&& !isZSLMode() && getRecordingHintValue()) {
numOfBufs = 1;
}
return numOfBufs;
}
/*===========================================================================
* FUNCTION : setToneMapMode
*
* DESCRIPTION: enable or disable tone map
*
* PARAMETERS :
* @enable : enable: 1; disable 0
* @initCommit: if configuration list needs to be initialized and commited
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setToneMapMode(uint32_t enable, bool initCommit)
{
int32_t rc = NO_ERROR;
LOGH("tone map mode %d ", enable);
if (initCommit) {
if (initBatchUpdate(m_pParamBuf) < 0) {
LOGE("Failed to initialize group update table");
return FAILED_TRANSACTION;
}
}
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_TONE_MAP_MODE, enable)) {
LOGE("Failed to update tone map mode");
return BAD_VALUE;
}
if (initCommit) {
rc = commitSetBatch();
if (rc != NO_ERROR) {
LOGE("Failed to commit tone map mode");
return rc;
}
}
return rc;
}
/*===========================================================================
* FUNCTION : getLongshotStages
*
* DESCRIPTION: get number of stages for longshot
*
* PARAMETERS : none
*
* RETURN : number of stages
*==========================================================================*/
uint8_t QCameraParameters::getLongshotStages()
{
uint8_t numStages =
isLowMemoryDevice() ? CAMERA_MIN_LONGSHOT_STAGES : CAMERA_DEFAULT_LONGSHOT_STAGES;
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.longshot.stages", prop, "0");
uint8_t propStages = atoi(prop);
if (propStages > 0 && propStages <= CAMERA_DEFAULT_LONGSHOT_STAGES) {
numStages = propStages;
}
return numStages;
}
/*===========================================================================
* FUNCTION : setCDSMode
*
* DESCRIPTION: set CDS mode
*
* PARAMETERS :
* @cds_mode : cds mode
* @initCommit: if configuration list needs to be initialized and commited
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setCDSMode(int32_t cds_mode, bool initCommit)
{
if (initCommit) {
if (initBatchUpdate(m_pParamBuf) < 0) {
LOGE("Failed to initialize group update table");
return FAILED_TRANSACTION;
}
}
int32_t rc = NO_ERROR;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_CDS_MODE, cds_mode)) {
LOGE("Failed to update cds mode");
return BAD_VALUE;
}
if (initCommit) {
rc = commitSetBatch();
if (NO_ERROR != rc) {
LOGE("Failed to set cds mode");
return rc;
}
}
LOGH("cds mode -> %d", cds_mode);
return rc;
}
/*===========================================================================
* FUNCTION : setLowLightCapture
*
* DESCRIPTION: Function to enable low light capture
*==========================================================================*/
void QCameraParameters::setLowLightCapture()
{
char prop[PROPERTY_VALUE_MAX];
memset(prop, 0, sizeof(prop));
property_get("persist.camera.llc", prop, "0");
m_LLCaptureEnabled = (atoi(prop) > 0) ? TRUE : FALSE;
if (!m_LLCaptureEnabled) {
m_LowLightLevel = CAM_LOW_LIGHT_OFF;
}
}
/*===========================================================================
* FUNCTION : fdModeInVideo
*
* DESCRIPTION: FD in Video change
*
* PARAMETERS : none
*
* RETURN : FD Mode in Video
* 0 : If FD in Video disabled
* 1 : If FD in Video enabled for Detection, focus
* 2 : If FD in Video enabled only for focus
*==========================================================================*/
uint8_t QCameraParameters::fdModeInVideo()
{
char value[PROPERTY_VALUE_MAX];
uint8_t fdvideo = 0;
cam_analysis_info_t *pAnalysisInfo =
&m_pCapability->analysis_info[CAM_ANALYSIS_INFO_FD_VIDEO];
if (!pAnalysisInfo->hw_analysis_supported) {
return 0;
}
property_get("persist.camera.fdvideo", value, "0");
fdvideo = (atoi(value) > 0) ? atoi(value) : 0;
LOGD("FD mode in Video : %d", fdvideo);
return fdvideo;
}
/*===========================================================================
* FUNCTION : setManualCaptureMode
*
* DESCRIPTION: Function to set Manual capture modes
*
* PARAMETERS :
* @mode : Capture mode configured
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setManualCaptureMode(QCameraManualCaptureModes mode)
{
int32_t rc = NO_ERROR;
char value[PROPERTY_VALUE_MAX];
int8_t count = 0;
property_get("persist.camera.manual.capture", value, "0");
count = atoi(value);
if (count) {
if (mode == CAM_MANUAL_CAPTURE_TYPE_OFF) {
m_ManualCaptureMode = CAM_MANUAL_CAPTURE_TYPE_1;
} else {
m_ManualCaptureMode = mode;
}
} else {
m_ManualCaptureMode = CAM_MANUAL_CAPTURE_TYPE_OFF;
}
if (m_ManualCaptureMode == CAM_MANUAL_CAPTURE_TYPE_2) {
setOfflineRAW(FALSE);
} else if (m_ManualCaptureMode >= CAM_MANUAL_CAPTURE_TYPE_3) {
setOfflineRAW(TRUE);
} else {
setOfflineRAW(FALSE);
}
setReprocCount();
LOGH("Manual capture mode - %d", m_ManualCaptureMode);
return rc;
}
/*===========================================================================
* FUNCTION : isReprocScaleEnabled
*
* DESCRIPTION: Whether reprocess scale is enabled or not
*
* PARAMETERS : none
*
* RETURN : TRUE : Reprocess scale is enabled
* FALSE : Reprocess scale is not enabled
*==========================================================================*/
bool QCameraParameters::isReprocScaleEnabled()
{
return m_reprocScaleParam.isScaleEnabled();
}
/*===========================================================================
* FUNCTION : isUnderReprocScaling
*
* DESCRIPTION: Whether image is under reprocess scaling
*
* PARAMETERS : none
*
* RETURN : TRUE : Image is under reprocess scaling
* FALSE : Image is not under reprocess scaling
*==========================================================================*/
bool QCameraParameters::isUnderReprocScaling()
{
return m_reprocScaleParam.isUnderScaling();
}
/*===========================================================================
* FUNCTION : getPicSizeFromAPK
*
* DESCRIPTION: Get picture size set from application.
*
* PARAMETERS :
* @width : with set by application
* @height : height set by application
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getPicSizeFromAPK(int &width, int &height)
{
return m_reprocScaleParam.getPicSizeFromAPK(width, height);
}
/*===========================================================================
* FUNCTION : setDualLedCalibration
*
* DESCRIPTION: set dual led calibration
*
* PARAMETERS :
* @params : user setting parameters
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setDualLedCalibration(
__unused const QCameraParameters& params)
{
char value[PROPERTY_VALUE_MAX];
int32_t calibration = 0;
memset(value, 0, sizeof(value));
property_get("persist.camera.dual_led_calib", value, "0");
calibration = atoi(value);
if (calibration != m_dualLedCalibration) {
m_dualLedCalibration = calibration;
LOGD("%s:updating calibration=%d m_dualLedCalibration=%d",
__func__, calibration, m_dualLedCalibration);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_DUAL_LED_CALIBRATION,
m_dualLedCalibration)) {
LOGE("%s:Failed to update dual led calibration param", __func__);
return BAD_VALUE;
}
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : setinstantAEC
*
* DESCRIPTION: set instant AEC value to backend
*
* PARAMETERS :
* @value : instant aec enabled or not.
* 0 - disable
* 1 - Enable and set agressive AEC algo to the backend
* 2 - Enable and set fast AEC algo to the backend
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setInstantAEC(uint8_t value, bool initCommit)
{
if (initCommit) {
if (initBatchUpdate(m_pParamBuf) < 0) {
LOGE("Failed to initialize group update table");
return FAILED_TRANSACTION;
}
}
int32_t rc = NO_ERROR;
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf, CAM_INTF_PARM_INSTANT_AEC, value)) {
LOGE("Failed to instant aec value");
return BAD_VALUE;
}
// set the new value
char val[8];
snprintf(val, sizeof(val), "%d", value);
updateParamEntry(KEY_QC_INSTANT_AEC, val);
if (initCommit) {
rc = commitSetBatch();
if (NO_ERROR != rc) {
LOGE("Failed to instant aec value");
return rc;
}
}
LOGD(" Instant AEC value set to backend %d", value);
m_bInstantAEC = value;
return rc;
}
/*===========================================================================
* FUNCTION : setAdvancedCaptureMode
*
* DESCRIPTION: set advanced capture mode
*
* PARAMETERS : none
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::setAdvancedCaptureMode()
{
uint8_t value = isAdvCamFeaturesEnabled();
LOGD("updating advanced capture mode value to %d",value);
if (ADD_SET_PARAM_ENTRY_TO_BATCH(m_pParamBuf,
CAM_INTF_PARM_ADV_CAPTURE_MODE, value)) {
LOGE("Failed to set advanced capture mode param");
return BAD_VALUE;
}
return NO_ERROR;
}
/*===========================================================================
* FUNCTION : getAnalysisInfo
*
* DESCRIPTION: Get the Analysis information based on
* current mode and feature mask
*
* PARAMETERS :
* @fdVideoEnabled : Whether fdVideo enabled currently
* @videoEnabled : Whether hal3 or hal1
* @featureMask : Feature mask
* @analysis_info : Analysis info to be filled
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCameraParameters::getAnalysisInfo(
bool fdVideoEnabled,
bool hal3,
uint32_t featureMask,
cam_analysis_info_t *pAnalysisInfo)
{
return mCommon.getAnalysisInfo(fdVideoEnabled, hal3, featureMask, pAnalysisInfo);
}
}; // namespace qcamera