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