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_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 ExynosCamera2InfoS5K4E5::ExynosCamera2InfoS5K4E5()
 151 {
 152     sensorW             = 2560;
 153     sensorH             = 1920;
 154     sensorRawW          = (2560 + 16);
 155     sensorRawH          = (1920 + 10);
 156     numScalerResolution = ARRAY_SIZE(scalerResolutionS5K4E5)/2;
 157     scalerResolutions   = scalerResolutionS5K4E5;
 158     numJpegResolution   = ARRAY_SIZE(jpegResolutionS5K4E5)/2;
 159     jpegResolutions     = jpegResolutionS5K4E5;
 160     minFocusDistance    = 0.1f;
 161     focalLength         = 3.43f;
 162     aperture            = 2.7f;
 163     fnumber             = 2.7f;
 164 }
 165
 166 ExynosCamera2InfoS5K4E5::~ExynosCamera2InfoS5K4E5()
 167 {
 168     ALOGV("%s", __FUNCTION__);
 169 }
 170 const int32_t scalerResolutionS5K6A3[] =
 171 {
 172     1392, 1392, // 1:1
 173     1344,  896, // 3:2
 174     1280, 1024, // 5:4
 175     1280,  960, // 4:3
 176     1280,  720, // 16:9
 177      960,  720, // 4:3
 178      800,  480, // 5:3
 179      768,  576, // 4:3
 180      720,  576, // 5:4
 181      720,  480, // 3:2
 182      640,  480, // 4:3
 183      352,  288, // 11:9
 184      320,  240, // 4:3
 185      240,  160, // 3:2
 186      176,  144, // 6:5
 187      128,   96, // 4:3
 188 };
 189
 190 const int32_t jpegResolutionS5K6A3[] =
 191 {
 192     1392, 1392,
 193     1392, 1040,
 194     1392,  928,
 195     1392,  784,
 196     1280, 1024,
 197     1280,  960,
 198     1280,  720,
 199     1152,  864,
 200      640,  480,
 201      320,  240,
 202 };
 203
 204 ExynosCamera2InfoS5K6A3::ExynosCamera2InfoS5K6A3()
 205 {
 206     sensorW     = 1392;
 207     sensorH     = 1392;
 208     sensorRawW  = (1392 + 16);
 209     sensorRawH  = (1392 + 10);
 210     numScalerResolution = ARRAY_SIZE(scalerResolutionS5K6A3)/2;
 211     scalerResolutions   = scalerResolutionS5K6A3;
 212     numJpegResolution   = ARRAY_SIZE(jpegResolutionS5K6A3)/2;
 213     jpegResolutions     = jpegResolutionS5K6A3;
 214     minFocusDistance    = 0.0f;
 215     focalLength         = 2.73f;
 216     aperture            = 2.8f;
 217     fnumber             = 2.8f;
 218 }
 219
 220 ExynosCamera2InfoS5K6A3::~ExynosCamera2InfoS5K6A3()
 221 {
 222     ALOGV("%s", __FUNCTION__);
 223 }
 224 ExynosCamera2::ExynosCamera2(int cameraId):
 225     m_cameraId(cameraId)
 226 {
 227     if (cameraId == 0)
 228         m_curCameraInfo      = new ExynosCamera2InfoS5K4E5;
 229     else
 230         m_curCameraInfo      = new ExynosCamera2InfoS5K6A3;
 231 }
 232
 233 ExynosCamera2::~ExynosCamera2()
 234 {
 235     ALOGV("%s", __FUNCTION__);
 236         delete m_curCameraInfo;
 237     m_curCameraInfo = NULL;
 238 }
 239
 240 int32_t ExynosCamera2::getSensorW()
 241 {
 242     return m_curCameraInfo->sensorW;
 243 }
 244
 245 int32_t ExynosCamera2::getSensorH()
 246 {
 247     return m_curCameraInfo->sensorH;
 248 }
 249
 250 int32_t ExynosCamera2::getSensorRawW()
 251 {
 252     return m_curCameraInfo->sensorRawW;
 253 }
 254
 255 int32_t ExynosCamera2::getSensorRawH()
 256 {
 257     return m_curCameraInfo->sensorRawH;
 258 }
 259
 260 bool ExynosCamera2::isSupportedResolution(int width, int height)
 261 {
 262     int i;
 263     for (i = 0 ; i < m_curCameraInfo->numScalerResolution ; i++) {
 264         if (m_curCameraInfo->scalerResolutions[2*i] == width
 265                 && m_curCameraInfo->scalerResolutions[2*i+1] == height) {
 266             return true;
 267         }
 268     }
 269     return false;
 270 }
 271
 272 bool ExynosCamera2::isSupportedJpegResolution(int width, int height)
 273 {
 274     int i;
 275     for (i = 0 ; i < m_curCameraInfo->numJpegResolution ; i++) {
 276         if (m_curCameraInfo->jpegResolutions[2*i] == width
 277                 && m_curCameraInfo->jpegResolutions[2*i+1] == height) {
 278             return true;
 279         }
 280     }
 281     return false;
 282 }
 283
 284 status_t addOrSize(camera_metadata_t *request,
 285         bool sizeRequest,
 286         size_t *entryCount,
 287         size_t *dataCount,
 288         uint32_t tag,
 289         const void *entryData,
 290         size_t entryDataCount) {
 291     status_t res;
 292     if (!sizeRequest) {
 293         return add_camera_metadata_entry(request, tag, entryData,
 294                 entryDataCount);
 295     } else {
 296         int type = get_camera_metadata_tag_type(tag);
 297         if (type < 0 ) return BAD_VALUE;
 298         (*entryCount)++;
 299         (*dataCount) += calculate_camera_metadata_entry_data_size(type,
 300                 entryDataCount);
 301         return OK;
 302     }
 303 }
 304
 305 status_t ExynosCamera2::constructStaticInfo(camera_metadata_t **info,
 306         int cameraId, bool sizeRequest) {
 307
 308     size_t entryCount = 0;
 309     size_t dataCount = 0;
 310     status_t ret;
 311
 312 #define ADD_OR_SIZE( tag, data, count ) \
 313     if ( ( ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, \
 314             tag, data, count) ) != OK ) return ret
 315
 316     // android.lens
 317
 318     ADD_OR_SIZE(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE,
 319             &(m_curCameraInfo->minFocusDistance), 1);
 320     ADD_OR_SIZE(ANDROID_LENS_HYPERFOCAL_DISTANCE,
 321             &(m_curCameraInfo->minFocusDistance), 1);
 322
 323     ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS,
 324             &m_curCameraInfo->focalLength, 1);
 325     ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_APERTURES,
 326             &m_curCameraInfo->aperture, 1);
 327
 328     static const float filterDensity = 0;
 329     ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_FILTER_DENSITY,
 330             &filterDensity, 1);
 331     static const uint8_t availableOpticalStabilization =
 332             ANDROID_LENS_OPTICAL_STABILIZATION_OFF;
 333     ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_OPTICAL_STABILIZATION,
 334             &availableOpticalStabilization, 1);
 335
 336     static const int32_t lensShadingMapSize[] = {1, 1};
 337     ADD_OR_SIZE(ANDROID_LENS_SHADING_MAP_SIZE, lensShadingMapSize,
 338             sizeof(lensShadingMapSize)/sizeof(int32_t));
 339
 340     static const float lensShadingMap[3 * 1 * 1 ] =
 341             { 1.f, 1.f, 1.f };
 342     ADD_OR_SIZE(ANDROID_LENS_SHADING_MAP, lensShadingMap,
 343             sizeof(lensShadingMap)/sizeof(float));
 344
 345     int32_t lensFacing = cameraId ?
 346             ANDROID_LENS_FACING_FRONT : ANDROID_LENS_FACING_BACK;
 347     ADD_OR_SIZE(ANDROID_LENS_FACING, &lensFacing, 1);
 348
 349     // android.sensor
 350     ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME_RANGE,
 351             Sensor::kExposureTimeRange, 2);
 352
 353     ADD_OR_SIZE(ANDROID_SENSOR_MAX_FRAME_DURATION,
 354             &Sensor::kFrameDurationRange[1], 1);
 355
 356     ADD_OR_SIZE(ANDROID_SENSOR_AVAILABLE_SENSITIVITIES,
 357             Sensor::kAvailableSensitivities,
 358             sizeof(Sensor::kAvailableSensitivities)
 359             /sizeof(uint32_t));
 360
 361     ADD_OR_SIZE(ANDROID_SENSOR_COLOR_FILTER_ARRANGEMENT,
 362             &Sensor::kColorFilterArrangement, 1);
 363
 364     static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm
 365     ADD_OR_SIZE(ANDROID_SENSOR_PHYSICAL_SIZE,
 366             sensorPhysicalSize, 2);
 367
 368     int32_t pixelArraySize[2] = {
 369         m_curCameraInfo->sensorW, m_curCameraInfo->sensorH
 370     };
 371     ADD_OR_SIZE(ANDROID_SENSOR_PIXEL_ARRAY_SIZE, pixelArraySize, 2);
 372     ADD_OR_SIZE(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, pixelArraySize,2);
 373
 374     ADD_OR_SIZE(ANDROID_SENSOR_WHITE_LEVEL,
 375             &Sensor::kMaxRawValue, 1);
 376
 377     static const int32_t blackLevelPattern[4] = {
 378             Sensor::kBlackLevel, Sensor::kBlackLevel,
 379             Sensor::kBlackLevel, Sensor::kBlackLevel
 380     };
 381     ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
 382             blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t));
 383
 384     //TODO: sensor color calibration fields
 385
 386     // android.flash
 387     uint8_t flashAvailable;
 388     if (cameraId == 0)
 389         flashAvailable = 1;
 390     else
 391         flashAvailable = 0;
 392     ADD_OR_SIZE(ANDROID_FLASH_AVAILABLE, &flashAvailable, 1);
 393
 394     static const int64_t flashChargeDuration = 0;
 395     ADD_OR_SIZE(ANDROID_FLASH_CHARGE_DURATION, &flashChargeDuration, 1);
 396
 397     // android.tonemap
 398
 399     static const int32_t tonemapCurvePoints = 128;
 400     ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1);
 401
 402     // android.scaler
 403
 404     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS,
 405             kAvailableFormats,
 406             sizeof(kAvailableFormats)/sizeof(uint32_t));
 407
 408     int32_t availableRawSizes[2] = {
 409         m_curCameraInfo->sensorRawW, m_curCameraInfo->sensorRawH
 410     };
 411     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
 412             availableRawSizes, 2);
 413
 414     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
 415             kAvailableRawMinDurations,
 416             sizeof(kAvailableRawMinDurations)/sizeof(uint64_t));
 417
 418
 419     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
 420         m_curCameraInfo->scalerResolutions,
 421         (m_curCameraInfo->numScalerResolution)*2);
 422     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
 423         m_curCameraInfo->jpegResolutions,
 424         (m_curCameraInfo->numJpegResolution)*2);
 425
 426     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
 427             kAvailableProcessedMinDurations,
 428             sizeof(kAvailableProcessedMinDurations)/sizeof(uint64_t));
 429
 430     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
 431             kAvailableJpegMinDurations,
 432             sizeof(kAvailableJpegMinDurations)/sizeof(uint64_t));
 433
 434     static const float maxZoom = 4;
 435     ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, &maxZoom, 1);
 436
 437     // android.jpeg
 438
 439     static const int32_t jpegThumbnailSizes[] = {
 440             160, 120,
 441             160, 160,
 442             160, 90,
 443             144, 96,
 444               0, 0
 445     };
 446
 447     ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
 448             jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t));
 449
 450     static const int32_t jpegMaxSize = 10 * 1024 * 1024;
 451     ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1);
 452
 453     // android.stats
 454
 455     static const uint8_t availableFaceDetectModes[] = {
 456             ANDROID_STATS_FACE_DETECTION_OFF,
 457             ANDROID_STATS_FACE_DETECTION_FULL
 458     };
 459     ADD_OR_SIZE(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES,
 460             availableFaceDetectModes,
 461             sizeof(availableFaceDetectModes));
 462
 463     m_curCameraInfo->maxFaceCount = CAMERA2_MAX_FACES;
 464     ADD_OR_SIZE(ANDROID_STATS_MAX_FACE_COUNT,
 465             &(m_curCameraInfo->maxFaceCount), 1);
 466
 467     static const int32_t histogramSize = 64;
 468     ADD_OR_SIZE(ANDROID_STATS_HISTOGRAM_BUCKET_COUNT,
 469             &histogramSize, 1);
 470
 471     static const int32_t maxHistogramCount = 1000;
 472     ADD_OR_SIZE(ANDROID_STATS_MAX_HISTOGRAM_COUNT,
 473             &maxHistogramCount, 1);
 474
 475     static const int32_t sharpnessMapSize[2] = {64, 64};
 476     ADD_OR_SIZE(ANDROID_STATS_SHARPNESS_MAP_SIZE,
 477             sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t));
 478
 479     static const int32_t maxSharpnessMapValue = 1000;
 480     ADD_OR_SIZE(ANDROID_STATS_MAX_SHARPNESS_MAP_VALUE,
 481             &maxSharpnessMapValue, 1);
 482
 483     // android.control
 484
 485     static const uint8_t availableSceneModes[] = {
 486             ANDROID_CONTROL_SCENE_MODE_ACTION,
 487             ANDROID_CONTROL_SCENE_MODE_NIGHT,
 488             ANDROID_CONTROL_SCENE_MODE_SUNSET,
 489             ANDROID_CONTROL_SCENE_MODE_PARTY
 490     };
 491     ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
 492             availableSceneModes, sizeof(availableSceneModes));
 493
 494     static const uint8_t availableEffects[] = {
 495             ANDROID_CONTROL_EFFECT_OFF
 496     };
 497     ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS,
 498             availableEffects, sizeof(availableEffects));
 499
 500     int32_t max3aRegions = 1;
 501     ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS,
 502             &max3aRegions, 1);
 503
 504     static const uint8_t availableAeModes[] = {
 505             ANDROID_CONTROL_AE_OFF,
 506             ANDROID_CONTROL_AE_ON,
 507             ANDROID_CONTROL_AE_ON_AUTO_FLASH
 508     };
 509     ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES,
 510             availableAeModes, sizeof(availableAeModes));
 511
 512     static const camera_metadata_rational exposureCompensationStep = {
 513             1, 1
 514     };
 515     ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP,
 516             &exposureCompensationStep, 1);
 517
 518     int32_t exposureCompensationRange[] = {-3, 3};
 519     ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE,
 520             exposureCompensationRange,
 521             sizeof(exposureCompensationRange)/sizeof(int32_t));
 522
 523     static const int32_t availableTargetFpsRanges[] = {
 524             15, 30, 30, 30
 525     };
 526     ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
 527             availableTargetFpsRanges,
 528             sizeof(availableTargetFpsRanges)/sizeof(int32_t));
 529
 530     static const uint8_t availableAntibandingModes[] = {
 531             ANDROID_CONTROL_AE_ANTIBANDING_OFF,
 532             ANDROID_CONTROL_AE_ANTIBANDING_AUTO
 533     };
 534     ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
 535             availableAntibandingModes, sizeof(availableAntibandingModes));
 536
 537     static const uint8_t availableAwbModes[] = {
 538             ANDROID_CONTROL_AWB_OFF,
 539             ANDROID_CONTROL_AWB_AUTO,
 540             ANDROID_CONTROL_AWB_INCANDESCENT,
 541             ANDROID_CONTROL_AWB_FLUORESCENT,
 542             ANDROID_CONTROL_AWB_DAYLIGHT,
 543             ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT
 544     };
 545     ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
 546             availableAwbModes, sizeof(availableAwbModes));
 547
 548     static const uint8_t availableAfModes[] = {
 549             ANDROID_CONTROL_AF_OFF,
 550             ANDROID_CONTROL_AF_AUTO,
 551             ANDROID_CONTROL_AF_MACRO,
 552             ANDROID_CONTROL_AF_CONTINUOUS_PICTURE,
 553             ANDROID_CONTROL_AF_CONTINUOUS_VIDEO
 554     };
 555     ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES,
 556             availableAfModes, sizeof(availableAfModes));
 557
 558     static const uint8_t availableVstabModes[] = {
 559             ANDROID_CONTROL_VIDEO_STABILIZATION_OFF,
 560             ANDROID_CONTROL_VIDEO_STABILIZATION_ON
 561     };
 562     ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
 563             availableVstabModes, sizeof(availableVstabModes));
 564
 565     static const uint8_t sceneModeOverrides[] = {
 566         // ANDROID_CONTROL_SCENE_MODE_ACTION
 567             ANDROID_CONTROL_AE_ON,
 568             ANDROID_CONTROL_AWB_AUTO,
 569             ANDROID_CONTROL_AF_CONTINUOUS_PICTURE,
 570         // ANDROID_CONTROL_SCENE_MODE_NIGHT
 571             ANDROID_CONTROL_AE_ON,
 572             ANDROID_CONTROL_AWB_AUTO,
 573             ANDROID_CONTROL_AF_CONTINUOUS_PICTURE,
 574         // ANDROID_CONTROL_SCENE_MODE_SUNSET
 575             ANDROID_CONTROL_AE_ON,
 576             ANDROID_CONTROL_AWB_DAYLIGHT,
 577             ANDROID_CONTROL_AF_CONTINUOUS_PICTURE,
 578         // ANDROID_CONTROL_SCENE_MODE_PARTY
 579             ANDROID_CONTROL_AE_ON_AUTO_FLASH,
 580             ANDROID_CONTROL_AWB_AUTO,
 581             ANDROID_CONTROL_AF_CONTINUOUS_PICTURE
 582     };
 583     ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
 584             sceneModeOverrides, sizeof(sceneModeOverrides));
 585
 586     static const uint8_t quirkTriggerAuto = 1;
 587     ADD_OR_SIZE(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO,
 588             &quirkTriggerAuto, 1);
 589
 590     static const uint8_t quirkUseZslFormat = 1;
 591     ADD_OR_SIZE(ANDROID_QUIRKS_USE_ZSL_FORMAT,
 592             &quirkUseZslFormat, 1);
 593
 594 #undef ADD_OR_SIZE
 595     /** Allocate metadata if sizing */
 596     if (sizeRequest) {
 597         ALOGV("Allocating %d entries, %d extra bytes for "
 598                 "static camera info",
 599                 entryCount, dataCount);
 600         *info = allocate_camera_metadata(entryCount, dataCount);
 601         if (*info == NULL) {
 602             ALOGE("Unable to allocate camera static info"
 603                     "(%d entries, %d bytes extra data)",
 604                     entryCount, dataCount);
 605             return NO_MEMORY;
 606         }
 607     }
 608     return OK;
 609 }
 610
 611 status_t ExynosCamera2::constructDefaultRequest(
 612         int request_template,
 613         camera_metadata_t **request,
 614         bool sizeRequest) {
 615
 616     size_t entryCount = 0;
 617     size_t dataCount = 0;
 618     status_t ret;
 619
 620 #define ADD_OR_SIZE( tag, data, count ) \
 621     if ( ( ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, \
 622             tag, data, count) ) != OK ) return ret
 623
 624     static const int64_t USEC = 1000LL;
 625     static const int64_t MSEC = USEC * 1000LL;
 626     static const int64_t SEC = MSEC * 1000LL;
 627
 628     /** android.request */
 629
 630     static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_NONE;
 631     ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1);
 632
 633     static const int32_t id = 0;
 634     ADD_OR_SIZE(ANDROID_REQUEST_ID, &id, 1);
 635
 636     static const int32_t frameCount = 0;
 637     ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1);
 638
 639     // OUTPUT_STREAMS set by user
 640     entryCount += 1;
 641     dataCount += 5; // TODO: Should be maximum stream number
 642
 643     /** android.lens */
 644
 645     static const float focusDistance = 0;
 646     ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1);
 647
 648     ADD_OR_SIZE(ANDROID_LENS_APERTURE, &m_curCameraInfo->aperture, 1);
 649
 650     ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH, &m_curCameraInfo->focalLength, 1);
 651
 652     static const float filterDensity = 0;
 653     ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1);
 654
 655     static const uint8_t opticalStabilizationMode =
 656             ANDROID_LENS_OPTICAL_STABILIZATION_OFF;
 657     ADD_OR_SIZE(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
 658             &opticalStabilizationMode, 1);
 659
 660
 661     /** android.sensor */
 662
 663
 664     static const int64_t frameDuration = 33333333L; // 1/30 s
 665     ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1);
 666
 667
 668     /** android.flash */
 669
 670     static const uint8_t flashMode = ANDROID_FLASH_OFF;
 671     ADD_OR_SIZE(ANDROID_FLASH_MODE, &flashMode, 1);
 672
 673     static const uint8_t flashPower = 10;
 674     ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER, &flashPower, 1);
 675
 676     static const int64_t firingTime = 0;
 677     ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME, &firingTime, 1);
 678
 679     /** Processing block modes */
 680     uint8_t hotPixelMode = 0;
 681     uint8_t demosaicMode = 0;
 682     uint8_t noiseMode = 0;
 683     uint8_t shadingMode = 0;
 684     uint8_t geometricMode = 0;
 685     uint8_t colorMode = 0;
 686     uint8_t tonemapMode = 0;
 687     uint8_t edgeMode = 0;
 688     uint8_t vstabMode = 0;
 689
 690     switch (request_template) {
 691       case CAMERA2_TEMPLATE_PREVIEW:
 692         hotPixelMode = ANDROID_PROCESSING_FAST;
 693         demosaicMode = ANDROID_PROCESSING_FAST;
 694         noiseMode = ANDROID_PROCESSING_FAST;
 695         shadingMode = ANDROID_PROCESSING_FAST;
 696         geometricMode = ANDROID_PROCESSING_FAST;
 697         colorMode = ANDROID_PROCESSING_FAST;
 698         tonemapMode = ANDROID_PROCESSING_FAST;
 699         edgeMode = ANDROID_PROCESSING_FAST;
 700         vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
 701         break;
 702       case CAMERA2_TEMPLATE_STILL_CAPTURE:
 703         hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY;
 704         demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY;
 705         noiseMode = ANDROID_PROCESSING_HIGH_QUALITY;
 706         shadingMode = ANDROID_PROCESSING_HIGH_QUALITY;
 707         geometricMode = ANDROID_PROCESSING_HIGH_QUALITY;
 708         colorMode = ANDROID_PROCESSING_HIGH_QUALITY;
 709         tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY;
 710         edgeMode = ANDROID_PROCESSING_HIGH_QUALITY;
 711         vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
 712         break;
 713       case CAMERA2_TEMPLATE_VIDEO_RECORD:
 714         hotPixelMode = ANDROID_PROCESSING_FAST;
 715         demosaicMode = ANDROID_PROCESSING_FAST;
 716         noiseMode = ANDROID_PROCESSING_FAST;
 717         shadingMode = ANDROID_PROCESSING_FAST;
 718         geometricMode = ANDROID_PROCESSING_FAST;
 719         colorMode = ANDROID_PROCESSING_FAST;
 720         tonemapMode = ANDROID_PROCESSING_FAST;
 721         edgeMode = ANDROID_PROCESSING_FAST;
 722         vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_ON;
 723         break;
 724       case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
 725         hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY;
 726         demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY;
 727         noiseMode = ANDROID_PROCESSING_HIGH_QUALITY;
 728         shadingMode = ANDROID_PROCESSING_HIGH_QUALITY;
 729         geometricMode = ANDROID_PROCESSING_HIGH_QUALITY;
 730         colorMode = ANDROID_PROCESSING_HIGH_QUALITY;
 731         tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY;
 732         edgeMode = ANDROID_PROCESSING_HIGH_QUALITY;
 733         vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_ON;
 734         break;
 735       case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
 736         hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY;
 737         demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY;
 738         noiseMode = ANDROID_PROCESSING_HIGH_QUALITY;
 739         shadingMode = ANDROID_PROCESSING_HIGH_QUALITY;
 740         geometricMode = ANDROID_PROCESSING_HIGH_QUALITY;
 741         colorMode = ANDROID_PROCESSING_HIGH_QUALITY;
 742         tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY;
 743         edgeMode = ANDROID_PROCESSING_HIGH_QUALITY;
 744         vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
 745         break;
 746       default:
 747         hotPixelMode = ANDROID_PROCESSING_FAST;
 748         demosaicMode = ANDROID_PROCESSING_FAST;
 749         noiseMode = ANDROID_PROCESSING_FAST;
 750         shadingMode = ANDROID_PROCESSING_FAST;
 751         geometricMode = ANDROID_PROCESSING_FAST;
 752         colorMode = ANDROID_PROCESSING_FAST;
 753         tonemapMode = ANDROID_PROCESSING_FAST;
 754         edgeMode = ANDROID_PROCESSING_FAST;
 755         vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
 756         break;
 757     }
 758     ADD_OR_SIZE(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1);
 759     ADD_OR_SIZE(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1);
 760     ADD_OR_SIZE(ANDROID_NOISE_MODE, &noiseMode, 1);
 761     ADD_OR_SIZE(ANDROID_SHADING_MODE, &shadingMode, 1);
 762     ADD_OR_SIZE(ANDROID_GEOMETRIC_MODE, &geometricMode, 1);
 763     ADD_OR_SIZE(ANDROID_COLOR_MODE, &colorMode, 1);
 764     ADD_OR_SIZE(ANDROID_TONEMAP_MODE, &tonemapMode, 1);
 765     ADD_OR_SIZE(ANDROID_EDGE_MODE, &edgeMode, 1);
 766     ADD_OR_SIZE(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1);
 767
 768     /** android.noise */
 769     static const uint8_t noiseStrength = 5;
 770     ADD_OR_SIZE(ANDROID_NOISE_STRENGTH, &noiseStrength, 1);
 771
 772     /** android.color */
 773     static const float colorTransform[9] = {
 774         1.0f, 0.f, 0.f,
 775         0.f, 1.f, 0.f,
 776         0.f, 0.f, 1.f
 777     };
 778     ADD_OR_SIZE(ANDROID_COLOR_TRANSFORM, colorTransform, 9);
 779
 780     /** android.tonemap */
 781     static const float tonemapCurve[4] = {
 782         0.f, 0.f,
 783         1.f, 1.f
 784     };
 785     ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 32); // sungjoong
 786     ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 32);
 787     ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 32);
 788
 789     /** android.edge */
 790     static const uint8_t edgeStrength = 5;
 791     ADD_OR_SIZE(ANDROID_EDGE_STRENGTH, &edgeStrength, 1);
 792
 793     /** android.scaler */
 794     int32_t cropRegion[3] = {
 795         0, 0, m_curCameraInfo->sensorW
 796     };
 797     ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3);
 798
 799     /** android.jpeg */
 800     static const int32_t jpegQuality = 80;
 801     ADD_OR_SIZE(ANDROID_JPEG_QUALITY, &jpegQuality, 1);
 802
 803     static const int32_t thumbnailSize[2] = {
 804         160, 120
 805     };
 806     ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2);
 807
 808     static const int32_t thumbnailQuality = 80;
 809     ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1);
 810
 811     static const double gpsCoordinates[3] = {
 812         0, 0, 0
 813     };
 814     ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 3);
 815
 816     static const uint8_t gpsProcessingMethod[32] = "None";
 817     ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32);
 818
 819     static const int64_t gpsTimestamp = 0;
 820     ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1);
 821
 822     static const int32_t jpegOrientation = 0;
 823     ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1);
 824
 825     /** android.stats */
 826
 827     static const uint8_t faceDetectMode = ANDROID_STATS_FACE_DETECTION_FULL;
 828     ADD_OR_SIZE(ANDROID_STATS_FACE_DETECT_MODE, &faceDetectMode, 1);
 829
 830     static const uint8_t histogramMode = ANDROID_STATS_OFF;
 831     ADD_OR_SIZE(ANDROID_STATS_HISTOGRAM_MODE, &histogramMode, 1);
 832
 833     static const uint8_t sharpnessMapMode = ANDROID_STATS_OFF;
 834     ADD_OR_SIZE(ANDROID_STATS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1);
 835
 836
 837     /** android.control */
 838
 839     uint8_t controlIntent = 0;
 840     switch (request_template) {
 841       case CAMERA2_TEMPLATE_PREVIEW:
 842         controlIntent = ANDROID_CONTROL_INTENT_PREVIEW;
 843         break;
 844       case CAMERA2_TEMPLATE_STILL_CAPTURE:
 845         controlIntent = ANDROID_CONTROL_INTENT_STILL_CAPTURE;
 846         break;
 847       case CAMERA2_TEMPLATE_VIDEO_RECORD:
 848         controlIntent = ANDROID_CONTROL_INTENT_VIDEO_RECORD;
 849         break;
 850       case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
 851         controlIntent = ANDROID_CONTROL_INTENT_VIDEO_SNAPSHOT;
 852         break;
 853       case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
 854         controlIntent = ANDROID_CONTROL_INTENT_ZERO_SHUTTER_LAG;
 855         break;
 856       default:
 857         controlIntent = ANDROID_CONTROL_INTENT_CUSTOM;
 858         break;
 859     }
 860     ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
 861
 862     static const uint8_t controlMode = ANDROID_CONTROL_AUTO;
 863     ADD_OR_SIZE(ANDROID_CONTROL_MODE, &controlMode, 1);
 864
 865     static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_OFF;
 866     ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1);
 867
 868     static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
 869     ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
 870
 871     static const uint8_t aeMode = ANDROID_CONTROL_AE_ON;
 872     ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
 873
 874     int32_t controlRegions[5] = {
 875         0, 0, m_curCameraInfo->sensorW, m_curCameraInfo->sensorH, 1000
 876     };
 877     ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5);
 878
 879     static const int32_t aeExpCompensation = 0;
 880     ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION, &aeExpCompensation, 1);
 881
 882     static const int32_t aeTargetFpsRange[2] = {
 883         15, 30
 884     };
 885     ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2);
 886
 887     static const uint8_t aeAntibandingMode =
 888             ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
 889     ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1);
 890
 891     static const uint8_t awbMode =
 892             ANDROID_CONTROL_AWB_AUTO;
 893     ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
 894
 895     ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5);
 896
 897     uint8_t afMode = 0;
 898     switch (request_template) {
 899       case CAMERA2_TEMPLATE_PREVIEW:
 900         afMode = ANDROID_CONTROL_AF_CONTINUOUS_PICTURE;
 901         break;
 902       case CAMERA2_TEMPLATE_STILL_CAPTURE:
 903         afMode = ANDROID_CONTROL_AF_CONTINUOUS_PICTURE;
 904         break;
 905       case CAMERA2_TEMPLATE_VIDEO_RECORD:
 906         afMode = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO;
 907         break;
 908       case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
 909         afMode = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO;
 910         break;
 911       case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
 912         afMode = ANDROID_CONTROL_AF_CONTINUOUS_PICTURE;
 913         break;
 914       default:
 915         afMode = ANDROID_CONTROL_AF_AUTO;
 916         break;
 917     }
 918     ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE, &afMode, 1);
 919
 920     ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5);
 921
 922     if (sizeRequest) {
 923         ALOGV("Allocating %d entries, %d extra bytes for "
 924                 "request template type %d",
 925                 entryCount, dataCount, request_template);
 926         *request = allocate_camera_metadata(entryCount, dataCount);
 927         if (*request == NULL) {
 928             ALOGE("Unable to allocate new request template type %d "
 929                     "(%d entries, %d bytes extra data)", request_template,
 930                     entryCount, dataCount);
 931             return NO_MEMORY;
 932         }
 933     }
 934     return OK;
 935 #undef ADD_OR_SIZE
 936 }
 937
 938 }