libcamera2/ExynosCamera2.cpp

   1 /*
   2 **
   3 ** Copyright 2008, The Android Open Source Project
   4 ** Copyright 2012, Samsung Electronics Co. LTD
   5 **
   6 ** Licensed under the Apache License, Version 2.0 (the "License");
   7 ** you may not use this file except in compliance with the License.
   8 ** You may obtain a copy of the License at
   9 **
  10 **     http://www.apache.org/licenses/LICENSE-2.0
  11 **
  12 ** Unless required by applicable law or agreed to in writing, software
  13 ** distributed under the License is distributed on an "AS IS" BASIS,
  14 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 ** See the License for the specific language governing permissions and
  16 ** limitations under the License.
  17 */
  18
  19 /*!
  20  * \file      ExynosCamera2.cpp
  21  * \brief     source file for static information of camera2
  22  * \author    Sungjoong Kang(sj3.kang@samsung.com)
  23  * \date      2012/08/06
  24  *
  25  * <b>Revision History: </b>
  26  * - 2012/08/06 : Sungjoong Kang(sj3.kang@samsung.com) \n
  27  *   Initial Release
  28  *
  29  */
  30
  31 //#define LOG_NDEBUG 0
  32 #define LOG_TAG "ExynosCamera2"
  33 #include <utils/Log.h>
  34
  35 #include "ExynosCamera2.h"
  36
  37 #define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
  38
  39 namespace android {
  40
  41 class Sensor {
  42 public:
  43     /**
  44      * Static sensor characteristics
  45      */
  46     static const unsigned int kResolution[2][2];
  47
  48     static const nsecs_t kExposureTimeRange[2];
  49     static const nsecs_t kFrameDurationRange[2];
  50     static const nsecs_t kMinVerticalBlank;
  51
  52     static const uint8_t kColorFilterArrangement;
  53
  54     // Output image data characteristics
  55     static const uint32_t kMaxRawValue;
  56     static const uint32_t kBlackLevel;
  57     // Sensor sensitivity, approximate
  58
  59     static const float kSaturationVoltage;
  60     static const uint32_t kSaturationElectrons;
  61     static const float kVoltsPerLuxSecond;
  62     static const float kElectronsPerLuxSecond;
  63
  64     static const float kBaseGainFactor;
  65
  66     static const float kReadNoiseStddevBeforeGain; // In electrons
  67     static const float kReadNoiseStddevAfterGain;  // In raw digital units
  68     static const float kReadNoiseVarBeforeGain;
  69     static const float kReadNoiseVarAfterGain;
  70
  71     // While each row has to read out, reset, and then expose, the (reset +
  72     // expose) sequence can be overlapped by other row readouts, so the final
  73     // minimum frame duration is purely a function of row readout time, at least
  74     // if there's a reasonable number of rows.
  75     static const nsecs_t kRowReadoutTime;
  76
  77     static const uint32_t kAvailableSensitivities[5];
  78     static const uint32_t kDefaultSensitivity;
  79
  80 };
  81
  82
  83
  84 const uint32_t Sensor::kAvailableSensitivities[5] =
  85     {100, 200, 400, 800, 1600};
  86 const nsecs_t Sensor::kExposureTimeRange[2] =
  87     {1000L, 30000000000L} ; // 1 us - 30 sec
  88 const nsecs_t Sensor::kFrameDurationRange[2] =
  89     {33331760L, 30000000000L}; // ~1/30 s - 30 sec
  90
  91 const uint8_t Sensor::kColorFilterArrangement = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB;
  92
  93 const uint32_t kAvailableFormats[5] = {
  94         HAL_PIXEL_FORMAT_RAW_SENSOR,
  95         HAL_PIXEL_FORMAT_BLOB,
  96         HAL_PIXEL_FORMAT_RGBA_8888,
  97         HAL_PIXEL_FORMAT_YV12,
  98         HAL_PIXEL_FORMAT_YCrCb_420_SP
  99 };
 100
 101 // Output image data characteristics
 102 const uint32_t Sensor::kMaxRawValue = 4000;
 103 const uint32_t Sensor::kBlackLevel  = 1000;
 104
 105 const uint64_t kAvailableRawMinDurations[1] = {
 106     Sensor::kFrameDurationRange[0]
 107 };
 108
 109 const uint64_t kAvailableProcessedMinDurations[1] = {
 110     Sensor::kFrameDurationRange[0]
 111 };
 112 const uint64_t kAvailableJpegMinDurations[1] = {
 113     Sensor::kFrameDurationRange[0]
 114 };
 115
 116 const int32_t scalerResolutionS5K4E5[] =
 117 {
 118     1920, 1080, // 16:9
 119     1440, 1080, // 4:3
 120     1440,  960, // 3:2
 121     1280, 1024, // 5:4
 122     1280,  720, // 16:9
 123      960,  720, // 4:3
 124      800,  480, // 5:3
 125      768,  576, // 4:3
 126      720,  576, // 5:4
 127      720,  480, // 3:2
 128      640,  480, // 4:3
 129      352,  288, // 11:9
 130      320,  240, // 4:3
 131      240,  160, // 3:2
 132      176,  144, // 6:5
 133      128,   96, // 4:3
 134 };
 135
 136 const int32_t jpegResolutionS5K4E5[] =
 137 {
 138     2560, 1920,
 139     2560, 1440,
 140     2160, 1440,
 141     2048, 1536,
 142     1600, 1200,
 143     1280, 1024,
 144     1280,  960,
 145     1152,  864,
 146      640,  480,
 147      320,  240,
 148 };
 149
 150 const uint8_t availableAfModesS5K4E5[] =
 151 {
 152     ANDROID_CONTROL_AF_MODE_OFF,
 153     ANDROID_CONTROL_AF_MODE_AUTO,
 154     ANDROID_CONTROL_AF_MODE_MACRO,
 155     ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
 156     ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO
 157 };
 158
 159 const uint8_t sceneModeOverridesS5K4E5[] =
 160 {
 161     // ANDROID_CONTROL_SCENE_MODE_ACTION
 162     ANDROID_CONTROL_AE_MODE_ON,
 163     ANDROID_CONTROL_AWB_MODE_AUTO,
 164     ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
 165     // ANDROID_CONTROL_SCENE_MODE_NIGHT
 166     ANDROID_CONTROL_AE_MODE_ON,
 167     ANDROID_CONTROL_AWB_MODE_AUTO,
 168     ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
 169     // ANDROID_CONTROL_SCENE_MODE_SUNSET
 170     ANDROID_CONTROL_AE_MODE_ON,
 171     ANDROID_CONTROL_AWB_MODE_DAYLIGHT,
 172     ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
 173     // ANDROID_CONTROL_SCENE_MODE_PARTY
 174     ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH,
 175     ANDROID_CONTROL_AWB_MODE_AUTO,
 176     ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE
 177 };
 178
 179 const uint8_t availableAeModesS5K4E5[] =
 180 {
 181     ANDROID_CONTROL_AE_MODE_OFF,
 182     ANDROID_CONTROL_AE_MODE_ON,
 183     ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH
 184 };
 185
 186 ExynosCamera2InfoS5K4E5::ExynosCamera2InfoS5K4E5()
 187 {
 188     sensorW             = 2560;
 189     sensorH             = 1920;
 190     sensorRawW          = (2560 + 16);
 191     sensorRawH          = (1920 + 10);
 192     numScalerResolution = ARRAY_SIZE(scalerResolutionS5K4E5)/2;
 193     scalerResolutions   = scalerResolutionS5K4E5;
 194     numJpegResolution   = ARRAY_SIZE(jpegResolutionS5K4E5)/2;
 195     jpegResolutions     = jpegResolutionS5K4E5;
 196     minFocusDistance    = 0.1f;
 197     focalLength         = 3.43f;
 198     aperture            = 2.7f;
 199     fnumber             = 2.7f;
 200     availableAfModes    = availableAfModesS5K4E5;
 201     numAvailableAfModes = ARRAY_SIZE(availableAfModesS5K4E5);
 202     sceneModeOverrides  = sceneModeOverridesS5K4E5;
 203     numSceneModeOverrides = ARRAY_SIZE(sceneModeOverridesS5K4E5);
 204     availableAeModes    = availableAeModesS5K4E5;
 205     numAvailableAeModes = ARRAY_SIZE(availableAeModesS5K4E5);
 206 }
 207
 208 ExynosCamera2InfoS5K4E5::~ExynosCamera2InfoS5K4E5()
 209 {
 210     ALOGV("%s", __FUNCTION__);
 211 }
 212 const int32_t scalerResolutionS5K6A3[] =
 213 {
 214     1344,  896, // 3:2
 215     1280, 1024, // 5:4
 216     1024, 1024, // 1:1
 217     1280,  960, // 4:3
 218     1280,  720, // 16:9
 219      960,  720, // 4:3
 220      800,  480, // 5:3
 221      768,  576, // 4:3
 222      720,  576, // 5:4
 223      720,  480, // 3:2
 224      640,  480, // 4:3
 225      352,  288, // 11:9
 226      320,  240, // 4:3
 227      240,  160, // 3:2
 228      176,  144, // 6:5
 229      128,   96, // 4:3
 230 };
 231
 232 const int32_t jpegResolutionS5K6A3[] =
 233 {
 234     1392, 1392,
 235     1392, 1040,
 236     1392,  928,
 237     1392,  784,
 238     1280, 1024,
 239     1280,  960,
 240     1280,  720,
 241     1152,  864,
 242      640,  480,
 243      320,  240,
 244 };
 245
 246 const uint8_t availableAfModesS5K6A3[] =
 247 {
 248     ANDROID_CONTROL_AF_MODE_OFF
 249 };
 250
 251 const uint8_t sceneModeOverridesS5K6A3[] =
 252 {
 253     // ANDROID_CONTROL_SCENE_MODE_ACTION
 254     ANDROID_CONTROL_AE_MODE_ON,
 255     ANDROID_CONTROL_AWB_MODE_AUTO,
 256     ANDROID_CONTROL_AF_MODE_OFF,
 257     // ANDROID_CONTROL_SCENE_MODE_NIGHT
 258     ANDROID_CONTROL_AE_MODE_ON,
 259     ANDROID_CONTROL_AWB_MODE_AUTO,
 260     ANDROID_CONTROL_AF_MODE_OFF,
 261     // ANDROID_CONTROL_SCENE_MODE_SUNSET
 262     ANDROID_CONTROL_AE_MODE_ON,
 263     ANDROID_CONTROL_AWB_MODE_DAYLIGHT,
 264     ANDROID_CONTROL_AF_MODE_OFF,
 265     // ANDROID_CONTROL_SCENE_MODE_PARTY
 266     ANDROID_CONTROL_AE_MODE_ON,
 267     ANDROID_CONTROL_AWB_MODE_AUTO,
 268     ANDROID_CONTROL_AF_MODE_OFF
 269 };
 270
 271 const uint8_t availableAeModesS5K6A3[] =
 272 {
 273     ANDROID_CONTROL_AE_MODE_OFF,
 274     ANDROID_CONTROL_AE_MODE_ON
 275 };
 276
 277 ExynosCamera2InfoS5K6A3::ExynosCamera2InfoS5K6A3()
 278 {
 279     sensorW     = 1392;
 280     sensorH     = 1392;
 281     sensorRawW  = (1392 + 16);
 282     sensorRawH  = (1392 + 10);
 283     numScalerResolution = ARRAY_SIZE(scalerResolutionS5K6A3)/2;
 284     scalerResolutions   = scalerResolutionS5K6A3;
 285     numJpegResolution   = ARRAY_SIZE(jpegResolutionS5K6A3)/2;
 286     jpegResolutions     = jpegResolutionS5K6A3;
 287     minFocusDistance    = 0.0f;
 288     focalLength         = 2.73f;
 289     aperture            = 2.8f;
 290     fnumber             = 2.8f;
 291     availableAfModes    = availableAfModesS5K6A3;
 292     numAvailableAfModes = ARRAY_SIZE(availableAfModesS5K6A3);
 293     sceneModeOverrides  = sceneModeOverridesS5K6A3;
 294     numSceneModeOverrides = ARRAY_SIZE(sceneModeOverridesS5K6A3);
 295     availableAeModes    = availableAeModesS5K6A3;
 296     numAvailableAeModes = ARRAY_SIZE(availableAeModesS5K6A3);
 297 }
 298
 299 ExynosCamera2InfoS5K6A3::~ExynosCamera2InfoS5K6A3()
 300 {
 301     ALOGV("%s", __FUNCTION__);
 302 }
 303 ExynosCamera2::ExynosCamera2(int cameraId):
 304     m_cameraId(cameraId)
 305 {
 306     if (cameraId == 0)
 307         m_curCameraInfo      = new ExynosCamera2InfoS5K4E5;
 308     else
 309         m_curCameraInfo      = new ExynosCamera2InfoS5K6A3;
 310 }
 311
 312 ExynosCamera2::~ExynosCamera2()
 313 {
 314     ALOGV("%s", __FUNCTION__);
 315         delete m_curCameraInfo;
 316     m_curCameraInfo = NULL;
 317 }
 318
 319 int32_t ExynosCamera2::getSensorW()
 320 {
 321     return m_curCameraInfo->sensorW;
 322 }
 323
 324 int32_t ExynosCamera2::getSensorH()
 325 {
 326     return m_curCameraInfo->sensorH;
 327 }
 328
 329 int32_t ExynosCamera2::getSensorRawW()
 330 {
 331     return m_curCameraInfo->sensorRawW;
 332 }
 333
 334 int32_t ExynosCamera2::getSensorRawH()
 335 {
 336     return m_curCameraInfo->sensorRawH;
 337 }
 338
 339 bool ExynosCamera2::isSupportedResolution(int width, int height)
 340 {
 341     int i;
 342     for (i = 0 ; i < m_curCameraInfo->numScalerResolution ; i++) {
 343         if (m_curCameraInfo->scalerResolutions[2*i] == width
 344                 && m_curCameraInfo->scalerResolutions[2*i+1] == height) {
 345             return true;
 346         }
 347     }
 348     return false;
 349 }
 350
 351 bool ExynosCamera2::isSupportedJpegResolution(int width, int height)
 352 {
 353     int i;
 354     for (i = 0 ; i < m_curCameraInfo->numJpegResolution ; i++) {
 355         if (m_curCameraInfo->jpegResolutions[2*i] == width
 356                 && m_curCameraInfo->jpegResolutions[2*i+1] == height) {
 357             return true;
 358         }
 359     }
 360     return false;
 361 }
 362
 363 status_t addOrSize(camera_metadata_t *request,
 364         bool sizeRequest,
 365         size_t *entryCount,
 366         size_t *dataCount,
 367         uint32_t tag,
 368         const void *entryData,
 369         size_t entryDataCount) {
 370     status_t res;
 371     if (!sizeRequest) {
 372         return add_camera_metadata_entry(request, tag, entryData,
 373                 entryDataCount);
 374     } else {
 375         int type = get_camera_metadata_tag_type(tag);
 376         if (type < 0 ) return BAD_VALUE;
 377         (*entryCount)++;
 378         (*dataCount) += calculate_camera_metadata_entry_data_size(type,
 379                 entryDataCount);
 380         return OK;
 381     }
 382 }
 383
 384 status_t ExynosCamera2::constructStaticInfo(camera_metadata_t **info,
 385         int cameraId, bool sizeRequest) {
 386
 387     size_t entryCount = 0;
 388     size_t dataCount = 0;
 389     status_t ret;
 390
 391 #define ADD_OR_SIZE( tag, data, count ) \
 392     if ( ( ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, \
 393             tag, data, count) ) != OK ) return ret
 394
 395     // android.lens
 396
 397     ADD_OR_SIZE(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
 398             &(m_curCameraInfo->minFocusDistance), 1);
 399     ADD_OR_SIZE(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
 400             &(m_curCameraInfo->minFocusDistance), 1);
 401
 402     ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
 403             &m_curCameraInfo->focalLength, 1);
 404     ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
 405             &m_curCameraInfo->aperture, 1);
 406
 407     static const float filterDensity = 0;
 408     ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
 409             &filterDensity, 1);
 410     static const uint8_t availableOpticalStabilization =
 411             ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
 412     ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
 413             &availableOpticalStabilization, 1);
 414
 415     static const int32_t lensShadingMapSize[] = {1, 1};
 416     ADD_OR_SIZE(ANDROID_LENS_INFO_SHADING_MAP_SIZE, lensShadingMapSize,
 417             sizeof(lensShadingMapSize)/sizeof(int32_t));
 418
 419     static const float lensShadingMap[3 * 1 * 1 ] =
 420             { 1.f, 1.f, 1.f };
 421     ADD_OR_SIZE(ANDROID_LENS_INFO_SHADING_MAP, lensShadingMap,
 422             sizeof(lensShadingMap)/sizeof(float));
 423
 424     int32_t lensFacing = cameraId ?
 425             ANDROID_LENS_FACING_FRONT : ANDROID_LENS_FACING_BACK;
 426     ADD_OR_SIZE(ANDROID_LENS_FACING, &lensFacing, 1);
 427
 428     // android.sensor
 429     ADD_OR_SIZE(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
 430             Sensor::kExposureTimeRange, 2);
 431
 432     ADD_OR_SIZE(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
 433             &Sensor::kFrameDurationRange[1], 1);
 434
 435     ADD_OR_SIZE(ANDROID_SENSOR_INFO_AVAILABLE_SENSITIVITIES,
 436             Sensor::kAvailableSensitivities,
 437             sizeof(Sensor::kAvailableSensitivities)
 438             /sizeof(uint32_t));
 439
 440     ADD_OR_SIZE(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
 441             &Sensor::kColorFilterArrangement, 1);
 442
 443     // Empirically derived to get correct FOV measurements
 444     static const float sensorPhysicalSize[2] = {3.50f, 2.625f}; // mm
 445     ADD_OR_SIZE(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
 446             sensorPhysicalSize, 2);
 447
 448     int32_t pixelArraySize[2] = {
 449         m_curCameraInfo->sensorW, m_curCameraInfo->sensorH
 450     };
 451     ADD_OR_SIZE(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, pixelArraySize, 2);
 452     ADD_OR_SIZE(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, pixelArraySize,2);
 453
 454     ADD_OR_SIZE(ANDROID_SENSOR_INFO_WHITE_LEVEL,
 455             &Sensor::kMaxRawValue, 1);
 456
 457     static const int32_t blackLevelPattern[4] = {
 458             Sensor::kBlackLevel, Sensor::kBlackLevel,
 459             Sensor::kBlackLevel, Sensor::kBlackLevel
 460     };
 461     ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
 462             blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t));
 463
 464     //TODO: sensor color calibration fields
 465
 466     // android.flash
 467     uint8_t flashAvailable;
 468     if (cameraId == 0)
 469         flashAvailable = 1;
 470     else
 471         flashAvailable = 0;
 472     ADD_OR_SIZE(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1);
 473
 474     static const int64_t flashChargeDuration = 0;
 475     ADD_OR_SIZE(ANDROID_FLASH_INFO_CHARGE_DURATION, &flashChargeDuration, 1);
 476
 477     // android.tonemap
 478
 479     static const int32_t tonemapCurvePoints = 128;
 480     ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1);
 481
 482     // android.scaler
 483
 484     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS,
 485             kAvailableFormats,
 486             sizeof(kAvailableFormats)/sizeof(uint32_t));
 487
 488     int32_t availableRawSizes[2] = {
 489         m_curCameraInfo->sensorRawW, m_curCameraInfo->sensorRawH
 490     };
 491     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
 492             availableRawSizes, 2);
 493
 494     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
 495             kAvailableRawMinDurations,
 496             sizeof(kAvailableRawMinDurations)/sizeof(uint64_t));
 497
 498
 499     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
 500         m_curCameraInfo->scalerResolutions,
 501         (m_curCameraInfo->numScalerResolution)*2);
 502     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
 503         m_curCameraInfo->jpegResolutions,
 504         (m_curCameraInfo->numJpegResolution)*2);
 505
 506     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
 507             kAvailableProcessedMinDurations,
 508             sizeof(kAvailableProcessedMinDurations)/sizeof(uint64_t));
 509
 510     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
 511             kAvailableJpegMinDurations,
 512             sizeof(kAvailableJpegMinDurations)/sizeof(uint64_t));
 513
 514     static const float maxZoom = 4;
 515     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, &maxZoom, 1);
 516
 517     // android.jpeg
 518
 519     static const int32_t jpegThumbnailSizes[] = {
 520             160, 120,
 521             160, 160,
 522             160, 90,
 523             144, 96,
 524               0, 0
 525     };
 526
 527     ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
 528             jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t));
 529
 530     static const int32_t jpegMaxSize = 10 * 1024 * 1024;
 531     ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1);
 532
 533     // android.stats
 534
 535     static const uint8_t availableFaceDetectModes[] = {
 536             ANDROID_STATISTICS_FACE_DETECT_MODE_OFF,
 537             ANDROID_STATISTICS_FACE_DETECT_MODE_FULL
 538     };
 539     ADD_OR_SIZE(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
 540             availableFaceDetectModes,
 541             sizeof(availableFaceDetectModes));
 542
 543     m_curCameraInfo->maxFaceCount = CAMERA2_MAX_FACES;
 544     ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
 545             &(m_curCameraInfo->maxFaceCount), 1);
 546
 547     static const int32_t histogramSize = 64;
 548     ADD_OR_SIZE(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
 549             &histogramSize, 1);
 550
 551     static const int32_t maxHistogramCount = 1000;
 552     ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
 553             &maxHistogramCount, 1);
 554
 555     static const int32_t sharpnessMapSize[2] = {64, 64};
 556     ADD_OR_SIZE(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,
 557             sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t));
 558
 559     static const int32_t maxSharpnessMapValue = 1000;
 560     ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
 561             &maxSharpnessMapValue, 1);
 562
 563     // android.control
 564
 565     static const uint8_t availableSceneModes[] = {
 566             ANDROID_CONTROL_SCENE_MODE_ACTION,
 567             ANDROID_CONTROL_SCENE_MODE_NIGHT,
 568             ANDROID_CONTROL_SCENE_MODE_SUNSET,
 569             ANDROID_CONTROL_SCENE_MODE_PARTY
 570     };
 571     ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
 572             availableSceneModes, sizeof(availableSceneModes));
 573
 574     static const uint8_t availableEffects[] = {
 575             ANDROID_CONTROL_EFFECT_MODE_OFF
 576     };
 577     ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS,
 578             availableEffects, sizeof(availableEffects));
 579
 580     int32_t max3aRegions = 1;
 581     ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS,
 582             &max3aRegions, 1);
 583
 584     ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES,
 585             m_curCameraInfo->availableAeModes, m_curCameraInfo->numAvailableAeModes);
 586
 587     static const camera_metadata_rational exposureCompensationStep = {
 588             1, 1
 589     };
 590     ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_STEP,
 591             &exposureCompensationStep, 1);
 592
 593     int32_t exposureCompensationRange[] = {-3, 3};
 594     ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
 595             exposureCompensationRange,
 596             sizeof(exposureCompensationRange)/sizeof(int32_t));
 597
 598     static const int32_t availableTargetFpsRanges[] = {
 599             15, 15, 24, 24, 25, 25, 15, 30, 30, 30
 600     };
 601     ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
 602             availableTargetFpsRanges,
 603             sizeof(availableTargetFpsRanges)/sizeof(int32_t));
 604
 605     static const uint8_t availableAntibandingModes[] = {
 606             ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF,
 607             ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO
 608     };
 609     ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
 610             availableAntibandingModes, sizeof(availableAntibandingModes));
 611
 612     static const uint8_t availableAwbModes[] = {
 613             ANDROID_CONTROL_AWB_MODE_OFF,
 614             ANDROID_CONTROL_AWB_MODE_AUTO,
 615             ANDROID_CONTROL_AWB_MODE_INCANDESCENT,
 616             ANDROID_CONTROL_AWB_MODE_FLUORESCENT,
 617             ANDROID_CONTROL_AWB_MODE_DAYLIGHT,
 618             ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT
 619     };
 620     ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
 621             availableAwbModes, sizeof(availableAwbModes));
 622
 623     ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES,
 624                 m_curCameraInfo->availableAfModes, m_curCameraInfo->numAvailableAfModes);
 625
 626     static const uint8_t availableVstabModes[] = {
 627             ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF,
 628             ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON
 629     };
 630     ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
 631             availableVstabModes, sizeof(availableVstabModes));
 632
 633     ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
 634             m_curCameraInfo->sceneModeOverrides, m_curCameraInfo->numSceneModeOverrides);
 635
 636     static const uint8_t quirkTriggerAuto = 1;
 637     ADD_OR_SIZE(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO,
 638             &quirkTriggerAuto, 1);
 639
 640     static const uint8_t quirkUseZslFormat = 1;
 641     ADD_OR_SIZE(ANDROID_QUIRKS_USE_ZSL_FORMAT,
 642             &quirkUseZslFormat, 1);
 643
 644     static const uint8_t quirkMeteringCropRegion = 1;
 645     ADD_OR_SIZE(ANDROID_QUIRKS_METERING_CROP_REGION,
 646             &quirkMeteringCropRegion, 1);
 647
 648
 649 #undef ADD_OR_SIZE
 650     /** Allocate metadata if sizing */
 651     if (sizeRequest) {
 652         ALOGV("Allocating %d entries, %d extra bytes for "
 653                 "static camera info",
 654                 entryCount, dataCount);
 655         *info = allocate_camera_metadata(entryCount, dataCount);
 656         if (*info == NULL) {
 657             ALOGE("Unable to allocate camera static info"
 658                     "(%d entries, %d bytes extra data)",
 659                     entryCount, dataCount);
 660             return NO_MEMORY;
 661         }
 662     }
 663     return OK;
 664 }
 665
 666 status_t ExynosCamera2::constructDefaultRequest(
 667         int request_template,
 668         camera_metadata_t **request,
 669         bool sizeRequest) {
 670
 671     size_t entryCount = 0;
 672     size_t dataCount = 0;
 673     status_t ret;
 674
 675 #define ADD_OR_SIZE( tag, data, count ) \
 676     if ( ( ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, \
 677             tag, data, count) ) != OK ) return ret
 678
 679     static const int64_t USEC = 1000LL;
 680     static const int64_t MSEC = USEC * 1000LL;
 681     static const int64_t SEC = MSEC * 1000LL;
 682
 683     /** android.request */
 684
 685     static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_NONE;
 686     ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1);
 687
 688     static const int32_t id = 0;
 689     ADD_OR_SIZE(ANDROID_REQUEST_ID, &id, 1);
 690
 691     static const int32_t frameCount = 0;
 692     ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1);
 693
 694     // OUTPUT_STREAMS set by user
 695     entryCount += 1;
 696     dataCount += 5; // TODO: Should be maximum stream number
 697
 698     /** android.lens */
 699
 700     static const float focusDistance = 0;
 701     ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1);
 702
 703     ADD_OR_SIZE(ANDROID_LENS_APERTURE, &m_curCameraInfo->aperture, 1);
 704
 705     ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH, &m_curCameraInfo->focalLength, 1);
 706
 707     static const float filterDensity = 0;
 708     ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1);
 709
 710     static const uint8_t opticalStabilizationMode =
 711             ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
 712     ADD_OR_SIZE(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
 713             &opticalStabilizationMode, 1);
 714
 715
 716     /** android.sensor */
 717
 718
 719     static const int64_t frameDuration = 33333333L; // 1/30 s
 720     ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1);
 721
 722
 723     /** android.flash */
 724
 725     static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF;
 726     ADD_OR_SIZE(ANDROID_FLASH_MODE, &flashMode, 1);
 727
 728     static const uint8_t flashPower = 10;
 729     ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER, &flashPower, 1);
 730
 731     static const int64_t firingTime = 0;
 732     ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME, &firingTime, 1);
 733
 734     /** Processing block modes */
 735     uint8_t hotPixelMode = 0;
 736     uint8_t demosaicMode = 0;
 737     uint8_t noiseMode = 0;
 738     uint8_t shadingMode = 0;
 739     uint8_t geometricMode = 0;
 740     uint8_t colorMode = 0;
 741     uint8_t tonemapMode = 0;
 742     uint8_t edgeMode = 0;
 743     uint8_t vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
 744
 745     switch (request_template) {
 746       case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
 747         vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
 748         // fall-through
 749       case CAMERA2_TEMPLATE_STILL_CAPTURE:
 750         // fall-through
 751       case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
 752         hotPixelMode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY;
 753         demosaicMode = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY;
 754         noiseMode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY;
 755         shadingMode = ANDROID_SHADING_MODE_HIGH_QUALITY;
 756         geometricMode = ANDROID_GEOMETRIC_MODE_HIGH_QUALITY;
 757         colorMode = ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY;
 758         tonemapMode = ANDROID_TONEMAP_MODE_HIGH_QUALITY;
 759         edgeMode = ANDROID_EDGE_MODE_HIGH_QUALITY;
 760         break;
 761       case CAMERA2_TEMPLATE_VIDEO_RECORD:
 762         vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
 763         // fall-through
 764       case CAMERA2_TEMPLATE_PREVIEW:
 765         // fall-through
 766       default:
 767         hotPixelMode = ANDROID_HOT_PIXEL_MODE_FAST;
 768         demosaicMode = ANDROID_DEMOSAIC_MODE_FAST;
 769         noiseMode = ANDROID_NOISE_REDUCTION_MODE_FAST;
 770         shadingMode = ANDROID_SHADING_MODE_FAST;
 771         geometricMode = ANDROID_GEOMETRIC_MODE_FAST;
 772         colorMode = ANDROID_COLOR_CORRECTION_MODE_FAST;
 773         tonemapMode = ANDROID_TONEMAP_MODE_FAST;
 774         edgeMode = ANDROID_EDGE_MODE_FAST;
 775         break;
 776     }
 777     ADD_OR_SIZE(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1);
 778     ADD_OR_SIZE(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1);
 779     ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_MODE, &noiseMode, 1);
 780     ADD_OR_SIZE(ANDROID_SHADING_MODE, &shadingMode, 1);
 781     ADD_OR_SIZE(ANDROID_GEOMETRIC_MODE, &geometricMode, 1);
 782     ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_MODE, &colorMode, 1);
 783     ADD_OR_SIZE(ANDROID_TONEMAP_MODE, &tonemapMode, 1);
 784     ADD_OR_SIZE(ANDROID_EDGE_MODE, &edgeMode, 1);
 785     ADD_OR_SIZE(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1);
 786
 787     /** android.noise */
 788     static const uint8_t noiseStrength = 5;
 789     ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_STRENGTH, &noiseStrength, 1);
 790
 791     /** android.color */
 792     static const float colorTransform[9] = {
 793         1.0f, 0.f, 0.f,
 794         0.f, 1.f, 0.f,
 795         0.f, 0.f, 1.f
 796     };
 797     ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_TRANSFORM, colorTransform, 9);
 798
 799     /** android.tonemap */
 800     static const float tonemapCurve[4] = {
 801         0.f, 0.f,
 802         1.f, 1.f
 803     };
 804     ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 32); // sungjoong
 805     ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 32);
 806     ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 32);
 807
 808     /** android.edge */
 809     static const uint8_t edgeStrength = 5;
 810     ADD_OR_SIZE(ANDROID_EDGE_STRENGTH, &edgeStrength, 1);
 811
 812     /** android.scaler */
 813     int32_t cropRegion[3] = {
 814         0, 0, m_curCameraInfo->sensorW
 815     };
 816     ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3);
 817
 818     /** android.jpeg */
 819     static const int32_t jpegQuality = 100;
 820     ADD_OR_SIZE(ANDROID_JPEG_QUALITY, &jpegQuality, 1);
 821
 822     static const int32_t thumbnailSize[2] = {
 823         160, 120
 824     };
 825     ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2);
 826
 827     static const int32_t thumbnailQuality = 100;
 828     ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1);
 829
 830     static const double gpsCoordinates[3] = {
 831         0, 0, 0
 832     };
 833     ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 3);
 834
 835     static const uint8_t gpsProcessingMethod[32] = "None";
 836     ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32);
 837
 838     static const int64_t gpsTimestamp = 0;
 839     ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1);
 840
 841     static const int32_t jpegOrientation = 0;
 842     ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1);
 843
 844     /** android.stats */
 845
 846     static const uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_FULL;
 847     ADD_OR_SIZE(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1);
 848
 849     static const uint8_t histogramMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;
 850     ADD_OR_SIZE(ANDROID_STATISTICS_HISTOGRAM_MODE, &histogramMode, 1);
 851
 852     static const uint8_t sharpnessMapMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;
 853     ADD_OR_SIZE(ANDROID_STATISTICS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1);
 854
 855
 856     /** android.control */
 857
 858     uint8_t controlIntent = 0;
 859     switch (request_template) {
 860       case CAMERA2_TEMPLATE_PREVIEW:
 861         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
 862         break;
 863       case CAMERA2_TEMPLATE_STILL_CAPTURE:
 864         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
 865         break;
 866       case CAMERA2_TEMPLATE_VIDEO_RECORD:
 867         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
 868         break;
 869       case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
 870         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
 871         break;
 872       case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
 873         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
 874         break;
 875       default:
 876         controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
 877         break;
 878     }
 879     ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
 880
 881     static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
 882     ADD_OR_SIZE(ANDROID_CONTROL_MODE, &controlMode, 1);
 883
 884     static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
 885     ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1);
 886
 887     static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
 888     ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
 889
 890     static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON;
 891     ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
 892
 893     int32_t controlRegions[5] = {
 894         0, 0, m_curCameraInfo->sensorW, m_curCameraInfo->sensorH, 1000
 895     };
 896     ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5);
 897
 898     static const int32_t aeExpCompensation = 0;
 899     ADD_OR_SIZE(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExpCompensation, 1);
 900
 901     static const int32_t aeTargetFpsRange[2] = {
 902         15, 30
 903     };
 904     ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2);
 905
 906     static const uint8_t aeAntibandingMode =
 907             ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
 908     ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1);
 909
 910     static const uint8_t awbMode =
 911             ANDROID_CONTROL_AWB_MODE_AUTO;
 912     ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
 913
 914     ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5);
 915
 916     uint8_t afMode = 0;
 917     switch (request_template) {
 918       case CAMERA2_TEMPLATE_PREVIEW:
 919         afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
 920         break;
 921       case CAMERA2_TEMPLATE_STILL_CAPTURE:
 922         afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
 923         break;
 924       case CAMERA2_TEMPLATE_VIDEO_RECORD:
 925         afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
 926         break;
 927       case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
 928         afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
 929         break;
 930       case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
 931         afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
 932         break;
 933       default:
 934         afMode = ANDROID_CONTROL_AF_MODE_AUTO;
 935         break;
 936     }
 937     ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE, &afMode, 1);
 938
 939     ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5);
 940
 941     if (sizeRequest) {
 942         ALOGV("Allocating %d entries, %d extra bytes for "
 943                 "request template type %d",
 944                 entryCount, dataCount, request_template);
 945         *request = allocate_camera_metadata(entryCount, dataCount);
 946         if (*request == NULL) {
 947             ALOGE("Unable to allocate new request template type %d "
 948                     "(%d entries, %d bytes extra data)", request_template,
 949                     entryCount, dataCount);
 950             return NO_MEMORY;
 951         }
 952     }
 953     return OK;
 954 #undef ADD_OR_SIZE
 955 }
 956
 957 }