1 /* 2 * Copyright (C) 2013 The Android Open Source Project 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 /* 18 * Contains implementation of a class EmulatedFakeCamera3 that encapsulates 19 * functionality of an advanced fake camera. 20 */ 21 22 #include <inttypes.h> 23 24 //#define LOG_NDEBUG 0 25 //#define LOG_NNDEBUG 0 26 #define LOG_TAG "EmulatedCamera_FakeCamera3" 27 #include <cutils/properties.h> 28 #include <utils/Log.h> 29 30 #include "EmulatedFakeCamera3.h" 31 #include "EmulatedCameraFactory.h" 32 #include <ui/Fence.h> 33 #include <ui/Rect.h> 34 #include <ui/GraphicBufferMapper.h> 35 #include "gralloc_cb.h" 36 37 #include "fake-pipeline2/Sensor.h" 38 #include "fake-pipeline2/JpegCompressor.h" 39 #include <cmath> 40 41 #include <vector> 42 43 #if defined(LOG_NNDEBUG) && LOG_NNDEBUG == 0 44 #define ALOGVV ALOGV 45 #else 46 #define ALOGVV(...) ((void)0) 47 #endif 48 49 namespace android { 50 51 /** 52 * Constants for camera capabilities 53 */ 54 55 const int64_t USEC = 1000LL; 56 const int64_t MSEC = USEC * 1000LL; 57 const int64_t SEC = MSEC * 1000LL; 58 59 const int32_t EmulatedFakeCamera3::kAvailableFormats[] = { 60 HAL_PIXEL_FORMAT_RAW16, 61 HAL_PIXEL_FORMAT_BLOB, 62 HAL_PIXEL_FORMAT_RGBA_8888, 63 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 64 // These are handled by YCbCr_420_888 65 // HAL_PIXEL_FORMAT_YV12, 66 // HAL_PIXEL_FORMAT_YCrCb_420_SP, 67 HAL_PIXEL_FORMAT_YCbCr_420_888, 68 HAL_PIXEL_FORMAT_Y16 69 }; 70 71 /** 72 * 3A constants 73 */ 74 75 // Default exposure and gain targets for different scenarios 76 const nsecs_t EmulatedFakeCamera3::kNormalExposureTime = 10 * MSEC; 77 const nsecs_t EmulatedFakeCamera3::kFacePriorityExposureTime = 30 * MSEC; 78 const int EmulatedFakeCamera3::kNormalSensitivity = 100; 79 const int EmulatedFakeCamera3::kFacePrioritySensitivity = 400; 80 const float EmulatedFakeCamera3::kExposureTrackRate = 0.1; 81 const int EmulatedFakeCamera3::kPrecaptureMinFrames = 10; 82 const int EmulatedFakeCamera3::kStableAeMaxFrames = 100; 83 const float EmulatedFakeCamera3::kExposureWanderMin = -2; 84 const float EmulatedFakeCamera3::kExposureWanderMax = 1; 85 86 /** 87 * Camera device lifecycle methods 88 */ 89 90 EmulatedFakeCamera3::EmulatedFakeCamera3(int cameraId, bool facingBack, 91 struct hw_module_t* module) : 92 EmulatedCamera3(cameraId, module), 93 mFacingBack(facingBack) { 94 ALOGI("Constructing emulated fake camera 3: ID %d, facing %s", 95 mCameraID, facingBack ? "back" : "front"); 96 97 for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++) { 98 mDefaultTemplates[i] = NULL; 99 } 100 101 } 102 103 EmulatedFakeCamera3::~EmulatedFakeCamera3() { 104 for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++) { 105 if (mDefaultTemplates[i] != NULL) { 106 free_camera_metadata(mDefaultTemplates[i]); 107 } 108 } 109 } 110 111 status_t EmulatedFakeCamera3::Initialize() { 112 ALOGV("%s: E", __FUNCTION__); 113 status_t res; 114 115 if (mStatus != STATUS_ERROR) { 116 ALOGE("%s: Already initialized!", __FUNCTION__); 117 return INVALID_OPERATION; 118 } 119 120 res = getCameraCapabilities(); 121 if (res != OK) { 122 ALOGE("%s: Unable to get camera capabilities: %s (%d)", 123 __FUNCTION__, strerror(-res), res); 124 return res; 125 } 126 127 res = constructStaticInfo(); 128 if (res != OK) { 129 ALOGE("%s: Unable to allocate static info: %s (%d)", 130 __FUNCTION__, strerror(-res), res); 131 return res; 132 } 133 134 return EmulatedCamera3::Initialize(); 135 } 136 137 status_t EmulatedFakeCamera3::connectCamera(hw_device_t** device) { 138 ALOGV("%s: E", __FUNCTION__); 139 Mutex::Autolock l(mLock); 140 status_t res; 141 142 if (mStatus != STATUS_CLOSED) { 143 ALOGE("%s: Can't connect in state %d", __FUNCTION__, mStatus); 144 return INVALID_OPERATION; 145 } 146 147 mSensor = new Sensor(); 148 mSensor->setSensorListener(this); 149 150 res = mSensor->startUp(); 151 if (res != NO_ERROR) return res; 152 153 mReadoutThread = new ReadoutThread(this); 154 mJpegCompressor = new JpegCompressor(); 155 156 res = mReadoutThread->run("EmuCam3::readoutThread"); 157 if (res != NO_ERROR) return res; 158 159 // Initialize fake 3A 160 161 mControlMode = ANDROID_CONTROL_MODE_AUTO; 162 mFacePriority = false; 163 mAeMode = ANDROID_CONTROL_AE_MODE_ON; 164 mAfMode = ANDROID_CONTROL_AF_MODE_AUTO; 165 mAwbMode = ANDROID_CONTROL_AWB_MODE_AUTO; 166 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; 167 mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; 168 mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; 169 mAeCounter = 0; 170 mAeTargetExposureTime = kNormalExposureTime; 171 mAeCurrentExposureTime = kNormalExposureTime; 172 mAeCurrentSensitivity = kNormalSensitivity; 173 174 return EmulatedCamera3::connectCamera(device); 175 } 176 177 status_t EmulatedFakeCamera3::closeCamera() { 178 ALOGV("%s: E", __FUNCTION__); 179 status_t res; 180 { 181 Mutex::Autolock l(mLock); 182 if (mStatus == STATUS_CLOSED) return OK; 183 184 res = mSensor->shutDown(); 185 if (res != NO_ERROR) { 186 ALOGE("%s: Unable to shut down sensor: %d", __FUNCTION__, res); 187 return res; 188 } 189 mSensor.clear(); 190 191 mReadoutThread->requestExit(); 192 } 193 194 mReadoutThread->join(); 195 196 { 197 Mutex::Autolock l(mLock); 198 // Clear out private stream information 199 for (StreamIterator s = mStreams.begin(); s != mStreams.end(); s++) { 200 PrivateStreamInfo *privStream = 201 static_cast<PrivateStreamInfo*>((*s)->priv); 202 delete privStream; 203 (*s)->priv = NULL; 204 } 205 mStreams.clear(); 206 mReadoutThread.clear(); 207 } 208 209 return EmulatedCamera3::closeCamera(); 210 } 211 212 status_t EmulatedFakeCamera3::getCameraInfo(struct camera_info *info) { 213 info->facing = mFacingBack ? CAMERA_FACING_BACK : CAMERA_FACING_FRONT; 214 info->orientation = gEmulatedCameraFactory.getFakeCameraOrientation(); 215 return EmulatedCamera3::getCameraInfo(info); 216 } 217 218 /** 219 * Camera3 interface methods 220 */ 221 222 status_t EmulatedFakeCamera3::configureStreams( 223 camera3_stream_configuration *streamList) { 224 Mutex::Autolock l(mLock); 225 ALOGV("%s: %d streams", __FUNCTION__, streamList->num_streams); 226 227 if (mStatus != STATUS_OPEN && mStatus != STATUS_READY) { 228 ALOGE("%s: Cannot configure streams in state %d", 229 __FUNCTION__, mStatus); 230 return NO_INIT; 231 } 232 233 /** 234 * Sanity-check input list. 235 */ 236 if (streamList == NULL) { 237 ALOGE("%s: NULL stream configuration", __FUNCTION__); 238 return BAD_VALUE; 239 } 240 241 if (streamList->streams == NULL) { 242 ALOGE("%s: NULL stream list", __FUNCTION__); 243 return BAD_VALUE; 244 } 245 246 if (streamList->num_streams < 1) { 247 ALOGE("%s: Bad number of streams requested: %d", __FUNCTION__, 248 streamList->num_streams); 249 return BAD_VALUE; 250 } 251 252 camera3_stream_t *inputStream = NULL; 253 for (size_t i = 0; i < streamList->num_streams; i++) { 254 camera3_stream_t *newStream = streamList->streams[i]; 255 256 if (newStream == NULL) { 257 ALOGE("%s: Stream index %zu was NULL", 258 __FUNCTION__, i); 259 return BAD_VALUE; 260 } 261 262 ALOGV("%s: Stream %p (id %zu), type %d, usage 0x%x, format 0x%x", 263 __FUNCTION__, newStream, i, newStream->stream_type, 264 newStream->usage, 265 newStream->format); 266 267 if (newStream->stream_type == CAMERA3_STREAM_INPUT || 268 newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL) { 269 if (inputStream != NULL) { 270 271 ALOGE("%s: Multiple input streams requested!", __FUNCTION__); 272 return BAD_VALUE; 273 } 274 inputStream = newStream; 275 } 276 277 bool validFormat = false; 278 for (size_t f = 0; 279 f < sizeof(kAvailableFormats)/sizeof(kAvailableFormats[0]); 280 f++) { 281 if (newStream->format == kAvailableFormats[f]) { 282 validFormat = true; 283 break; 284 } 285 } 286 if (!validFormat) { 287 ALOGE("%s: Unsupported stream format 0x%x requested", 288 __FUNCTION__, newStream->format); 289 return BAD_VALUE; 290 } 291 } 292 mInputStream = inputStream; 293 294 /** 295 * Initially mark all existing streams as not alive 296 */ 297 for (StreamIterator s = mStreams.begin(); s != mStreams.end(); ++s) { 298 PrivateStreamInfo *privStream = 299 static_cast<PrivateStreamInfo*>((*s)->priv); 300 privStream->alive = false; 301 } 302 303 /** 304 * Find new streams and mark still-alive ones 305 */ 306 for (size_t i = 0; i < streamList->num_streams; i++) { 307 camera3_stream_t *newStream = streamList->streams[i]; 308 if (newStream->priv == NULL) { 309 // New stream, construct info 310 PrivateStreamInfo *privStream = new PrivateStreamInfo(); 311 privStream->alive = true; 312 313 newStream->max_buffers = kMaxBufferCount; 314 newStream->priv = privStream; 315 mStreams.push_back(newStream); 316 } else { 317 // Existing stream, mark as still alive. 318 PrivateStreamInfo *privStream = 319 static_cast<PrivateStreamInfo*>(newStream->priv); 320 privStream->alive = true; 321 } 322 // Always update usage and max buffers 323 newStream->max_buffers = kMaxBufferCount; 324 switch (newStream->stream_type) { 325 case CAMERA3_STREAM_OUTPUT: 326 newStream->usage = GRALLOC_USAGE_HW_CAMERA_WRITE; 327 break; 328 case CAMERA3_STREAM_INPUT: 329 newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ; 330 break; 331 case CAMERA3_STREAM_BIDIRECTIONAL: 332 newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ | 333 GRALLOC_USAGE_HW_CAMERA_WRITE; 334 break; 335 } 336 } 337 338 /** 339 * Reap the dead streams 340 */ 341 for (StreamIterator s = mStreams.begin(); s != mStreams.end();) { 342 PrivateStreamInfo *privStream = 343 static_cast<PrivateStreamInfo*>((*s)->priv); 344 if (!privStream->alive) { 345 (*s)->priv = NULL; 346 delete privStream; 347 s = mStreams.erase(s); 348 } else { 349 ++s; 350 } 351 } 352 353 /** 354 * Can't reuse settings across configure call 355 */ 356 mPrevSettings.clear(); 357 358 return OK; 359 } 360 361 status_t EmulatedFakeCamera3::registerStreamBuffers( 362 const camera3_stream_buffer_set *bufferSet) { 363 ALOGV("%s: E", __FUNCTION__); 364 Mutex::Autolock l(mLock); 365 366 // Should not be called in HAL versions >= 3.2 367 368 ALOGE("%s: Should not be invoked on new HALs!", 369 __FUNCTION__); 370 return NO_INIT; 371 } 372 373 const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings( 374 int type) { 375 ALOGV("%s: E", __FUNCTION__); 376 Mutex::Autolock l(mLock); 377 378 if (type < 0 || type >= CAMERA3_TEMPLATE_COUNT) { 379 ALOGE("%s: Unknown request settings template: %d", 380 __FUNCTION__, type); 381 return NULL; 382 } 383 384 if (!hasCapability(BACKWARD_COMPATIBLE) && type != CAMERA3_TEMPLATE_PREVIEW) { 385 ALOGE("%s: Template %d not supported w/o BACKWARD_COMPATIBLE capability", 386 __FUNCTION__, type); 387 return NULL; 388 } 389 390 /** 391 * Cache is not just an optimization - pointer returned has to live at 392 * least as long as the camera device instance does. 393 */ 394 if (mDefaultTemplates[type] != NULL) { 395 return mDefaultTemplates[type]; 396 } 397 398 CameraMetadata settings; 399 400 /** android.request */ 401 402 static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL; 403 settings.update(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1); 404 405 static const int32_t id = 0; 406 settings.update(ANDROID_REQUEST_ID, &id, 1); 407 408 static const int32_t frameCount = 0; 409 settings.update(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1); 410 411 /** android.lens */ 412 413 static const float focalLength = 5.0f; 414 settings.update(ANDROID_LENS_FOCAL_LENGTH, &focalLength, 1); 415 416 if (hasCapability(BACKWARD_COMPATIBLE)) { 417 static const float focusDistance = 0; 418 settings.update(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1); 419 420 static const float aperture = 2.8f; 421 settings.update(ANDROID_LENS_APERTURE, &aperture, 1); 422 423 static const float filterDensity = 0; 424 settings.update(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1); 425 426 static const uint8_t opticalStabilizationMode = 427 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; 428 settings.update(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, 429 &opticalStabilizationMode, 1); 430 431 // FOCUS_RANGE set only in frame 432 } 433 434 /** android.sensor */ 435 436 if (hasCapability(MANUAL_SENSOR)) { 437 static const int64_t exposureTime = 10 * MSEC; 438 settings.update(ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime, 1); 439 440 static const int64_t frameDuration = 33333333L; // 1/30 s 441 settings.update(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1); 442 443 static const int32_t sensitivity = 100; 444 settings.update(ANDROID_SENSOR_SENSITIVITY, &sensitivity, 1); 445 } 446 447 // TIMESTAMP set only in frame 448 449 /** android.flash */ 450 451 if (hasCapability(BACKWARD_COMPATIBLE)) { 452 static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF; 453 settings.update(ANDROID_FLASH_MODE, &flashMode, 1); 454 455 static const uint8_t flashPower = 10; 456 settings.update(ANDROID_FLASH_FIRING_POWER, &flashPower, 1); 457 458 static const int64_t firingTime = 0; 459 settings.update(ANDROID_FLASH_FIRING_TIME, &firingTime, 1); 460 } 461 462 /** Processing block modes */ 463 if (hasCapability(MANUAL_POST_PROCESSING)) { 464 uint8_t hotPixelMode = 0; 465 uint8_t demosaicMode = 0; 466 uint8_t noiseMode = 0; 467 uint8_t shadingMode = 0; 468 uint8_t colorMode = 0; 469 uint8_t tonemapMode = 0; 470 uint8_t edgeMode = 0; 471 switch (type) { 472 case CAMERA3_TEMPLATE_STILL_CAPTURE: 473 // fall-through 474 case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT: 475 // fall-through 476 case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG: 477 hotPixelMode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY; 478 demosaicMode = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY; 479 noiseMode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY; 480 shadingMode = ANDROID_SHADING_MODE_HIGH_QUALITY; 481 colorMode = ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY; 482 tonemapMode = ANDROID_TONEMAP_MODE_HIGH_QUALITY; 483 edgeMode = ANDROID_EDGE_MODE_HIGH_QUALITY; 484 break; 485 case CAMERA3_TEMPLATE_PREVIEW: 486 // fall-through 487 case CAMERA3_TEMPLATE_VIDEO_RECORD: 488 // fall-through 489 default: 490 hotPixelMode = ANDROID_HOT_PIXEL_MODE_FAST; 491 demosaicMode = ANDROID_DEMOSAIC_MODE_FAST; 492 noiseMode = ANDROID_NOISE_REDUCTION_MODE_FAST; 493 shadingMode = ANDROID_SHADING_MODE_FAST; 494 colorMode = ANDROID_COLOR_CORRECTION_MODE_FAST; 495 tonemapMode = ANDROID_TONEMAP_MODE_FAST; 496 edgeMode = ANDROID_EDGE_MODE_FAST; 497 break; 498 } 499 settings.update(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1); 500 settings.update(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1); 501 settings.update(ANDROID_NOISE_REDUCTION_MODE, &noiseMode, 1); 502 settings.update(ANDROID_SHADING_MODE, &shadingMode, 1); 503 settings.update(ANDROID_COLOR_CORRECTION_MODE, &colorMode, 1); 504 settings.update(ANDROID_TONEMAP_MODE, &tonemapMode, 1); 505 settings.update(ANDROID_EDGE_MODE, &edgeMode, 1); 506 } 507 508 /** android.colorCorrection */ 509 510 if (hasCapability(MANUAL_POST_PROCESSING)) { 511 static const camera_metadata_rational colorTransform[9] = { 512 {1,1}, {0,1}, {0,1}, 513 {0,1}, {1,1}, {0,1}, 514 {0,1}, {0,1}, {1,1} 515 }; 516 settings.update(ANDROID_COLOR_CORRECTION_TRANSFORM, colorTransform, 9); 517 518 static const float colorGains[4] = { 519 1.0f, 1.0f, 1.0f, 1.0f 520 }; 521 settings.update(ANDROID_COLOR_CORRECTION_GAINS, colorGains, 4); 522 } 523 524 /** android.tonemap */ 525 526 if (hasCapability(MANUAL_POST_PROCESSING)) { 527 static const float tonemapCurve[4] = { 528 0.f, 0.f, 529 1.f, 1.f 530 }; 531 settings.update(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 4); 532 settings.update(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 4); 533 settings.update(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 4); 534 } 535 536 /** android.scaler */ 537 if (hasCapability(BACKWARD_COMPATIBLE)) { 538 static const int32_t cropRegion[4] = { 539 0, 0, (int32_t)Sensor::kResolution[0], (int32_t)Sensor::kResolution[1] 540 }; 541 settings.update(ANDROID_SCALER_CROP_REGION, cropRegion, 4); 542 } 543 544 /** android.jpeg */ 545 if (hasCapability(BACKWARD_COMPATIBLE)) { 546 static const uint8_t jpegQuality = 80; 547 settings.update(ANDROID_JPEG_QUALITY, &jpegQuality, 1); 548 549 static const int32_t thumbnailSize[2] = { 550 640, 480 551 }; 552 settings.update(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2); 553 554 static const uint8_t thumbnailQuality = 80; 555 settings.update(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1); 556 557 static const double gpsCoordinates[2] = { 558 0, 0 559 }; 560 settings.update(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 2); 561 562 static const uint8_t gpsProcessingMethod[32] = "None"; 563 settings.update(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32); 564 565 static const int64_t gpsTimestamp = 0; 566 settings.update(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1); 567 568 static const int32_t jpegOrientation = 0; 569 settings.update(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1); 570 } 571 572 /** android.stats */ 573 574 if (hasCapability(BACKWARD_COMPATIBLE)) { 575 static const uint8_t faceDetectMode = 576 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; 577 settings.update(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1); 578 579 static const uint8_t hotPixelMapMode = 580 ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF; 581 settings.update(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, &hotPixelMapMode, 1); 582 } 583 584 // faceRectangles, faceScores, faceLandmarks, faceIds, histogram, 585 // sharpnessMap only in frames 586 587 /** android.control */ 588 589 uint8_t controlIntent = 0; 590 switch (type) { 591 case CAMERA3_TEMPLATE_PREVIEW: 592 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; 593 break; 594 case CAMERA3_TEMPLATE_STILL_CAPTURE: 595 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE; 596 break; 597 case CAMERA3_TEMPLATE_VIDEO_RECORD: 598 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD; 599 break; 600 case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT: 601 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT; 602 break; 603 case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG: 604 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG; 605 break; 606 case CAMERA3_TEMPLATE_MANUAL: 607 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_MANUAL; 608 break; 609 default: 610 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM; 611 break; 612 } 613 settings.update(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1); 614 615 const uint8_t controlMode = (type == CAMERA3_TEMPLATE_MANUAL) ? 616 ANDROID_CONTROL_MODE_OFF : 617 ANDROID_CONTROL_MODE_AUTO; 618 settings.update(ANDROID_CONTROL_MODE, &controlMode, 1); 619 620 int32_t aeTargetFpsRange[2] = { 621 5, 30 622 }; 623 if (type == CAMERA3_TEMPLATE_VIDEO_RECORD || type == CAMERA3_TEMPLATE_VIDEO_SNAPSHOT) { 624 aeTargetFpsRange[0] = 30; 625 } 626 settings.update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2); 627 628 if (hasCapability(BACKWARD_COMPATIBLE)) { 629 630 static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; 631 settings.update(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1); 632 633 static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; 634 settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1); 635 636 const uint8_t aeMode = (type == CAMERA3_TEMPLATE_MANUAL) ? 637 ANDROID_CONTROL_AE_MODE_OFF : 638 ANDROID_CONTROL_AE_MODE_ON; 639 settings.update(ANDROID_CONTROL_AE_MODE, &aeMode, 1); 640 641 static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF; 642 settings.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1); 643 644 static const int32_t controlRegions[5] = { 645 0, 0, 0, 0, 0 646 }; 647 settings.update(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5); 648 649 static const int32_t aeExpCompensation = 0; 650 settings.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExpCompensation, 1); 651 652 653 static const uint8_t aeAntibandingMode = 654 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO; 655 settings.update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1); 656 657 static const uint8_t aePrecaptureTrigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE; 658 settings.update(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, &aePrecaptureTrigger, 1); 659 660 const uint8_t awbMode = (type == CAMERA3_TEMPLATE_MANUAL) ? 661 ANDROID_CONTROL_AWB_MODE_OFF : 662 ANDROID_CONTROL_AWB_MODE_AUTO; 663 settings.update(ANDROID_CONTROL_AWB_MODE, &awbMode, 1); 664 665 static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF; 666 settings.update(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1); 667 668 uint8_t afMode = 0; 669 switch (type) { 670 case CAMERA3_TEMPLATE_PREVIEW: 671 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE; 672 break; 673 case CAMERA3_TEMPLATE_STILL_CAPTURE: 674 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE; 675 break; 676 case CAMERA3_TEMPLATE_VIDEO_RECORD: 677 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO; 678 break; 679 case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT: 680 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO; 681 break; 682 case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG: 683 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE; 684 break; 685 case CAMERA3_TEMPLATE_MANUAL: 686 afMode = ANDROID_CONTROL_AF_MODE_OFF; 687 break; 688 default: 689 afMode = ANDROID_CONTROL_AF_MODE_AUTO; 690 break; 691 } 692 settings.update(ANDROID_CONTROL_AF_MODE, &afMode, 1); 693 694 settings.update(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5); 695 696 static const uint8_t afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE; 697 settings.update(ANDROID_CONTROL_AF_TRIGGER, &afTrigger, 1); 698 699 static const uint8_t vstabMode = 700 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; 701 settings.update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1); 702 703 static const uint8_t blackLevelLock = ANDROID_BLACK_LEVEL_LOCK_OFF; 704 settings.update(ANDROID_BLACK_LEVEL_LOCK, &blackLevelLock, 1); 705 706 static const uint8_t lensShadingMapMode = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF; 707 settings.update(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, &lensShadingMapMode, 1); 708 709 static const uint8_t aberrationMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST; 710 settings.update(ANDROID_COLOR_CORRECTION_ABERRATION_MODE, &aberrationMode, 1); 711 712 static const int32_t testPatternMode = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF; 713 settings.update(ANDROID_SENSOR_TEST_PATTERN_MODE, &testPatternMode, 1); 714 } 715 716 mDefaultTemplates[type] = settings.release(); 717 718 return mDefaultTemplates[type]; 719 } 720 721 status_t EmulatedFakeCamera3::processCaptureRequest( 722 camera3_capture_request *request) { 723 724 Mutex::Autolock l(mLock); 725 status_t res; 726 727 /** Validation */ 728 729 if (mStatus < STATUS_READY) { 730 ALOGE("%s: Can't submit capture requests in state %d", __FUNCTION__, 731 mStatus); 732 return INVALID_OPERATION; 733 } 734 735 if (request == NULL) { 736 ALOGE("%s: NULL request!", __FUNCTION__); 737 return BAD_VALUE; 738 } 739 740 uint32_t frameNumber = request->frame_number; 741 742 if (request->settings == NULL && mPrevSettings.isEmpty()) { 743 ALOGE("%s: Request %d: NULL settings for first request after" 744 "configureStreams()", __FUNCTION__, frameNumber); 745 return BAD_VALUE; 746 } 747 748 if (request->input_buffer != NULL && 749 request->input_buffer->stream != mInputStream) { 750 ALOGE("%s: Request %d: Input buffer not from input stream!", 751 __FUNCTION__, frameNumber); 752 ALOGV("%s: Bad stream %p, expected: %p", 753 __FUNCTION__, request->input_buffer->stream, 754 mInputStream); 755 ALOGV("%s: Bad stream type %d, expected stream type %d", 756 __FUNCTION__, request->input_buffer->stream->stream_type, 757 mInputStream ? mInputStream->stream_type : -1); 758 759 return BAD_VALUE; 760 } 761 762 if (request->num_output_buffers < 1 || request->output_buffers == NULL) { 763 ALOGE("%s: Request %d: No output buffers provided!", 764 __FUNCTION__, frameNumber); 765 return BAD_VALUE; 766 } 767 768 // Validate all buffers, starting with input buffer if it's given 769 770 ssize_t idx; 771 const camera3_stream_buffer_t *b; 772 if (request->input_buffer != NULL) { 773 idx = -1; 774 b = request->input_buffer; 775 } else { 776 idx = 0; 777 b = request->output_buffers; 778 } 779 do { 780 PrivateStreamInfo *priv = 781 static_cast<PrivateStreamInfo*>(b->stream->priv); 782 if (priv == NULL) { 783 ALOGE("%s: Request %d: Buffer %zu: Unconfigured stream!", 784 __FUNCTION__, frameNumber, idx); 785 return BAD_VALUE; 786 } 787 if (!priv->alive) { 788 ALOGE("%s: Request %d: Buffer %zu: Dead stream!", 789 __FUNCTION__, frameNumber, idx); 790 return BAD_VALUE; 791 } 792 if (b->status != CAMERA3_BUFFER_STATUS_OK) { 793 ALOGE("%s: Request %d: Buffer %zu: Status not OK!", 794 __FUNCTION__, frameNumber, idx); 795 return BAD_VALUE; 796 } 797 if (b->release_fence != -1) { 798 ALOGE("%s: Request %d: Buffer %zu: Has a release fence!", 799 __FUNCTION__, frameNumber, idx); 800 return BAD_VALUE; 801 } 802 if (b->buffer == NULL) { 803 ALOGE("%s: Request %d: Buffer %zu: NULL buffer handle!", 804 __FUNCTION__, frameNumber, idx); 805 return BAD_VALUE; 806 } 807 idx++; 808 b = &(request->output_buffers[idx]); 809 } while (idx < (ssize_t)request->num_output_buffers); 810 811 // TODO: Validate settings parameters 812 813 /** 814 * Start processing this request 815 */ 816 817 mStatus = STATUS_ACTIVE; 818 819 CameraMetadata settings; 820 821 if (request->settings == NULL) { 822 settings.acquire(mPrevSettings); 823 } else { 824 settings = request->settings; 825 } 826 827 res = process3A(settings); 828 if (res != OK) { 829 return res; 830 } 831 832 // TODO: Handle reprocessing 833 834 /** 835 * Get ready for sensor config 836 */ 837 838 nsecs_t exposureTime; 839 nsecs_t frameDuration; 840 uint32_t sensitivity; 841 bool needJpeg = false; 842 camera_metadata_entry_t entry; 843 844 entry = settings.find(ANDROID_SENSOR_EXPOSURE_TIME); 845 exposureTime = (entry.count > 0) ? entry.data.i64[0] : Sensor::kExposureTimeRange[0]; 846 entry = settings.find(ANDROID_SENSOR_FRAME_DURATION); 847 frameDuration = (entry.count > 0)? entry.data.i64[0] : Sensor::kFrameDurationRange[0]; 848 entry = settings.find(ANDROID_SENSOR_SENSITIVITY); 849 sensitivity = (entry.count > 0) ? entry.data.i32[0] : Sensor::kSensitivityRange[0]; 850 851 if (exposureTime > frameDuration) { 852 frameDuration = exposureTime + Sensor::kMinVerticalBlank; 853 settings.update(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1); 854 } 855 856 Buffers *sensorBuffers = new Buffers(); 857 HalBufferVector *buffers = new HalBufferVector(); 858 859 sensorBuffers->setCapacity(request->num_output_buffers); 860 buffers->setCapacity(request->num_output_buffers); 861 862 // Process all the buffers we got for output, constructing internal buffer 863 // structures for them, and lock them for writing. 864 for (size_t i = 0; i < request->num_output_buffers; i++) { 865 const camera3_stream_buffer &srcBuf = request->output_buffers[i]; 866 const cb_handle_t *privBuffer = 867 static_cast<const cb_handle_t*>(*srcBuf.buffer); 868 if (!cb_handle_t::validate(privBuffer)) { 869 privBuffer = nullptr; 870 } 871 StreamBuffer destBuf; 872 destBuf.streamId = kGenericStreamId; 873 destBuf.width = srcBuf.stream->width; 874 destBuf.height = srcBuf.stream->height; 875 // If we have more specific format information, use it. 876 destBuf.format = (privBuffer) ? privBuffer->format : srcBuf.stream->format; 877 destBuf.stride = srcBuf.stream->width; // TODO: query from gralloc 878 destBuf.dataSpace = srcBuf.stream->data_space; 879 destBuf.buffer = srcBuf.buffer; 880 881 if (destBuf.format == HAL_PIXEL_FORMAT_BLOB) { 882 needJpeg = true; 883 } 884 885 // Wait on fence 886 sp<Fence> bufferAcquireFence = new Fence(srcBuf.acquire_fence); 887 res = bufferAcquireFence->wait(kFenceTimeoutMs); 888 if (res == TIMED_OUT) { 889 ALOGE("%s: Request %d: Buffer %zu: Fence timed out after %d ms", 890 __FUNCTION__, frameNumber, i, kFenceTimeoutMs); 891 } 892 if (res == OK) { 893 // Lock buffer for writing 894 const Rect rect(destBuf.width, destBuf.height); 895 if (srcBuf.stream->format == HAL_PIXEL_FORMAT_YCbCr_420_888) { 896 if (destBuf.format == HAL_PIXEL_FORMAT_YCrCb_420_SP) { 897 android_ycbcr ycbcr = android_ycbcr(); 898 res = GraphicBufferMapper::get().lockYCbCr( 899 *(destBuf.buffer), 900 GRALLOC_USAGE_HW_CAMERA_WRITE, rect, 901 &ycbcr); 902 // This is only valid because we know that emulator's 903 // YCbCr_420_888 is really contiguous NV21 under the hood 904 destBuf.img = static_cast<uint8_t*>(ycbcr.y); 905 } else { 906 ALOGE("Unexpected private format for flexible YUV: 0x%x", 907 destBuf.format); 908 res = INVALID_OPERATION; 909 } 910 } else { 911 res = GraphicBufferMapper::get().lock(*(destBuf.buffer), 912 GRALLOC_USAGE_HW_CAMERA_WRITE, rect, 913 (void**)&(destBuf.img)); 914 } 915 if (res != OK) { 916 ALOGE("%s: Request %d: Buffer %zu: Unable to lock buffer", 917 __FUNCTION__, frameNumber, i); 918 } 919 } 920 921 if (res != OK) { 922 // Either waiting or locking failed. Unlock locked buffers and bail 923 // out. 924 for (size_t j = 0; j < i; j++) { 925 GraphicBufferMapper::get().unlock( 926 *(request->output_buffers[i].buffer)); 927 } 928 delete sensorBuffers; 929 delete buffers; 930 return NO_INIT; 931 } 932 933 sensorBuffers->push_back(destBuf); 934 buffers->push_back(srcBuf); 935 } 936 937 /** 938 * Wait for JPEG compressor to not be busy, if needed 939 */ 940 if (needJpeg) { 941 bool ready = mJpegCompressor->waitForDone(kFenceTimeoutMs); 942 if (!ready) { 943 ALOGE("%s: Timeout waiting for JPEG compression to complete!", 944 __FUNCTION__); 945 return NO_INIT; 946 } 947 } 948 949 /** 950 * Wait until the in-flight queue has room 951 */ 952 res = mReadoutThread->waitForReadout(); 953 if (res != OK) { 954 ALOGE("%s: Timeout waiting for previous requests to complete!", 955 __FUNCTION__); 956 return NO_INIT; 957 } 958 959 /** 960 * Wait until sensor's ready. This waits for lengthy amounts of time with 961 * mLock held, but the interface spec is that no other calls may by done to 962 * the HAL by the framework while process_capture_request is happening. 963 */ 964 int syncTimeoutCount = 0; 965 while(!mSensor->waitForVSync(kSyncWaitTimeout)) { 966 if (mStatus == STATUS_ERROR) { 967 return NO_INIT; 968 } 969 if (syncTimeoutCount == kMaxSyncTimeoutCount) { 970 ALOGE("%s: Request %d: Sensor sync timed out after %" PRId64 " ms", 971 __FUNCTION__, frameNumber, 972 kSyncWaitTimeout * kMaxSyncTimeoutCount / 1000000); 973 return NO_INIT; 974 } 975 syncTimeoutCount++; 976 } 977 978 /** 979 * Configure sensor and queue up the request to the readout thread 980 */ 981 mSensor->setExposureTime(exposureTime); 982 mSensor->setFrameDuration(frameDuration); 983 mSensor->setSensitivity(sensitivity); 984 mSensor->setDestinationBuffers(sensorBuffers); 985 mSensor->setFrameNumber(request->frame_number); 986 987 ReadoutThread::Request r; 988 r.frameNumber = request->frame_number; 989 r.settings = settings; 990 r.sensorBuffers = sensorBuffers; 991 r.buffers = buffers; 992 993 mReadoutThread->queueCaptureRequest(r); 994 ALOGVV("%s: Queued frame %d", __FUNCTION__, request->frame_number); 995 996 // Cache the settings for next time 997 mPrevSettings.acquire(settings); 998 999 return OK; 1000 } 1001 1002 status_t EmulatedFakeCamera3::flush() { 1003 ALOGW("%s: Not implemented; ignored", __FUNCTION__); 1004 return OK; 1005 } 1006 1007 /** Debug methods */ 1008 1009 void EmulatedFakeCamera3::dump(int fd) { 1010 1011 } 1012 1013 /** 1014 * Private methods 1015 */ 1016 1017 status_t EmulatedFakeCamera3::getCameraCapabilities() { 1018 1019 const char *key = mFacingBack ? "qemu.sf.back_camera_caps" : "qemu.sf.front_camera_caps"; 1020 1021 /* Defined by 'qemu.sf.*_camera_caps' boot property: if the 1022 * property doesn't exist, it is assumed to list FULL. */ 1023 char prop[PROPERTY_VALUE_MAX]; 1024 if (property_get(key, prop, NULL) > 0) { 1025 char *saveptr = nullptr; 1026 char *cap = strtok_r(prop, " ,", &saveptr); 1027 while (cap != NULL) { 1028 for (int i = 0; i < NUM_CAPABILITIES; i++) { 1029 if (!strcasecmp(cap, sAvailableCapabilitiesStrings[i])) { 1030 mCapabilities.add(static_cast<AvailableCapabilities>(i)); 1031 break; 1032 } 1033 } 1034 cap = strtok_r(NULL, " ,", &saveptr); 1035 } 1036 if (mCapabilities.size() == 0) { 1037 ALOGE("qemu.sf.back_camera_caps had no valid capabilities: %s", prop); 1038 } 1039 } 1040 // Default to FULL_LEVEL plus RAW if nothing is defined 1041 if (mCapabilities.size() == 0) { 1042 mCapabilities.add(FULL_LEVEL); 1043 mCapabilities.add(RAW); 1044 } 1045 1046 // Add level-based caps 1047 if (hasCapability(FULL_LEVEL)) { 1048 mCapabilities.add(BURST_CAPTURE); 1049 mCapabilities.add(READ_SENSOR_SETTINGS); 1050 mCapabilities.add(MANUAL_SENSOR); 1051 mCapabilities.add(MANUAL_POST_PROCESSING); 1052 }; 1053 1054 // Backwards-compatible is required for most other caps 1055 // Not required for DEPTH_OUTPUT, though. 1056 if (hasCapability(BURST_CAPTURE) || 1057 hasCapability(READ_SENSOR_SETTINGS) || 1058 hasCapability(RAW) || 1059 hasCapability(MANUAL_SENSOR) || 1060 hasCapability(MANUAL_POST_PROCESSING) || 1061 hasCapability(PRIVATE_REPROCESSING) || 1062 hasCapability(YUV_REPROCESSING) || 1063 hasCapability(CONSTRAINED_HIGH_SPEED_VIDEO)) { 1064 mCapabilities.add(BACKWARD_COMPATIBLE); 1065 } 1066 1067 ALOGI("Camera %d capabilities:", mCameraID); 1068 for (size_t i = 0; i < mCapabilities.size(); i++) { 1069 ALOGI(" %s", sAvailableCapabilitiesStrings[mCapabilities[i]]); 1070 } 1071 1072 return OK; 1073 } 1074 1075 bool EmulatedFakeCamera3::hasCapability(AvailableCapabilities cap) { 1076 ssize_t idx = mCapabilities.indexOf(cap); 1077 return idx >= 0; 1078 } 1079 1080 status_t EmulatedFakeCamera3::constructStaticInfo() { 1081 1082 CameraMetadata info; 1083 Vector<int32_t> availableCharacteristicsKeys; 1084 status_t res; 1085 1086 #define ADD_STATIC_ENTRY(name, varptr, count) \ 1087 availableCharacteristicsKeys.add(name); \ 1088 res = info.update(name, varptr, count); \ 1089 if (res != OK) return res 1090 1091 // android.sensor 1092 1093 if (hasCapability(MANUAL_SENSOR)) { 1094 1095 ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, 1096 Sensor::kExposureTimeRange, 2); 1097 1098 ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, 1099 &Sensor::kFrameDurationRange[1], 1); 1100 1101 ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, 1102 Sensor::kSensitivityRange, 1103 sizeof(Sensor::kSensitivityRange) 1104 /sizeof(int32_t)); 1105 1106 ADD_STATIC_ENTRY(ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY, 1107 &Sensor::kSensitivityRange[1], 1); 1108 } 1109 1110 static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm 1111 ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, 1112 sensorPhysicalSize, 2); 1113 1114 ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, 1115 (int32_t*)Sensor::kResolution, 2); 1116 1117 ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, 1118 (int32_t*)Sensor::kActiveArray, 4); 1119 1120 static const int32_t orientation = 90; // Aligned with 'long edge' 1121 ADD_STATIC_ENTRY(ANDROID_SENSOR_ORIENTATION, &orientation, 1); 1122 1123 static const uint8_t timestampSource = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME; 1124 ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE, ×tampSource, 1); 1125 1126 if (hasCapability(RAW)) { 1127 ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, 1128 &Sensor::kColorFilterArrangement, 1); 1129 1130 ADD_STATIC_ENTRY(ANDROID_SENSOR_INFO_WHITE_LEVEL, 1131 (int32_t*)&Sensor::kMaxRawValue, 1); 1132 1133 static const int32_t blackLevelPattern[4] = { 1134 (int32_t)Sensor::kBlackLevel, (int32_t)Sensor::kBlackLevel, 1135 (int32_t)Sensor::kBlackLevel, (int32_t)Sensor::kBlackLevel 1136 }; 1137 ADD_STATIC_ENTRY(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, 1138 blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t)); 1139 } 1140 1141 if (hasCapability(BACKWARD_COMPATIBLE)) { 1142 static const int32_t availableTestPatternModes[] = { 1143 ANDROID_SENSOR_TEST_PATTERN_MODE_OFF 1144 }; 1145 ADD_STATIC_ENTRY(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES, 1146 availableTestPatternModes, sizeof(availableTestPatternModes)/sizeof(int32_t)); 1147 } 1148 1149 // android.lens 1150 1151 static const float focalLength = 3.30f; // mm 1152 ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, 1153 &focalLength, 1); 1154 1155 if (hasCapability(BACKWARD_COMPATIBLE)) { 1156 // 5 cm min focus distance for back camera, infinity (fixed focus) for front 1157 const float minFocusDistance = mFacingBack ? 1.0/0.05 : 0.0; 1158 ADD_STATIC_ENTRY(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 1159 &minFocusDistance, 1); 1160 1161 // 5 m hyperfocal distance for back camera, infinity (fixed focus) for front 1162 const float hyperFocalDistance = mFacingBack ? 1.0/5.0 : 0.0; 1163 ADD_STATIC_ENTRY(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, 1164 &minFocusDistance, 1); 1165 1166 static const float aperture = 2.8f; 1167 ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_APERTURES, 1168 &aperture, 1); 1169 static const float filterDensity = 0; 1170 ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, 1171 &filterDensity, 1); 1172 static const uint8_t availableOpticalStabilization = 1173 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; 1174 ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, 1175 &availableOpticalStabilization, 1); 1176 1177 static const int32_t lensShadingMapSize[] = {1, 1}; 1178 ADD_STATIC_ENTRY(ANDROID_LENS_INFO_SHADING_MAP_SIZE, lensShadingMapSize, 1179 sizeof(lensShadingMapSize)/sizeof(int32_t)); 1180 1181 static const uint8_t lensFocusCalibration = 1182 ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE; 1183 ADD_STATIC_ENTRY(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION, &lensFocusCalibration, 1); 1184 } 1185 1186 if (hasCapability(DEPTH_OUTPUT)) { 1187 // These could be included for non-DEPTH capability as well, but making this variable for 1188 // testing coverage 1189 1190 // 90 degree rotation to align with long edge of a phone device that's by default portrait 1191 static const float qO[] = { 0.707107f, 0.f, 0.f, 0.707107f}; 1192 1193 // Either a 180-degree rotation for back-facing, or no rotation for front-facing 1194 const float qF[] = {0, (mFacingBack ? 1.f : 0.f), 0, (mFacingBack ? 0.f : 1.f)}; 1195 1196 // Quarternion product, orientation change then facing 1197 const float lensPoseRotation[] = {qO[0]*qF[0] - qO[1]*qF[1] - qO[2]*qF[2] - qO[3]*qF[3], 1198 qO[0]*qF[1] + qO[1]*qF[0] + qO[2]*qF[3] - qO[3]*qF[2], 1199 qO[0]*qF[2] + qO[2]*qF[0] + qO[1]*qF[3] - qO[3]*qF[1], 1200 qO[0]*qF[3] + qO[3]*qF[0] + qO[1]*qF[2] - qO[2]*qF[1]}; 1201 1202 ADD_STATIC_ENTRY(ANDROID_LENS_POSE_ROTATION, lensPoseRotation, 1203 sizeof(lensPoseRotation)/sizeof(float)); 1204 1205 // Only one camera facing each way, so 0 translation needed to the center of the 'main' 1206 // camera 1207 static const float lensPoseTranslation[] = {0.f, 0.f, 0.f}; 1208 1209 ADD_STATIC_ENTRY(ANDROID_LENS_POSE_TRANSLATION, lensPoseTranslation, 1210 sizeof(lensPoseTranslation)/sizeof(float)); 1211 1212 // Intrinsics are 'ideal' (f_x, f_y, c_x, c_y, s) match focal length and active array size 1213 float f_x = focalLength * Sensor::kActiveArray[2] / sensorPhysicalSize[0]; 1214 float f_y = focalLength * Sensor::kActiveArray[3] / sensorPhysicalSize[1]; 1215 float c_x = Sensor::kActiveArray[2] / 2.f; 1216 float c_y = Sensor::kActiveArray[3] / 2.f; 1217 float s = 0.f; 1218 const float lensIntrinsics[] = { f_x, f_y, c_x, c_y, s }; 1219 1220 ADD_STATIC_ENTRY(ANDROID_LENS_INTRINSIC_CALIBRATION, lensIntrinsics, 1221 sizeof(lensIntrinsics)/sizeof(float)); 1222 1223 // No radial or tangential distortion 1224 1225 float lensRadialDistortion[] = {1.0f, 0.f, 0.f, 0.f, 0.f, 0.f}; 1226 1227 ADD_STATIC_ENTRY(ANDROID_LENS_RADIAL_DISTORTION, lensRadialDistortion, 1228 sizeof(lensRadialDistortion)/sizeof(float)); 1229 1230 } 1231 1232 1233 static const uint8_t lensFacing = mFacingBack ? 1234 ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT; 1235 ADD_STATIC_ENTRY(ANDROID_LENS_FACING, &lensFacing, 1); 1236 1237 // android.flash 1238 1239 static const uint8_t flashAvailable = 0; 1240 ADD_STATIC_ENTRY(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1); 1241 1242 // android.tonemap 1243 1244 if (hasCapability(MANUAL_POST_PROCESSING)) { 1245 static const int32_t tonemapCurvePoints = 128; 1246 ADD_STATIC_ENTRY(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1); 1247 1248 static const uint8_t availableToneMapModes[] = { 1249 ANDROID_TONEMAP_MODE_CONTRAST_CURVE, ANDROID_TONEMAP_MODE_FAST, 1250 ANDROID_TONEMAP_MODE_HIGH_QUALITY 1251 }; 1252 ADD_STATIC_ENTRY(ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES, availableToneMapModes, 1253 sizeof(availableToneMapModes)); 1254 } 1255 1256 // android.scaler 1257 1258 const std::vector<int32_t> availableStreamConfigurationsBasic = { 1259 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, 1260 HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, 1261 HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, 1262 HAL_PIXEL_FORMAT_BLOB, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT 1263 }; 1264 const std::vector<int32_t> availableStreamConfigurationsRaw = { 1265 HAL_PIXEL_FORMAT_RAW16, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT 1266 }; 1267 const std::vector<int32_t> availableStreamConfigurationsBurst = { 1268 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, 1269 HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT, 1270 HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT 1271 }; 1272 1273 std::vector<int32_t> availableStreamConfigurations; 1274 1275 if (hasCapability(BACKWARD_COMPATIBLE)) { 1276 availableStreamConfigurations.insert(availableStreamConfigurations.end(), 1277 availableStreamConfigurationsBasic.begin(), 1278 availableStreamConfigurationsBasic.end()); 1279 } 1280 if (hasCapability(RAW)) { 1281 availableStreamConfigurations.insert(availableStreamConfigurations.end(), 1282 availableStreamConfigurationsRaw.begin(), 1283 availableStreamConfigurationsRaw.end()); 1284 } 1285 if (hasCapability(BURST_CAPTURE)) { 1286 availableStreamConfigurations.insert(availableStreamConfigurations.end(), 1287 availableStreamConfigurationsBurst.begin(), 1288 availableStreamConfigurationsBurst.end()); 1289 } 1290 1291 if (availableStreamConfigurations.size() > 0) { 1292 ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, 1293 &availableStreamConfigurations[0], 1294 availableStreamConfigurations.size()); 1295 } 1296 1297 const std::vector<int64_t> availableMinFrameDurationsBasic = { 1298 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, Sensor::kFrameDurationRange[0], 1299 HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, Sensor::kFrameDurationRange[0], 1300 HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, Sensor::kFrameDurationRange[0], 1301 HAL_PIXEL_FORMAT_BLOB, 640, 480, Sensor::kFrameDurationRange[0] 1302 }; 1303 const std::vector<int64_t> availableMinFrameDurationsRaw = { 1304 HAL_PIXEL_FORMAT_RAW16, 640, 480, Sensor::kFrameDurationRange[0] 1305 }; 1306 const std::vector<int64_t> availableMinFrameDurationsBurst = { 1307 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, Sensor::kFrameDurationRange[0], 1308 HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, Sensor::kFrameDurationRange[0], 1309 HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, Sensor::kFrameDurationRange[0], 1310 }; 1311 1312 std::vector<int64_t> availableMinFrameDurations; 1313 1314 if (hasCapability(BACKWARD_COMPATIBLE)) { 1315 availableMinFrameDurations.insert(availableMinFrameDurations.end(), 1316 availableMinFrameDurationsBasic.begin(), 1317 availableMinFrameDurationsBasic.end()); 1318 } 1319 if (hasCapability(RAW)) { 1320 availableMinFrameDurations.insert(availableMinFrameDurations.end(), 1321 availableMinFrameDurationsRaw.begin(), 1322 availableMinFrameDurationsRaw.end()); 1323 } 1324 if (hasCapability(BURST_CAPTURE)) { 1325 availableMinFrameDurations.insert(availableMinFrameDurations.end(), 1326 availableMinFrameDurationsBurst.begin(), 1327 availableMinFrameDurationsBurst.end()); 1328 } 1329 1330 if (availableMinFrameDurations.size() > 0) { 1331 ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, 1332 &availableMinFrameDurations[0], 1333 availableMinFrameDurations.size()); 1334 } 1335 1336 const std::vector<int64_t> availableStallDurationsBasic = { 1337 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 320, 240, 0, 1338 HAL_PIXEL_FORMAT_YCbCr_420_888, 320, 240, 0, 1339 HAL_PIXEL_FORMAT_RGBA_8888, 320, 240, 0, 1340 HAL_PIXEL_FORMAT_BLOB, 640, 480, Sensor::kFrameDurationRange[0] 1341 }; 1342 const std::vector<int64_t> availableStallDurationsRaw = { 1343 HAL_PIXEL_FORMAT_RAW16, 640, 480, Sensor::kFrameDurationRange[0] 1344 }; 1345 const std::vector<int64_t> availableStallDurationsBurst = { 1346 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 640, 480, 0, 1347 HAL_PIXEL_FORMAT_YCbCr_420_888, 640, 480, 0, 1348 HAL_PIXEL_FORMAT_RGBA_8888, 640, 480, 0 1349 }; 1350 1351 std::vector<int64_t> availableStallDurations; 1352 1353 if (hasCapability(BACKWARD_COMPATIBLE)) { 1354 availableStallDurations.insert(availableStallDurations.end(), 1355 availableStallDurationsBasic.begin(), 1356 availableStallDurationsBasic.end()); 1357 } 1358 if (hasCapability(RAW)) { 1359 availableStallDurations.insert(availableStallDurations.end(), 1360 availableStallDurationsRaw.begin(), 1361 availableStallDurationsRaw.end()); 1362 } 1363 if (hasCapability(BURST_CAPTURE)) { 1364 availableStallDurations.insert(availableStallDurations.end(), 1365 availableStallDurationsBurst.begin(), 1366 availableStallDurationsBurst.end()); 1367 } 1368 1369 if (availableStallDurations.size() > 0) { 1370 ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS, 1371 &availableStallDurations[0], 1372 availableStallDurations.size()); 1373 } 1374 1375 if (hasCapability(BACKWARD_COMPATIBLE)) { 1376 static const uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_FREEFORM; 1377 ADD_STATIC_ENTRY(ANDROID_SCALER_CROPPING_TYPE, 1378 &croppingType, 1); 1379 1380 static const float maxZoom = 10; 1381 ADD_STATIC_ENTRY(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, 1382 &maxZoom, 1); 1383 } 1384 1385 // android.jpeg 1386 1387 if (hasCapability(BACKWARD_COMPATIBLE)) { 1388 static const int32_t jpegThumbnailSizes[] = { 1389 0, 0, 1390 160, 120, 1391 320, 240 1392 }; 1393 ADD_STATIC_ENTRY(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 1394 jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t)); 1395 1396 static const int32_t jpegMaxSize = JpegCompressor::kMaxJpegSize; 1397 ADD_STATIC_ENTRY(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1); 1398 } 1399 1400 // android.stats 1401 1402 if (hasCapability(BACKWARD_COMPATIBLE)) { 1403 static const uint8_t availableFaceDetectModes[] = { 1404 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF, 1405 ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE, 1406 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL 1407 }; 1408 ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, 1409 availableFaceDetectModes, 1410 sizeof(availableFaceDetectModes)); 1411 1412 static const int32_t maxFaceCount = 8; 1413 ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, 1414 &maxFaceCount, 1); 1415 1416 1417 static const uint8_t availableShadingMapModes[] = { 1418 ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF 1419 }; 1420 ADD_STATIC_ENTRY(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES, 1421 availableShadingMapModes, sizeof(availableShadingMapModes)); 1422 } 1423 1424 // android.sync 1425 1426 static const int32_t maxLatency = 1427 hasCapability(FULL_LEVEL) ? ANDROID_SYNC_MAX_LATENCY_PER_FRAME_CONTROL : 3; 1428 ADD_STATIC_ENTRY(ANDROID_SYNC_MAX_LATENCY, &maxLatency, 1); 1429 1430 // android.control 1431 1432 if (hasCapability(BACKWARD_COMPATIBLE)) { 1433 static const uint8_t availableControlModes[] = { 1434 ANDROID_CONTROL_MODE_OFF, ANDROID_CONTROL_MODE_AUTO, ANDROID_CONTROL_MODE_USE_SCENE_MODE 1435 }; 1436 ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_MODES, 1437 availableControlModes, sizeof(availableControlModes)); 1438 } else { 1439 static const uint8_t availableControlModes[] = { 1440 ANDROID_CONTROL_MODE_AUTO 1441 }; 1442 ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_MODES, 1443 availableControlModes, sizeof(availableControlModes)); 1444 } 1445 1446 static const uint8_t availableSceneModes[] = { 1447 hasCapability(BACKWARD_COMPATIBLE) ? 1448 ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY : 1449 ANDROID_CONTROL_SCENE_MODE_DISABLED 1450 }; 1451 ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 1452 availableSceneModes, sizeof(availableSceneModes)); 1453 1454 if (hasCapability(BACKWARD_COMPATIBLE)) { 1455 static const uint8_t availableEffects[] = { 1456 ANDROID_CONTROL_EFFECT_MODE_OFF 1457 }; 1458 ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_EFFECTS, 1459 availableEffects, sizeof(availableEffects)); 1460 } 1461 1462 if (hasCapability(BACKWARD_COMPATIBLE)) { 1463 static const int32_t max3aRegions[] = {/*AE*/ 1,/*AWB*/ 0,/*AF*/ 1}; 1464 ADD_STATIC_ENTRY(ANDROID_CONTROL_MAX_REGIONS, 1465 max3aRegions, sizeof(max3aRegions)/sizeof(max3aRegions[0])); 1466 1467 static const uint8_t availableAeModes[] = { 1468 ANDROID_CONTROL_AE_MODE_OFF, 1469 ANDROID_CONTROL_AE_MODE_ON 1470 }; 1471 ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_MODES, 1472 availableAeModes, sizeof(availableAeModes)); 1473 1474 static const camera_metadata_rational exposureCompensationStep = { 1475 1, 3 1476 }; 1477 ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_STEP, 1478 &exposureCompensationStep, 1); 1479 1480 int32_t exposureCompensationRange[] = {-9, 9}; 1481 ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_RANGE, 1482 exposureCompensationRange, 1483 sizeof(exposureCompensationRange)/sizeof(int32_t)); 1484 } 1485 1486 static const int32_t availableTargetFpsRanges[] = { 1487 5, 30, 15, 30, 15, 15, 30, 30 1488 }; 1489 ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 1490 availableTargetFpsRanges, 1491 sizeof(availableTargetFpsRanges)/sizeof(int32_t)); 1492 1493 if (hasCapability(BACKWARD_COMPATIBLE)) { 1494 static const uint8_t availableAntibandingModes[] = { 1495 ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF, 1496 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO 1497 }; 1498 ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, 1499 availableAntibandingModes, sizeof(availableAntibandingModes)); 1500 } 1501 1502 static const uint8_t aeLockAvailable = hasCapability(BACKWARD_COMPATIBLE) ? 1503 ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE : ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE; 1504 1505 ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_LOCK_AVAILABLE, 1506 &aeLockAvailable, 1); 1507 1508 if (hasCapability(BACKWARD_COMPATIBLE)) { 1509 static const uint8_t availableAwbModes[] = { 1510 ANDROID_CONTROL_AWB_MODE_OFF, 1511 ANDROID_CONTROL_AWB_MODE_AUTO, 1512 ANDROID_CONTROL_AWB_MODE_INCANDESCENT, 1513 ANDROID_CONTROL_AWB_MODE_FLUORESCENT, 1514 ANDROID_CONTROL_AWB_MODE_DAYLIGHT, 1515 ANDROID_CONTROL_AWB_MODE_SHADE 1516 }; 1517 ADD_STATIC_ENTRY(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 1518 availableAwbModes, sizeof(availableAwbModes)); 1519 } 1520 1521 static const uint8_t awbLockAvailable = hasCapability(BACKWARD_COMPATIBLE) ? 1522 ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE : ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE; 1523 1524 ADD_STATIC_ENTRY(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, 1525 &awbLockAvailable, 1); 1526 1527 static const uint8_t availableAfModesBack[] = { 1528 ANDROID_CONTROL_AF_MODE_OFF, 1529 ANDROID_CONTROL_AF_MODE_AUTO, 1530 ANDROID_CONTROL_AF_MODE_MACRO, 1531 ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, 1532 ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE 1533 }; 1534 1535 static const uint8_t availableAfModesFront[] = { 1536 ANDROID_CONTROL_AF_MODE_OFF 1537 }; 1538 1539 if (mFacingBack && hasCapability(BACKWARD_COMPATIBLE)) { 1540 ADD_STATIC_ENTRY(ANDROID_CONTROL_AF_AVAILABLE_MODES, 1541 availableAfModesBack, sizeof(availableAfModesBack)); 1542 } else { 1543 ADD_STATIC_ENTRY(ANDROID_CONTROL_AF_AVAILABLE_MODES, 1544 availableAfModesFront, sizeof(availableAfModesFront)); 1545 } 1546 1547 static const uint8_t availableVstabModes[] = { 1548 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF 1549 }; 1550 ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 1551 availableVstabModes, sizeof(availableVstabModes)); 1552 1553 // android.colorCorrection 1554 1555 if (hasCapability(BACKWARD_COMPATIBLE)) { 1556 static const uint8_t availableAberrationModes[] = { 1557 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF, 1558 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST, 1559 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY 1560 }; 1561 ADD_STATIC_ENTRY(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, 1562 availableAberrationModes, sizeof(availableAberrationModes)); 1563 } else { 1564 static const uint8_t availableAberrationModes[] = { 1565 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF, 1566 }; 1567 ADD_STATIC_ENTRY(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, 1568 availableAberrationModes, sizeof(availableAberrationModes)); 1569 } 1570 // android.edge 1571 1572 if (hasCapability(BACKWARD_COMPATIBLE)) { 1573 static const uint8_t availableEdgeModes[] = { 1574 ANDROID_EDGE_MODE_OFF, ANDROID_EDGE_MODE_FAST, ANDROID_EDGE_MODE_HIGH_QUALITY 1575 }; 1576 ADD_STATIC_ENTRY(ANDROID_EDGE_AVAILABLE_EDGE_MODES, 1577 availableEdgeModes, sizeof(availableEdgeModes)); 1578 } else { 1579 static const uint8_t availableEdgeModes[] = { 1580 ANDROID_EDGE_MODE_OFF 1581 }; 1582 ADD_STATIC_ENTRY(ANDROID_EDGE_AVAILABLE_EDGE_MODES, 1583 availableEdgeModes, sizeof(availableEdgeModes)); 1584 } 1585 1586 // android.info 1587 1588 static const uint8_t supportedHardwareLevel = 1589 hasCapability(FULL_LEVEL) ? ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL : 1590 ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED; 1591 ADD_STATIC_ENTRY(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL, 1592 &supportedHardwareLevel, 1593 /*count*/1); 1594 1595 // android.noiseReduction 1596 1597 if (hasCapability(BACKWARD_COMPATIBLE)) { 1598 static const uint8_t availableNoiseReductionModes[] = { 1599 ANDROID_NOISE_REDUCTION_MODE_OFF, 1600 ANDROID_NOISE_REDUCTION_MODE_FAST, 1601 ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY 1602 }; 1603 ADD_STATIC_ENTRY(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, 1604 availableNoiseReductionModes, sizeof(availableNoiseReductionModes)); 1605 } else { 1606 static const uint8_t availableNoiseReductionModes[] = { 1607 ANDROID_NOISE_REDUCTION_MODE_OFF, 1608 }; 1609 ADD_STATIC_ENTRY(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, 1610 availableNoiseReductionModes, sizeof(availableNoiseReductionModes)); 1611 } 1612 1613 // android.depth 1614 1615 if (hasCapability(DEPTH_OUTPUT)) { 1616 1617 static const int32_t maxDepthSamples = 100; 1618 ADD_STATIC_ENTRY(ANDROID_DEPTH_MAX_DEPTH_SAMPLES, 1619 &maxDepthSamples, 1); 1620 1621 static const int32_t availableDepthStreamConfigurations[] = { 1622 HAL_PIXEL_FORMAT_Y16, 160, 120, ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT, 1623 HAL_PIXEL_FORMAT_BLOB, maxDepthSamples,1, ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS_OUTPUT 1624 }; 1625 ADD_STATIC_ENTRY(ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS, 1626 availableDepthStreamConfigurations, 1627 sizeof(availableDepthStreamConfigurations)/sizeof(int32_t)); 1628 1629 static const int64_t availableDepthMinFrameDurations[] = { 1630 HAL_PIXEL_FORMAT_Y16, 160, 120, Sensor::kFrameDurationRange[0], 1631 HAL_PIXEL_FORMAT_BLOB, maxDepthSamples,1, Sensor::kFrameDurationRange[0] 1632 }; 1633 ADD_STATIC_ENTRY(ANDROID_DEPTH_AVAILABLE_DEPTH_MIN_FRAME_DURATIONS, 1634 availableDepthMinFrameDurations, 1635 sizeof(availableDepthMinFrameDurations)/sizeof(int64_t)); 1636 1637 static const int64_t availableDepthStallDurations[] = { 1638 HAL_PIXEL_FORMAT_Y16, 160, 120, Sensor::kFrameDurationRange[0], 1639 HAL_PIXEL_FORMAT_BLOB, maxDepthSamples,1, Sensor::kFrameDurationRange[0] 1640 }; 1641 ADD_STATIC_ENTRY(ANDROID_DEPTH_AVAILABLE_DEPTH_STALL_DURATIONS, 1642 availableDepthStallDurations, 1643 sizeof(availableDepthStallDurations)/sizeof(int64_t)); 1644 1645 uint8_t depthIsExclusive = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE; 1646 ADD_STATIC_ENTRY(ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE, 1647 &depthIsExclusive, 1); 1648 } 1649 1650 // android.shading 1651 1652 if (hasCapability(BACKWARD_COMPATIBLE)) { 1653 static const uint8_t availableShadingModes[] = { 1654 ANDROID_SHADING_MODE_OFF, ANDROID_SHADING_MODE_FAST, ANDROID_SHADING_MODE_HIGH_QUALITY 1655 }; 1656 ADD_STATIC_ENTRY(ANDROID_SHADING_AVAILABLE_MODES, availableShadingModes, 1657 sizeof(availableShadingModes)); 1658 } else { 1659 static const uint8_t availableShadingModes[] = { 1660 ANDROID_SHADING_MODE_OFF 1661 }; 1662 ADD_STATIC_ENTRY(ANDROID_SHADING_AVAILABLE_MODES, availableShadingModes, 1663 sizeof(availableShadingModes)); 1664 } 1665 1666 // android.request 1667 1668 static const int32_t maxNumOutputStreams[] = { 1669 kMaxRawStreamCount, kMaxProcessedStreamCount, kMaxJpegStreamCount 1670 }; 1671 ADD_STATIC_ENTRY(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, maxNumOutputStreams, 3); 1672 1673 static const uint8_t maxPipelineDepth = kMaxBufferCount; 1674 ADD_STATIC_ENTRY(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, &maxPipelineDepth, 1); 1675 1676 static const int32_t partialResultCount = 1; 1677 ADD_STATIC_ENTRY(ANDROID_REQUEST_PARTIAL_RESULT_COUNT, 1678 &partialResultCount, /*count*/1); 1679 1680 SortedVector<uint8_t> caps; 1681 for (size_t i = 0; i < mCapabilities.size(); i++) { 1682 switch(mCapabilities[i]) { 1683 case BACKWARD_COMPATIBLE: 1684 caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE); 1685 break; 1686 case MANUAL_SENSOR: 1687 caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR); 1688 break; 1689 case MANUAL_POST_PROCESSING: 1690 caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING); 1691 break; 1692 case RAW: 1693 caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW); 1694 break; 1695 case PRIVATE_REPROCESSING: 1696 caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING); 1697 break; 1698 case READ_SENSOR_SETTINGS: 1699 caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS); 1700 break; 1701 case BURST_CAPTURE: 1702 caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE); 1703 break; 1704 case YUV_REPROCESSING: 1705 caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_YUV_REPROCESSING); 1706 break; 1707 case DEPTH_OUTPUT: 1708 caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT); 1709 break; 1710 case CONSTRAINED_HIGH_SPEED_VIDEO: 1711 caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO); 1712 break; 1713 default: 1714 // Ignore LEVELs 1715 break; 1716 } 1717 } 1718 ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_CAPABILITIES, caps.array(), caps.size()); 1719 1720 // Scan a default request template for included request keys 1721 Vector<int32_t> availableRequestKeys; 1722 const camera_metadata_t *previewRequest = 1723 constructDefaultRequestSettings(CAMERA3_TEMPLATE_PREVIEW); 1724 for (size_t i = 0; i < get_camera_metadata_entry_count(previewRequest); i++) { 1725 camera_metadata_ro_entry_t entry; 1726 get_camera_metadata_ro_entry(previewRequest, i, &entry); 1727 availableRequestKeys.add(entry.tag); 1728 } 1729 ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, availableRequestKeys.array(), 1730 availableRequestKeys.size()); 1731 1732 // Add a few more result keys. Must be kept up to date with the various places that add these 1733 1734 Vector<int32_t> availableResultKeys(availableRequestKeys); 1735 if (hasCapability(BACKWARD_COMPATIBLE)) { 1736 availableResultKeys.add(ANDROID_CONTROL_AE_STATE); 1737 availableResultKeys.add(ANDROID_CONTROL_AF_STATE); 1738 availableResultKeys.add(ANDROID_CONTROL_AWB_STATE); 1739 availableResultKeys.add(ANDROID_FLASH_STATE); 1740 availableResultKeys.add(ANDROID_LENS_STATE); 1741 availableResultKeys.add(ANDROID_LENS_FOCUS_RANGE); 1742 availableResultKeys.add(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW); 1743 availableResultKeys.add(ANDROID_STATISTICS_SCENE_FLICKER); 1744 } 1745 1746 if (hasCapability(DEPTH_OUTPUT)) { 1747 availableResultKeys.add(ANDROID_LENS_POSE_ROTATION); 1748 availableResultKeys.add(ANDROID_LENS_POSE_TRANSLATION); 1749 availableResultKeys.add(ANDROID_LENS_INTRINSIC_CALIBRATION); 1750 availableResultKeys.add(ANDROID_LENS_RADIAL_DISTORTION); 1751 } 1752 1753 availableResultKeys.add(ANDROID_REQUEST_PIPELINE_DEPTH); 1754 availableResultKeys.add(ANDROID_SENSOR_TIMESTAMP); 1755 1756 ADD_STATIC_ENTRY(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, availableResultKeys.array(), 1757 availableResultKeys.size()); 1758 1759 // Needs to be last, to collect all the keys set 1760 1761 availableCharacteristicsKeys.add(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS); 1762 info.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, 1763 availableCharacteristicsKeys); 1764 1765 mCameraInfo = info.release(); 1766 1767 #undef ADD_STATIC_ENTRY 1768 return OK; 1769 } 1770 1771 status_t EmulatedFakeCamera3::process3A(CameraMetadata &settings) { 1772 /** 1773 * Extract top-level 3A controls 1774 */ 1775 status_t res; 1776 1777 bool facePriority = false; 1778 1779 camera_metadata_entry e; 1780 1781 e = settings.find(ANDROID_CONTROL_MODE); 1782 if (e.count == 0) { 1783 ALOGE("%s: No control mode entry!", __FUNCTION__); 1784 return BAD_VALUE; 1785 } 1786 uint8_t controlMode = e.data.u8[0]; 1787 1788 if (controlMode == ANDROID_CONTROL_MODE_OFF) { 1789 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; 1790 mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; 1791 mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; 1792 update3A(settings); 1793 return OK; 1794 } else if (controlMode == ANDROID_CONTROL_MODE_USE_SCENE_MODE) { 1795 if (!hasCapability(BACKWARD_COMPATIBLE)) { 1796 ALOGE("%s: Can't use scene mode when BACKWARD_COMPATIBLE not supported!", 1797 __FUNCTION__); 1798 return BAD_VALUE; 1799 } 1800 1801 e = settings.find(ANDROID_CONTROL_SCENE_MODE); 1802 if (e.count == 0) { 1803 ALOGE("%s: No scene mode entry!", __FUNCTION__); 1804 return BAD_VALUE; 1805 } 1806 uint8_t sceneMode = e.data.u8[0]; 1807 1808 switch(sceneMode) { 1809 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY: 1810 mFacePriority = true; 1811 break; 1812 default: 1813 ALOGE("%s: Emulator doesn't support scene mode %d", 1814 __FUNCTION__, sceneMode); 1815 return BAD_VALUE; 1816 } 1817 } else { 1818 mFacePriority = false; 1819 } 1820 1821 // controlMode == AUTO or sceneMode = FACE_PRIORITY 1822 // Process individual 3A controls 1823 1824 res = doFakeAE(settings); 1825 if (res != OK) return res; 1826 1827 res = doFakeAF(settings); 1828 if (res != OK) return res; 1829 1830 res = doFakeAWB(settings); 1831 if (res != OK) return res; 1832 1833 update3A(settings); 1834 return OK; 1835 } 1836 1837 status_t EmulatedFakeCamera3::doFakeAE(CameraMetadata &settings) { 1838 camera_metadata_entry e; 1839 1840 e = settings.find(ANDROID_CONTROL_AE_MODE); 1841 if (e.count == 0 && hasCapability(BACKWARD_COMPATIBLE)) { 1842 ALOGE("%s: No AE mode entry!", __FUNCTION__); 1843 return BAD_VALUE; 1844 } 1845 uint8_t aeMode = (e.count > 0) ? e.data.u8[0] : (uint8_t)ANDROID_CONTROL_AE_MODE_ON; 1846 1847 switch (aeMode) { 1848 case ANDROID_CONTROL_AE_MODE_OFF: 1849 // AE is OFF 1850 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; 1851 return OK; 1852 case ANDROID_CONTROL_AE_MODE_ON: 1853 // OK for AUTO modes 1854 break; 1855 default: 1856 // Mostly silently ignore unsupported modes 1857 ALOGV("%s: Emulator doesn't support AE mode %d, assuming ON", 1858 __FUNCTION__, aeMode); 1859 break; 1860 } 1861 1862 e = settings.find(ANDROID_CONTROL_AE_LOCK); 1863 bool aeLocked = (e.count > 0) ? (e.data.u8[0] == ANDROID_CONTROL_AE_LOCK_ON) : false; 1864 1865 e = settings.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER); 1866 bool precaptureTrigger = false; 1867 if (e.count != 0) { 1868 precaptureTrigger = 1869 (e.data.u8[0] == ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START); 1870 } 1871 1872 if (precaptureTrigger) { 1873 ALOGV("%s: Pre capture trigger = %d", __FUNCTION__, precaptureTrigger); 1874 } else if (e.count > 0) { 1875 ALOGV("%s: Pre capture trigger was present? %zu", 1876 __FUNCTION__, 1877 e.count); 1878 } 1879 1880 if (precaptureTrigger || mAeState == ANDROID_CONTROL_AE_STATE_PRECAPTURE) { 1881 // Run precapture sequence 1882 if (mAeState != ANDROID_CONTROL_AE_STATE_PRECAPTURE) { 1883 mAeCounter = 0; 1884 } 1885 1886 if (mFacePriority) { 1887 mAeTargetExposureTime = kFacePriorityExposureTime; 1888 } else { 1889 mAeTargetExposureTime = kNormalExposureTime; 1890 } 1891 1892 if (mAeCounter > kPrecaptureMinFrames && 1893 (mAeTargetExposureTime - mAeCurrentExposureTime) < 1894 mAeTargetExposureTime / 10) { 1895 // Done with precapture 1896 mAeCounter = 0; 1897 mAeState = aeLocked ? ANDROID_CONTROL_AE_STATE_LOCKED : 1898 ANDROID_CONTROL_AE_STATE_CONVERGED; 1899 } else { 1900 // Converge some more 1901 mAeCurrentExposureTime += 1902 (mAeTargetExposureTime - mAeCurrentExposureTime) * 1903 kExposureTrackRate; 1904 mAeCounter++; 1905 mAeState = ANDROID_CONTROL_AE_STATE_PRECAPTURE; 1906 } 1907 1908 } else if (!aeLocked) { 1909 // Run standard occasional AE scan 1910 switch (mAeState) { 1911 case ANDROID_CONTROL_AE_STATE_CONVERGED: 1912 case ANDROID_CONTROL_AE_STATE_INACTIVE: 1913 mAeCounter++; 1914 if (mAeCounter > kStableAeMaxFrames) { 1915 mAeTargetExposureTime = 1916 mFacePriority ? kFacePriorityExposureTime : 1917 kNormalExposureTime; 1918 float exposureStep = ((double)rand() / RAND_MAX) * 1919 (kExposureWanderMax - kExposureWanderMin) + 1920 kExposureWanderMin; 1921 mAeTargetExposureTime *= std::pow(2, exposureStep); 1922 mAeState = ANDROID_CONTROL_AE_STATE_SEARCHING; 1923 } 1924 break; 1925 case ANDROID_CONTROL_AE_STATE_SEARCHING: 1926 mAeCurrentExposureTime += 1927 (mAeTargetExposureTime - mAeCurrentExposureTime) * 1928 kExposureTrackRate; 1929 if (abs(mAeTargetExposureTime - mAeCurrentExposureTime) < 1930 mAeTargetExposureTime / 10) { 1931 // Close enough 1932 mAeState = ANDROID_CONTROL_AE_STATE_CONVERGED; 1933 mAeCounter = 0; 1934 } 1935 break; 1936 case ANDROID_CONTROL_AE_STATE_LOCKED: 1937 mAeState = ANDROID_CONTROL_AE_STATE_CONVERGED; 1938 mAeCounter = 0; 1939 break; 1940 default: 1941 ALOGE("%s: Emulator in unexpected AE state %d", 1942 __FUNCTION__, mAeState); 1943 return INVALID_OPERATION; 1944 } 1945 } else { 1946 // AE is locked 1947 mAeState = ANDROID_CONTROL_AE_STATE_LOCKED; 1948 } 1949 1950 return OK; 1951 } 1952 1953 status_t EmulatedFakeCamera3::doFakeAF(CameraMetadata &settings) { 1954 camera_metadata_entry e; 1955 1956 e = settings.find(ANDROID_CONTROL_AF_MODE); 1957 if (e.count == 0 && hasCapability(BACKWARD_COMPATIBLE)) { 1958 ALOGE("%s: No AF mode entry!", __FUNCTION__); 1959 return BAD_VALUE; 1960 } 1961 uint8_t afMode = (e.count > 0) ? e.data.u8[0] : (uint8_t)ANDROID_CONTROL_AF_MODE_OFF; 1962 1963 e = settings.find(ANDROID_CONTROL_AF_TRIGGER); 1964 typedef camera_metadata_enum_android_control_af_trigger af_trigger_t; 1965 af_trigger_t afTrigger; 1966 if (e.count != 0) { 1967 afTrigger = static_cast<af_trigger_t>(e.data.u8[0]); 1968 1969 ALOGV("%s: AF trigger set to 0x%x", __FUNCTION__, afTrigger); 1970 ALOGV("%s: AF mode is 0x%x", __FUNCTION__, afMode); 1971 } else { 1972 afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE; 1973 } 1974 1975 switch (afMode) { 1976 case ANDROID_CONTROL_AF_MODE_OFF: 1977 mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; 1978 return OK; 1979 case ANDROID_CONTROL_AF_MODE_AUTO: 1980 case ANDROID_CONTROL_AF_MODE_MACRO: 1981 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 1982 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 1983 if (!mFacingBack) { 1984 ALOGE("%s: Front camera doesn't support AF mode %d", 1985 __FUNCTION__, afMode); 1986 return BAD_VALUE; 1987 } 1988 // OK, handle transitions lower on 1989 break; 1990 default: 1991 ALOGE("%s: Emulator doesn't support AF mode %d", 1992 __FUNCTION__, afMode); 1993 return BAD_VALUE; 1994 } 1995 1996 bool afModeChanged = mAfMode != afMode; 1997 mAfMode = afMode; 1998 1999 /** 2000 * Simulate AF triggers. Transition at most 1 state per frame. 2001 * - Focusing always succeeds (goes into locked, or PASSIVE_SCAN). 2002 */ 2003 2004 bool afTriggerStart = false; 2005 bool afTriggerCancel = false; 2006 switch (afTrigger) { 2007 case ANDROID_CONTROL_AF_TRIGGER_IDLE: 2008 break; 2009 case ANDROID_CONTROL_AF_TRIGGER_START: 2010 afTriggerStart = true; 2011 break; 2012 case ANDROID_CONTROL_AF_TRIGGER_CANCEL: 2013 afTriggerCancel = true; 2014 // Cancel trigger always transitions into INACTIVE 2015 mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; 2016 2017 ALOGV("%s: AF State transition to STATE_INACTIVE", __FUNCTION__); 2018 2019 // Stay in 'inactive' until at least next frame 2020 return OK; 2021 default: 2022 ALOGE("%s: Unknown af trigger value %d", __FUNCTION__, afTrigger); 2023 return BAD_VALUE; 2024 } 2025 2026 // If we get down here, we're either in an autofocus mode 2027 // or in a continuous focus mode (and no other modes) 2028 2029 int oldAfState = mAfState; 2030 switch (mAfState) { 2031 case ANDROID_CONTROL_AF_STATE_INACTIVE: 2032 if (afTriggerStart) { 2033 switch (afMode) { 2034 case ANDROID_CONTROL_AF_MODE_AUTO: 2035 // fall-through 2036 case ANDROID_CONTROL_AF_MODE_MACRO: 2037 mAfState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; 2038 break; 2039 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 2040 // fall-through 2041 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 2042 mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 2043 break; 2044 } 2045 } else { 2046 // At least one frame stays in INACTIVE 2047 if (!afModeChanged) { 2048 switch (afMode) { 2049 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 2050 // fall-through 2051 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 2052 mAfState = ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN; 2053 break; 2054 } 2055 } 2056 } 2057 break; 2058 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 2059 /** 2060 * When the AF trigger is activated, the algorithm should finish 2061 * its PASSIVE_SCAN if active, and then transition into AF_FOCUSED 2062 * or AF_NOT_FOCUSED as appropriate 2063 */ 2064 if (afTriggerStart) { 2065 // Randomly transition to focused or not focused 2066 if (rand() % 3) { 2067 mAfState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; 2068 } else { 2069 mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 2070 } 2071 } 2072 /** 2073 * When the AF trigger is not involved, the AF algorithm should 2074 * start in INACTIVE state, and then transition into PASSIVE_SCAN 2075 * and PASSIVE_FOCUSED states 2076 */ 2077 else if (!afTriggerCancel) { 2078 // Randomly transition to passive focus 2079 if (rand() % 3 == 0) { 2080 mAfState = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED; 2081 } 2082 } 2083 2084 break; 2085 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 2086 if (afTriggerStart) { 2087 // Randomly transition to focused or not focused 2088 if (rand() % 3) { 2089 mAfState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; 2090 } else { 2091 mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 2092 } 2093 } 2094 // TODO: initiate passive scan (PASSIVE_SCAN) 2095 break; 2096 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: 2097 // Simulate AF sweep completing instantaneously 2098 2099 // Randomly transition to focused or not focused 2100 if (rand() % 3) { 2101 mAfState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; 2102 } else { 2103 mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 2104 } 2105 break; 2106 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 2107 if (afTriggerStart) { 2108 switch (afMode) { 2109 case ANDROID_CONTROL_AF_MODE_AUTO: 2110 // fall-through 2111 case ANDROID_CONTROL_AF_MODE_MACRO: 2112 mAfState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; 2113 break; 2114 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 2115 // fall-through 2116 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 2117 // continuous autofocus => trigger start has no effect 2118 break; 2119 } 2120 } 2121 break; 2122 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 2123 if (afTriggerStart) { 2124 switch (afMode) { 2125 case ANDROID_CONTROL_AF_MODE_AUTO: 2126 // fall-through 2127 case ANDROID_CONTROL_AF_MODE_MACRO: 2128 mAfState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; 2129 break; 2130 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 2131 // fall-through 2132 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 2133 // continuous autofocus => trigger start has no effect 2134 break; 2135 } 2136 } 2137 break; 2138 default: 2139 ALOGE("%s: Bad af state %d", __FUNCTION__, mAfState); 2140 } 2141 2142 { 2143 char afStateString[100] = {0,}; 2144 camera_metadata_enum_snprint(ANDROID_CONTROL_AF_STATE, 2145 oldAfState, 2146 afStateString, 2147 sizeof(afStateString)); 2148 2149 char afNewStateString[100] = {0,}; 2150 camera_metadata_enum_snprint(ANDROID_CONTROL_AF_STATE, 2151 mAfState, 2152 afNewStateString, 2153 sizeof(afNewStateString)); 2154 ALOGVV("%s: AF state transitioned from %s to %s", 2155 __FUNCTION__, afStateString, afNewStateString); 2156 } 2157 2158 2159 return OK; 2160 } 2161 2162 status_t EmulatedFakeCamera3::doFakeAWB(CameraMetadata &settings) { 2163 camera_metadata_entry e; 2164 2165 e = settings.find(ANDROID_CONTROL_AWB_MODE); 2166 if (e.count == 0 && hasCapability(BACKWARD_COMPATIBLE)) { 2167 ALOGE("%s: No AWB mode entry!", __FUNCTION__); 2168 return BAD_VALUE; 2169 } 2170 uint8_t awbMode = (e.count > 0) ? e.data.u8[0] : (uint8_t)ANDROID_CONTROL_AWB_MODE_AUTO; 2171 2172 // TODO: Add white balance simulation 2173 2174 switch (awbMode) { 2175 case ANDROID_CONTROL_AWB_MODE_OFF: 2176 mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; 2177 return OK; 2178 case ANDROID_CONTROL_AWB_MODE_AUTO: 2179 case ANDROID_CONTROL_AWB_MODE_INCANDESCENT: 2180 case ANDROID_CONTROL_AWB_MODE_FLUORESCENT: 2181 case ANDROID_CONTROL_AWB_MODE_DAYLIGHT: 2182 case ANDROID_CONTROL_AWB_MODE_SHADE: 2183 // OK 2184 break; 2185 default: 2186 ALOGE("%s: Emulator doesn't support AWB mode %d", 2187 __FUNCTION__, awbMode); 2188 return BAD_VALUE; 2189 } 2190 2191 return OK; 2192 } 2193 2194 2195 void EmulatedFakeCamera3::update3A(CameraMetadata &settings) { 2196 if (mAeMode != ANDROID_CONTROL_AE_MODE_OFF) { 2197 settings.update(ANDROID_SENSOR_EXPOSURE_TIME, 2198 &mAeCurrentExposureTime, 1); 2199 settings.update(ANDROID_SENSOR_SENSITIVITY, 2200 &mAeCurrentSensitivity, 1); 2201 } 2202 2203 settings.update(ANDROID_CONTROL_AE_STATE, 2204 &mAeState, 1); 2205 settings.update(ANDROID_CONTROL_AF_STATE, 2206 &mAfState, 1); 2207 settings.update(ANDROID_CONTROL_AWB_STATE, 2208 &mAwbState, 1); 2209 2210 uint8_t lensState; 2211 switch (mAfState) { 2212 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 2213 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: 2214 lensState = ANDROID_LENS_STATE_MOVING; 2215 break; 2216 case ANDROID_CONTROL_AF_STATE_INACTIVE: 2217 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 2218 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 2219 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 2220 case ANDROID_CONTROL_AF_STATE_PASSIVE_UNFOCUSED: 2221 default: 2222 lensState = ANDROID_LENS_STATE_STATIONARY; 2223 break; 2224 } 2225 settings.update(ANDROID_LENS_STATE, &lensState, 1); 2226 2227 } 2228 2229 void EmulatedFakeCamera3::signalReadoutIdle() { 2230 Mutex::Autolock l(mLock); 2231 // Need to chek isIdle again because waiting on mLock may have allowed 2232 // something to be placed in the in-flight queue. 2233 if (mStatus == STATUS_ACTIVE && mReadoutThread->isIdle()) { 2234 ALOGV("Now idle"); 2235 mStatus = STATUS_READY; 2236 } 2237 } 2238 2239 void EmulatedFakeCamera3::onSensorEvent(uint32_t frameNumber, Event e, 2240 nsecs_t timestamp) { 2241 switch(e) { 2242 case Sensor::SensorListener::EXPOSURE_START: { 2243 ALOGVV("%s: Frame %d: Sensor started exposure at %lld", 2244 __FUNCTION__, frameNumber, timestamp); 2245 // Trigger shutter notify to framework 2246 camera3_notify_msg_t msg; 2247 msg.type = CAMERA3_MSG_SHUTTER; 2248 msg.message.shutter.frame_number = frameNumber; 2249 msg.message.shutter.timestamp = timestamp; 2250 sendNotify(&msg); 2251 break; 2252 } 2253 default: 2254 ALOGW("%s: Unexpected sensor event %d at %" PRId64, __FUNCTION__, 2255 e, timestamp); 2256 break; 2257 } 2258 } 2259 2260 EmulatedFakeCamera3::ReadoutThread::ReadoutThread(EmulatedFakeCamera3 *parent) : 2261 mParent(parent), mJpegWaiting(false) { 2262 } 2263 2264 EmulatedFakeCamera3::ReadoutThread::~ReadoutThread() { 2265 for (List<Request>::iterator i = mInFlightQueue.begin(); 2266 i != mInFlightQueue.end(); i++) { 2267 delete i->buffers; 2268 delete i->sensorBuffers; 2269 } 2270 } 2271 2272 void EmulatedFakeCamera3::ReadoutThread::queueCaptureRequest(const Request &r) { 2273 Mutex::Autolock l(mLock); 2274 2275 mInFlightQueue.push_back(r); 2276 mInFlightSignal.signal(); 2277 } 2278 2279 bool EmulatedFakeCamera3::ReadoutThread::isIdle() { 2280 Mutex::Autolock l(mLock); 2281 return mInFlightQueue.empty() && !mThreadActive; 2282 } 2283 2284 status_t EmulatedFakeCamera3::ReadoutThread::waitForReadout() { 2285 status_t res; 2286 Mutex::Autolock l(mLock); 2287 int loopCount = 0; 2288 while (mInFlightQueue.size() >= kMaxQueueSize) { 2289 res = mInFlightSignal.waitRelative(mLock, kWaitPerLoop); 2290 if (res != OK && res != TIMED_OUT) { 2291 ALOGE("%s: Error waiting for in-flight queue to shrink", 2292 __FUNCTION__); 2293 return INVALID_OPERATION; 2294 } 2295 if (loopCount == kMaxWaitLoops) { 2296 ALOGE("%s: Timed out waiting for in-flight queue to shrink", 2297 __FUNCTION__); 2298 return TIMED_OUT; 2299 } 2300 loopCount++; 2301 } 2302 return OK; 2303 } 2304 2305 bool EmulatedFakeCamera3::ReadoutThread::threadLoop() { 2306 status_t res; 2307 2308 ALOGVV("%s: ReadoutThread waiting for request", __FUNCTION__); 2309 2310 // First wait for a request from the in-flight queue 2311 2312 if (mCurrentRequest.settings.isEmpty()) { 2313 Mutex::Autolock l(mLock); 2314 if (mInFlightQueue.empty()) { 2315 res = mInFlightSignal.waitRelative(mLock, kWaitPerLoop); 2316 if (res == TIMED_OUT) { 2317 ALOGVV("%s: ReadoutThread: Timed out waiting for request", 2318 __FUNCTION__); 2319 return true; 2320 } else if (res != NO_ERROR) { 2321 ALOGE("%s: Error waiting for capture requests: %d", 2322 __FUNCTION__, res); 2323 return false; 2324 } 2325 } 2326 mCurrentRequest.frameNumber = mInFlightQueue.begin()->frameNumber; 2327 mCurrentRequest.settings.acquire(mInFlightQueue.begin()->settings); 2328 mCurrentRequest.buffers = mInFlightQueue.begin()->buffers; 2329 mCurrentRequest.sensorBuffers = mInFlightQueue.begin()->sensorBuffers; 2330 mInFlightQueue.erase(mInFlightQueue.begin()); 2331 mInFlightSignal.signal(); 2332 mThreadActive = true; 2333 ALOGVV("%s: Beginning readout of frame %d", __FUNCTION__, 2334 mCurrentRequest.frameNumber); 2335 } 2336 2337 // Then wait for it to be delivered from the sensor 2338 ALOGVV("%s: ReadoutThread: Wait for frame to be delivered from sensor", 2339 __FUNCTION__); 2340 2341 nsecs_t captureTime; 2342 bool gotFrame = 2343 mParent->mSensor->waitForNewFrame(kWaitPerLoop, &captureTime); 2344 if (!gotFrame) { 2345 ALOGVV("%s: ReadoutThread: Timed out waiting for sensor frame", 2346 __FUNCTION__); 2347 return true; 2348 } 2349 2350 ALOGVV("Sensor done with readout for frame %d, captured at %lld ", 2351 mCurrentRequest.frameNumber, captureTime); 2352 2353 // Check if we need to JPEG encode a buffer, and send it for async 2354 // compression if so. Otherwise prepare the buffer for return. 2355 bool needJpeg = false; 2356 HalBufferVector::iterator buf = mCurrentRequest.buffers->begin(); 2357 while(buf != mCurrentRequest.buffers->end()) { 2358 bool goodBuffer = true; 2359 if ( buf->stream->format == 2360 HAL_PIXEL_FORMAT_BLOB && buf->stream->data_space != HAL_DATASPACE_DEPTH) { 2361 Mutex::Autolock jl(mJpegLock); 2362 if (mJpegWaiting) { 2363 // This shouldn't happen, because processCaptureRequest should 2364 // be stalling until JPEG compressor is free. 2365 ALOGE("%s: Already processing a JPEG!", __FUNCTION__); 2366 goodBuffer = false; 2367 } 2368 if (goodBuffer) { 2369 // Compressor takes ownership of sensorBuffers here 2370 res = mParent->mJpegCompressor->start(mCurrentRequest.sensorBuffers, 2371 this); 2372 goodBuffer = (res == OK); 2373 } 2374 if (goodBuffer) { 2375 needJpeg = true; 2376 2377 mJpegHalBuffer = *buf; 2378 mJpegFrameNumber = mCurrentRequest.frameNumber; 2379 mJpegWaiting = true; 2380 2381 mCurrentRequest.sensorBuffers = NULL; 2382 buf = mCurrentRequest.buffers->erase(buf); 2383 2384 continue; 2385 } 2386 ALOGE("%s: Error compressing output buffer: %s (%d)", 2387 __FUNCTION__, strerror(-res), res); 2388 // fallthrough for cleanup 2389 } 2390 GraphicBufferMapper::get().unlock(*(buf->buffer)); 2391 2392 buf->status = goodBuffer ? CAMERA3_BUFFER_STATUS_OK : 2393 CAMERA3_BUFFER_STATUS_ERROR; 2394 buf->acquire_fence = -1; 2395 buf->release_fence = -1; 2396 2397 ++buf; 2398 } // end while 2399 2400 // Construct result for all completed buffers and results 2401 2402 camera3_capture_result result; 2403 2404 if (mParent->hasCapability(BACKWARD_COMPATIBLE)) { 2405 static const uint8_t sceneFlicker = ANDROID_STATISTICS_SCENE_FLICKER_NONE; 2406 mCurrentRequest.settings.update(ANDROID_STATISTICS_SCENE_FLICKER, 2407 &sceneFlicker, 1); 2408 2409 static const uint8_t flashState = ANDROID_FLASH_STATE_UNAVAILABLE; 2410 mCurrentRequest.settings.update(ANDROID_FLASH_STATE, 2411 &flashState, 1); 2412 2413 nsecs_t rollingShutterSkew = Sensor::kFrameDurationRange[0]; 2414 mCurrentRequest.settings.update(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW, 2415 &rollingShutterSkew, 1); 2416 2417 float focusRange[] = { 1.0f/5.0f, 0 }; // 5 m to infinity in focus 2418 mCurrentRequest.settings.update(ANDROID_LENS_FOCUS_RANGE, 2419 focusRange, sizeof(focusRange)/sizeof(float)); 2420 } 2421 2422 if (mParent->hasCapability(DEPTH_OUTPUT)) { 2423 camera_metadata_entry_t entry; 2424 2425 find_camera_metadata_entry(mParent->mCameraInfo, ANDROID_LENS_POSE_TRANSLATION, &entry); 2426 mCurrentRequest.settings.update(ANDROID_LENS_POSE_TRANSLATION, 2427 entry.data.f, entry.count); 2428 2429 find_camera_metadata_entry(mParent->mCameraInfo, ANDROID_LENS_POSE_ROTATION, &entry); 2430 mCurrentRequest.settings.update(ANDROID_LENS_POSE_ROTATION, 2431 entry.data.f, entry.count); 2432 2433 find_camera_metadata_entry(mParent->mCameraInfo, ANDROID_LENS_INTRINSIC_CALIBRATION, &entry); 2434 mCurrentRequest.settings.update(ANDROID_LENS_INTRINSIC_CALIBRATION, 2435 entry.data.f, entry.count); 2436 2437 find_camera_metadata_entry(mParent->mCameraInfo, ANDROID_LENS_RADIAL_DISTORTION, &entry); 2438 mCurrentRequest.settings.update(ANDROID_LENS_RADIAL_DISTORTION, 2439 entry.data.f, entry.count); 2440 } 2441 2442 mCurrentRequest.settings.update(ANDROID_SENSOR_TIMESTAMP, 2443 &captureTime, 1); 2444 2445 2446 // JPEGs take a stage longer 2447 const uint8_t pipelineDepth = needJpeg ? kMaxBufferCount : kMaxBufferCount - 1; 2448 mCurrentRequest.settings.update(ANDROID_REQUEST_PIPELINE_DEPTH, 2449 &pipelineDepth, 1); 2450 2451 result.frame_number = mCurrentRequest.frameNumber; 2452 result.result = mCurrentRequest.settings.getAndLock(); 2453 result.num_output_buffers = mCurrentRequest.buffers->size(); 2454 result.output_buffers = mCurrentRequest.buffers->array(); 2455 result.input_buffer = nullptr; 2456 result.partial_result = 1; 2457 2458 // Go idle if queue is empty, before sending result 2459 bool signalIdle = false; 2460 { 2461 Mutex::Autolock l(mLock); 2462 if (mInFlightQueue.empty()) { 2463 mThreadActive = false; 2464 signalIdle = true; 2465 } 2466 } 2467 if (signalIdle) mParent->signalReadoutIdle(); 2468 2469 // Send it off to the framework 2470 ALOGVV("%s: ReadoutThread: Send result to framework", 2471 __FUNCTION__); 2472 mParent->sendCaptureResult(&result); 2473 2474 // Clean up 2475 mCurrentRequest.settings.unlock(result.result); 2476 2477 delete mCurrentRequest.buffers; 2478 mCurrentRequest.buffers = NULL; 2479 if (!needJpeg) { 2480 delete mCurrentRequest.sensorBuffers; 2481 mCurrentRequest.sensorBuffers = NULL; 2482 } 2483 mCurrentRequest.settings.clear(); 2484 2485 return true; 2486 } 2487 2488 void EmulatedFakeCamera3::ReadoutThread::onJpegDone( 2489 const StreamBuffer &jpegBuffer, bool success) { 2490 Mutex::Autolock jl(mJpegLock); 2491 2492 GraphicBufferMapper::get().unlock(*(jpegBuffer.buffer)); 2493 2494 mJpegHalBuffer.status = success ? 2495 CAMERA3_BUFFER_STATUS_OK : CAMERA3_BUFFER_STATUS_ERROR; 2496 mJpegHalBuffer.acquire_fence = -1; 2497 mJpegHalBuffer.release_fence = -1; 2498 mJpegWaiting = false; 2499 2500 camera3_capture_result result; 2501 result.frame_number = mJpegFrameNumber; 2502 result.result = NULL; 2503 result.num_output_buffers = 1; 2504 result.output_buffers = &mJpegHalBuffer; 2505 2506 if (!success) { 2507 ALOGE("%s: Compression failure, returning error state buffer to" 2508 " framework", __FUNCTION__); 2509 } else { 2510 ALOGV("%s: Compression complete, returning buffer to framework", 2511 __FUNCTION__); 2512 } 2513 2514 mParent->sendCaptureResult(&result); 2515 } 2516 2517 void EmulatedFakeCamera3::ReadoutThread::onJpegInputDone( 2518 const StreamBuffer &inputBuffer) { 2519 // Should never get here, since the input buffer has to be returned 2520 // by end of processCaptureRequest 2521 ALOGE("%s: Unexpected input buffer from JPEG compressor!", __FUNCTION__); 2522 } 2523 2524 2525 }; // namespace android 2526
