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