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