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 (at) samsung.com) 23 * \date 2012/08/06 24 * 25 * <b>Revision History: </b> 26 * - 2012/08/06 : Sungjoong Kang(sj3.kang (at) 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 1344, 896, // 3:2 215 1280, 1024, // 5:4 216 1024, 1024, // 1:1 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, 15, 24, 24, 25, 25, 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 } 993
