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 <utils/Log.h> 28 29 #include "EmulatedFakeCamera3.h" 30 #include "EmulatedCameraFactory.h" 31 #include <ui/Fence.h> 32 #include <ui/Rect.h> 33 #include <ui/GraphicBufferMapper.h> 34 #include "gralloc_cb.h" 35 36 #include "fake-pipeline2/Sensor.h" 37 #include "fake-pipeline2/JpegCompressor.h" 38 #include <cmath> 39 40 #if defined(LOG_NNDEBUG) && LOG_NNDEBUG == 0 41 #define ALOGVV ALOGV 42 #else 43 #define ALOGVV(...) ((void)0) 44 #endif 45 46 namespace android { 47 48 /** 49 * Constants for camera capabilities 50 */ 51 52 const int64_t USEC = 1000LL; 53 const int64_t MSEC = USEC * 1000LL; 54 const int64_t SEC = MSEC * 1000LL; 55 56 const int32_t EmulatedFakeCamera3::kAvailableFormats[5] = { 57 HAL_PIXEL_FORMAT_RAW_SENSOR, 58 HAL_PIXEL_FORMAT_BLOB, 59 HAL_PIXEL_FORMAT_RGBA_8888, 60 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED, 61 // These are handled by YCbCr_420_888 62 // HAL_PIXEL_FORMAT_YV12, 63 // HAL_PIXEL_FORMAT_YCrCb_420_SP, 64 HAL_PIXEL_FORMAT_YCbCr_420_888 65 }; 66 67 const uint32_t EmulatedFakeCamera3::kAvailableRawSizes[2] = { 68 640, 480 69 // Sensor::kResolution[0], Sensor::kResolution[1] 70 }; 71 72 const uint64_t EmulatedFakeCamera3::kAvailableRawMinDurations[1] = { 73 (const uint64_t)Sensor::kFrameDurationRange[0] 74 }; 75 76 const uint32_t EmulatedFakeCamera3::kAvailableProcessedSizesBack[4] = { 77 640, 480, 320, 240 78 // Sensor::kResolution[0], Sensor::kResolution[1] 79 }; 80 81 const uint32_t EmulatedFakeCamera3::kAvailableProcessedSizesFront[4] = { 82 320, 240, 160, 120 83 // Sensor::kResolution[0], Sensor::kResolution[1] 84 }; 85 86 const uint64_t EmulatedFakeCamera3::kAvailableProcessedMinDurations[1] = { 87 (const uint64_t)Sensor::kFrameDurationRange[0] 88 }; 89 90 const uint32_t EmulatedFakeCamera3::kAvailableJpegSizesBack[2] = { 91 640, 480 92 // Sensor::kResolution[0], Sensor::kResolution[1] 93 }; 94 95 const uint32_t EmulatedFakeCamera3::kAvailableJpegSizesFront[2] = { 96 320, 240 97 // Sensor::kResolution[0], Sensor::kResolution[1] 98 }; 99 100 101 const uint64_t EmulatedFakeCamera3::kAvailableJpegMinDurations[1] = { 102 (const uint64_t)Sensor::kFrameDurationRange[0] 103 }; 104 105 /** 106 * 3A constants 107 */ 108 109 // Default exposure and gain targets for different scenarios 110 const nsecs_t EmulatedFakeCamera3::kNormalExposureTime = 10 * MSEC; 111 const nsecs_t EmulatedFakeCamera3::kFacePriorityExposureTime = 30 * MSEC; 112 const int EmulatedFakeCamera3::kNormalSensitivity = 100; 113 const int EmulatedFakeCamera3::kFacePrioritySensitivity = 400; 114 const float EmulatedFakeCamera3::kExposureTrackRate = 0.1; 115 const int EmulatedFakeCamera3::kPrecaptureMinFrames = 10; 116 const int EmulatedFakeCamera3::kStableAeMaxFrames = 100; 117 const float EmulatedFakeCamera3::kExposureWanderMin = -2; 118 const float EmulatedFakeCamera3::kExposureWanderMax = 1; 119 120 /** 121 * Camera device lifecycle methods 122 */ 123 124 EmulatedFakeCamera3::EmulatedFakeCamera3(int cameraId, bool facingBack, 125 struct hw_module_t* module) : 126 EmulatedCamera3(cameraId, module), 127 mFacingBack(facingBack) { 128 ALOGI("Constructing emulated fake camera 3 facing %s", 129 facingBack ? "back" : "front"); 130 131 for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++) { 132 mDefaultTemplates[i] = NULL; 133 } 134 135 /** 136 * Front cameras = limited mode 137 * Back cameras = full mode 138 */ 139 mFullMode = facingBack; 140 } 141 142 EmulatedFakeCamera3::~EmulatedFakeCamera3() { 143 for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++) { 144 if (mDefaultTemplates[i] != NULL) { 145 free_camera_metadata(mDefaultTemplates[i]); 146 } 147 } 148 } 149 150 status_t EmulatedFakeCamera3::Initialize() { 151 ALOGV("%s: E", __FUNCTION__); 152 status_t res; 153 154 if (mStatus != STATUS_ERROR) { 155 ALOGE("%s: Already initialized!", __FUNCTION__); 156 return INVALID_OPERATION; 157 } 158 159 res = constructStaticInfo(); 160 if (res != OK) { 161 ALOGE("%s: Unable to allocate static info: %s (%d)", 162 __FUNCTION__, strerror(-res), res); 163 return res; 164 } 165 166 return EmulatedCamera3::Initialize(); 167 } 168 169 status_t EmulatedFakeCamera3::connectCamera(hw_device_t** device) { 170 ALOGV("%s: E", __FUNCTION__); 171 Mutex::Autolock l(mLock); 172 status_t res; 173 174 if (mStatus != STATUS_CLOSED) { 175 ALOGE("%s: Can't connect in state %d", __FUNCTION__, mStatus); 176 return INVALID_OPERATION; 177 } 178 179 mSensor = new Sensor(); 180 mSensor->setSensorListener(this); 181 182 res = mSensor->startUp(); 183 if (res != NO_ERROR) return res; 184 185 mReadoutThread = new ReadoutThread(this); 186 mJpegCompressor = new JpegCompressor(); 187 188 res = mReadoutThread->run("EmuCam3::readoutThread"); 189 if (res != NO_ERROR) return res; 190 191 // Initialize fake 3A 192 193 mControlMode = ANDROID_CONTROL_MODE_AUTO; 194 mFacePriority = false; 195 mAeMode = ANDROID_CONTROL_AE_MODE_ON; 196 mAfMode = ANDROID_CONTROL_AF_MODE_AUTO; 197 mAwbMode = ANDROID_CONTROL_AWB_MODE_AUTO; 198 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; 199 mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; 200 mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; 201 mAfTriggerId = 0; 202 mAeTriggerId = 0; 203 mAeCurrentExposureTime = kNormalExposureTime; 204 mAeCurrentSensitivity = kNormalSensitivity; 205 206 return EmulatedCamera3::connectCamera(device); 207 } 208 209 status_t EmulatedFakeCamera3::closeCamera() { 210 ALOGV("%s: E", __FUNCTION__); 211 status_t res; 212 { 213 Mutex::Autolock l(mLock); 214 if (mStatus == STATUS_CLOSED) return OK; 215 216 res = mSensor->shutDown(); 217 if (res != NO_ERROR) { 218 ALOGE("%s: Unable to shut down sensor: %d", __FUNCTION__, res); 219 return res; 220 } 221 mSensor.clear(); 222 223 mReadoutThread->requestExit(); 224 } 225 226 mReadoutThread->join(); 227 228 { 229 Mutex::Autolock l(mLock); 230 // Clear out private stream information 231 for (StreamIterator s = mStreams.begin(); s != mStreams.end(); s++) { 232 PrivateStreamInfo *privStream = 233 static_cast<PrivateStreamInfo*>((*s)->priv); 234 delete privStream; 235 (*s)->priv = NULL; 236 } 237 mStreams.clear(); 238 mReadoutThread.clear(); 239 } 240 241 return EmulatedCamera3::closeCamera(); 242 } 243 244 status_t EmulatedFakeCamera3::getCameraInfo(struct camera_info *info) { 245 info->facing = mFacingBack ? CAMERA_FACING_BACK : CAMERA_FACING_FRONT; 246 info->orientation = gEmulatedCameraFactory.getFakeCameraOrientation(); 247 return EmulatedCamera3::getCameraInfo(info); 248 } 249 250 /** 251 * Camera3 interface methods 252 */ 253 254 status_t EmulatedFakeCamera3::configureStreams( 255 camera3_stream_configuration *streamList) { 256 Mutex::Autolock l(mLock); 257 ALOGV("%s: %d streams", __FUNCTION__, streamList->num_streams); 258 259 if (mStatus != STATUS_OPEN && mStatus != STATUS_READY) { 260 ALOGE("%s: Cannot configure streams in state %d", 261 __FUNCTION__, mStatus); 262 return NO_INIT; 263 } 264 265 /** 266 * Sanity-check input list. 267 */ 268 if (streamList == NULL) { 269 ALOGE("%s: NULL stream configuration", __FUNCTION__); 270 return BAD_VALUE; 271 } 272 273 if (streamList->streams == NULL) { 274 ALOGE("%s: NULL stream list", __FUNCTION__); 275 return BAD_VALUE; 276 } 277 278 if (streamList->num_streams < 1) { 279 ALOGE("%s: Bad number of streams requested: %d", __FUNCTION__, 280 streamList->num_streams); 281 return BAD_VALUE; 282 } 283 284 camera3_stream_t *inputStream = NULL; 285 for (size_t i = 0; i < streamList->num_streams; i++) { 286 camera3_stream_t *newStream = streamList->streams[i]; 287 288 if (newStream == NULL) { 289 ALOGE("%s: Stream index %zu was NULL", 290 __FUNCTION__, i); 291 return BAD_VALUE; 292 } 293 294 ALOGV("%s: Stream %p (id %zu), type %d, usage 0x%x, format 0x%x", 295 __FUNCTION__, newStream, i, newStream->stream_type, 296 newStream->usage, 297 newStream->format); 298 299 if (newStream->stream_type == CAMERA3_STREAM_INPUT || 300 newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL) { 301 if (inputStream != NULL) { 302 303 ALOGE("%s: Multiple input streams requested!", __FUNCTION__); 304 return BAD_VALUE; 305 } 306 inputStream = newStream; 307 } 308 309 bool validFormat = false; 310 for (size_t f = 0; 311 f < sizeof(kAvailableFormats)/sizeof(kAvailableFormats[0]); 312 f++) { 313 if (newStream->format == kAvailableFormats[f]) { 314 validFormat = true; 315 break; 316 } 317 } 318 if (!validFormat) { 319 ALOGE("%s: Unsupported stream format 0x%x requested", 320 __FUNCTION__, newStream->format); 321 return BAD_VALUE; 322 } 323 } 324 mInputStream = inputStream; 325 326 /** 327 * Initially mark all existing streams as not alive 328 */ 329 for (StreamIterator s = mStreams.begin(); s != mStreams.end(); ++s) { 330 PrivateStreamInfo *privStream = 331 static_cast<PrivateStreamInfo*>((*s)->priv); 332 privStream->alive = false; 333 } 334 335 /** 336 * Find new streams and mark still-alive ones 337 */ 338 for (size_t i = 0; i < streamList->num_streams; i++) { 339 camera3_stream_t *newStream = streamList->streams[i]; 340 if (newStream->priv == NULL) { 341 // New stream, construct info 342 PrivateStreamInfo *privStream = new PrivateStreamInfo(); 343 privStream->alive = true; 344 privStream->registered = false; 345 346 switch (newStream->stream_type) { 347 case CAMERA3_STREAM_OUTPUT: 348 newStream->usage = GRALLOC_USAGE_HW_CAMERA_WRITE; 349 break; 350 case CAMERA3_STREAM_INPUT: 351 newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ; 352 break; 353 case CAMERA3_STREAM_BIDIRECTIONAL: 354 newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ | 355 GRALLOC_USAGE_HW_CAMERA_WRITE; 356 break; 357 } 358 newStream->max_buffers = kMaxBufferCount; 359 newStream->priv = privStream; 360 mStreams.push_back(newStream); 361 } else { 362 // Existing stream, mark as still alive. 363 PrivateStreamInfo *privStream = 364 static_cast<PrivateStreamInfo*>(newStream->priv); 365 privStream->alive = true; 366 } 367 } 368 369 /** 370 * Reap the dead streams 371 */ 372 for (StreamIterator s = mStreams.begin(); s != mStreams.end();) { 373 PrivateStreamInfo *privStream = 374 static_cast<PrivateStreamInfo*>((*s)->priv); 375 if (!privStream->alive) { 376 (*s)->priv = NULL; 377 delete privStream; 378 s = mStreams.erase(s); 379 } else { 380 ++s; 381 } 382 } 383 384 /** 385 * Can't reuse settings across configure call 386 */ 387 mPrevSettings.clear(); 388 389 return OK; 390 } 391 392 status_t EmulatedFakeCamera3::registerStreamBuffers( 393 const camera3_stream_buffer_set *bufferSet) { 394 ALOGV("%s: E", __FUNCTION__); 395 Mutex::Autolock l(mLock); 396 397 /** 398 * Sanity checks 399 */ 400 401 // OK: register streams at any time during configure 402 // (but only once per stream) 403 if (mStatus != STATUS_READY && mStatus != STATUS_ACTIVE) { 404 ALOGE("%s: Cannot register buffers in state %d", 405 __FUNCTION__, mStatus); 406 return NO_INIT; 407 } 408 409 if (bufferSet == NULL) { 410 ALOGE("%s: NULL buffer set!", __FUNCTION__); 411 return BAD_VALUE; 412 } 413 414 StreamIterator s = mStreams.begin(); 415 for (; s != mStreams.end(); ++s) { 416 if (bufferSet->stream == *s) break; 417 } 418 if (s == mStreams.end()) { 419 ALOGE("%s: Trying to register buffers for a non-configured stream!", 420 __FUNCTION__); 421 return BAD_VALUE; 422 } 423 424 /** 425 * Register the buffers. This doesn't mean anything to the emulator besides 426 * marking them off as registered. 427 */ 428 429 PrivateStreamInfo *privStream = 430 static_cast<PrivateStreamInfo*>((*s)->priv); 431 432 if (privStream->registered) { 433 ALOGE("%s: Illegal to register buffer more than once", __FUNCTION__); 434 return BAD_VALUE; 435 } 436 437 privStream->registered = true; 438 439 return OK; 440 } 441 442 const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings( 443 int type) { 444 ALOGV("%s: E", __FUNCTION__); 445 Mutex::Autolock l(mLock); 446 447 if (type < 0 || type >= CAMERA2_TEMPLATE_COUNT) { 448 ALOGE("%s: Unknown request settings template: %d", 449 __FUNCTION__, type); 450 return NULL; 451 } 452 453 /** 454 * Cache is not just an optimization - pointer returned has to live at 455 * least as long as the camera device instance does. 456 */ 457 if (mDefaultTemplates[type] != NULL) { 458 return mDefaultTemplates[type]; 459 } 460 461 CameraMetadata settings; 462 463 /** android.request */ 464 465 static const uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE; 466 settings.update(ANDROID_REQUEST_TYPE, &requestType, 1); 467 468 static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL; 469 settings.update(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1); 470 471 static const int32_t id = 0; 472 settings.update(ANDROID_REQUEST_ID, &id, 1); 473 474 static const int32_t frameCount = 0; 475 settings.update(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1); 476 477 /** android.lens */ 478 479 static const float focusDistance = 0; 480 settings.update(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1); 481 482 static const float aperture = 2.8f; 483 settings.update(ANDROID_LENS_APERTURE, &aperture, 1); 484 485 static const float focalLength = 5.0f; 486 settings.update(ANDROID_LENS_FOCAL_LENGTH, &focalLength, 1); 487 488 static const float filterDensity = 0; 489 settings.update(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1); 490 491 static const uint8_t opticalStabilizationMode = 492 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; 493 settings.update(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, 494 &opticalStabilizationMode, 1); 495 496 // FOCUS_RANGE set only in frame 497 498 /** android.sensor */ 499 500 static const int64_t exposureTime = 10 * MSEC; 501 settings.update(ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime, 1); 502 503 static const int64_t frameDuration = 33333333L; // 1/30 s 504 settings.update(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1); 505 506 static const int32_t sensitivity = 100; 507 settings.update(ANDROID_SENSOR_SENSITIVITY, &sensitivity, 1); 508 509 // TIMESTAMP set only in frame 510 511 /** android.flash */ 512 513 static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF; 514 settings.update(ANDROID_FLASH_MODE, &flashMode, 1); 515 516 static const uint8_t flashPower = 10; 517 settings.update(ANDROID_FLASH_FIRING_POWER, &flashPower, 1); 518 519 static const int64_t firingTime = 0; 520 settings.update(ANDROID_FLASH_FIRING_TIME, &firingTime, 1); 521 522 /** Processing block modes */ 523 uint8_t hotPixelMode = 0; 524 uint8_t demosaicMode = 0; 525 uint8_t noiseMode = 0; 526 uint8_t shadingMode = 0; 527 uint8_t colorMode = 0; 528 uint8_t tonemapMode = 0; 529 uint8_t edgeMode = 0; 530 switch (type) { 531 case CAMERA2_TEMPLATE_STILL_CAPTURE: 532 // fall-through 533 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: 534 // fall-through 535 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: 536 hotPixelMode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY; 537 demosaicMode = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY; 538 noiseMode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY; 539 shadingMode = ANDROID_SHADING_MODE_HIGH_QUALITY; 540 colorMode = ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY; 541 tonemapMode = ANDROID_TONEMAP_MODE_HIGH_QUALITY; 542 edgeMode = ANDROID_EDGE_MODE_HIGH_QUALITY; 543 break; 544 case CAMERA2_TEMPLATE_PREVIEW: 545 // fall-through 546 case CAMERA2_TEMPLATE_VIDEO_RECORD: 547 // fall-through 548 default: 549 hotPixelMode = ANDROID_HOT_PIXEL_MODE_FAST; 550 demosaicMode = ANDROID_DEMOSAIC_MODE_FAST; 551 noiseMode = ANDROID_NOISE_REDUCTION_MODE_FAST; 552 shadingMode = ANDROID_SHADING_MODE_FAST; 553 colorMode = ANDROID_COLOR_CORRECTION_MODE_FAST; 554 tonemapMode = ANDROID_TONEMAP_MODE_FAST; 555 edgeMode = ANDROID_EDGE_MODE_FAST; 556 break; 557 } 558 settings.update(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1); 559 settings.update(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1); 560 settings.update(ANDROID_NOISE_REDUCTION_MODE, &noiseMode, 1); 561 settings.update(ANDROID_SHADING_MODE, &shadingMode, 1); 562 settings.update(ANDROID_COLOR_CORRECTION_MODE, &colorMode, 1); 563 settings.update(ANDROID_TONEMAP_MODE, &tonemapMode, 1); 564 settings.update(ANDROID_EDGE_MODE, &edgeMode, 1); 565 566 /** android.noise */ 567 static const uint8_t noiseStrength = 5; 568 settings.update(ANDROID_NOISE_REDUCTION_STRENGTH, &noiseStrength, 1); 569 570 /** android.color */ 571 static const float colorTransform[9] = { 572 1.0f, 0.f, 0.f, 573 0.f, 1.f, 0.f, 574 0.f, 0.f, 1.f 575 }; 576 settings.update(ANDROID_COLOR_CORRECTION_TRANSFORM, colorTransform, 9); 577 578 /** android.tonemap */ 579 static const float tonemapCurve[4] = { 580 0.f, 0.f, 581 1.f, 1.f 582 }; 583 settings.update(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 4); 584 settings.update(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 4); 585 settings.update(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 4); 586 587 /** android.edge */ 588 static const uint8_t edgeStrength = 5; 589 settings.update(ANDROID_EDGE_STRENGTH, &edgeStrength, 1); 590 591 /** android.scaler */ 592 static const int32_t cropRegion[3] = { 593 0, 0, (int32_t)Sensor::kResolution[0] 594 }; 595 settings.update(ANDROID_SCALER_CROP_REGION, cropRegion, 3); 596 597 /** android.jpeg */ 598 static const uint8_t jpegQuality = 80; 599 settings.update(ANDROID_JPEG_QUALITY, &jpegQuality, 1); 600 601 static const int32_t thumbnailSize[2] = { 602 640, 480 603 }; 604 settings.update(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2); 605 606 static const uint8_t thumbnailQuality = 80; 607 settings.update(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1); 608 609 static const double gpsCoordinates[2] = { 610 0, 0 611 }; 612 settings.update(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 2); 613 614 static const uint8_t gpsProcessingMethod[32] = "None"; 615 settings.update(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32); 616 617 static const int64_t gpsTimestamp = 0; 618 settings.update(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1); 619 620 static const int32_t jpegOrientation = 0; 621 settings.update(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1); 622 623 /** android.stats */ 624 625 static const uint8_t faceDetectMode = 626 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; 627 settings.update(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1); 628 629 static const uint8_t histogramMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF; 630 settings.update(ANDROID_STATISTICS_HISTOGRAM_MODE, &histogramMode, 1); 631 632 static const uint8_t sharpnessMapMode = 633 ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF; 634 settings.update(ANDROID_STATISTICS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1); 635 636 // faceRectangles, faceScores, faceLandmarks, faceIds, histogram, 637 // sharpnessMap only in frames 638 639 /** android.control */ 640 641 uint8_t controlIntent = 0; 642 switch (type) { 643 case CAMERA2_TEMPLATE_PREVIEW: 644 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; 645 break; 646 case CAMERA2_TEMPLATE_STILL_CAPTURE: 647 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE; 648 break; 649 case CAMERA2_TEMPLATE_VIDEO_RECORD: 650 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD; 651 break; 652 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: 653 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT; 654 break; 655 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: 656 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG; 657 break; 658 default: 659 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM; 660 break; 661 } 662 settings.update(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1); 663 664 static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO; 665 settings.update(ANDROID_CONTROL_MODE, &controlMode, 1); 666 667 static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; 668 settings.update(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1); 669 670 static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; 671 settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1); 672 673 static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON; 674 settings.update(ANDROID_CONTROL_AE_MODE, &aeMode, 1); 675 676 static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF; 677 settings.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1); 678 679 static const int32_t controlRegions[5] = { 680 0, 0, (int32_t)Sensor::kResolution[0], (int32_t)Sensor::kResolution[1], 681 1000 682 }; 683 settings.update(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5); 684 685 static const int32_t aeExpCompensation = 0; 686 settings.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExpCompensation, 1); 687 688 static const int32_t aeTargetFpsRange[2] = { 689 10, 30 690 }; 691 settings.update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2); 692 693 static const uint8_t aeAntibandingMode = 694 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO; 695 settings.update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1); 696 697 static const uint8_t awbMode = 698 ANDROID_CONTROL_AWB_MODE_AUTO; 699 settings.update(ANDROID_CONTROL_AWB_MODE, &awbMode, 1); 700 701 static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF; 702 settings.update(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1); 703 704 settings.update(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5); 705 706 uint8_t afMode = 0; 707 switch (type) { 708 case CAMERA2_TEMPLATE_PREVIEW: 709 afMode = ANDROID_CONTROL_AF_MODE_AUTO; 710 break; 711 case CAMERA2_TEMPLATE_STILL_CAPTURE: 712 afMode = ANDROID_CONTROL_AF_MODE_AUTO; 713 break; 714 case CAMERA2_TEMPLATE_VIDEO_RECORD: 715 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO; 716 break; 717 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: 718 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO; 719 break; 720 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: 721 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE; 722 break; 723 default: 724 afMode = ANDROID_CONTROL_AF_MODE_AUTO; 725 break; 726 } 727 settings.update(ANDROID_CONTROL_AF_MODE, &afMode, 1); 728 729 settings.update(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5); 730 731 static const uint8_t vstabMode = 732 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; 733 settings.update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1); 734 735 // aeState, awbState, afState only in frame 736 737 mDefaultTemplates[type] = settings.release(); 738 739 return mDefaultTemplates[type]; 740 } 741 742 status_t EmulatedFakeCamera3::processCaptureRequest( 743 camera3_capture_request *request) { 744 745 Mutex::Autolock l(mLock); 746 status_t res; 747 748 /** Validation */ 749 750 if (mStatus < STATUS_READY) { 751 ALOGE("%s: Can't submit capture requests in state %d", __FUNCTION__, 752 mStatus); 753 return INVALID_OPERATION; 754 } 755 756 if (request == NULL) { 757 ALOGE("%s: NULL request!", __FUNCTION__); 758 return BAD_VALUE; 759 } 760 761 uint32_t frameNumber = request->frame_number; 762 763 if (request->settings == NULL && mPrevSettings.isEmpty()) { 764 ALOGE("%s: Request %d: NULL settings for first request after" 765 "configureStreams()", __FUNCTION__, frameNumber); 766 return BAD_VALUE; 767 } 768 769 if (request->input_buffer != NULL && 770 request->input_buffer->stream != mInputStream) { 771 ALOGE("%s: Request %d: Input buffer not from input stream!", 772 __FUNCTION__, frameNumber); 773 ALOGV("%s: Bad stream %p, expected: %p", 774 __FUNCTION__, request->input_buffer->stream, 775 mInputStream); 776 ALOGV("%s: Bad stream type %d, expected stream type %d", 777 __FUNCTION__, request->input_buffer->stream->stream_type, 778 mInputStream ? mInputStream->stream_type : -1); 779 780 return BAD_VALUE; 781 } 782 783 if (request->num_output_buffers < 1 || request->output_buffers == NULL) { 784 ALOGE("%s: Request %d: No output buffers provided!", 785 __FUNCTION__, frameNumber); 786 return BAD_VALUE; 787 } 788 789 // Validate all buffers, starting with input buffer if it's given 790 791 ssize_t idx; 792 const camera3_stream_buffer_t *b; 793 if (request->input_buffer != NULL) { 794 idx = -1; 795 b = request->input_buffer; 796 } else { 797 idx = 0; 798 b = request->output_buffers; 799 } 800 do { 801 PrivateStreamInfo *priv = 802 static_cast<PrivateStreamInfo*>(b->stream->priv); 803 if (priv == NULL) { 804 ALOGE("%s: Request %d: Buffer %zu: Unconfigured stream!", 805 __FUNCTION__, frameNumber, idx); 806 return BAD_VALUE; 807 } 808 if (!priv->alive || !priv->registered) { 809 ALOGE("%s: Request %d: Buffer %zu: Unregistered or dead stream!", 810 __FUNCTION__, frameNumber, idx); 811 return BAD_VALUE; 812 } 813 if (b->status != CAMERA3_BUFFER_STATUS_OK) { 814 ALOGE("%s: Request %d: Buffer %zu: Status not OK!", 815 __FUNCTION__, frameNumber, idx); 816 return BAD_VALUE; 817 } 818 if (b->release_fence != -1) { 819 ALOGE("%s: Request %d: Buffer %zu: Has a release fence!", 820 __FUNCTION__, frameNumber, idx); 821 return BAD_VALUE; 822 } 823 if (b->buffer == NULL) { 824 ALOGE("%s: Request %d: Buffer %zu: NULL buffer handle!", 825 __FUNCTION__, frameNumber, idx); 826 return BAD_VALUE; 827 } 828 idx++; 829 b = &(request->output_buffers[idx]); 830 } while (idx < (ssize_t)request->num_output_buffers); 831 832 // TODO: Validate settings parameters 833 834 /** 835 * Start processing this request 836 */ 837 838 mStatus = STATUS_ACTIVE; 839 840 CameraMetadata settings; 841 842 if (request->settings == NULL) { 843 settings.acquire(mPrevSettings); 844 } else { 845 settings = request->settings; 846 } 847 848 res = process3A(settings); 849 if (res != OK) { 850 return res; 851 } 852 853 // TODO: Handle reprocessing 854 855 /** 856 * Get ready for sensor config 857 */ 858 859 nsecs_t exposureTime; 860 nsecs_t frameDuration; 861 uint32_t sensitivity; 862 bool needJpeg = false; 863 864 exposureTime = settings.find(ANDROID_SENSOR_EXPOSURE_TIME).data.i64[0]; 865 frameDuration = settings.find(ANDROID_SENSOR_FRAME_DURATION).data.i64[0]; 866 sensitivity = settings.find(ANDROID_SENSOR_SENSITIVITY).data.i32[0]; 867 868 Buffers *sensorBuffers = new Buffers(); 869 HalBufferVector *buffers = new HalBufferVector(); 870 871 sensorBuffers->setCapacity(request->num_output_buffers); 872 buffers->setCapacity(request->num_output_buffers); 873 874 // Process all the buffers we got for output, constructing internal buffer 875 // structures for them, and lock them for writing. 876 for (size_t i = 0; i < request->num_output_buffers; i++) { 877 const camera3_stream_buffer &srcBuf = request->output_buffers[i]; 878 const cb_handle_t *privBuffer = 879 static_cast<const cb_handle_t*>(*srcBuf.buffer); 880 StreamBuffer destBuf; 881 destBuf.streamId = kGenericStreamId; 882 destBuf.width = srcBuf.stream->width; 883 destBuf.height = srcBuf.stream->height; 884 destBuf.format = privBuffer->format; // Use real private format 885 destBuf.stride = srcBuf.stream->width; // TODO: query from gralloc 886 destBuf.buffer = srcBuf.buffer; 887 888 if (destBuf.format == HAL_PIXEL_FORMAT_BLOB) { 889 needJpeg = true; 890 } 891 892 // Wait on fence 893 sp<Fence> bufferAcquireFence = new Fence(srcBuf.acquire_fence); 894 res = bufferAcquireFence->wait(kFenceTimeoutMs); 895 if (res == TIMED_OUT) { 896 ALOGE("%s: Request %d: Buffer %zu: Fence timed out after %d ms", 897 __FUNCTION__, frameNumber, i, kFenceTimeoutMs); 898 } 899 if (res == OK) { 900 // Lock buffer for writing 901 const Rect rect(destBuf.width, destBuf.height); 902 if (srcBuf.stream->format == HAL_PIXEL_FORMAT_YCbCr_420_888) { 903 if (privBuffer->format == HAL_PIXEL_FORMAT_YCrCb_420_SP) { 904 android_ycbcr ycbcr = android_ycbcr(); 905 res = GraphicBufferMapper::get().lockYCbCr( 906 *(destBuf.buffer), 907 GRALLOC_USAGE_HW_CAMERA_WRITE, rect, 908 &ycbcr); 909 // This is only valid because we know that emulator's 910 // YCbCr_420_888 is really contiguous NV21 under the hood 911 destBuf.img = static_cast<uint8_t*>(ycbcr.y); 912 } else { 913 ALOGE("Unexpected private format for flexible YUV: 0x%x", 914 privBuffer->format); 915 res = INVALID_OPERATION; 916 } 917 } else { 918 res = GraphicBufferMapper::get().lock(*(destBuf.buffer), 919 GRALLOC_USAGE_HW_CAMERA_WRITE, rect, 920 (void**)&(destBuf.img)); 921 } 922 if (res != OK) { 923 ALOGE("%s: Request %d: Buffer %zu: Unable to lock buffer", 924 __FUNCTION__, frameNumber, i); 925 } 926 } 927 928 if (res != OK) { 929 // Either waiting or locking failed. Unlock locked buffers and bail 930 // out. 931 for (size_t j = 0; j < i; j++) { 932 GraphicBufferMapper::get().unlock( 933 *(request->output_buffers[i].buffer)); 934 } 935 return NO_INIT; 936 } 937 938 sensorBuffers->push_back(destBuf); 939 buffers->push_back(srcBuf); 940 } 941 942 /** 943 * Wait for JPEG compressor to not be busy, if needed 944 */ 945 if (needJpeg) { 946 bool ready = mJpegCompressor->waitForDone(kFenceTimeoutMs); 947 if (!ready) { 948 ALOGE("%s: Timeout waiting for JPEG compression to complete!", 949 __FUNCTION__); 950 return NO_INIT; 951 } 952 } 953 954 /** 955 * Wait until the in-flight queue has room 956 */ 957 res = mReadoutThread->waitForReadout(); 958 if (res != OK) { 959 ALOGE("%s: Timeout waiting for previous requests to complete!", 960 __FUNCTION__); 961 return NO_INIT; 962 } 963 964 /** 965 * Wait until sensor's ready. This waits for lengthy amounts of time with 966 * mLock held, but the interface spec is that no other calls may by done to 967 * the HAL by the framework while process_capture_request is happening. 968 */ 969 int syncTimeoutCount = 0; 970 while(!mSensor->waitForVSync(kSyncWaitTimeout)) { 971 if (mStatus == STATUS_ERROR) { 972 return NO_INIT; 973 } 974 if (syncTimeoutCount == kMaxSyncTimeoutCount) { 975 ALOGE("%s: Request %d: Sensor sync timed out after %" PRId64 " ms", 976 __FUNCTION__, frameNumber, 977 kSyncWaitTimeout * kMaxSyncTimeoutCount / 1000000); 978 return NO_INIT; 979 } 980 syncTimeoutCount++; 981 } 982 983 /** 984 * Configure sensor and queue up the request to the readout thread 985 */ 986 mSensor->setExposureTime(exposureTime); 987 mSensor->setFrameDuration(frameDuration); 988 mSensor->setSensitivity(sensitivity); 989 mSensor->setDestinationBuffers(sensorBuffers); 990 mSensor->setFrameNumber(request->frame_number); 991 992 ReadoutThread::Request r; 993 r.frameNumber = request->frame_number; 994 r.settings = settings; 995 r.sensorBuffers = sensorBuffers; 996 r.buffers = buffers; 997 998 mReadoutThread->queueCaptureRequest(r); 999 ALOGVV("%s: Queued frame %d", __FUNCTION__, request->frame_number); 1000 1001 // Cache the settings for next time 1002 mPrevSettings.acquire(settings); 1003 1004 return OK; 1005 } 1006 1007 /** Debug methods */ 1008 1009 void EmulatedFakeCamera3::dump(int fd) { 1010 1011 } 1012 1013 /** Tag query methods */ 1014 const char* EmulatedFakeCamera3::getVendorSectionName(uint32_t tag) { 1015 return NULL; 1016 } 1017 1018 const char* EmulatedFakeCamera3::getVendorTagName(uint32_t tag) { 1019 return NULL; 1020 } 1021 1022 int EmulatedFakeCamera3::getVendorTagType(uint32_t tag) { 1023 return 0; 1024 } 1025 1026 /** 1027 * Private methods 1028 */ 1029 1030 status_t EmulatedFakeCamera3::constructStaticInfo() { 1031 1032 CameraMetadata info; 1033 // android.lens 1034 1035 // 5 cm min focus distance for back camera, infinity (fixed focus) for front 1036 const float minFocusDistance = mFacingBack ? 1.0/0.05 : 0.0; 1037 info.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 1038 &minFocusDistance, 1); 1039 1040 // 5 m hyperfocal distance for back camera, infinity (fixed focus) for front 1041 const float hyperFocalDistance = mFacingBack ? 1.0/5.0 : 0.0; 1042 info.update(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, 1043 &minFocusDistance, 1); 1044 1045 static const float focalLength = 3.30f; // mm 1046 info.update(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, 1047 &focalLength, 1); 1048 static const float aperture = 2.8f; 1049 info.update(ANDROID_LENS_INFO_AVAILABLE_APERTURES, 1050 &aperture, 1); 1051 static const float filterDensity = 0; 1052 info.update(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, 1053 &filterDensity, 1); 1054 static const uint8_t availableOpticalStabilization = 1055 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; 1056 info.update(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, 1057 &availableOpticalStabilization, 1); 1058 1059 static const int32_t lensShadingMapSize[] = {1, 1}; 1060 info.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE, lensShadingMapSize, 1061 sizeof(lensShadingMapSize)/sizeof(int32_t)); 1062 1063 uint8_t lensFacing = mFacingBack ? 1064 ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT; 1065 info.update(ANDROID_LENS_FACING, &lensFacing, 1); 1066 1067 float lensPosition[3]; 1068 if (mFacingBack) { 1069 // Back-facing camera is center-top on device 1070 lensPosition[0] = 0; 1071 lensPosition[1] = 20; 1072 lensPosition[2] = -5; 1073 } else { 1074 // Front-facing camera is center-right on device 1075 lensPosition[0] = 20; 1076 lensPosition[1] = 20; 1077 lensPosition[2] = 0; 1078 } 1079 info.update(ANDROID_LENS_POSITION, lensPosition, sizeof(lensPosition)/ 1080 sizeof(float)); 1081 1082 // android.sensor 1083 1084 info.update(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, 1085 Sensor::kExposureTimeRange, 2); 1086 1087 info.update(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, 1088 &Sensor::kFrameDurationRange[1], 1); 1089 1090 info.update(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, 1091 Sensor::kSensitivityRange, 1092 sizeof(Sensor::kSensitivityRange) 1093 /sizeof(int32_t)); 1094 1095 info.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, 1096 &Sensor::kColorFilterArrangement, 1); 1097 1098 static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm 1099 info.update(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, 1100 sensorPhysicalSize, 2); 1101 1102 info.update(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, 1103 (int32_t*)Sensor::kResolution, 2); 1104 1105 info.update(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, 1106 (int32_t*)Sensor::kResolution, 2); 1107 1108 info.update(ANDROID_SENSOR_INFO_WHITE_LEVEL, 1109 (int32_t*)&Sensor::kMaxRawValue, 1); 1110 1111 static const int32_t blackLevelPattern[4] = { 1112 (int32_t)Sensor::kBlackLevel, (int32_t)Sensor::kBlackLevel, 1113 (int32_t)Sensor::kBlackLevel, (int32_t)Sensor::kBlackLevel 1114 }; 1115 info.update(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, 1116 blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t)); 1117 1118 static const int32_t orientation = 0; // unrotated (0 degrees) 1119 info.update(ANDROID_SENSOR_ORIENTATION, &orientation, 1); 1120 1121 //TODO: sensor color calibration fields 1122 1123 // android.flash 1124 static const uint8_t flashAvailable = 0; 1125 info.update(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1); 1126 1127 static const int64_t flashChargeDuration = 0; 1128 info.update(ANDROID_FLASH_INFO_CHARGE_DURATION, &flashChargeDuration, 1); 1129 1130 // android.tonemap 1131 1132 static const int32_t tonemapCurvePoints = 128; 1133 info.update(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1); 1134 1135 // android.scaler 1136 1137 info.update(ANDROID_SCALER_AVAILABLE_FORMATS, 1138 kAvailableFormats, 1139 sizeof(kAvailableFormats)/sizeof(int32_t)); 1140 1141 info.update(ANDROID_SCALER_AVAILABLE_RAW_SIZES, 1142 (int32_t*)kAvailableRawSizes, 1143 sizeof(kAvailableRawSizes)/sizeof(uint32_t)); 1144 1145 info.update(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS, 1146 (int64_t*)kAvailableRawMinDurations, 1147 sizeof(kAvailableRawMinDurations)/sizeof(uint64_t)); 1148 1149 if (mFacingBack) { 1150 info.update(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 1151 (int32_t*)kAvailableProcessedSizesBack, 1152 sizeof(kAvailableProcessedSizesBack)/sizeof(uint32_t)); 1153 } else { 1154 info.update(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 1155 (int32_t*)kAvailableProcessedSizesFront, 1156 sizeof(kAvailableProcessedSizesFront)/sizeof(uint32_t)); 1157 } 1158 1159 info.update(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS, 1160 (int64_t*)kAvailableProcessedMinDurations, 1161 sizeof(kAvailableProcessedMinDurations)/sizeof(uint64_t)); 1162 1163 if (mFacingBack) { 1164 info.update(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 1165 (int32_t*)kAvailableJpegSizesBack, 1166 sizeof(kAvailableJpegSizesBack)/sizeof(uint32_t)); 1167 } else { 1168 info.update(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 1169 (int32_t*)kAvailableJpegSizesFront, 1170 sizeof(kAvailableJpegSizesFront)/sizeof(uint32_t)); 1171 } 1172 1173 info.update(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS, 1174 (int64_t*)kAvailableJpegMinDurations, 1175 sizeof(kAvailableJpegMinDurations)/sizeof(uint64_t)); 1176 1177 static const float maxZoom = 10; 1178 info.update(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, 1179 &maxZoom, 1); 1180 1181 // android.jpeg 1182 1183 static const int32_t jpegThumbnailSizes[] = { 1184 0, 0, 1185 160, 120, 1186 320, 240 1187 }; 1188 info.update(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 1189 jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t)); 1190 1191 static const int32_t jpegMaxSize = JpegCompressor::kMaxJpegSize; 1192 info.update(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1); 1193 1194 // android.stats 1195 1196 static const uint8_t availableFaceDetectModes[] = { 1197 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF, 1198 ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE, 1199 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL 1200 }; 1201 1202 info.update(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, 1203 availableFaceDetectModes, 1204 sizeof(availableFaceDetectModes)); 1205 1206 static const int32_t maxFaceCount = 8; 1207 info.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, 1208 &maxFaceCount, 1); 1209 1210 static const int32_t histogramSize = 64; 1211 info.update(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT, 1212 &histogramSize, 1); 1213 1214 static const int32_t maxHistogramCount = 1000; 1215 info.update(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT, 1216 &maxHistogramCount, 1); 1217 1218 static const int32_t sharpnessMapSize[2] = {64, 64}; 1219 info.update(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE, 1220 sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t)); 1221 1222 static const int32_t maxSharpnessMapValue = 1000; 1223 info.update(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE, 1224 &maxSharpnessMapValue, 1); 1225 1226 // android.control 1227 1228 static const uint8_t availableSceneModes[] = { 1229 ANDROID_CONTROL_SCENE_MODE_DISABLED 1230 }; 1231 info.update(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 1232 availableSceneModes, sizeof(availableSceneModes)); 1233 1234 static const uint8_t availableEffects[] = { 1235 ANDROID_CONTROL_EFFECT_MODE_OFF 1236 }; 1237 info.update(ANDROID_CONTROL_AVAILABLE_EFFECTS, 1238 availableEffects, sizeof(availableEffects)); 1239 1240 static const int32_t max3aRegions[] = {/*AE*/ 0,/*AWB*/ 0,/*AF*/ 0}; 1241 info.update(ANDROID_CONTROL_MAX_REGIONS, 1242 max3aRegions, sizeof(max3aRegions)/sizeof(max3aRegions[0])); 1243 1244 static const uint8_t availableAeModes[] = { 1245 ANDROID_CONTROL_AE_MODE_OFF, 1246 ANDROID_CONTROL_AE_MODE_ON 1247 }; 1248 info.update(ANDROID_CONTROL_AE_AVAILABLE_MODES, 1249 availableAeModes, sizeof(availableAeModes)); 1250 1251 static const camera_metadata_rational exposureCompensationStep = { 1252 1, 3 1253 }; 1254 info.update(ANDROID_CONTROL_AE_COMPENSATION_STEP, 1255 &exposureCompensationStep, 1); 1256 1257 int32_t exposureCompensationRange[] = {-9, 9}; 1258 info.update(ANDROID_CONTROL_AE_COMPENSATION_RANGE, 1259 exposureCompensationRange, 1260 sizeof(exposureCompensationRange)/sizeof(int32_t)); 1261 1262 static const int32_t availableTargetFpsRanges[] = { 1263 5, 30, 15, 30 1264 }; 1265 info.update(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 1266 availableTargetFpsRanges, 1267 sizeof(availableTargetFpsRanges)/sizeof(int32_t)); 1268 1269 static const uint8_t availableAntibandingModes[] = { 1270 ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF, 1271 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO 1272 }; 1273 info.update(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, 1274 availableAntibandingModes, sizeof(availableAntibandingModes)); 1275 1276 static const uint8_t availableAwbModes[] = { 1277 ANDROID_CONTROL_AWB_MODE_OFF, 1278 ANDROID_CONTROL_AWB_MODE_AUTO, 1279 ANDROID_CONTROL_AWB_MODE_INCANDESCENT, 1280 ANDROID_CONTROL_AWB_MODE_FLUORESCENT, 1281 ANDROID_CONTROL_AWB_MODE_DAYLIGHT, 1282 ANDROID_CONTROL_AWB_MODE_SHADE 1283 }; 1284 info.update(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 1285 availableAwbModes, sizeof(availableAwbModes)); 1286 1287 static const uint8_t availableAfModesBack[] = { 1288 ANDROID_CONTROL_AF_MODE_OFF, 1289 ANDROID_CONTROL_AF_MODE_AUTO, 1290 ANDROID_CONTROL_AF_MODE_MACRO, 1291 ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, 1292 ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE 1293 }; 1294 1295 static const uint8_t availableAfModesFront[] = { 1296 ANDROID_CONTROL_AF_MODE_OFF 1297 }; 1298 1299 if (mFacingBack) { 1300 info.update(ANDROID_CONTROL_AF_AVAILABLE_MODES, 1301 availableAfModesBack, sizeof(availableAfModesBack)); 1302 } else { 1303 info.update(ANDROID_CONTROL_AF_AVAILABLE_MODES, 1304 availableAfModesFront, sizeof(availableAfModesFront)); 1305 } 1306 1307 static const uint8_t availableVstabModes[] = { 1308 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF 1309 }; 1310 info.update(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 1311 availableVstabModes, sizeof(availableVstabModes)); 1312 1313 // android.info 1314 const uint8_t supportedHardwareLevel = 1315 mFullMode ? ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL : 1316 ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED; 1317 info.update(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL, 1318 &supportedHardwareLevel, 1319 /*count*/1); 1320 1321 mCameraInfo = info.release(); 1322 1323 return OK; 1324 } 1325 1326 status_t EmulatedFakeCamera3::process3A(CameraMetadata &settings) { 1327 /** 1328 * Extract top-level 3A controls 1329 */ 1330 status_t res; 1331 1332 bool facePriority = false; 1333 1334 camera_metadata_entry e; 1335 1336 e = settings.find(ANDROID_CONTROL_MODE); 1337 if (e.count == 0) { 1338 ALOGE("%s: No control mode entry!", __FUNCTION__); 1339 return BAD_VALUE; 1340 } 1341 uint8_t controlMode = e.data.u8[0]; 1342 1343 e = settings.find(ANDROID_CONTROL_SCENE_MODE); 1344 if (e.count == 0) { 1345 ALOGE("%s: No scene mode entry!", __FUNCTION__); 1346 return BAD_VALUE; 1347 } 1348 uint8_t sceneMode = e.data.u8[0]; 1349 1350 if (controlMode == ANDROID_CONTROL_MODE_OFF) { 1351 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; 1352 mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; 1353 mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; 1354 update3A(settings); 1355 return OK; 1356 } else if (controlMode == ANDROID_CONTROL_MODE_USE_SCENE_MODE) { 1357 switch(sceneMode) { 1358 case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY: 1359 mFacePriority = true; 1360 break; 1361 default: 1362 ALOGE("%s: Emulator doesn't support scene mode %d", 1363 __FUNCTION__, sceneMode); 1364 return BAD_VALUE; 1365 } 1366 } else { 1367 mFacePriority = false; 1368 } 1369 1370 // controlMode == AUTO or sceneMode = FACE_PRIORITY 1371 // Process individual 3A controls 1372 1373 res = doFakeAE(settings); 1374 if (res != OK) return res; 1375 1376 res = doFakeAF(settings); 1377 if (res != OK) return res; 1378 1379 res = doFakeAWB(settings); 1380 if (res != OK) return res; 1381 1382 update3A(settings); 1383 return OK; 1384 } 1385 1386 status_t EmulatedFakeCamera3::doFakeAE(CameraMetadata &settings) { 1387 camera_metadata_entry e; 1388 1389 e = settings.find(ANDROID_CONTROL_AE_MODE); 1390 if (e.count == 0) { 1391 ALOGE("%s: No AE mode entry!", __FUNCTION__); 1392 return BAD_VALUE; 1393 } 1394 uint8_t aeMode = e.data.u8[0]; 1395 1396 switch (aeMode) { 1397 case ANDROID_CONTROL_AE_MODE_OFF: 1398 // AE is OFF 1399 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; 1400 return OK; 1401 case ANDROID_CONTROL_AE_MODE_ON: 1402 // OK for AUTO modes 1403 break; 1404 default: 1405 ALOGE("%s: Emulator doesn't support AE mode %d", 1406 __FUNCTION__, aeMode); 1407 return BAD_VALUE; 1408 } 1409 1410 e = settings.find(ANDROID_CONTROL_AE_LOCK); 1411 if (e.count == 0) { 1412 ALOGE("%s: No AE lock entry!", __FUNCTION__); 1413 return BAD_VALUE; 1414 } 1415 bool aeLocked = (e.data.u8[0] == ANDROID_CONTROL_AE_LOCK_ON); 1416 1417 e = settings.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER); 1418 bool precaptureTrigger = false; 1419 if (e.count != 0) { 1420 precaptureTrigger = 1421 (e.data.u8[0] == ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START); 1422 } 1423 1424 if (precaptureTrigger) { 1425 ALOGV("%s: Pre capture trigger = %d", __FUNCTION__, precaptureTrigger); 1426 } else if (e.count > 0) { 1427 ALOGV("%s: Pre capture trigger was present? %zu", 1428 __FUNCTION__, 1429 e.count); 1430 } 1431 1432 // If we have an aePrecaptureTrigger, aePrecaptureId should be set too 1433 if (e.count != 0) { 1434 e = settings.find(ANDROID_CONTROL_AE_PRECAPTURE_ID); 1435 1436 if (e.count == 0) { 1437 ALOGE("%s: When android.control.aePrecaptureTrigger is set " 1438 " in the request, aePrecaptureId needs to be set as well", 1439 __FUNCTION__); 1440 return BAD_VALUE; 1441 } 1442 1443 mAeTriggerId = e.data.i32[0]; 1444 } 1445 1446 if (precaptureTrigger || mAeState == ANDROID_CONTROL_AE_STATE_PRECAPTURE) { 1447 // Run precapture sequence 1448 if (mAeState != ANDROID_CONTROL_AE_STATE_PRECAPTURE) { 1449 mAeCounter = 0; 1450 } 1451 1452 if (mFacePriority) { 1453 mAeTargetExposureTime = kFacePriorityExposureTime; 1454 } else { 1455 mAeTargetExposureTime = kNormalExposureTime; 1456 } 1457 1458 if (mAeCounter > kPrecaptureMinFrames && 1459 (mAeTargetExposureTime - mAeCurrentExposureTime) < 1460 mAeTargetExposureTime / 10) { 1461 // Done with precapture 1462 mAeCounter = 0; 1463 mAeState = aeLocked ? ANDROID_CONTROL_AE_STATE_LOCKED : 1464 ANDROID_CONTROL_AE_STATE_CONVERGED; 1465 } else { 1466 // Converge some more 1467 mAeCurrentExposureTime += 1468 (mAeTargetExposureTime - mAeCurrentExposureTime) * 1469 kExposureTrackRate; 1470 mAeCounter++; 1471 mAeState = ANDROID_CONTROL_AE_STATE_PRECAPTURE; 1472 } 1473 1474 } else if (!aeLocked) { 1475 // Run standard occasional AE scan 1476 switch (mAeState) { 1477 case ANDROID_CONTROL_AE_STATE_CONVERGED: 1478 case ANDROID_CONTROL_AE_STATE_INACTIVE: 1479 mAeCounter++; 1480 if (mAeCounter > kStableAeMaxFrames) { 1481 mAeTargetExposureTime = 1482 mFacePriority ? kFacePriorityExposureTime : 1483 kNormalExposureTime; 1484 float exposureStep = ((double)rand() / RAND_MAX) * 1485 (kExposureWanderMax - kExposureWanderMin) + 1486 kExposureWanderMin; 1487 mAeTargetExposureTime *= std::pow(2, exposureStep); 1488 mAeState = ANDROID_CONTROL_AE_STATE_SEARCHING; 1489 } 1490 break; 1491 case ANDROID_CONTROL_AE_STATE_SEARCHING: 1492 mAeCurrentExposureTime += 1493 (mAeTargetExposureTime - mAeCurrentExposureTime) * 1494 kExposureTrackRate; 1495 if (abs(mAeTargetExposureTime - mAeCurrentExposureTime) < 1496 mAeTargetExposureTime / 10) { 1497 // Close enough 1498 mAeState = ANDROID_CONTROL_AE_STATE_CONVERGED; 1499 mAeCounter = 0; 1500 } 1501 break; 1502 case ANDROID_CONTROL_AE_STATE_LOCKED: 1503 mAeState = ANDROID_CONTROL_AE_STATE_CONVERGED; 1504 mAeCounter = 0; 1505 break; 1506 default: 1507 ALOGE("%s: Emulator in unexpected AE state %d", 1508 __FUNCTION__, mAeState); 1509 return INVALID_OPERATION; 1510 } 1511 } else { 1512 // AE is locked 1513 mAeState = ANDROID_CONTROL_AE_STATE_LOCKED; 1514 } 1515 1516 return OK; 1517 } 1518 1519 status_t EmulatedFakeCamera3::doFakeAF(CameraMetadata &settings) { 1520 camera_metadata_entry e; 1521 1522 e = settings.find(ANDROID_CONTROL_AF_MODE); 1523 if (e.count == 0) { 1524 ALOGE("%s: No AF mode entry!", __FUNCTION__); 1525 return BAD_VALUE; 1526 } 1527 uint8_t afMode = e.data.u8[0]; 1528 1529 e = settings.find(ANDROID_CONTROL_AF_TRIGGER); 1530 typedef camera_metadata_enum_android_control_af_trigger af_trigger_t; 1531 af_trigger_t afTrigger; 1532 // If we have an afTrigger, afTriggerId should be set too 1533 if (e.count != 0) { 1534 afTrigger = static_cast<af_trigger_t>(e.data.u8[0]); 1535 1536 e = settings.find(ANDROID_CONTROL_AF_TRIGGER_ID); 1537 1538 if (e.count == 0) { 1539 ALOGE("%s: When android.control.afTrigger is set " 1540 " in the request, afTriggerId needs to be set as well", 1541 __FUNCTION__); 1542 return BAD_VALUE; 1543 } 1544 1545 mAfTriggerId = e.data.i32[0]; 1546 1547 ALOGV("%s: AF trigger set to 0x%x", __FUNCTION__, afTrigger); 1548 ALOGV("%s: AF trigger ID set to 0x%x", __FUNCTION__, mAfTriggerId); 1549 ALOGV("%s: AF mode is 0x%x", __FUNCTION__, afMode); 1550 } else { 1551 afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE; 1552 } 1553 1554 switch (afMode) { 1555 case ANDROID_CONTROL_AF_MODE_OFF: 1556 mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; 1557 return OK; 1558 case ANDROID_CONTROL_AF_MODE_AUTO: 1559 case ANDROID_CONTROL_AF_MODE_MACRO: 1560 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 1561 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 1562 if (!mFacingBack) { 1563 ALOGE("%s: Front camera doesn't support AF mode %d", 1564 __FUNCTION__, afMode); 1565 return BAD_VALUE; 1566 } 1567 // OK, handle transitions lower on 1568 break; 1569 default: 1570 ALOGE("%s: Emulator doesn't support AF mode %d", 1571 __FUNCTION__, afMode); 1572 return BAD_VALUE; 1573 } 1574 1575 bool afModeChanged = mAfMode != afMode; 1576 mAfMode = afMode; 1577 1578 /** 1579 * Simulate AF triggers. Transition at most 1 state per frame. 1580 * - Focusing always succeeds (goes into locked, or PASSIVE_SCAN). 1581 */ 1582 1583 bool afTriggerStart = false; 1584 bool afTriggerCancel = false; 1585 switch (afTrigger) { 1586 case ANDROID_CONTROL_AF_TRIGGER_IDLE: 1587 break; 1588 case ANDROID_CONTROL_AF_TRIGGER_START: 1589 afTriggerStart = true; 1590 break; 1591 case ANDROID_CONTROL_AF_TRIGGER_CANCEL: 1592 afTriggerCancel = true; 1593 // Cancel trigger always transitions into INACTIVE 1594 mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; 1595 1596 ALOGV("%s: AF State transition to STATE_INACTIVE", __FUNCTION__); 1597 1598 // Stay in 'inactive' until at least next frame 1599 return OK; 1600 default: 1601 ALOGE("%s: Unknown af trigger value %d", __FUNCTION__, afTrigger); 1602 return BAD_VALUE; 1603 } 1604 1605 // If we get down here, we're either in an autofocus mode 1606 // or in a continuous focus mode (and no other modes) 1607 1608 int oldAfState = mAfState; 1609 switch (mAfState) { 1610 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1611 if (afTriggerStart) { 1612 switch (afMode) { 1613 case ANDROID_CONTROL_AF_MODE_AUTO: 1614 // fall-through 1615 case ANDROID_CONTROL_AF_MODE_MACRO: 1616 mAfState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; 1617 break; 1618 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 1619 // fall-through 1620 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 1621 mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 1622 break; 1623 } 1624 } else { 1625 // At least one frame stays in INACTIVE 1626 if (!afModeChanged) { 1627 switch (afMode) { 1628 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 1629 // fall-through 1630 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 1631 mAfState = ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN; 1632 break; 1633 } 1634 } 1635 } 1636 break; 1637 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1638 /** 1639 * When the AF trigger is activated, the algorithm should finish 1640 * its PASSIVE_SCAN if active, and then transition into AF_FOCUSED 1641 * or AF_NOT_FOCUSED as appropriate 1642 */ 1643 if (afTriggerStart) { 1644 // Randomly transition to focused or not focused 1645 if (rand() % 3) { 1646 mAfState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; 1647 } else { 1648 mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 1649 } 1650 } 1651 /** 1652 * When the AF trigger is not involved, the AF algorithm should 1653 * start in INACTIVE state, and then transition into PASSIVE_SCAN 1654 * and PASSIVE_FOCUSED states 1655 */ 1656 else if (!afTriggerCancel) { 1657 // Randomly transition to passive focus 1658 if (rand() % 3 == 0) { 1659 mAfState = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED; 1660 } 1661 } 1662 1663 break; 1664 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1665 if (afTriggerStart) { 1666 // Randomly transition to focused or not focused 1667 if (rand() % 3) { 1668 mAfState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; 1669 } else { 1670 mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 1671 } 1672 } 1673 // TODO: initiate passive scan (PASSIVE_SCAN) 1674 break; 1675 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: 1676 // Simulate AF sweep completing instantaneously 1677 1678 // Randomly transition to focused or not focused 1679 if (rand() % 3) { 1680 mAfState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; 1681 } else { 1682 mAfState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 1683 } 1684 break; 1685 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1686 if (afTriggerStart) { 1687 switch (afMode) { 1688 case ANDROID_CONTROL_AF_MODE_AUTO: 1689 // fall-through 1690 case ANDROID_CONTROL_AF_MODE_MACRO: 1691 mAfState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; 1692 break; 1693 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 1694 // fall-through 1695 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 1696 // continuous autofocus => trigger start has no effect 1697 break; 1698 } 1699 } 1700 break; 1701 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1702 if (afTriggerStart) { 1703 switch (afMode) { 1704 case ANDROID_CONTROL_AF_MODE_AUTO: 1705 // fall-through 1706 case ANDROID_CONTROL_AF_MODE_MACRO: 1707 mAfState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; 1708 break; 1709 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 1710 // fall-through 1711 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 1712 // continuous autofocus => trigger start has no effect 1713 break; 1714 } 1715 } 1716 break; 1717 default: 1718 ALOGE("%s: Bad af state %d", __FUNCTION__, mAfState); 1719 } 1720 1721 { 1722 char afStateString[100] = {0,}; 1723 camera_metadata_enum_snprint(ANDROID_CONTROL_AF_STATE, 1724 oldAfState, 1725 afStateString, 1726 sizeof(afStateString)); 1727 1728 char afNewStateString[100] = {0,}; 1729 camera_metadata_enum_snprint(ANDROID_CONTROL_AF_STATE, 1730 mAfState, 1731 afNewStateString, 1732 sizeof(afNewStateString)); 1733 ALOGVV("%s: AF state transitioned from %s to %s", 1734 __FUNCTION__, afStateString, afNewStateString); 1735 } 1736 1737 1738 return OK; 1739 } 1740 1741 status_t EmulatedFakeCamera3::doFakeAWB(CameraMetadata &settings) { 1742 camera_metadata_entry e; 1743 1744 e = settings.find(ANDROID_CONTROL_AWB_MODE); 1745 if (e.count == 0) { 1746 ALOGE("%s: No AWB mode entry!", __FUNCTION__); 1747 return BAD_VALUE; 1748 } 1749 uint8_t awbMode = e.data.u8[0]; 1750 1751 // TODO: Add white balance simulation 1752 1753 switch (awbMode) { 1754 case ANDROID_CONTROL_AWB_MODE_OFF: 1755 mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; 1756 return OK; 1757 case ANDROID_CONTROL_AWB_MODE_AUTO: 1758 case ANDROID_CONTROL_AWB_MODE_INCANDESCENT: 1759 case ANDROID_CONTROL_AWB_MODE_FLUORESCENT: 1760 case ANDROID_CONTROL_AWB_MODE_DAYLIGHT: 1761 case ANDROID_CONTROL_AWB_MODE_SHADE: 1762 // OK 1763 break; 1764 default: 1765 ALOGE("%s: Emulator doesn't support AWB mode %d", 1766 __FUNCTION__, awbMode); 1767 return BAD_VALUE; 1768 } 1769 1770 return OK; 1771 } 1772 1773 1774 void EmulatedFakeCamera3::update3A(CameraMetadata &settings) { 1775 if (mAeState != ANDROID_CONTROL_AE_STATE_INACTIVE) { 1776 settings.update(ANDROID_SENSOR_EXPOSURE_TIME, 1777 &mAeCurrentExposureTime, 1); 1778 settings.update(ANDROID_SENSOR_SENSITIVITY, 1779 &mAeCurrentSensitivity, 1); 1780 } 1781 1782 settings.update(ANDROID_CONTROL_AE_STATE, 1783 &mAeState, 1); 1784 settings.update(ANDROID_CONTROL_AF_STATE, 1785 &mAfState, 1); 1786 settings.update(ANDROID_CONTROL_AWB_STATE, 1787 &mAwbState, 1); 1788 /** 1789 * TODO: Trigger IDs need a think-through 1790 */ 1791 settings.update(ANDROID_CONTROL_AE_PRECAPTURE_ID, 1792 &mAeTriggerId, 1); 1793 settings.update(ANDROID_CONTROL_AF_TRIGGER_ID, 1794 &mAfTriggerId, 1); 1795 } 1796 1797 void EmulatedFakeCamera3::signalReadoutIdle() { 1798 Mutex::Autolock l(mLock); 1799 // Need to chek isIdle again because waiting on mLock may have allowed 1800 // something to be placed in the in-flight queue. 1801 if (mStatus == STATUS_ACTIVE && mReadoutThread->isIdle()) { 1802 ALOGV("Now idle"); 1803 mStatus = STATUS_READY; 1804 } 1805 } 1806 1807 void EmulatedFakeCamera3::onSensorEvent(uint32_t frameNumber, Event e, 1808 nsecs_t timestamp) { 1809 switch(e) { 1810 case Sensor::SensorListener::EXPOSURE_START: { 1811 ALOGVV("%s: Frame %d: Sensor started exposure at %lld", 1812 __FUNCTION__, frameNumber, timestamp); 1813 // Trigger shutter notify to framework 1814 camera3_notify_msg_t msg; 1815 msg.type = CAMERA3_MSG_SHUTTER; 1816 msg.message.shutter.frame_number = frameNumber; 1817 msg.message.shutter.timestamp = timestamp; 1818 sendNotify(&msg); 1819 break; 1820 } 1821 default: 1822 ALOGW("%s: Unexpected sensor event %d at %" PRId64, __FUNCTION__, 1823 e, timestamp); 1824 break; 1825 } 1826 } 1827 1828 EmulatedFakeCamera3::ReadoutThread::ReadoutThread(EmulatedFakeCamera3 *parent) : 1829 mParent(parent), mJpegWaiting(false) { 1830 } 1831 1832 EmulatedFakeCamera3::ReadoutThread::~ReadoutThread() { 1833 for (List<Request>::iterator i = mInFlightQueue.begin(); 1834 i != mInFlightQueue.end(); i++) { 1835 delete i->buffers; 1836 delete i->sensorBuffers; 1837 } 1838 } 1839 1840 void EmulatedFakeCamera3::ReadoutThread::queueCaptureRequest(const Request &r) { 1841 Mutex::Autolock l(mLock); 1842 1843 mInFlightQueue.push_back(r); 1844 mInFlightSignal.signal(); 1845 } 1846 1847 bool EmulatedFakeCamera3::ReadoutThread::isIdle() { 1848 Mutex::Autolock l(mLock); 1849 return mInFlightQueue.empty() && !mThreadActive; 1850 } 1851 1852 status_t EmulatedFakeCamera3::ReadoutThread::waitForReadout() { 1853 status_t res; 1854 Mutex::Autolock l(mLock); 1855 int loopCount = 0; 1856 while (mInFlightQueue.size() >= kMaxQueueSize) { 1857 res = mInFlightSignal.waitRelative(mLock, kWaitPerLoop); 1858 if (res != OK && res != TIMED_OUT) { 1859 ALOGE("%s: Error waiting for in-flight queue to shrink", 1860 __FUNCTION__); 1861 return INVALID_OPERATION; 1862 } 1863 if (loopCount == kMaxWaitLoops) { 1864 ALOGE("%s: Timed out waiting for in-flight queue to shrink", 1865 __FUNCTION__); 1866 return TIMED_OUT; 1867 } 1868 loopCount++; 1869 } 1870 return OK; 1871 } 1872 1873 bool EmulatedFakeCamera3::ReadoutThread::threadLoop() { 1874 status_t res; 1875 1876 ALOGVV("%s: ReadoutThread waiting for request", __FUNCTION__); 1877 1878 // First wait for a request from the in-flight queue 1879 1880 if (mCurrentRequest.settings.isEmpty()) { 1881 Mutex::Autolock l(mLock); 1882 if (mInFlightQueue.empty()) { 1883 res = mInFlightSignal.waitRelative(mLock, kWaitPerLoop); 1884 if (res == TIMED_OUT) { 1885 ALOGVV("%s: ReadoutThread: Timed out waiting for request", 1886 __FUNCTION__); 1887 return true; 1888 } else if (res != NO_ERROR) { 1889 ALOGE("%s: Error waiting for capture requests: %d", 1890 __FUNCTION__, res); 1891 return false; 1892 } 1893 } 1894 mCurrentRequest.frameNumber = mInFlightQueue.begin()->frameNumber; 1895 mCurrentRequest.settings.acquire(mInFlightQueue.begin()->settings); 1896 mCurrentRequest.buffers = mInFlightQueue.begin()->buffers; 1897 mCurrentRequest.sensorBuffers = mInFlightQueue.begin()->sensorBuffers; 1898 mInFlightQueue.erase(mInFlightQueue.begin()); 1899 mInFlightSignal.signal(); 1900 mThreadActive = true; 1901 ALOGVV("%s: Beginning readout of frame %d", __FUNCTION__, 1902 mCurrentRequest.frameNumber); 1903 } 1904 1905 // Then wait for it to be delivered from the sensor 1906 ALOGVV("%s: ReadoutThread: Wait for frame to be delivered from sensor", 1907 __FUNCTION__); 1908 1909 nsecs_t captureTime; 1910 bool gotFrame = 1911 mParent->mSensor->waitForNewFrame(kWaitPerLoop, &captureTime); 1912 if (!gotFrame) { 1913 ALOGVV("%s: ReadoutThread: Timed out waiting for sensor frame", 1914 __FUNCTION__); 1915 return true; 1916 } 1917 1918 ALOGVV("Sensor done with readout for frame %d, captured at %lld ", 1919 mCurrentRequest.frameNumber, captureTime); 1920 1921 // Check if we need to JPEG encode a buffer, and send it for async 1922 // compression if so. Otherwise prepare the buffer for return. 1923 bool needJpeg = false; 1924 HalBufferVector::iterator buf = mCurrentRequest.buffers->begin(); 1925 while(buf != mCurrentRequest.buffers->end()) { 1926 bool goodBuffer = true; 1927 if ( buf->stream->format == 1928 HAL_PIXEL_FORMAT_BLOB) { 1929 Mutex::Autolock jl(mJpegLock); 1930 if (mJpegWaiting) { 1931 // This shouldn't happen, because processCaptureRequest should 1932 // be stalling until JPEG compressor is free. 1933 ALOGE("%s: Already processing a JPEG!", __FUNCTION__); 1934 goodBuffer = false; 1935 } 1936 if (goodBuffer) { 1937 // Compressor takes ownership of sensorBuffers here 1938 res = mParent->mJpegCompressor->start(mCurrentRequest.sensorBuffers, 1939 this); 1940 goodBuffer = (res == OK); 1941 } 1942 if (goodBuffer) { 1943 needJpeg = true; 1944 1945 mJpegHalBuffer = *buf; 1946 mJpegFrameNumber = mCurrentRequest.frameNumber; 1947 mJpegWaiting = true; 1948 1949 mCurrentRequest.sensorBuffers = NULL; 1950 buf = mCurrentRequest.buffers->erase(buf); 1951 1952 continue; 1953 } 1954 ALOGE("%s: Error compressing output buffer: %s (%d)", 1955 __FUNCTION__, strerror(-res), res); 1956 // fallthrough for cleanup 1957 } 1958 GraphicBufferMapper::get().unlock(*(buf->buffer)); 1959 1960 buf->status = goodBuffer ? CAMERA3_BUFFER_STATUS_OK : 1961 CAMERA3_BUFFER_STATUS_ERROR; 1962 buf->acquire_fence = -1; 1963 buf->release_fence = -1; 1964 1965 ++buf; 1966 } // end while 1967 1968 // Construct result for all completed buffers and results 1969 1970 camera3_capture_result result; 1971 1972 mCurrentRequest.settings.update(ANDROID_SENSOR_TIMESTAMP, 1973 &captureTime, 1); 1974 1975 result.frame_number = mCurrentRequest.frameNumber; 1976 result.result = mCurrentRequest.settings.getAndLock(); 1977 result.num_output_buffers = mCurrentRequest.buffers->size(); 1978 result.output_buffers = mCurrentRequest.buffers->array(); 1979 1980 // Go idle if queue is empty, before sending result 1981 bool signalIdle = false; 1982 { 1983 Mutex::Autolock l(mLock); 1984 if (mInFlightQueue.empty()) { 1985 mThreadActive = false; 1986 signalIdle = true; 1987 } 1988 } 1989 if (signalIdle) mParent->signalReadoutIdle(); 1990 1991 // Send it off to the framework 1992 ALOGVV("%s: ReadoutThread: Send result to framework", 1993 __FUNCTION__); 1994 mParent->sendCaptureResult(&result); 1995 1996 // Clean up 1997 mCurrentRequest.settings.unlock(result.result); 1998 1999 delete mCurrentRequest.buffers; 2000 mCurrentRequest.buffers = NULL; 2001 if (!needJpeg) { 2002 delete mCurrentRequest.sensorBuffers; 2003 mCurrentRequest.sensorBuffers = NULL; 2004 } 2005 mCurrentRequest.settings.clear(); 2006 2007 return true; 2008 } 2009 2010 void EmulatedFakeCamera3::ReadoutThread::onJpegDone( 2011 const StreamBuffer &jpegBuffer, bool success) { 2012 Mutex::Autolock jl(mJpegLock); 2013 2014 GraphicBufferMapper::get().unlock(*(jpegBuffer.buffer)); 2015 2016 mJpegHalBuffer.status = success ? 2017 CAMERA3_BUFFER_STATUS_OK : CAMERA3_BUFFER_STATUS_ERROR; 2018 mJpegHalBuffer.acquire_fence = -1; 2019 mJpegHalBuffer.release_fence = -1; 2020 mJpegWaiting = false; 2021 2022 camera3_capture_result result; 2023 result.frame_number = mJpegFrameNumber; 2024 result.result = NULL; 2025 result.num_output_buffers = 1; 2026 result.output_buffers = &mJpegHalBuffer; 2027 2028 if (!success) { 2029 ALOGE("%s: Compression failure, returning error state buffer to" 2030 " framework", __FUNCTION__); 2031 } else { 2032 ALOGV("%s: Compression complete, returning buffer to framework", 2033 __FUNCTION__); 2034 } 2035 2036 mParent->sendCaptureResult(&result); 2037 } 2038 2039 void EmulatedFakeCamera3::ReadoutThread::onJpegInputDone( 2040 const StreamBuffer &inputBuffer) { 2041 // Should never get here, since the input buffer has to be returned 2042 // by end of processCaptureRequest 2043 ALOGE("%s: Unexpected input buffer from JPEG compressor!", __FUNCTION__); 2044 } 2045 2046 2047 }; // namespace android 2048
