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