1 /* 2 ** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved. 3 ** 4 ** Licensed under the Apache License, Version 2.0 (the "License"); 5 ** you may not use this file except in compliance with the License. 6 ** You may obtain a copy of the License at 7 ** 8 ** http://www.apache.org/licenses/LICENSE-2.0 9 ** 10 ** Unless required by applicable law or agreed to in writing, software 11 ** distributed under the License is distributed on an "AS IS" BASIS, 12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 ** See the License for the specific language governing permissions and 14 ** limitations under the License. 15 */ 16 17 /*#error uncomment this for compiler test!*/ 18 19 #define ALOG_NIDEBUG 0 20 21 #define ALOG_TAG __FILE__ 22 #include <utils/Log.h> 23 #include <utils/threads.h> 24 #include <cutils/properties.h> 25 #include <fcntl.h> 26 #include <sys/mman.h> 27 28 #include <hardware/camera2.h> 29 #include <mm_camera_interface.h> 30 31 32 namespace android { 33 34 35 const uint32_t QCAvailableFormats[4] = { 36 HAL_PIXEL_FORMAT_RAW16, 37 HAL_PIXEL_FORMAT_BLOB, 38 HAL_PIXEL_FORMAT_YV12, 39 HAL_PIXEL_FORMAT_YCrCb_420_SP 40 }; 41 42 const uint32_t QCAvailableRawSizes[2] = { 43 640, 480 44 }; 45 46 47 const nsecs_t QCExposureTimeRange[2] = 48 {1000L, 30000000000L} ; // 1 us - 30 sec 49 const nsecs_t QCFrameDurationRange[2] = 50 {33331760L, 30000000000L}; // ~1/30 s - 30 sec 51 const nsecs_t QCMinVerticalBlank = 10000L; 52 53 const uint8_t QCColorFilterArrangement = ANDROID_SENSOR_RGGB; 54 55 // Output image data characteristics 56 const uint32_t QCMaxRawValue = 4000; 57 const uint32_t QCBlackLevel = 1000; 58 59 const uint64_t QCAvailableRawMinDurations[1] = { 60 QCFrameDurationRange[0] 61 }; 62 63 const uint32_t QCAvailableProcessedSizes[4] = { 64 640, 480, 320, 240 65 // Sensor::kResolution[0], Sensor::kResolution[1] 66 }; 67 68 const uint64_t QCAvailableProcessedMinDurations[1] = { 69 QCFrameDurationRange[0] 70 }; 71 72 73 const uint32_t QCAvailableJpegSizes[2] = { 74 640, 480 75 // Sensor::kResolution[0], Sensor::kResolution[1] 76 }; 77 78 const uint64_t QCAvailableJpegMinDurations[1] = { 79 QCFrameDurationRange[0] 80 }; 81 82 static status_t addOrSize(camera_metadata_t *request, 83 bool sizeRequest, 84 size_t *entryCount, 85 size_t *dataCount, 86 uint32_t tag, 87 const void *entryData, 88 size_t entryDataCount) { 89 status_t res; 90 if (!sizeRequest) { 91 return add_camera_metadata_entry(request, tag, entryData, 92 entryDataCount); 93 } else { 94 int type = get_camera_metadata_tag_type(tag); 95 if (type < 0 ) return BAD_VALUE; 96 (*entryCount)++; 97 (*dataCount) += calculate_camera_metadata_entry_data_size(type, 98 entryDataCount); 99 return OK; 100 } 101 } 102 103 extern "C" status_t getStaticInfo(camera_metadata_t **info, 104 mm_camera_vtbl_t *camera_vtbl, bool sizeRequest) 105 { 106 size_t entryCount = 0; 107 size_t dataCount = 0; 108 status_t ret; 109 110 if(!camera_vtbl) return BAD_VALUE; 111 112 bool mFacingBack = (camera_vtbl->camera_info->camera_info.position==BACK_CAMERA)? 113 true:false; 114 115 #define ADD_OR_SIZE( tag, data, count ) \ 116 if ( ( ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, \ 117 tag, data, count) ) != OK ) return ret 118 119 // android.lens 120 121 static float minFocusDistance = 0; 122 ADD_OR_SIZE(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 123 &minFocusDistance, 1); 124 ADD_OR_SIZE(ANDROID_LENS_HYPERFOCAL_DISTANCE, 125 &minFocusDistance, 1); 126 127 static float focalLength = 0.0f; 128 camera_vtbl->ops->get_parm(camera_vtbl->camera_handle, 129 MM_CAMERA_PARM_FOCAL_LENGTH, 130 (void *)&focalLength); 131 ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS, 132 &focalLength, 1); 133 134 static float aperture = 2.8f; 135 camera_vtbl->ops->get_parm(camera_vtbl->camera_handle, 136 MM_CAMERA_PARM_APERTURE, 137 (void *)&aperture); 138 ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_APERTURES, 139 &aperture, 1); 140 141 static float filterDensity = 0; 142 ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_FILTER_DENSITY, 143 &filterDensity, 1); 144 145 static const uint8_t availableOpticalStabilization = 146 ANDROID_LENS_OPTICAL_STABILIZATION_OFF; 147 ADD_OR_SIZE(ANDROID_LENS_AVAILABLE_OPTICAL_STABILIZATION, 148 &availableOpticalStabilization, 1); 149 150 static const int32_t lensShadingMapSize[] = {1, 1}; 151 ADD_OR_SIZE(ANDROID_LENS_SHADING_MAP_SIZE, lensShadingMapSize, 152 sizeof(lensShadingMapSize)/sizeof(int32_t)); 153 154 static const float lensShadingMap[3 * 1 * 1 ] = 155 { 1.f, 1.f, 1.f }; 156 ADD_OR_SIZE(ANDROID_LENS_SHADING_MAP, lensShadingMap, 157 sizeof(lensShadingMap)/sizeof(float)); 158 159 // Identity transform 160 static const int32_t geometricCorrectionMapSize[] = {2, 2}; 161 ADD_OR_SIZE(ANDROID_LENS_GEOMETRIC_CORRECTION_MAP_SIZE, 162 geometricCorrectionMapSize, 163 sizeof(geometricCorrectionMapSize)/sizeof(int32_t)); 164 165 static const float geometricCorrectionMap[2 * 3 * 2 * 2] = { 166 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 167 1.f, 0.f, 1.f, 0.f, 1.f, 0.f, 168 0.f, 1.f, 0.f, 1.f, 0.f, 1.f, 169 1.f, 1.f, 1.f, 1.f, 1.f, 1.f}; 170 ADD_OR_SIZE(ANDROID_LENS_GEOMETRIC_CORRECTION_MAP, 171 geometricCorrectionMap, 172 sizeof(geometricCorrectionMap)/sizeof(float)); 173 174 int32_t lensFacing = mFacingBack ? 175 ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT; 176 ADD_OR_SIZE(ANDROID_LENS_FACING, &lensFacing, 1); 177 178 #if 0 179 // android.sensor 180 181 ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME_RANGE, 182 QCExposureTimeRange, 2); 183 184 ADD_OR_SIZE(ANDROID_SENSOR_MAX_FRAME_DURATION, 185 &QCFrameDurationRange[1], 1); 186 187 ADD_OR_SIZE(ANDROID_SENSOR_AVAILABLE_SENSITIVITIES, 188 QCAvailableSensitivities, 189 sizeof(QCAvailableSensitivities) 190 /sizeof(uint32_t)); 191 192 ADD_OR_SIZE(ANDROID_SENSOR_COLOR_FILTER_ARRANGEMENT, 193 &QCColorFilterArrangement, 1); 194 #endif 195 static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm 196 ADD_OR_SIZE(ANDROID_SENSOR_PHYSICAL_SIZE, 197 sensorPhysicalSize, 2); 198 199 const unsigned int kResolution[2] = {640, 480}; 200 ADD_OR_SIZE(ANDROID_SENSOR_PIXEL_ARRAY_SIZE, 201 kResolution, 2); 202 203 ADD_OR_SIZE(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 204 kResolution, 2); 205 206 #if 0 207 ADD_OR_SIZE(ANDROID_SENSOR_WHITE_LEVEL, 208 &QCMaxRawValue, 1); 209 210 static const int32_t blackLevelPattern[4] = { 211 QCBlackLevel, QCBlackLevel, 212 QCBlackLevel, QCBlackLevel 213 }; 214 ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, 215 blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t)); 216 217 #endif 218 //TODO: sensor color calibration fields 219 220 // android.flash 221 static const uint8_t flashAvailable = 0; 222 ADD_OR_SIZE(ANDROID_FLASH_AVAILABLE, &flashAvailable, 1); 223 224 static const int64_t flashChargeDuration = 0; 225 ADD_OR_SIZE(ANDROID_FLASH_CHARGE_DURATION, &flashChargeDuration, 1); 226 227 // android.tonemap 228 229 static const int32_t tonemapCurvePoints = 128; 230 ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1); 231 232 #if 1 233 // android.scaler 234 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS, 235 QCAvailableFormats, 236 sizeof(QCAvailableFormats)/sizeof(uint32_t)); 237 238 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES, 239 QCAvailableRawSizes, 240 sizeof(QCAvailableRawSizes)/sizeof(uint32_t)); 241 242 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS, 243 QCAvailableRawMinDurations, 244 sizeof(QCAvailableRawMinDurations)/sizeof(uint64_t)); 245 246 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 247 QCAvailableProcessedSizes, 248 sizeof(QCAvailableProcessedSizes)/sizeof(uint32_t)); 249 250 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS, 251 QCAvailableProcessedMinDurations, 252 sizeof(QCAvailableProcessedMinDurations)/sizeof(uint64_t)); 253 254 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 255 QCAvailableJpegSizes, 256 sizeof(QCAvailableJpegSizes)/sizeof(uint32_t)); 257 258 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS, 259 QCAvailableJpegMinDurations, 260 sizeof(QCAvailableJpegMinDurations)/sizeof(uint64_t)); 261 262 static const float maxZoom = 10; 263 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 264 &maxZoom, 1); 265 266 // android.jpeg 267 268 static const int32_t jpegThumbnailSizes[] = { 269 160, 120, 270 320, 240 271 }; 272 ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 273 jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t)); 274 275 static const int32_t jpegMaxSize = 300000; 276 ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1); 277 278 // android.stats 279 280 static const uint8_t availableFaceDetectModes[] = { 281 ANDROID_STATS_FACE_DETECTION_OFF 282 }; 283 ADD_OR_SIZE(ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES, 284 availableFaceDetectModes, 285 sizeof(availableFaceDetectModes)); 286 287 static const int32_t maxFaceCount = 0; 288 ADD_OR_SIZE(ANDROID_STATS_MAX_FACE_COUNT, 289 &maxFaceCount, 1); 290 291 static const int32_t histogramSize = 64; 292 ADD_OR_SIZE(ANDROID_STATS_HISTOGRAM_BUCKET_COUNT, 293 &histogramSize, 1); 294 295 static const int32_t maxHistogramCount = 1000; 296 ADD_OR_SIZE(ANDROID_STATS_MAX_HISTOGRAM_COUNT, 297 &maxHistogramCount, 1); 298 299 static const int32_t sharpnessMapSize[2] = {64, 64}; 300 ADD_OR_SIZE(ANDROID_STATS_SHARPNESS_MAP_SIZE, 301 sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t)); 302 303 static const int32_t maxSharpnessMapValue = 1000; 304 ADD_OR_SIZE(ANDROID_STATS_MAX_SHARPNESS_MAP_VALUE, 305 &maxSharpnessMapValue, 1); 306 307 // android.control 308 309 static const uint8_t availableSceneModes[] = { 310 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED 311 }; 312 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 313 availableSceneModes, sizeof(availableSceneModes)); 314 315 static const uint8_t availableEffects[] = { 316 ANDROID_CONTROL_EFFECT_OFF 317 }; 318 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS, 319 availableEffects, sizeof(availableEffects)); 320 321 int32_t max3aRegions = 0; 322 ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS, 323 &max3aRegions, 1); 324 325 static const uint8_t availableAeModes[] = { 326 ANDROID_CONTROL_AE_OFF, 327 ANDROID_CONTROL_AE_ON 328 }; 329 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES, 330 availableAeModes, sizeof(availableAeModes)); 331 332 static const camera_metadata_rational exposureCompensationStep = { 333 1, 3 334 }; 335 ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 336 &exposureCompensationStep, 1); 337 338 int32_t exposureCompensationRange[] = {-9, 9}; 339 ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 340 exposureCompensationRange, 341 sizeof(exposureCompensationRange)/sizeof(int32_t)); 342 343 static const int32_t availableTargetFpsRanges[] = { 344 5, 30, 15, 30 345 }; 346 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 347 availableTargetFpsRanges, 348 sizeof(availableTargetFpsRanges)/sizeof(int32_t)); 349 350 static const uint8_t availableAntibandingModes[] = { 351 ANDROID_CONTROL_AE_ANTIBANDING_OFF, 352 ANDROID_CONTROL_AE_ANTIBANDING_AUTO 353 }; 354 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, 355 availableAntibandingModes, sizeof(availableAntibandingModes)); 356 357 static const uint8_t availableAwbModes[] = { 358 ANDROID_CONTROL_AWB_OFF, 359 ANDROID_CONTROL_AWB_AUTO, 360 ANDROID_CONTROL_AWB_INCANDESCENT, 361 ANDROID_CONTROL_AWB_FLUORESCENT, 362 ANDROID_CONTROL_AWB_DAYLIGHT, 363 ANDROID_CONTROL_AWB_SHADE 364 }; 365 ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 366 availableAwbModes, sizeof(availableAwbModes)); 367 368 static const uint8_t availableAfModes[] = { 369 ANDROID_CONTROL_AF_OFF 370 }; 371 ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES, 372 availableAfModes, sizeof(availableAfModes)); 373 374 static const uint8_t availableVstabModes[] = { 375 ANDROID_CONTROL_VIDEO_STABILIZATION_OFF 376 }; 377 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 378 availableVstabModes, sizeof(availableVstabModes)); 379 #endif 380 #undef ADD_OR_SIZE 381 /** Allocate metadata if sizing */ 382 if (sizeRequest) { 383 ALOGV("Allocating %d entries, %d extra bytes for " 384 "static camera info", 385 entryCount, dataCount); 386 *info = allocate_camera_metadata(entryCount, dataCount); 387 if (*info == NULL) { 388 ALOGE("Unable to allocate camera static info" 389 "(%d entries, %d bytes extra data)", 390 entryCount, dataCount); 391 return NO_MEMORY; 392 } 393 } 394 return OK; 395 } 396 397 extern "C" status_t constructDefaultRequest(int request_template, 398 camera_metadata_t **request, bool sizeRequest) 399 { 400 size_t entryCount = 0; 401 size_t dataCount = 0; 402 status_t ret; 403 404 #define ADD_OR_SIZE( tag, data, count ) \ 405 if ( ( ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, \ 406 tag, data, count) ) != OK ) return ret 407 408 static const int64_t USEC = 1000LL; 409 static const int64_t MSEC = USEC * 1000LL; 410 static const int64_t SEC = MSEC * 1000LL; 411 412 /** android.request */ 413 414 static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_NONE; 415 ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1); 416 417 static const int32_t id = 0; 418 ADD_OR_SIZE(ANDROID_REQUEST_ID, &id, 1); 419 420 static const int32_t frameCount = 0; 421 ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1); 422 423 // OUTPUT_STREAMS set by user 424 entryCount += 1; 425 dataCount += 5; // TODO: Should be maximum stream number 426 427 /** android.lens */ 428 429 static const float focusDistance = 0; 430 ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1); 431 432 static const float aperture = 2.8f; 433 ADD_OR_SIZE(ANDROID_LENS_APERTURE, &aperture, 1); 434 435 static const float focalLength = 5.0f; 436 ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH, &focalLength, 1); 437 438 static const float filterDensity = 0; 439 ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1); 440 441 static const uint8_t opticalStabilizationMode = 442 ANDROID_LENS_OPTICAL_STABILIZATION_OFF; 443 ADD_OR_SIZE(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, 444 &opticalStabilizationMode, 1); 445 446 // FOCUS_RANGE set only in frame 447 448 /** android.sensor */ 449 450 static const int64_t exposureTime = 10 * MSEC; 451 ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime, 1); 452 453 static const int64_t frameDuration = 33333333L; // 1/30 s 454 ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1); 455 456 static const int32_t sensitivity = 100; 457 ADD_OR_SIZE(ANDROID_SENSOR_SENSITIVITY, &sensitivity, 1); 458 459 // TIMESTAMP set only in frame 460 461 /** android.flash */ 462 463 static const uint8_t flashMode = ANDROID_FLASH_OFF; 464 ADD_OR_SIZE(ANDROID_FLASH_MODE, &flashMode, 1); 465 466 static const uint8_t flashPower = 10; 467 ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER, &flashPower, 1); 468 469 static const int64_t firingTime = 0; 470 ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME, &firingTime, 1); 471 472 /** Processing block modes */ 473 uint8_t hotPixelMode = 0; 474 uint8_t demosaicMode = 0; 475 uint8_t noiseMode = 0; 476 uint8_t shadingMode = 0; 477 uint8_t geometricMode = 0; 478 uint8_t colorMode = 0; 479 uint8_t tonemapMode = 0; 480 uint8_t edgeMode = 0; 481 switch (request_template) { 482 case CAMERA2_TEMPLATE_PREVIEW: 483 hotPixelMode = ANDROID_PROCESSING_FAST; 484 demosaicMode = ANDROID_PROCESSING_FAST; 485 noiseMode = ANDROID_PROCESSING_FAST; 486 shadingMode = ANDROID_PROCESSING_FAST; 487 geometricMode = ANDROID_PROCESSING_FAST; 488 colorMode = ANDROID_PROCESSING_FAST; 489 tonemapMode = ANDROID_PROCESSING_FAST; 490 edgeMode = ANDROID_PROCESSING_FAST; 491 break; 492 case CAMERA2_TEMPLATE_STILL_CAPTURE: 493 hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY; 494 demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY; 495 noiseMode = ANDROID_PROCESSING_HIGH_QUALITY; 496 shadingMode = ANDROID_PROCESSING_HIGH_QUALITY; 497 geometricMode = ANDROID_PROCESSING_HIGH_QUALITY; 498 colorMode = ANDROID_PROCESSING_HIGH_QUALITY; 499 tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY; 500 edgeMode = ANDROID_PROCESSING_HIGH_QUALITY; 501 break; 502 case CAMERA2_TEMPLATE_VIDEO_RECORD: 503 hotPixelMode = ANDROID_PROCESSING_FAST; 504 demosaicMode = ANDROID_PROCESSING_FAST; 505 noiseMode = ANDROID_PROCESSING_FAST; 506 shadingMode = ANDROID_PROCESSING_FAST; 507 geometricMode = ANDROID_PROCESSING_FAST; 508 colorMode = ANDROID_PROCESSING_FAST; 509 tonemapMode = ANDROID_PROCESSING_FAST; 510 edgeMode = ANDROID_PROCESSING_FAST; 511 break; 512 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: 513 hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY; 514 demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY; 515 noiseMode = ANDROID_PROCESSING_HIGH_QUALITY; 516 shadingMode = ANDROID_PROCESSING_HIGH_QUALITY; 517 geometricMode = ANDROID_PROCESSING_HIGH_QUALITY; 518 colorMode = ANDROID_PROCESSING_HIGH_QUALITY; 519 tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY; 520 edgeMode = ANDROID_PROCESSING_HIGH_QUALITY; 521 break; 522 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: 523 hotPixelMode = ANDROID_PROCESSING_HIGH_QUALITY; 524 demosaicMode = ANDROID_PROCESSING_HIGH_QUALITY; 525 noiseMode = ANDROID_PROCESSING_HIGH_QUALITY; 526 shadingMode = ANDROID_PROCESSING_HIGH_QUALITY; 527 geometricMode = ANDROID_PROCESSING_HIGH_QUALITY; 528 colorMode = ANDROID_PROCESSING_HIGH_QUALITY; 529 tonemapMode = ANDROID_PROCESSING_HIGH_QUALITY; 530 edgeMode = ANDROID_PROCESSING_HIGH_QUALITY; 531 break; 532 default: 533 hotPixelMode = ANDROID_PROCESSING_FAST; 534 demosaicMode = ANDROID_PROCESSING_FAST; 535 noiseMode = ANDROID_PROCESSING_FAST; 536 shadingMode = ANDROID_PROCESSING_FAST; 537 geometricMode = ANDROID_PROCESSING_FAST; 538 colorMode = ANDROID_PROCESSING_FAST; 539 tonemapMode = ANDROID_PROCESSING_FAST; 540 edgeMode = ANDROID_PROCESSING_FAST; 541 break; 542 } 543 ADD_OR_SIZE(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1); 544 ADD_OR_SIZE(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1); 545 ADD_OR_SIZE(ANDROID_NOISE_MODE, &noiseMode, 1); 546 ADD_OR_SIZE(ANDROID_SHADING_MODE, &shadingMode, 1); 547 ADD_OR_SIZE(ANDROID_GEOMETRIC_MODE, &geometricMode, 1); 548 ADD_OR_SIZE(ANDROID_COLOR_MODE, &colorMode, 1); 549 ADD_OR_SIZE(ANDROID_TONEMAP_MODE, &tonemapMode, 1); 550 ADD_OR_SIZE(ANDROID_EDGE_MODE, &edgeMode, 1); 551 552 /** android.noise */ 553 static const uint8_t noiseStrength = 5; 554 ADD_OR_SIZE(ANDROID_NOISE_STRENGTH, &noiseStrength, 1); 555 556 /** android.color */ 557 static const float colorTransform[9] = { 558 1.0f, 0.f, 0.f, 559 0.f, 1.f, 0.f, 560 0.f, 0.f, 1.f 561 }; 562 ADD_OR_SIZE(ANDROID_COLOR_TRANSFORM, colorTransform, 9); 563 564 /** android.tonemap */ 565 static const float tonemapCurve[4] = { 566 0.f, 0.f, 567 1.f, 1.f 568 }; 569 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 4); 570 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 4); 571 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 4); 572 573 /** android.edge */ 574 static const uint8_t edgeStrength = 5; 575 ADD_OR_SIZE(ANDROID_EDGE_STRENGTH, &edgeStrength, 1); 576 577 /** android.scaler */ 578 static const int32_t cropRegion[3] = { 579 0, 0, /*kResolution[0]*/ 580 }; 581 ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3); 582 583 /** android.jpeg */ 584 static const int32_t jpegQuality = 80; 585 ADD_OR_SIZE(ANDROID_JPEG_QUALITY, &jpegQuality, 1); 586 587 static const int32_t thumbnailSize[2] = { 588 640, 480 589 }; 590 ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2); 591 592 static const int32_t thumbnailQuality = 80; 593 ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1); 594 595 static const double gpsCoordinates[2] = { 596 0, 0 597 }; 598 ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 2); 599 600 static const uint8_t gpsProcessingMethod[32] = "None"; 601 ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32); 602 603 static const int64_t gpsTimestamp = 0; 604 ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1); 605 606 static const int32_t jpegOrientation = 0; 607 ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1); 608 609 /** android.stats */ 610 611 static const uint8_t faceDetectMode = ANDROID_STATS_FACE_DETECTION_OFF; 612 ADD_OR_SIZE(ANDROID_STATS_FACE_DETECT_MODE, &faceDetectMode, 1); 613 614 static const uint8_t histogramMode = ANDROID_STATS_OFF; 615 ADD_OR_SIZE(ANDROID_STATS_HISTOGRAM_MODE, &histogramMode, 1); 616 617 static const uint8_t sharpnessMapMode = ANDROID_STATS_OFF; 618 ADD_OR_SIZE(ANDROID_STATS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1); 619 620 // faceRectangles, faceScores, faceLandmarks, faceIds, histogram, 621 // sharpnessMap only in frames 622 623 /** android.control */ 624 625 uint8_t controlIntent = 0; 626 switch (request_template) { 627 case CAMERA2_TEMPLATE_PREVIEW: 628 controlIntent = ANDROID_CONTROL_INTENT_PREVIEW; 629 break; 630 case CAMERA2_TEMPLATE_STILL_CAPTURE: 631 controlIntent = ANDROID_CONTROL_INTENT_STILL_CAPTURE; 632 break; 633 case CAMERA2_TEMPLATE_VIDEO_RECORD: 634 controlIntent = ANDROID_CONTROL_INTENT_VIDEO_RECORD; 635 break; 636 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: 637 controlIntent = ANDROID_CONTROL_INTENT_VIDEO_SNAPSHOT; 638 break; 639 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: 640 controlIntent = ANDROID_CONTROL_INTENT_ZERO_SHUTTER_LAG; 641 break; 642 default: 643 controlIntent = ANDROID_CONTROL_INTENT_CUSTOM; 644 break; 645 } 646 ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1); 647 648 static const uint8_t controlMode = ANDROID_CONTROL_AUTO; 649 ADD_OR_SIZE(ANDROID_CONTROL_MODE, &controlMode, 1); 650 651 static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_OFF; 652 ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1); 653 654 static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; 655 ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1); 656 657 static const uint8_t aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; 658 ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE, &aeMode, 1); 659 660 const unsigned int kResolution[2] = {640, 480}; 661 static const int32_t controlRegions[5] = { 662 0, 0, kResolution[0], kResolution[1], 1000 663 }; 664 ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5); 665 666 static const int32_t aeExpCompensation = 0; 667 ADD_OR_SIZE(ANDROID_CONTROL_AE_EXP_COMPENSATION, &aeExpCompensation, 1); 668 669 static const int32_t aeTargetFpsRange[2] = { 670 10, 30 671 }; 672 ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2); 673 674 static const uint8_t aeAntibandingMode = 675 ANDROID_CONTROL_AE_ANTIBANDING_AUTO; 676 ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1); 677 678 static const uint8_t awbMode = 679 ANDROID_CONTROL_AWB_AUTO; 680 ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE, &awbMode, 1); 681 682 ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5); 683 684 uint8_t afMode = 0; 685 switch (request_template) { 686 case CAMERA2_TEMPLATE_PREVIEW: 687 afMode = ANDROID_CONTROL_AF_AUTO; 688 break; 689 case CAMERA2_TEMPLATE_STILL_CAPTURE: 690 afMode = ANDROID_CONTROL_AF_AUTO; 691 break; 692 case CAMERA2_TEMPLATE_VIDEO_RECORD: 693 afMode = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO; 694 break; 695 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: 696 afMode = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO; 697 break; 698 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: 699 afMode = ANDROID_CONTROL_AF_CONTINUOUS_PICTURE; 700 break; 701 default: 702 afMode = ANDROID_CONTROL_AF_AUTO; 703 break; 704 } 705 ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE, &afMode, 1); 706 707 ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5); 708 709 static const uint8_t vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_OFF; 710 ADD_OR_SIZE(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1); 711 712 // aeState, awbState, afState only in frame 713 714 /** Allocate metadata if sizing */ 715 if (sizeRequest) { 716 ALOGV("Allocating %d entries, %d extra bytes for " 717 "request template type %d", 718 entryCount, dataCount, request_template); 719 *request = allocate_camera_metadata(entryCount, dataCount); 720 if (*request == NULL) { 721 ALOGE("Unable to allocate new request template type %d " 722 "(%d entries, %d bytes extra data)", request_template, 723 entryCount, dataCount); 724 return NO_MEMORY; 725 } 726 } 727 return OK; 728 #undef ADD_OR_SIZE 729 } 730 731 }; 732
