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