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