PageRenderTime 41ms CodeModel.GetById 1ms RepoModel.GetById 0ms app.codeStats 1ms

/QCamera2/HAL/QCameraParameters.cpp

https://github.com/Evervolv/android_hardware_qcom_camera
C++ | 6148 lines | 3694 code | 448 blank | 2006 comment | 826 complexity | f3cb585f5a9720ab4d08a9cf76e1c054 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. /* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
    2. 

  2.  *
    3. 

  3.  * Redistribution and use in source and binary forms, with or without
    4. 

  4.  * modification, are permitted provided that the following conditions are
    5. 

  5.  * met:
    6. 

  6.  *     * Redistributions of source code must retain the above copyright
    7. 

  7.  *       notice, this list of conditions and the following disclaimer.
    8. 

  8.  *     * Redistributions in binary form must reproduce the above
    9. 

  9.  *       copyright notice, this list of conditions and the following
    10. 

  10.  *       disclaimer in the documentation and/or other materials provided
    11. 

  11.  *       with the distribution.
    12. 

  12.  *     * Neither the name of The Linux Foundation nor the names of its
    13. 

  13.  *       contributors may be used to endorse or promote products derived
    14. 

  14.  *       from this software without specific prior written permission.
    15. 

  15.  *
    16. 

  16.  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
    17. 

  17.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
    18. 

  18.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
    19. 

  19.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
    20. 

  20.  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    21. 

  21.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    22. 

  22.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
    23. 

  23.  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
    24. 

  24.  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
    25. 

  25.  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
    26. 

  26.  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    27. 

  27.  *
    28. 

  28.  */
    29. 

  29. 

  30. #define LOG_TAG "QCameraParameters"
    31. 

  31. 

  32. #include <cutils/properties.h>
    33. 

  33. #include <math.h>
    34. 

  34. #include <utils/Errors.h>
    35. 

  35. #include <string.h>
    36. 

  36. #include <stdlib.h>
    37. 

  37. #include <gralloc_priv.h>
    38. 

  38. #include "QCamera2HWI.h"
    39. 

  39. #include "QCameraParameters.h"
    40. 

  40. 

  41. #define ASPECT_TOLERANCE 0.001
    42. 

  42. #define FLIP_V_H (FLIP_H | FLIP_V)
    43. 

  43. 

  44. namespace qcamera {
    45. 

  45. // Parameter keys to communicate between camera application and driver.
    46. 

  46. const char QCameraParameters::KEY_QC_SUPPORTED_HFR_SIZES[] = "hfr-size-values";
    47. 

  47. const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_MODE[] = "preview-frame-rate-mode";
    48. 

  48. const char QCameraParameters::KEY_QC_SUPPORTED_PREVIEW_FRAME_RATE_MODES[] = "preview-frame-rate-modes";
    49. 

  49. const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_AUTO_MODE[] = "frame-rate-auto";
    50. 

  50. const char QCameraParameters::KEY_QC_PREVIEW_FRAME_RATE_FIXED_MODE[] = "frame-rate-fixed";
    51. 

  51. const char QCameraParameters::KEY_QC_TOUCH_AF_AEC[] = "touch-af-aec";
    52. 

  52. const char QCameraParameters::KEY_QC_SUPPORTED_TOUCH_AF_AEC[] = "touch-af-aec-values";
    53. 

  53. const char QCameraParameters::KEY_QC_TOUCH_INDEX_AEC[] = "touch-index-aec";
    54. 

  54. const char QCameraParameters::KEY_QC_TOUCH_INDEX_AF[] = "touch-index-af";
    55. 

  55. const char QCameraParameters::KEY_QC_SCENE_DETECT[] = "scene-detect";
    56. 

  56. const char QCameraParameters::KEY_QC_SUPPORTED_SCENE_DETECT[] = "scene-detect-values";
    57. 

  57. const char QCameraParameters::KEY_QC_ISO_MODE[] = "iso";
    58. 

  58. const char QCameraParameters::KEY_QC_SUPPORTED_ISO_MODES[] = "iso-values";
    59. 

  59. const char QCameraParameters::KEY_QC_LENSSHADE[] = "lensshade";
    60. 

  60. const char QCameraParameters::KEY_QC_SUPPORTED_LENSSHADE_MODES[] = "lensshade-values";
    61. 

  61. const char QCameraParameters::KEY_QC_AUTO_EXPOSURE[] = "auto-exposure";
    62. 

  62. const char QCameraParameters::KEY_QC_SUPPORTED_AUTO_EXPOSURE[] = "auto-exposure-values";
    63. 

  63. const char QCameraParameters::KEY_QC_DENOISE[] = "denoise";
    64. 

  64. const char QCameraParameters::KEY_QC_SUPPORTED_DENOISE[] = "denoise-values";
    65. 

  65. const char QCameraParameters::KEY_QC_FOCUS_ALGO[] = "selectable-zone-af";
    66. 

  66. const char QCameraParameters::KEY_QC_SUPPORTED_FOCUS_ALGOS[] = "selectable-zone-af-values";
    67. 

  67. const char QCameraParameters::KEY_QC_FACE_DETECTION[] = "face-detection";
    68. 

  68. const char QCameraParameters::KEY_QC_SUPPORTED_FACE_DETECTION[] = "face-detection-values";
    69. 

  69. const char QCameraParameters::KEY_QC_FACE_RECOGNITION[] = "face-recognition";
    70. 

  70. const char QCameraParameters::KEY_QC_SUPPORTED_FACE_RECOGNITION[] = "face-recognition-values";
    71. 

  71. const char QCameraParameters::KEY_QC_MEMORY_COLOR_ENHANCEMENT[] = "mce";
    72. 

  72. const char QCameraParameters::KEY_QC_SUPPORTED_MEM_COLOR_ENHANCE_MODES[] = "mce-values";
    73. 

  73. const char QCameraParameters::KEY_QC_DIS[] = "dis";
    74. 

  74. const char QCameraParameters::KEY_QC_SUPPORTED_DIS_MODES[] = "dis-values";
    75. 

  75. const char QCameraParameters::KEY_QC_VIDEO_HIGH_FRAME_RATE[] = "video-hfr";
    76. 

  76. const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HIGH_FRAME_RATE_MODES[] = "video-hfr-values";
    77. 

  77. const char QCameraParameters::KEY_QC_REDEYE_REDUCTION[] = "redeye-reduction";
    78. 

  78. const char QCameraParameters::KEY_QC_SUPPORTED_REDEYE_REDUCTION[] = "redeye-reduction-values";
    79. 

  79. const char QCameraParameters::KEY_QC_HIGH_DYNAMIC_RANGE_IMAGING[] = "hdr";
    80. 

  80. const char QCameraParameters::KEY_QC_SUPPORTED_HDR_IMAGING_MODES[] = "hdr-values";
    81. 

  81. const char QCameraParameters::KEY_QC_ZSL[] = "zsl";
    82. 

  82. const char QCameraParameters::KEY_QC_SUPPORTED_ZSL_MODES[] = "zsl-values";
    83. 

  83. const char QCameraParameters::KEY_QC_ZSL_BURST_INTERVAL[] = "capture-burst-interval";
    84. 

  84. const char QCameraParameters::KEY_QC_ZSL_BURST_LOOKBACK[] = "capture-burst-retroactive";
    85. 

  85. const char QCameraParameters::KEY_QC_ZSL_QUEUE_DEPTH[] = "capture-burst-queue-depth";
    86. 

  86. const char QCameraParameters::KEY_QC_CAMERA_MODE[] = "camera-mode";
    87. 

  87. const char QCameraParameters::KEY_QC_AE_BRACKET_HDR[] = "ae-bracket-hdr";
    88. 

  88. const char QCameraParameters::KEY_QC_SUPPORTED_AE_BRACKET_MODES[] = "ae-bracket-hdr-values";
    89. 

  89. const char QCameraParameters::KEY_QC_SUPPORTED_RAW_FORMATS[] = "raw-format-values";
    90. 

  90. const char QCameraParameters::KEY_QC_RAW_FORMAT[] = "raw-format";
    91. 

  91. const char QCameraParameters::KEY_QC_ORIENTATION[] = "orientation";
    92. 

  92. const char QCameraParameters::KEY_QC_SELECTABLE_ZONE_AF[] = "selectable-zone-af";
    93. 

  93. const char QCameraParameters::KEY_QC_CAPTURE_BURST_EXPOSURE[] = "capture-burst-exposures";
    94. 

  94. const char QCameraParameters::KEY_QC_NUM_SNAPSHOT_PER_SHUTTER[] = "num-snaps-per-shutter";
    95. 

  95. const char QCameraParameters::KEY_QC_NO_DISPLAY_MODE[] = "no-display-mode";
    96. 

  96. const char QCameraParameters::KEY_QC_RAW_PICUTRE_SIZE[] = "raw-size";
    97. 

  97. const char QCameraParameters::KEY_QC_SUPPORTED_SKIN_TONE_ENHANCEMENT_MODES[] = "skinToneEnhancement-values";
    98. 

  98. const char QCameraParameters::KEY_QC_SUPPORTED_LIVESNAPSHOT_SIZES[] = "supported-live-snapshot-sizes";
    99. 

  99. const char QCameraParameters::KEY_QC_HDR_NEED_1X[] = "hdr-need-1x";
    100. 

  100. const char QCameraParameters::KEY_QC_PREVIEW_FLIP[] = "preview-flip";
    101. 

  101. const char QCameraParameters::KEY_QC_VIDEO_FLIP[] = "video-flip";
    102. 

  102. const char QCameraParameters::KEY_QC_SNAPSHOT_PICTURE_FLIP[] = "snapshot-picture-flip";
    103. 

  103. const char QCameraParameters::KEY_QC_SUPPORTED_FLIP_MODES[] = "flip-mode-values";
    104. 

  104. const char QCameraParameters::KEY_QC_VIDEO_HDR[] = "video-hdr";
    105. 

  105. const char QCameraParameters::KEY_QC_SUPPORTED_VIDEO_HDR_MODES[] = "video-hdr-values";
    106. 

  106. 

  107. // Values for effect settings.
    108. 

  108. const char QCameraParameters::EFFECT_EMBOSS[] = "emboss";
    109. 

  109. const char QCameraParameters::EFFECT_SKETCH[] = "sketch";
    110. 

  110. const char QCameraParameters::EFFECT_NEON[] = "neon";
    111. 

  111. 

  112. // Values for auto exposure settings.
    113. 

  113. const char QCameraParameters::TOUCH_AF_AEC_OFF[] = "touch-off";
    114. 

  114. const char QCameraParameters::TOUCH_AF_AEC_ON[] = "touch-on";
    115. 

  115. 

  116. // Values for scene mode settings.
    117. 

  117. const char QCameraParameters::SCENE_MODE_ASD[] = "asd";   // corresponds to CAMERA_BESTSHOT_AUTO in HAL
    118. 

  118. const char QCameraParameters::SCENE_MODE_BACKLIGHT[] = "backlight";
    119. 

  119. const char QCameraParameters::SCENE_MODE_FLOWERS[] = "flowers";
    120. 

  120. const char QCameraParameters::SCENE_MODE_AR[] = "AR";
    121. 

  121. const char QCameraParameters::SCENE_MODE_HDR[] = "hdr";
    122. 

  122. 

  123. // Formats for setPreviewFormat and setPictureFormat.
    124. 

  124. const char QCameraParameters::PIXEL_FORMAT_YUV420SP_ADRENO[] = "yuv420sp-adreno";
    125. 

  125. const char QCameraParameters::PIXEL_FORMAT_YV12[] = "yuv420p";
    126. 

  126. const char QCameraParameters::PIXEL_FORMAT_NV12[] = "nv12";
    127. 

  127. 

  128. // Values for raw image formats
    129. 

  129. const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV[] = "yuv-raw8-yuyv";
    130. 

  130. const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU[] = "yuv-raw8-yvyu";
    131. 

  131. const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY[] = "yuv-raw8-uyvy";
    132. 

  132. const char QCameraParameters::QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY[] = "yuv-raw8-vyuy";
    133. 

  133. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG[] = "bayer-qcom-8gbrg";
    134. 

  134. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG[] = "bayer-qcom-8grbg";
    135. 

  135. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB[] = "bayer-qcom-8rggb";
    136. 

  136. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR[] = "bayer-qcom-8bggr";
    137. 

  137. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG[] = "bayer-qcom-10gbrg";
    138. 

  138. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG[] = "bayer-qcom-10grbg";
    139. 

  139. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB[] = "bayer-qcom-10rggb";
    140. 

  140. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR[] = "bayer-qcom-10bggr";
    141. 

  141. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG[] = "bayer-qcom-12gbrg";
    142. 

  142. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG[] = "bayer-qcom-12grbg";
    143. 

  143. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB[] = "bayer-qcom-12rggb";
    144. 

  144. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR[] = "bayer-qcom-12bggr";
    145. 

  145. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG[] = "bayer-mipi-8gbrg";
    146. 

  146. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG[] = "bayer-mipi-8grbg";
    147. 

  147. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB[] = "bayer-mipi-8rggb";
    148. 

  148. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR[] = "bayer-mipi-8bggr";
    149. 

  149. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG[] = "bayer-mipi-10gbrg";
    150. 

  150. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG[] = "bayer-mipi-10grbg";
    151. 

  151. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB[] = "bayer-mipi-10rggb";
    152. 

  152. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR[] = "bayer-mipi-10bggr";
    153. 

  153. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG[] = "bayer-mipi-12gbrg";
    154. 

  154. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG[] = "bayer-mipi-12grbg";
    155. 

  155. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB[] = "bayer-mipi-12rggb";
    156. 

  156. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR[] = "bayer-mipi-12bggr";
    157. 

  157. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG[] = "bayer-ideal-qcom-8gbrg";
    158. 

  158. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG[] = "bayer-ideal-qcom-8grbg";
    159. 

  159. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB[] = "bayer-ideal-qcom-8rggb";
    160. 

  160. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR[] = "bayer-ideal-qcom-8bggr";
    161. 

  161. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG[] = "bayer-ideal-qcom-10gbrg";
    162. 

  162. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG[] = "bayer-ideal-qcom-10grbg";
    163. 

  163. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB[] = "bayer-ideal-qcom-10rggb";
    164. 

  164. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR[] = "bayer-ideal-qcom-10bggr";
    165. 

  165. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG[] = "bayer-ideal-qcom-12gbrg";
    166. 

  166. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG[] = "bayer-ideal-qcom-12grbg";
    167. 

  167. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB[] = "bayer-ideal-qcom-12rggb";
    168. 

  168. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR[] = "bayer-ideal-qcom-12bggr";
    169. 

  169. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG[] = "bayer-ideal-mipi-8gbrg";
    170. 

  170. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG[] = "bayer-ideal-mipi-8grbg";
    171. 

  171. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB[] = "bayer-ideal-mipi-8rggb";
    172. 

  172. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR[] = "bayer-ideal-mipi-8bggr";
    173. 

  173. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG[] = "bayer-ideal-mipi-10gbrg";
    174. 

  174. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG[] = "bayer-ideal-mipi-10grbg";
    175. 

  175. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB[] = "bayer-ideal-mipi-10rggb";
    176. 

  176. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR[] = "bayer-ideal-mipi-10bggr";
    177. 

  177. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG[] = "bayer-ideal-mipi-12gbrg";
    178. 

  178. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG[] = "bayer-ideal-mipi-12grbg";
    179. 

  179. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB[] = "bayer-ideal-mipi-12rggb";
    180. 

  180. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR[] = "bayer-ideal-mipi-12bggr";
    181. 

  181. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG[] = "bayer-ideal-plain8-8gbrg";
    182. 

  182. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG[] = "bayer-ideal-plain8-8grbg";
    183. 

  183. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB[] = "bayer-ideal-plain8-8rggb";
    184. 

  184. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR[] = "bayer-ideal-plain8-8bggr";
    185. 

  185. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG[] = "bayer-ideal-plain16-8gbrg";
    186. 

  186. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG[] = "bayer-ideal-plain16-8grbg";
    187. 

  187. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB[] = "bayer-ideal-plain16-8rggb";
    188. 

  188. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR[] = "bayer-ideal-plain16-8bggr";
    189. 

  189. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG[] = "bayer-ideal-plain16-10gbrg";
    190. 

  190. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG[] = "bayer-ideal-plain16-10grbg";
    191. 

  191. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB[] = "bayer-ideal-plain16-10rggb";
    192. 

  192. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR[] = "bayer-ideal-plain16-10bggr";
    193. 

  193. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG[] = "bayer-ideal-plain16-12gbrg";
    194. 

  194. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG[] = "bayer-ideal-plain16-12grbg";
    195. 

  195. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB[] = "bayer-ideal-plain16-12rggb";
    196. 

  196. const char QCameraParameters::QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR[] = "bayer-ideal-plain16-12bggr";
    197. 

  197. 

  198. // Values for ISO Settings
    199. 

  199. const char QCameraParameters::ISO_AUTO[] = "auto";
    200. 

  200. const char QCameraParameters::ISO_HJR[] = "ISO_HJR";
    201. 

  201. const char QCameraParameters::ISO_100[] = "ISO100";
    202. 

  202. const char QCameraParameters::ISO_200[] = "ISO200";
    203. 

  203. const char QCameraParameters::ISO_400[] = "ISO400";
    204. 

  204. const char QCameraParameters::ISO_800[] = "ISO800";
    205. 

  205. const char QCameraParameters::ISO_1600[] = "ISO1600";
    206. 

  206. 

  207. // Values for auto exposure settings.
    208. 

  208. const char QCameraParameters::AUTO_EXPOSURE_FRAME_AVG[] = "frame-average";
    209. 

  209. const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED[] = "center-weighted";
    210. 

  210. const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING[] = "spot-metering";
    211. 

  211. const char QCameraParameters::AUTO_EXPOSURE_SMART_METERING[] = "smart-metering";
    212. 

  212. const char QCameraParameters::AUTO_EXPOSURE_USER_METERING[] = "user-metering";
    213. 

  213. const char QCameraParameters::AUTO_EXPOSURE_SPOT_METERING_ADV[] = "spot-metering-adv";
    214. 

  214. const char QCameraParameters::AUTO_EXPOSURE_CENTER_WEIGHTED_ADV[] = "center-weighted-adv";
    215. 

  215. 

  216. const char QCameraParameters::KEY_QC_GPS_LATITUDE_REF[] = "gps-latitude-ref";
    217. 

  217. const char QCameraParameters::KEY_QC_GPS_LONGITUDE_REF[] = "gps-longitude-ref";
    218. 

  218. const char QCameraParameters::KEY_QC_GPS_ALTITUDE_REF[] = "gps-altitude-ref";
    219. 

  219. const char QCameraParameters::KEY_QC_GPS_STATUS[] = "gps-status";
    220. 

  220. 

  221. const char QCameraParameters::KEY_QC_HISTOGRAM[] = "histogram";
    222. 

  222. const char QCameraParameters::KEY_QC_SUPPORTED_HISTOGRAM_MODES[] = "histogram-values";
    223. 

  223. 

  224. const char QCameraParameters::VALUE_ENABLE[] = "enable";
    225. 

  225. const char QCameraParameters::VALUE_DISABLE[] = "disable";
    226. 

  226. const char QCameraParameters::VALUE_OFF[] = "off";
    227. 

  227. const char QCameraParameters::VALUE_ON[] = "on";
    228. 

  228. const char QCameraParameters::VALUE_TRUE[] = "true";
    229. 

  229. const char QCameraParameters::VALUE_FALSE[] = "false";
    230. 

  230. 

  231. const char QCameraParameters::KEY_QC_SHARPNESS[] = "sharpness";
    232. 

  232. const char QCameraParameters::KEY_QC_MIN_SHARPNESS[] = "min-sharpness";
    233. 

  233. const char QCameraParameters::KEY_QC_MAX_SHARPNESS[] = "max-sharpness";
    234. 

  234. const char QCameraParameters::KEY_QC_SHARPNESS_STEP[] = "sharpness-step";
    235. 

  235. const char QCameraParameters::KEY_QC_CONTRAST[] = "contrast";
    236. 

  236. const char QCameraParameters::KEY_QC_MIN_CONTRAST[] = "min-contrast";
    237. 

  237. const char QCameraParameters::KEY_QC_MAX_CONTRAST[] = "max-contrast";
    238. 

  238. const char QCameraParameters::KEY_QC_CONTRAST_STEP[] = "contrast-step";
    239. 

  239. const char QCameraParameters::KEY_QC_SATURATION[] = "saturation";
    240. 

  240. const char QCameraParameters::KEY_QC_MIN_SATURATION[] = "min-saturation";
    241. 

  241. const char QCameraParameters::KEY_QC_MAX_SATURATION[] = "max-saturation";
    242. 

  242. const char QCameraParameters::KEY_QC_SATURATION_STEP[] = "saturation-step";
    243. 

  243. const char QCameraParameters::KEY_QC_BRIGHTNESS[] = "luma-adaptation";
    244. 

  244. const char QCameraParameters::KEY_QC_MIN_BRIGHTNESS[] = "min-brightness";
    245. 

  245. const char QCameraParameters::KEY_QC_MAX_BRIGHTNESS[] = "max-brightness";
    246. 

  246. const char QCameraParameters::KEY_QC_BRIGHTNESS_STEP[] = "brightness-step";
    247. 

  247. const char QCameraParameters::KEY_QC_SCE_FACTOR[] = "skinToneEnhancement";
    248. 

  248. const char QCameraParameters::KEY_QC_MIN_SCE_FACTOR[] = "min-sce-factor";
    249. 

  249. const char QCameraParameters::KEY_QC_MAX_SCE_FACTOR[] = "max-sce-factor";
    250. 

  250. const char QCameraParameters::KEY_QC_SCE_FACTOR_STEP[] = "sce-factor-step";
    251. 

  251. 

  252. const char QCameraParameters::KEY_QC_SUPPORTED_CAMERA_FEATURES[] = "qc-camera-features";
    253. 

  253. const char QCameraParameters::KEY_QC_MAX_NUM_REQUESTED_FACES[] = "qc-max-num-requested-faces";
    254. 

  254. 

  255. //Values for DENOISE
    256. 

  256. const char QCameraParameters::DENOISE_OFF[] = "denoise-off";
    257. 

  257. const char QCameraParameters::DENOISE_ON[] = "denoise-on";
    258. 

  258. 

  259. // Values for selectable zone af Settings
    260. 

  260. const char QCameraParameters::FOCUS_ALGO_AUTO[] = "auto";
    261. 

  261. const char QCameraParameters::FOCUS_ALGO_SPOT_METERING[] = "spot-metering";
    262. 

  262. const char QCameraParameters::FOCUS_ALGO_CENTER_WEIGHTED[] = "center-weighted";
    263. 

  263. const char QCameraParameters::FOCUS_ALGO_FRAME_AVERAGE[] = "frame-average";
    264. 

  264. 

  265. // Values for HFR settings.
    266. 

  266. const char QCameraParameters::VIDEO_HFR_OFF[] = "off";
    267. 

  267. const char QCameraParameters::VIDEO_HFR_2X[] = "60";
    268. 

  268. const char QCameraParameters::VIDEO_HFR_3X[] = "90";
    269. 

  269. const char QCameraParameters::VIDEO_HFR_4X[] = "120";
    270. 

  270. const char QCameraParameters::VIDEO_HFR_5X[] = "150";
    271. 

  271. 

  272. // Values for HDR Bracketing settings.
    273. 

  273. const char QCameraParameters::AE_BRACKET_OFF[] = "Off";
    274. 

  274. const char QCameraParameters::AE_BRACKET[] = "AE-Bracket";
    275. 

  275. 

  276. // Values for FLIP settings.
    277. 

  277. const char QCameraParameters::FLIP_MODE_OFF[] = "off";
    278. 

  278. const char QCameraParameters::FLIP_MODE_V[] = "flip-v";
    279. 

  279. const char QCameraParameters::FLIP_MODE_H[] = "flip-h";
    280. 

  280. const char QCameraParameters::FLIP_MODE_VH[] = "flip-vh";
    281. 

  281. 

  282. static const char* portrait = "portrait";
    283. 

  283. static const char* landscape = "landscape";
    284. 

  284. 

  285. const cam_dimension_t QCameraParameters::THUMBNAIL_SIZES_MAP[] = {
    286. 

  286.     { 512, 288 }, //1.777778
    287. 

  287.     { 480, 288 }, //1.666667
    288. 

  288.     { 256, 154 }, //1.66233
    289. 

  289.     { 432, 288 }, //1.5
    290. 

  290.     { 320, 240 }, //1.33333
    291. 

  291.     { 176, 144 }, //1.222222
    292. 

  292.     { 0, 0 }      // required by Android SDK
    293. 

  293. };
    294. 

  294. 

  295. const QCameraParameters::QCameraMap QCameraParameters::AUTO_EXPOSURE_MAP[] = {
    296. 

  296.     { AUTO_EXPOSURE_FRAME_AVG,           CAM_AEC_MODE_FRAME_AVERAGE },
    297. 

  297.     { AUTO_EXPOSURE_CENTER_WEIGHTED,     CAM_AEC_MODE_CENTER_WEIGHTED },
    298. 

  298.     { AUTO_EXPOSURE_SPOT_METERING,       CAM_AEC_MODE_SPOT_METERING },
    299. 

  299.     { AUTO_EXPOSURE_SMART_METERING,      CAM_AEC_MODE_SMART_METERING },
    300. 

  300.     { AUTO_EXPOSURE_USER_METERING,       CAM_AEC_MODE_USER_METERING },
    301. 

  301.     { AUTO_EXPOSURE_SPOT_METERING_ADV,   CAM_AEC_MODE_SPOT_METERING_ADV },
    302. 

  302.     { AUTO_EXPOSURE_CENTER_WEIGHTED_ADV, CAM_AEC_MODE_CENTER_WEIGHTED_ADV },
    303. 

  303. };
    304. 

  304. 

  305. const QCameraParameters::QCameraMap QCameraParameters::PREVIEW_FORMATS_MAP[] = {
    306. 

  306.     {PIXEL_FORMAT_YUV420SP,        CAM_FORMAT_YUV_420_NV21},
    307. 

  307.     {PIXEL_FORMAT_YUV420P,         CAM_FORMAT_YUV_420_YV12},
    308. 

  308.     {PIXEL_FORMAT_YUV420SP_ADRENO, CAM_FORMAT_YUV_420_NV21_ADRENO},
    309. 

  309.     {PIXEL_FORMAT_YV12,            CAM_FORMAT_YUV_420_YV12},
    310. 

  310.     {PIXEL_FORMAT_NV12,            CAM_FORMAT_YUV_420_NV12}
    311. 

  311. };
    312. 

  312. 

  313. const QCameraParameters::QCameraMap QCameraParameters::PICTURE_TYPES_MAP[] = {
    314. 

  314.     {PIXEL_FORMAT_JPEG,                          CAM_FORMAT_JPEG},
    315. 

  315.     {PIXEL_FORMAT_YUV422SP,                      CAM_FORMAT_YUV_422_NV16},
    316. 

  316.     {QC_PIXEL_FORMAT_YUV_RAW_8BIT_YUYV,          CAM_FORMAT_YUV_RAW_8BIT_YUYV},
    317. 

  317.     {QC_PIXEL_FORMAT_YUV_RAW_8BIT_YVYU,          CAM_FORMAT_YUV_RAW_8BIT_YVYU},
    318. 

  318.     {QC_PIXEL_FORMAT_YUV_RAW_8BIT_UYVY,          CAM_FORMAT_YUV_RAW_8BIT_UYVY},
    319. 

  319.     {QC_PIXEL_FORMAT_YUV_RAW_8BIT_VYUY,          CAM_FORMAT_YUV_RAW_8BIT_VYUY},
    320. 

  320.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GBRG,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GBRG},
    321. 

  321.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8GRBG,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GRBG},
    322. 

  322.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8RGGB,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_RGGB},
    323. 

  323.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_8BGGR,       CAM_FORMAT_BAYER_QCOM_RAW_8BPP_BGGR},
    324. 

  324.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GBRG,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GBRG},
    325. 

  325.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10GRBG,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GRBG},
    326. 

  326.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10RGGB,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_RGGB},
    327. 

  327.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_10BGGR,      CAM_FORMAT_BAYER_QCOM_RAW_10BPP_BGGR},
    328. 

  328.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GBRG,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GBRG},
    329. 

  329.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12GRBG,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GRBG},
    330. 

  330.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12RGGB,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_RGGB},
    331. 

  331.     {QC_PIXEL_FORMAT_BAYER_QCOM_RAW_12BGGR,      CAM_FORMAT_BAYER_QCOM_RAW_12BPP_BGGR},
    332. 

  332.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GBRG,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GBRG},
    333. 

  333.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8GRBG,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GRBG},
    334. 

  334.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8RGGB,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_RGGB},
    335. 

  335.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_8BGGR,       CAM_FORMAT_BAYER_MIPI_RAW_8BPP_BGGR},
    336. 

  336.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GBRG,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG},
    337. 

  337.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10GRBG,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GRBG},
    338. 

  338.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10RGGB,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_RGGB},
    339. 

  339.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_10BGGR,      CAM_FORMAT_BAYER_MIPI_RAW_10BPP_BGGR},
    340. 

  340.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GBRG,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GBRG},
    341. 

  341.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12GRBG,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GRBG},
    342. 

  342.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12RGGB,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_RGGB},
    343. 

  343.     {QC_PIXEL_FORMAT_BAYER_MIPI_RAW_12BGGR,      CAM_FORMAT_BAYER_MIPI_RAW_12BPP_BGGR},
    344. 

  344.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GBRG,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GBRG},
    345. 

  345.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8GRBG,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_GRBG},
    346. 

  346.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8RGGB,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_RGGB},
    347. 

  347.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_8BGGR,     CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_8BPP_BGGR},
    348. 

  348.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GBRG},
    349. 

  349.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_GRBG},
    350. 

  350.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_RGGB},
    351. 

  351.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_10BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_10BPP_BGGR},
    352. 

  352.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GBRG},
    353. 

  353.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_GRBG},
    354. 

  354.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_RGGB},
    355. 

  355.     {QC_PIXEL_FORMAT_BAYER_IDEAL_QCOM_12BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_QCOM_12BPP_BGGR},
    356. 

  356.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GBRG,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GBRG},
    357. 

  357.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8GRBG,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_GRBG},
    358. 

  358.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8RGGB,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_RGGB},
    359. 

  359.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_8BGGR,     CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_8BPP_BGGR},
    360. 

  360.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GBRG},
    361. 

  361.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_GRBG},
    362. 

  362.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_RGGB},
    363. 

  363.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_10BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_10BPP_BGGR},
    364. 

  364.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GBRG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GBRG},
    365. 

  365.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12GRBG,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_GRBG},
    366. 

  366.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12RGGB,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_RGGB},
    367. 

  367.     {QC_PIXEL_FORMAT_BAYER_IDEAL_MIPI_12BGGR,    CAM_FORMAT_BAYER_IDEAL_RAW_MIPI_12BPP_BGGR},
    368. 

  368.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GBRG,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GBRG},
    369. 

  369.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8GRBG,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_GRBG},
    370. 

  370.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8RGGB,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_RGGB},
    371. 

  371.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN8_8BGGR,   CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN8_8BPP_BGGR},
    372. 

  372.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GBRG,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GBRG},
    373. 

  373.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8GRBG,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_GRBG},
    374. 

  374.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8RGGB,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_RGGB},
    375. 

  375.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_8BGGR,  CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_8BPP_BGGR},
    376. 

  376.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GBRG},
    377. 

  377.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_GRBG},
    378. 

  378.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_RGGB},
    379. 

  379.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_10BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_10BPP_BGGR},
    380. 

  380.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GBRG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GBRG},
    381. 

  381.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12GRBG, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_GRBG},
    382. 

  382.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12RGGB, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_RGGB},
    383. 

  383.     {QC_PIXEL_FORMAT_BAYER_IDEAL_PLAIN16_12BGGR, CAM_FORMAT_BAYER_IDEAL_RAW_PLAIN16_12BPP_BGGR}
    384. 

  384. };
    385. 

  385. 

  386. const QCameraParameters::QCameraMap QCameraParameters::RAW_FORMATS_MAP[] = {
    387. 

  387. };
    388. 

  388. 

  389. const QCameraParameters::QCameraMap QCameraParameters::FOCUS_MODES_MAP[] = {
    390. 

  390.     { FOCUS_MODE_AUTO,               CAM_FOCUS_MODE_AUTO },
    391. 

  391.     { FOCUS_MODE_INFINITY,           CAM_FOCUS_MODE_INFINITY },
    392. 

  392.     { FOCUS_MODE_MACRO,              CAM_FOCUS_MODE_MACRO },
    393. 

  393.     { FOCUS_MODE_FIXED,              CAM_FOCUS_MODE_FIXED },
    394. 

  394.     { FOCUS_MODE_EDOF,               CAM_FOCUS_MODE_EDOF },
    395. 

  395.     { FOCUS_MODE_CONTINUOUS_PICTURE, CAM_FOCUS_MODE_CONTINOUS_PICTURE },
    396. 

  396.     { FOCUS_MODE_CONTINUOUS_VIDEO,   CAM_FOCUS_MODE_CONTINOUS_VIDEO }
    397. 

  397. };
    398. 

  398. 

  399. const QCameraParameters::QCameraMap QCameraParameters::EFFECT_MODES_MAP[] = {
    400. 

  400.     { EFFECT_NONE,       CAM_EFFECT_MODE_OFF },
    401. 

  401.     { EFFECT_MONO,       CAM_EFFECT_MODE_MONO },
    402. 

  402.     { EFFECT_NEGATIVE,   CAM_EFFECT_MODE_NEGATIVE },
    403. 

  403.     { EFFECT_SOLARIZE,   CAM_EFFECT_MODE_SOLARIZE },
    404. 

  404.     { EFFECT_SEPIA,      CAM_EFFECT_MODE_SEPIA },
    405. 

  405.     { EFFECT_POSTERIZE,  CAM_EFFECT_MODE_POSTERIZE },
    406. 

  406.     { EFFECT_WHITEBOARD, CAM_EFFECT_MODE_WHITEBOARD },
    407. 

  407.     { EFFECT_BLACKBOARD, CAM_EFFECT_MODE_BLACKBOARD },
    408. 

  408.     { EFFECT_AQUA,       CAM_EFFECT_MODE_AQUA },
    409. 

  409.     { EFFECT_EMBOSS,     CAM_EFFECT_MODE_EMBOSS },
    410. 

  410.     { EFFECT_SKETCH,     CAM_EFFECT_MODE_SKETCH },
    411. 

  411.     { EFFECT_NEON,       CAM_EFFECT_MODE_NEON }
    412. 

  412. };
    413. 

  413. 

  414. const QCameraParameters::QCameraMap QCameraParameters::SCENE_MODES_MAP[] = {
    415. 

  415.     { SCENE_MODE_AUTO,           CAM_SCENE_MODE_OFF },
    416. 

  416.     { SCENE_MODE_ACTION,         CAM_SCENE_MODE_ACTION },
    417. 

  417.     { SCENE_MODE_PORTRAIT,       CAM_SCENE_MODE_PORTRAIT },
    418. 

  418.     { SCENE_MODE_LANDSCAPE,      CAM_SCENE_MODE_LANDSCAPE },
    419. 

  419.     { SCENE_MODE_NIGHT,          CAM_SCENE_MODE_NIGHT },
    420. 

  420.     { SCENE_MODE_NIGHT_PORTRAIT, CAM_SCENE_MODE_NIGHT_PORTRAIT },
    421. 

  421.     { SCENE_MODE_THEATRE,        CAM_SCENE_MODE_THEATRE },
    422. 

  422.     { SCENE_MODE_BEACH,          CAM_SCENE_MODE_BEACH },
    423. 

  423.     { SCENE_MODE_SNOW,           CAM_SCENE_MODE_SNOW },
    424. 

  424.     { SCENE_MODE_SUNSET,         CAM_SCENE_MODE_SUNSET },
    425. 

  425.     { SCENE_MODE_STEADYPHOTO,    CAM_SCENE_MODE_ANTISHAKE },
    426. 

  426.     { SCENE_MODE_FIREWORKS ,     CAM_SCENE_MODE_FIREWORKS },
    427. 

  427.     { SCENE_MODE_SPORTS ,        CAM_SCENE_MODE_SPORTS },
    428. 

  428.     { SCENE_MODE_PARTY,          CAM_SCENE_MODE_PARTY },
    429. 

  429.     { SCENE_MODE_CANDLELIGHT,    CAM_SCENE_MODE_CANDLELIGHT },
    430. 

  430.     { SCENE_MODE_ASD,            CAM_SCENE_MODE_AUTO },
    431. 

  431.     { SCENE_MODE_BACKLIGHT,      CAM_SCENE_MODE_BACKLIGHT },
    432. 

  432.     { SCENE_MODE_FLOWERS,        CAM_SCENE_MODE_FLOWERS },
    433. 

  433.     { SCENE_MODE_AR,             CAM_SCENE_MODE_AR },
    434. 

  434.     { SCENE_MODE_HDR,            CAM_SCENE_MODE_OFF },
    435. 

  435. };
    436. 

  436. 

  437. const QCameraParameters::QCameraMap QCameraParameters::FLASH_MODES_MAP[] = {
    438. 

  438.     { FLASH_MODE_OFF,   CAM_FLASH_MODE_OFF },
    439. 

  439.     { FLASH_MODE_AUTO,  CAM_FLASH_MODE_AUTO },
    440. 

  440.     { FLASH_MODE_ON,    CAM_FLASH_MODE_ON },
    441. 

  441.     { FLASH_MODE_TORCH, CAM_FLASH_MODE_TORCH }
    442. 

  442. };
    443. 

  443. 

  444. const QCameraParameters::QCameraMap QCameraParameters::FOCUS_ALGO_MAP[] = {
    445. 

  445.     { FOCUS_ALGO_AUTO,            CAM_FOCUS_ALGO_AUTO },
    446. 

  446.     { FOCUS_ALGO_SPOT_METERING,   CAM_FOCUS_ALGO_SPOT },
    447. 

  447.     { FOCUS_ALGO_CENTER_WEIGHTED, CAM_FOCUS_ALGO_CENTER_WEIGHTED },
    448. 

  448.     { FOCUS_ALGO_FRAME_AVERAGE,   CAM_FOCUS_ALGO_AVERAGE }
    449. 

  449. };
    450. 

  450. 

  451. const QCameraParameters::QCameraMap QCameraParameters::WHITE_BALANCE_MODES_MAP[] = {
    452. 

  452.     { WHITE_BALANCE_AUTO,            CAM_WB_MODE_AUTO },
    453. 

  453.     { WHITE_BALANCE_INCANDESCENT,    CAM_WB_MODE_INCANDESCENT },
    454. 

  454.     { WHITE_BALANCE_FLUORESCENT,     CAM_WB_MODE_FLUORESCENT },
    455. 

  455.     { WHITE_BALANCE_WARM_FLUORESCENT,CAM_WB_MODE_WARM_FLUORESCENT},
    456. 

  456.     { WHITE_BALANCE_DAYLIGHT,        CAM_WB_MODE_DAYLIGHT },
    457. 

  457.     { WHITE_BALANCE_CLOUDY_DAYLIGHT, CAM_WB_MODE_CLOUDY_DAYLIGHT },
    458. 

  458.     { WHITE_BALANCE_TWILIGHT,        CAM_WB_MODE_TWILIGHT },
    459. 

  459.     { WHITE_BALANCE_SHADE,           CAM_WB_MODE_SHADE }
    460. 

  460. };
    461. 

  461. 

  462. const QCameraParameters::QCameraMap QCameraParameters::ANTIBANDING_MODES_MAP[] = {
    463. 

  463.     { ANTIBANDING_OFF,  CAM_ANTIBANDING_MODE_OFF },
    464. 

  464.     { ANTIBANDING_50HZ, CAM_ANTIBANDING_MODE_50HZ },
    465. 

  465.     { ANTIBANDING_60HZ, CAM_ANTIBANDING_MODE_60HZ },
    466. 

  466.     { ANTIBANDING_AUTO, CAM_ANTIBANDING_MODE_AUTO }
    467. 

  467. };
    468. 

  468. 

  469. const QCameraParameters::QCameraMap QCameraParameters::ISO_MODES_MAP[] = {
    470. 

  470.     { ISO_AUTO,  CAM_ISO_MODE_AUTO },
    471. 

  471.     { ISO_HJR,   CAM_ISO_MODE_DEBLUR },
    472. 

  472.     { ISO_100,   CAM_ISO_MODE_100 },
    473. 

  473.     { ISO_200,   CAM_ISO_MODE_200 },
    474. 

  474.     { ISO_400,   CAM_ISO_MODE_400 },
    475. 

  475.     { ISO_800,   CAM_ISO_MODE_800 },
    476. 

  476.     { ISO_1600,  CAM_ISO_MODE_1600 }
    477. 

  477. };
    478. 

  478. 

  479. const QCameraParameters::QCameraMap QCameraParameters::HFR_MODES_MAP[] = {
    480. 

  480.     { VIDEO_HFR_OFF, CAM_HFR_MODE_OFF },
    481. 

  481.     { VIDEO_HFR_2X,  CAM_HFR_MODE_60FPS },
    482. 

  482.     { VIDEO_HFR_3X,  CAM_HFR_MODE_90FPS },
    483. 

  483.     { VIDEO_HFR_4X,  CAM_HFR_MODE_120FPS },
    484. 

  484.     { VIDEO_HFR_5X,  CAM_HFR_MODE_150FPS }
    485. 

  485. };
    486. 

  486. 

  487. const QCameraParameters::QCameraMap QCameraParameters::BRACKETING_MODES_MAP[] = {
    488. 

  488.     { AE_BRACKET_OFF, CAM_EXP_BRACKETING_OFF },
    489. 

  489.     { AE_BRACKET,         CAM_EXP_BRACKETING_ON }
    490. 

  490. };
    491. 

  491. 

  492. const QCameraParameters::QCameraMap QCameraParameters::ON_OFF_MODES_MAP[] = {
    493. 

  493.     { VALUE_OFF, 0 },
    494. 

  494.     { VALUE_ON,  1 }
    495. 

  495. };
    496. 

  496. 

  497. const QCameraParameters::QCameraMap QCameraParameters::TOUCH_AF_AEC_MODES_MAP[] = {
    498. 

  498.     { QCameraParameters::TOUCH_AF_AEC_OFF, 0 },
    499. 

  499.     { QCameraParameters::TOUCH_AF_AEC_ON, 1 }
    500. 

  500. };
    501. 

  501. 

  502. const QCameraParameters::QCameraMap QCameraParameters::ENABLE_DISABLE_MODES_MAP[] = {
    503. 

  503.     { VALUE_ENABLE,  1 },
    504. 

  504.     { VALUE_DISABLE, 0 }
    505. 

  505. };
    506. 

  506. 

  507. const QCameraParameters::QCameraMap QCameraParameters::DENOISE_ON_OFF_MODES_MAP[] = {
    508. 

  508.     { DENOISE_OFF, 0 },
    509. 

  509.     { DENOISE_ON,  1 }
    510. 

  510. };
    511. 

  511. 

  512. const QCameraParameters::QCameraMap QCameraParameters::TRUE_FALSE_MODES_MAP[] = {
    513. 

  513.     { VALUE_FALSE, 0},
    514. 

  514.     { VALUE_TRUE,  1}
    515. 

  515. };
    516. 

  516. 

  517. const QCameraParameters::QCameraMap QCameraParameters::FLIP_MODES_MAP[] = {
    518. 

  518.     {FLIP_MODE_OFF, 0},
    519. 

  519.     {FLIP_MODE_V, FLIP_V},
    520. 

  520.     {FLIP_MODE_H, FLIP_H},
    521. 

  521.     {FLIP_MODE_VH, FLIP_V_H}
    522. 

  522. };
    523. 

  523. 

  524. #define DEFAULT_CAMERA_AREA "(0, 0, 0, 0, 0)"
    525. 

  525. #define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
    526. 

  526. 

  527. /*===========================================================================
    528. 

  528.  * FUNCTION   : QCameraParameters
    529. 

  529.  *
    530. 

  530.  * DESCRIPTION: default constructor of QCameraParameters
    531. 

  531.  *
    532. 

  532.  * PARAMETERS : none
    533. 

  533.  *
    534. 

  534.  * RETURN     : None
    535. 

  535.  *==========================================================================*/
    536. 

  536. QCameraParameters::QCameraParameters()
    537. 

  537.     : CameraParameters(),
    538. 

  538.       m_pCapability(NULL),
    539. 

  539.       m_pCamOpsTbl(NULL),
    540. 

  540.       m_pParamHeap(NULL),
    541. 

  541.       m_pParamBuf(NULL),
    542. 

  542.       m_bZslMode(false),
    543. 

  543.       m_bZslMode_new(false),
    544. 

  544.       m_bRecordingHint(false),
    545. 

  545.       m_bRecordingHint_new(false),
    546. 

  546.       m_bHistogramEnabled(false),
    547. 

  547.       m_nFaceProcMask(0),
    548. 

  548.       m_bDebugFps(false),
    549. 

  549.       mFocusMode(CAM_FOCUS_MODE_MAX),
    550. 

  550.       mPreviewFormat(CAM_FORMAT_YUV_420_NV21),
    551. 

  551.       mPictureFormat(CAM_FORMAT_JPEG),
    552. 

  552.       m_bNeedRestart(false),
    553. 

  553.       m_bNoDisplayMode(false),
    554. 

  554.       m_bWNROn(false),
    555. 

  555.       m_bNeedLockCAF(false),
    556. 

  556.       m_bCAFLocked(false),
    557. 

  557.       m_bAFRunning(false),
    558. 

  558.       m_tempMap()
    559. 

  559. {
    560. 

  560.     char value[PROPERTY_VALUE_MAX];
    561. 

  561.     // TODO: may move to parameter instead of sysprop
    562. 

  562.     property_get("persist.debug.sf.showfps", value, "0");
    563. 

  563.     m_bDebugFps = atoi(value) > 0 ? true : false;
    564. 

  564. 

  565.     // For thermal mode, it should be set as system property
    566. 

  566.     // because system property applies to all applications, while
    567. 

  567.     // parameters only apply to specific app.
    568. 

  568.     property_get("persist.camera.thermal.mode", value, "fps");
    569. 

  569.     if (!strcmp(value, "frameskip")) {
    570. 

  570.         m_ThermalMode = QCAMERA_THERMAL_ADJUST_FRAMESKIP;
    571. 

  571.     } else {
    572. 

  572.         if (strcmp(value, "fps"))
    573. 

  573.             ALOGE("%s: Invalid camera thermal mode %s", __func__, value);
    574. 

  574.         m_ThermalMode = QCAMERA_THERMAL_ADJUST_FPS;
    575. 

  575.     }
    576. 

  576. 

  577.     memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize));
    578. 

  578. }
    579. 

  579. 

  580. /*===========================================================================
    581. 

  581.  * FUNCTION   : QCameraParameters
    582. 

  582.  *
    583. 

  583.  * DESCRIPTION: constructor of QCameraParameters
    584. 

  584.  *
    585. 

  585.  * PARAMETERS :
    586. 

  586.  *   @params  : parameters in string
    587. 

  587.  *
    588. 

  588.  * RETURN     : None
    589. 

  589.  *==========================================================================*/
    590. 

  590. QCameraParameters::QCameraParameters(const String8 &params)
    591. 

  591.     : CameraParameters(params),
    592. 

  592.     m_pCapability(NULL),
    593. 

  593.     m_pCamOpsTbl(NULL),
    594. 

  594.     m_pParamHeap(NULL),
    595. 

  595.     m_pParamBuf(NULL),
    596. 

  596.     m_bZslMode(false),
    597. 

  597.     m_bZslMode_new(false),
    598. 

  598.     m_bRecordingHint(false),
    599. 

  599.     m_bRecordingHint_new(false),
    600. 

  600.     m_bHistogramEnabled(false),
    601. 

  601.     m_nFaceProcMask(0),
    602. 

  602.     m_bDebugFps(false),
    603. 

  603.     mFocusMode(CAM_FOCUS_MODE_MAX),
    604. 

  604.     mPreviewFormat(CAM_FORMAT_YUV_420_NV21),
    605. 

  605.     mPictureFormat(CAM_FORMAT_JPEG),
    606. 

  606.     m_bNeedRestart(false),
    607. 

  607.     m_bNoDisplayMode(false),
    608. 

  608.     m_bWNROn(false),
    609. 

  609.     m_bNeedLockCAF(false),
    610. 

  610.     m_bCAFLocked(false),
    611. 

  611.     m_bAFRunning(false),
    612. 

  612.     m_tempMap()
    613. 

  613. {
    614. 

  614.     memset(&m_LiveSnapshotSize, 0, sizeof(m_LiveSnapshotSize));
    615. 

  615. }
    616. 

  616. 

  617. /*===========================================================================
    618. 

  618.  * FUNCTION   : ~QCameraParameters
    619. 

  619.  *
    620. 

  620.  * DESCRIPTION: deconstructor of QCameraParameters
    621. 

  621.  *
    622. 

  622.  * PARAMETERS : none
    623. 

  623.  *
    624. 

  624.  * RETURN     : None
    625. 

  625.  *==========================================================================*/
    626. 

  626. QCameraParameters::~QCameraParameters()
    627. 

  627. {
    628. 

  628.     deinit();
    629. 

  629. }
    630. 

  630. 

  631. /*===========================================================================
    632. 

  632.  * FUNCTION   : createSizesString
    633. 

  633.  *
    634. 

  634.  * DESCRIPTION: create string obj contains array of dimensions
    635. 

  635.  *
    636. 

  636.  * PARAMETERS :
    637. 

  637.  *   @sizes   : array of dimensions
    638. 

  638.  *   @len     : size of dimension array
    639. 

  639.  *
    640. 

  640.  * RETURN     : string obj
    641. 

  641.  *==========================================================================*/
    642. 

  642. String8 QCameraParameters::createSizesString(const cam_dimension_t *sizes, int len)
    643. 

  643. {
    644. 

  644.     String8 str;
    645. 

  645.     char buffer[32];
    646. 

  646. 

  647.     if (len > 0) {
    648. 

  648.         snprintf(buffer, sizeof(buffer), "%dx%d", sizes[0].width, sizes[0].height);
    649. 

  649.         str.append(buffer);
    650. 

  650.     }
    651. 

  651.     for (int i = 1; i < len; i++) {
    652. 

  652.         snprintf(buffer, sizeof(buffer), ",%dx%d", sizes[i].width, sizes[i].height);
    653. 

  653.         str.append(buffer);
    654. 

  654.     }
    655. 

  655.     return str;
    656. 

  656. }
    657. 

  657. 

  658. /*===========================================================================
    659. 

  659.  * FUNCTION   : createValuesString
    660. 

  660.  *
    661. 

  661.  * DESCRIPTION: create string obj contains array of values from map when matched
    662. 

  662.  *              from input values array
    663. 

  663.  *
    664. 

  664.  * PARAMETERS :
    665. 

  665.  *   @values  : array of values
    666. 

  666.  *   @len     : size of values array
    667. 

  667.  *   @map     : map contains the mapping between values and enums
    668. 

  668.  *   @map_len : size of the map
    669. 

  669.  *
    670. 

  670.  * RETURN     : string obj
    671. 

  671.  *==========================================================================*/
    672. 

  672. String8 QCameraParameters::createValuesString(const int *values,
    673. 

  673.                                               int len,
    674. 

  674.                                               const QCameraMap* map,
    675. 

  675.                                               int map_len)
    676. 

  676. {
    677. 

  677.     String8 str;
    678. 

  678.     int count = 0;
    679. 

  679. 

  680.     for (int i = 0; i < len; i++ ) {
    681. 

  681.         for (int j = 0; j < map_len; j ++)
    682. 

  682.             if (map[j].val == values[i]) {
    683. 

  683.                 if (NULL != map[j].desc) {
    684. 

  684.                     if (count > 0) {
    685. 

  685.                         str.append(",");
    686. 

  686.                     }
    687. 

  687.                     str.append(map[j].desc);
    688. 

  688.                     count++;
    689. 

  689.                     break; //loop j
    690. 

  690.                 }
    691. 

  691.             }
    692. 

  692.     }
    693. 

  693.     return str;
    694. 

  694. }
    695. 

  695. 

  696. /*===========================================================================
    697. 

  697.  * FUNCTION   : createValuesStringFromMap
    698. 

  698.  *
    699. 

  699.  * DESCRIPTION: create string obj contains array of values directly from map
    700. 

  700.  *
    701. 

  701.  * PARAMETERS :
    702. 

  702.  *   @map     : map contains the mapping between values and enums
    703. 

  703.  *   @map_len : size of the map
    704. 

  704.  *
    705. 

  705.  * RETURN     : string obj
    706. 

  706.  *==========================================================================*/
    707. 

  707. String8 QCameraParameters::createValuesStringFromMap(const QCameraMap* map,
    708. 

  708.                                                      int map_len)
    709. 

  709. {
    710. 

  710.     String8 str;
    711. 

  711. 

  712.     for (int i = 0; i < map_len; i++) {
    713. 

  713.         if (NULL != map[i].desc) {
    714. 

  714.             if (i > 0) {
    715. 

  715.                 str.append(",");
    716. 

  716.             }
    717. 

  717.             str.append(map[i].desc);
    718. 

  718.         }
    719. 

  719.     }
    720. 

  720.     return str;
    721. 

  721. }
    722. 

  722. 

  723. /*===========================================================================
    724. 

  724.  * FUNCTION   : createZoomRatioValuesString
    725. 

  725.  *
    726. 

  726.  * DESCRIPTION: create string obj contains array of zoom ratio values
    727. 

  727.  *
    728. 

  728.  * PARAMETERS :
    729. 

  729.  *   @zoomRaios  : array of zoom ratios
    730. 

  730.  *   @length     : size of the array
    731. 

  731.  *
    732. 

  732.  * RETURN     : string obj
    733. 

  733.  *==========================================================================*/
    734. 

  734. String8 QCameraParameters::createZoomRatioValuesString(int *zoomRatios, int length)
    735. 

  735. {
    736. 

  736.     String8 str;
    737. 

  737.     char buffer[32] = {0};
    738. 

  738. 

  739.     if(length > 0){
    740. 

  740.         snprintf(buffer, sizeof(buffer), "%d", zoomRatios[0]);
    741. 

  741.         str.append(buffer);
    742. 

  742.     }
    743. 

  743. 

  744.     for (int i =1;i<length;i++){
    745. 

  745.         memset(buffer, 0, sizeof(buffer));
    746. 

  746.         snprintf(buffer, sizeof(buffer), ",%d", zoomRatios[i]);
    747. 

  747.         str.append(buffer);
    748. 

  748.     }
    749. 

  749.     return str;
    750. 

  750. }
    751. 

  751. 

  752. /*===========================================================================
    753. 

  753.  * FUNCTION   : createHfrValuesString
    754. 

  754.  *
    755. 

  755.  * DESCRIPTION: create string obj contains array of hfr values from map when
    756. 

  756.  *              matched from input hfr values
    757. 

  757.  *
    758. 

  758.  * PARAMETERS :
    759. 

  759.  *   @values  : array of hfr info
    760. 

  760.  *   @len     : size of the array
    761. 

  761.  *   @map     : map of hfr string value and enum
    762. 

  762.  *   map_len  : size of map
    763. 

  763.  *
    764. 

  764.  * RETURN     : string obj
    765. 

  765.  *==========================================================================*/
    766. 

  766. String8 QCameraParameters::createHfrValuesString(
    767. 

  767.                                 const cam_hfr_info_t *values,
    768. 

  768.                                 int len,
    769. 

  769.                                 const QCameraMap* map,
    770. 

  770.                                 int map_len)
    771. 

  771. {
    772. 

  772.     String8 str;
    773. 

  773.     int count = 0;
    774. 

  774. 

  775.     for (int i = 0; i < len; i++ ) {
    776. 

  776.         for (int j = 0; j < map_len; j ++)
    777. 

  777.             if (map[j].val == (int)values[i].mode) {
    778. 

  778.                 if (NULL != map[j].desc) {
    779. 

  779.                     if (count > 0) {
    780. 

  780.                         str.append(",");
    781. 

  781.                     }
    782. 

  782.                      str.append(map[j].desc);
    783. 

  783.                      count++;
    784. 

  784.                      break; //loop j
    785. 

  785.                 }
    786. 

  786.             }
    787. 

  787.     }
    788. 

  788.     return str;
    789. 

  789. }
    790. 

  790. 

  791. /*===========================================================================
    792. 

  792.  * FUNCTION   : createHfrSizesString
    793. 

  793.  *
    794. 

  794.  * DESCRIPTION: create string obj contains array of hfr sizes
    795. 

  795.  *
    796. 

  796.  * PARAMETERS :
    797. 

  797.  *   @values  : array of hfr info
    798. 

  798.  *   @len     : size of the array
    799. 

  799.  *
    800. 

  800.  * RETURN     : string obj
    801. 

  801.  *==========================================================================*/
    802. 

  802. String8 QCameraParameters::createHfrSizesString(
    803. 

  803.                                 const cam_hfr_info_t *values,
    804. 

  804.                                 int len)
    805. 

  805. {
    806. 

  806.     String8 str;
    807. 

  807.     char buffer[32];
    808. 

  808. 

  809.     if (len > 0) {
    810. 

  810.         snprintf(buffer, sizeof(buffer), "%dx%d",
    811. 

  811.                  values[0].dim.width, values[0].dim.height);
    812. 

  812.         str.append(buffer);
    813. 

  813.     }
    814. 

  814.     for (int i = 1; i < len; i++) {
    815. 

  815.         snprintf(buffer, sizeof(buffer), ",%dx%d",
    816. 

  816.                  values[i].dim.width, values[i].dim.height);
    817. 

  817.         str.append(buffer);
    818. 

  818.     }
    819. 

  819.     return str;
    820. 

  820. }
    821. 

  821. 

  822. /*===========================================================================
    823. 

  823.  * FUNCTION   : compareFPSValues
    824. 

  824.  *
    825. 

  825.  * DESCRIPTION: helper function for fps sorting
    826. 

  826.  *
    827. 

  827.  * PARAMETERS :
    828. 

  828.  *   @p1     : first array element
    829. 

  829.  *   @p2     : second array element
    830. 

  830.  *
    831. 

  831.  * RETURN     : -1 - left element is greater than right
    832. 

  832.  *              0  - elements are equals
    833. 

  833.  *              1  - left element is less than right
    834. 

  834.  *==========================================================================*/
    835. 

  835. int QCameraParameters::compareFPSValues(const void *p1, const void *p2)
    836. 

  836. {
    837. 

  837.     if ( *( (int *) p1) > *( (int *) p2) ) {
    838. 

  838.         return -1;
    839. 

  839.     } else if (  *( (int *) p1) < *( (int *) p2) ) {
    840. 

  840.         return 1;
    841. 

  841.     }
    842. 

  842. 

  843.     return 0;
    844. 

  844. }
    845. 

  845. 

  846. /*===========================================================================
    847. 

  847.  * FUNCTION   : createFpsString
    848. 

  848.  *
    849. 

  849.  * DESCRIPTION: create string obj contains array of FPS rates
    850. 

  850.  *
    851. 

  851.  * PARAMETERS :
    852. 

  852.  *   @fps     : array of fps ranges
    853. 

  853.  *   @len     : size of the array
    854. 

  854.  *
    855. 

  855.  * RETURN     : string obj
    856. 

  856.  *==========================================================================*/
    857. 

  857. String8 QCameraParameters::createFpsString(const cam_fps_range_t *fps, int len)
    858. 

  858. {
    859. 

  859.     String8 str;
    860. 

  860.     char buffer[32];
    861. 

  861.     int duplicate = INT_MAX;
    862. 

  862. 

  863.     int *fpsValues = new int[len];
    864. 

  864. 

  865.     for (int i = 0; i < len; i++ ) {
    866. 

  866.         fpsValues[i] = int(fps[i].max_fps);
    867. 

  867.     }
    868. 

  868. 

  869.     qsort(fpsValues, len, sizeof(int), compareFPSValues);
    870. 

  870. 

  871.     for (int i = 0; i < len; i++ ) {
    872. 

  872.         if ( duplicate != fpsValues[i] ) {
    873. 

  873.             snprintf(buffer, sizeof(buffer), "%d", fpsValues[i]);
    874. 

  874.             str.append(buffer);
    875. 

  875.             if (i < len-1) {
    876. 

  876.                 str.append(",");
    877. 

  877.             }
    878. 

  878.             duplicate = fpsValues[i];
    879. 

  879.         }
    880. 

  880.     }
    881. 

  881. 

  882.     delete [] fpsValues;
    883. 

  883. 

  884.     return str;
    885. 

  885. }
    886. 

  886. 

  887. /*===========================================================================
    888. 

  888.  * FUNCTION   : createFpsRangeString
    889. 

  889.  *
    890. 

  890.  * DESCRIPTION: create string obj contains array of FPS ranges
    891. 

  891.  *
    892. 

  892.  * PARAMETERS :
    893. 

  893.  *   @fps     : array of fps ranges
    894. 

  894.  *   @len     : size of the array
    895. 

  895.  *   @default_fps_index : reference to index of default fps range
    896. 

  896.  *
    897. 

  897.  * RETURN     : string obj
    898. 

  898.  *==========================================================================*/
    899. 

  899. String8 QCameraParameters::createFpsRangeString(const cam_fps_range_t* fps,
    900. 

  900.                                                 int len,
    901. 

  901.                                                 int &default_fps_index)
    902. 

  902. {
    903. 

  903.     String8 str;
    904. 

  904.     char buffer[32];
    905. 

  905.     int max_range = 0;
    906. 

  906.     int min_fps, max_fps;
    907. 

  907. 

  908.     if (len > 0) {
    909. 

  909.         min_fps = int(fps[0].min_fps * 1000);
    910. 

  910.         max_fps = int(fps[0].max_fps * 1000);
    911. 

  911.         max_range = max_fps - min_fps;
    912. 

  912.         default_fps_index = 0;
    913. 

  913.         snprintf(buffer, sizeof(buffer), "(%d,%d)", min_fps, max_fps);
    914. 

  914.         str.append(buffer);
    915. 

  915.     }
    916. 

  916.     for (int i = 1; i < len; i++) {
    917. 

  917.         min_fps = int(fps[i].min_fps * 1000);
    918. 

  918.         max_fps = int(fps[i].max_fps * 1000);
    919. 

  919.         if (max_range < (max_fps - min_fps)) {
    920. 

  920.             max_range = max_fps - min_fps;
    921. 

  921.             default_fps_index = i;
    922. 

  922.         }
    923. 

  923.         snprintf(buffer, sizeof(buffer), ",(%d,%d)", min_fps, max_fps);
    924. 

  924.         str.append(buffer);
    925. 

  925.     }
    926. 

  926.     return str;
    927. 

  927. }
    928. 

  928. 

  929. /*===========================================================================
    930. 

  930.  * FUNCTION   : lookupAttr
    931. 

  931.  *
    932. 

  932.  * DESCRIPTION: lookup a value by its name
    933. 

  933.  *
    934. 

  934.  * PARAMETERS :
    935. 

  935.  *   @attr    : map contains <name, value>
    936. 

  936.  *   @len     : size of the map
    937. 

  937.  *   @name    : name to be looked up
    938. 

  938.  *
    939. 

  939.  * RETURN     : valid value if found
    940. 

  940.  *              NAME_NOT_FOUND if not found
    941. 

  941.  *==========================================================================*/
    942. 

  942. int QCameraParameters::lookupAttr(const QCameraMap arr[], int len, const char *name)
    943. 

  943. {
    944. 

  944.     if (name) {
    945. 

  945.         for (int i = 0; i < len; i++) {
    946. 

  946.             if (!strcmp(arr[i].desc, name))
    947. 

  947.                 return arr[i].val;
    948. 

  948.         }
    949. 

  949.     }
    950. 

  950.     return NAME_NOT_FOUND;
    951. 

  951. }
    952. 

  952. 

  953. /*===========================================================================
    954. 

  954.  * FUNCTION   : lookupNameByValue
    955. 

  955.  *
    956. 

  956.  * DESCRIPTION: lookup a name by its value
    957. 

  957.  *
    958. 

  958.  * PARAMETERS :
    959. 

  959.  *   @attr    : map contains <name, value>
    960. 

  960.  *   @len     : size of the map
    961. 

  961.  *   @value   : value to be looked up
    962. 

  962.  *
    963. 

  963.  * RETURN     : name str or NULL if not found
    964. 

  964.  *==========================================================================*/
    965. 

  965. const char *QCameraParameters::lookupNameByValue(const QCameraMap arr[], int len, int value)
    966. 

  966. {
    967. 

  967.     for (int i = 0; i < len; i++) {
    968. 

  968.         if (arr[i].val == value) {
    969. 

  969.             return arr[i].desc;
    970. 

  970.         }
    971. 

  971.     }
    972. 

  972.     return NULL;
    973. 

  973. }
    974. 

  974. 

  975. /*===========================================================================
    976. 

  976.  * FUNCTION   : setPreviewSize
    977. 

  977.  *
    978. 

  978.  * DESCRIPTION: set preview size from user setting
    979. 

  979.  *
    980. 

  980.  * PARAMETERS :
    981. 

  981.  *   @params  : user setting parameters
    982. 

  982.  *
    983. 

  983.  * RETURN     : int32_t type of status
    984. 

  984.  *              NO_ERROR  -- success
    985. 

  985.  *              none-zero failure code
    986. 

  986.  *==========================================================================*/
    987. 

  987. int32_t QCameraParameters::setPreviewSize(const QCameraParameters& params)
    988. 

  988. {
    989. 

  989.     int width, height;
    990. 

  990.     params.getPreviewSize(&width, &height);
    991. 

  991.     ALOGV("Requested preview size %d x %d", width, height);
    992. 

  992. 

  993.     // Validate the preview size
    994. 

  994.     for (size_t i = 0; i < m_pCapability->preview_sizes_tbl_cnt; ++i) {
    995. 

  995.         if (width ==  m_pCapability->preview_sizes_tbl[i].width
    996. 

  996.            && height ==  m_pCapability->preview_sizes_tbl[i].height) {
    997. 

  997.             // check if need to restart preview in case of preview size change
    998. 

  998.             int old_width, old_height;
    999. 

  999.             CameraParameters::getPreviewSize(&old_width, &old_height);
    1000. 

  1000.             if (width != old_width || height != old_height) {
    1001. 

  1001.                 m_bNeedRestart = true;
    1002. 

  1002.             }
    1003. 

  1003. 

  1004.             // set the new value
    1005. 

  1005.             CameraParameters::setPreviewSize(width, height);
    1006. 

  1006.             return NO_ERROR;
    1007. 

  1007.         }
    1008. 

  1008.     }
    1009. 

  1009.     ALOGE("Invalid preview size requested: %dx%d", width, height);
    1010. 

  1010.     return BAD_VALUE;
    1011. 

  1011. }
    1012. 

  1012. 

  1013. /*===========================================================================
    1014. 

  1014.  * FUNCTION   : setPictureSize
    1015. 

  1015.  *
    1016. 

  1016.  * DESCRIPTION: set picture size from user setting
    1017. 

  1017.  *
    1018. 

  1018.  * PARAMETERS :
    1019. 

  1019.  *   @params  : user setting parameters
    1020. 

  1020.  *
    1021. 

  1021.  * RETURN     : int32_t type of status
    1022. 

  1022.  *              NO_ERROR  -- success
    1023. 

  1023.  *              none-zero failure code
    1024. 

  1024.  *==========================================================================*/
    1025. 

  1025. int32_t QCameraParameters::setPictureSize(const QCameraParameters& params)
    1026. 

  1026. {
    1027. 

  1027.     int width, height;
    1028. 

  1028.     params.getPictureSize(&width, &height);
    1029. 

  1029.     ALOGV("Requested picture size %d x %d", width, height);
    1030. 

  1030. 

  1031.     // Validate the picture size
    1032. 

  1032.     for (size_t i = 0; i < m_pCapability->picture_sizes_tbl_cnt; ++i) {
    1033. 

  1033.         if (width ==  m_pCapability->picture_sizes_tbl[i].width
    1034. 

  1034.            && height ==  m_pCapability->picture_sizes_tbl[i].height) {
    1035. 

  1035.             // check if need to restart preview in case of picture size change
    1036. 

  1036.             int old_width, old_height;
    1037. 

  1037.             CameraParameters::getPictureSize(&old_width, &old_height);
    1038. 

  1038.             if ((m_bZslMode || m_bRecordingHint) &&
    1039. 

  1039.                 (width != old_width || height != old_height)) {
    1040. 

  1040.                 m_bNeedRestart = true;
    1041. 

  1041.             }
    1042. 

  1042. 

  1043.             // set the new value
    1044. 

  1044.             CameraParameters::setPictureSize(width, height);
    1045. 

  1045.             return NO_ERROR;
    1046. 

  1046.         }
    1047. 

  1047.     }
    1048. 

  1048.     ALOGE("Invalid picture size requested: %dx%d", width, height);
    1049. 

  1049.     return BAD_VALUE;
    1050. 

  1050. }
    1051. 

  1051. 

  1052. /*===========================================================================
    1053. 

  1053.  * FUNCTION   : setVideoSize
    1054. 

  1054.  *
    1055. 

  1055.  * DESCRIPTION: set video size from user setting
    1056. 

  1056.  *
    1057. 

  1057.  * PARAMETERS :
    1058. 

  1058.  *   @params  : user setting parameters
    1059. 

  1059.  *
    1060. 

  1060.  * RETURN     : int32_t type of status
    1061. 

  1061.  *              NO_ERROR  -- success
    1062. 

  1062.  *              none-zero failure code
    1063. 

  1063.  *==========================================================================*/
    1064. 

  1064. int32_t QCameraParameters::setVideoSize(const QCameraParameters& params)
    1065. 

  1065. {
    1066. 

  1066.     const char *str= NULL;
    1067. 

  1067.     int width, height;
    1068. 

  1068.     str = params.get(KEY_VIDEO_SIZE);
    1069. 

  1069.     if(!str) {
    1070. 

  1070.         //If application didn't set this parameter string, use the values from
    1071. 

  1071.         //getPreviewSize() as video dimensions.
    1072. 

  1072.         params.getPreviewSize(&width, &height);
    1073. 

  1073.         AL…
    1074.

Large files files are truncated, but you can click here to view the full file