1 /* 2 * Copyright (C) 2012 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 EmulatedFakeCamera2 that encapsulates 19 * functionality of an advanced fake camera. 20 */ 21 22 //#define LOG_NDEBUG 0 23 #define LOG_TAG "EmulatedCamera_FakeCamera2" 24 #include <utils/Log.h> 25 26 #include "EmulatedFakeCamera2.h" 27 #include "EmulatedCameraFactory.h" 28 #include <ui/Rect.h> 29 #include <ui/GraphicBufferMapper.h> 30 #include "gralloc_cb.h" 31 32 #define ERROR_CAMERA_NOT_PRESENT -EPIPE 33 34 #define CAMERA2_EXT_TRIGGER_TESTING_DISCONNECT 0xFFFFFFFF 35 36 namespace android { 37 38 const int64_t USEC = 1000LL; 39 const int64_t MSEC = USEC * 1000LL; 40 const int64_t SEC = MSEC * 1000LL; 41 42 const uint32_t EmulatedFakeCamera2::kAvailableFormats[4] = { 43 HAL_PIXEL_FORMAT_RAW_SENSOR, 44 HAL_PIXEL_FORMAT_BLOB, 45 HAL_PIXEL_FORMAT_RGBA_8888, 46 // HAL_PIXEL_FORMAT_YV12, 47 HAL_PIXEL_FORMAT_YCrCb_420_SP 48 }; 49 50 const uint32_t EmulatedFakeCamera2::kAvailableRawSizes[2] = { 51 640, 480 52 // Sensor::kResolution[0], Sensor::kResolution[1] 53 }; 54 55 const uint64_t EmulatedFakeCamera2::kAvailableRawMinDurations[1] = { 56 Sensor::kFrameDurationRange[0] 57 }; 58 59 const uint32_t EmulatedFakeCamera2::kAvailableProcessedSizesBack[4] = { 60 640, 480, 320, 240 61 // Sensor::kResolution[0], Sensor::kResolution[1] 62 }; 63 64 const uint32_t EmulatedFakeCamera2::kAvailableProcessedSizesFront[4] = { 65 320, 240, 160, 120 66 // Sensor::kResolution[0], Sensor::kResolution[1] 67 }; 68 69 const uint64_t EmulatedFakeCamera2::kAvailableProcessedMinDurations[1] = { 70 Sensor::kFrameDurationRange[0] 71 }; 72 73 const uint32_t EmulatedFakeCamera2::kAvailableJpegSizesBack[2] = { 74 640, 480 75 // Sensor::kResolution[0], Sensor::kResolution[1] 76 }; 77 78 const uint32_t EmulatedFakeCamera2::kAvailableJpegSizesFront[2] = { 79 320, 240 80 // Sensor::kResolution[0], Sensor::kResolution[1] 81 }; 82 83 84 const uint64_t EmulatedFakeCamera2::kAvailableJpegMinDurations[1] = { 85 Sensor::kFrameDurationRange[0] 86 }; 87 88 89 EmulatedFakeCamera2::EmulatedFakeCamera2(int cameraId, 90 bool facingBack, 91 struct hw_module_t* module) 92 : EmulatedCamera2(cameraId,module), 93 mFacingBack(facingBack), 94 mIsConnected(false) 95 { 96 ALOGD("Constructing emulated fake camera 2 facing %s", 97 facingBack ? "back" : "front"); 98 } 99 100 EmulatedFakeCamera2::~EmulatedFakeCamera2() { 101 if (mCameraInfo != NULL) { 102 free_camera_metadata(mCameraInfo); 103 } 104 } 105 106 /**************************************************************************** 107 * Public API overrides 108 ***************************************************************************/ 109 110 status_t EmulatedFakeCamera2::Initialize() { 111 status_t res; 112 113 set_camera_metadata_vendor_tag_ops( 114 static_cast<vendor_tag_query_ops_t*>(&mVendorTagOps)); 115 116 res = constructStaticInfo(&mCameraInfo, true); 117 if (res != OK) { 118 ALOGE("%s: Unable to allocate static info: %s (%d)", 119 __FUNCTION__, strerror(-res), res); 120 return res; 121 } 122 res = constructStaticInfo(&mCameraInfo, false); 123 if (res != OK) { 124 ALOGE("%s: Unable to fill in static info: %s (%d)", 125 __FUNCTION__, strerror(-res), res); 126 return res; 127 } 128 if (res != OK) return res; 129 130 mNextStreamId = 1; 131 mNextReprocessStreamId = 1; 132 mRawStreamCount = 0; 133 mProcessedStreamCount = 0; 134 mJpegStreamCount = 0; 135 mReprocessStreamCount = 0; 136 137 return NO_ERROR; 138 } 139 140 /**************************************************************************** 141 * Camera module API overrides 142 ***************************************************************************/ 143 144 status_t EmulatedFakeCamera2::connectCamera(hw_device_t** device) { 145 status_t res; 146 ALOGV("%s", __FUNCTION__); 147 148 { 149 Mutex::Autolock l(mMutex); 150 if (!mStatusPresent) { 151 ALOGE("%s: Camera ID %d is unplugged", __FUNCTION__, 152 mCameraID); 153 return -ENODEV; 154 } 155 } 156 157 mConfigureThread = new ConfigureThread(this); 158 mReadoutThread = new ReadoutThread(this); 159 mControlThread = new ControlThread(this); 160 mSensor = new Sensor(); 161 mJpegCompressor = new JpegCompressor(); 162 163 mNextStreamId = 1; 164 mNextReprocessStreamId = 1; 165 166 res = mSensor->startUp(); 167 if (res != NO_ERROR) return res; 168 169 res = mConfigureThread->run("EmulatedFakeCamera2::configureThread"); 170 if (res != NO_ERROR) return res; 171 172 res = mReadoutThread->run("EmulatedFakeCamera2::readoutThread"); 173 if (res != NO_ERROR) return res; 174 175 res = mControlThread->run("EmulatedFakeCamera2::controlThread"); 176 if (res != NO_ERROR) return res; 177 178 status_t ret = EmulatedCamera2::connectCamera(device); 179 180 if (ret >= 0) { 181 mIsConnected = true; 182 } 183 184 return ret; 185 } 186 187 status_t EmulatedFakeCamera2::plugCamera() { 188 { 189 Mutex::Autolock l(mMutex); 190 191 if (!mStatusPresent) { 192 ALOGI("%s: Plugged back in", __FUNCTION__); 193 mStatusPresent = true; 194 } 195 } 196 197 return NO_ERROR; 198 } 199 200 status_t EmulatedFakeCamera2::unplugCamera() { 201 { 202 Mutex::Autolock l(mMutex); 203 204 if (mStatusPresent) { 205 ALOGI("%s: Unplugged camera", __FUNCTION__); 206 mStatusPresent = false; 207 } 208 } 209 210 return closeCamera(); 211 } 212 213 camera_device_status_t EmulatedFakeCamera2::getHotplugStatus() { 214 Mutex::Autolock l(mMutex); 215 return mStatusPresent ? 216 CAMERA_DEVICE_STATUS_PRESENT : 217 CAMERA_DEVICE_STATUS_NOT_PRESENT; 218 } 219 220 221 222 status_t EmulatedFakeCamera2::closeCamera() { 223 { 224 Mutex::Autolock l(mMutex); 225 226 status_t res; 227 ALOGV("%s", __FUNCTION__); 228 229 if (!mIsConnected) { 230 return NO_ERROR; 231 } 232 233 res = mSensor->shutDown(); 234 if (res != NO_ERROR) { 235 ALOGE("%s: Unable to shut down sensor: %d", __FUNCTION__, res); 236 return res; 237 } 238 239 mConfigureThread->requestExit(); 240 mReadoutThread->requestExit(); 241 mControlThread->requestExit(); 242 mJpegCompressor->cancel(); 243 } 244 245 // give up the lock since we will now block and the threads 246 // can call back into this object 247 mConfigureThread->join(); 248 mReadoutThread->join(); 249 mControlThread->join(); 250 251 ALOGV("%s exit", __FUNCTION__); 252 253 { 254 Mutex::Autolock l(mMutex); 255 mIsConnected = false; 256 } 257 258 return NO_ERROR; 259 } 260 261 status_t EmulatedFakeCamera2::getCameraInfo(struct camera_info *info) { 262 info->facing = mFacingBack ? CAMERA_FACING_BACK : CAMERA_FACING_FRONT; 263 info->orientation = gEmulatedCameraFactory.getFakeCameraOrientation(); 264 return EmulatedCamera2::getCameraInfo(info); 265 } 266 267 /**************************************************************************** 268 * Camera device API overrides 269 ***************************************************************************/ 270 271 /** Request input queue */ 272 273 int EmulatedFakeCamera2::requestQueueNotify() { 274 ALOGV("Request queue notification received"); 275 276 ALOG_ASSERT(mRequestQueueSrc != NULL, 277 "%s: Request queue src not set, but received queue notification!", 278 __FUNCTION__); 279 ALOG_ASSERT(mFrameQueueDst != NULL, 280 "%s: Request queue src not set, but received queue notification!", 281 __FUNCTION__); 282 ALOG_ASSERT(mStreams.size() != 0, 283 "%s: No streams allocated, but received queue notification!", 284 __FUNCTION__); 285 return mConfigureThread->newRequestAvailable(); 286 } 287 288 int EmulatedFakeCamera2::getInProgressCount() { 289 Mutex::Autolock l(mMutex); 290 291 if (!mStatusPresent) { 292 ALOGW("%s: Camera was physically disconnected", __FUNCTION__); 293 return ERROR_CAMERA_NOT_PRESENT; 294 } 295 296 int requestCount = 0; 297 requestCount += mConfigureThread->getInProgressCount(); 298 requestCount += mReadoutThread->getInProgressCount(); 299 requestCount += mJpegCompressor->isBusy() ? 1 : 0; 300 301 return requestCount; 302 } 303 304 int EmulatedFakeCamera2::constructDefaultRequest( 305 int request_template, 306 camera_metadata_t **request) { 307 308 if (request == NULL) return BAD_VALUE; 309 if (request_template < 0 || request_template >= CAMERA2_TEMPLATE_COUNT) { 310 return BAD_VALUE; 311 } 312 313 { 314 Mutex::Autolock l(mMutex); 315 if (!mStatusPresent) { 316 ALOGW("%s: Camera was physically disconnected", __FUNCTION__); 317 return ERROR_CAMERA_NOT_PRESENT; 318 } 319 } 320 321 status_t res; 322 // Pass 1, calculate size and allocate 323 res = constructDefaultRequest(request_template, 324 request, 325 true); 326 if (res != OK) { 327 return res; 328 } 329 // Pass 2, build request 330 res = constructDefaultRequest(request_template, 331 request, 332 false); 333 if (res != OK) { 334 ALOGE("Unable to populate new request for template %d", 335 request_template); 336 } 337 338 return res; 339 } 340 341 int EmulatedFakeCamera2::allocateStream( 342 uint32_t width, 343 uint32_t height, 344 int format, 345 const camera2_stream_ops_t *stream_ops, 346 uint32_t *stream_id, 347 uint32_t *format_actual, 348 uint32_t *usage, 349 uint32_t *max_buffers) { 350 Mutex::Autolock l(mMutex); 351 352 if (!mStatusPresent) { 353 ALOGW("%s: Camera was physically disconnected", __FUNCTION__); 354 return ERROR_CAMERA_NOT_PRESENT; 355 } 356 357 // Temporary shim until FORMAT_ZSL is removed 358 if (format == CAMERA2_HAL_PIXEL_FORMAT_ZSL) { 359 format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; 360 } 361 362 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { 363 unsigned int numFormats = sizeof(kAvailableFormats) / sizeof(uint32_t); 364 unsigned int formatIdx = 0; 365 unsigned int sizeOffsetIdx = 0; 366 for (; formatIdx < numFormats; formatIdx++) { 367 if (format == (int)kAvailableFormats[formatIdx]) break; 368 } 369 if (formatIdx == numFormats) { 370 ALOGE("%s: Format 0x%x is not supported", __FUNCTION__, format); 371 return BAD_VALUE; 372 } 373 } 374 375 const uint32_t *availableSizes; 376 size_t availableSizeCount; 377 switch (format) { 378 case HAL_PIXEL_FORMAT_RAW_SENSOR: 379 availableSizes = kAvailableRawSizes; 380 availableSizeCount = sizeof(kAvailableRawSizes)/sizeof(uint32_t); 381 break; 382 case HAL_PIXEL_FORMAT_BLOB: 383 availableSizes = mFacingBack ? 384 kAvailableJpegSizesBack : kAvailableJpegSizesFront; 385 availableSizeCount = mFacingBack ? 386 sizeof(kAvailableJpegSizesBack)/sizeof(uint32_t) : 387 sizeof(kAvailableJpegSizesFront)/sizeof(uint32_t); 388 break; 389 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 390 case HAL_PIXEL_FORMAT_RGBA_8888: 391 case HAL_PIXEL_FORMAT_YV12: 392 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 393 availableSizes = mFacingBack ? 394 kAvailableProcessedSizesBack : kAvailableProcessedSizesFront; 395 availableSizeCount = mFacingBack ? 396 sizeof(kAvailableProcessedSizesBack)/sizeof(uint32_t) : 397 sizeof(kAvailableProcessedSizesFront)/sizeof(uint32_t); 398 break; 399 default: 400 ALOGE("%s: Unknown format 0x%x", __FUNCTION__, format); 401 return BAD_VALUE; 402 } 403 404 unsigned int resIdx = 0; 405 for (; resIdx < availableSizeCount; resIdx++) { 406 if (availableSizes[resIdx * 2] == width && 407 availableSizes[resIdx * 2 + 1] == height) break; 408 } 409 if (resIdx == availableSizeCount) { 410 ALOGE("%s: Format 0x%x does not support resolution %d, %d", __FUNCTION__, 411 format, width, height); 412 return BAD_VALUE; 413 } 414 415 switch (format) { 416 case HAL_PIXEL_FORMAT_RAW_SENSOR: 417 if (mRawStreamCount >= kMaxRawStreamCount) { 418 ALOGE("%s: Cannot allocate another raw stream (%d already allocated)", 419 __FUNCTION__, mRawStreamCount); 420 return INVALID_OPERATION; 421 } 422 mRawStreamCount++; 423 break; 424 case HAL_PIXEL_FORMAT_BLOB: 425 if (mJpegStreamCount >= kMaxJpegStreamCount) { 426 ALOGE("%s: Cannot allocate another JPEG stream (%d already allocated)", 427 __FUNCTION__, mJpegStreamCount); 428 return INVALID_OPERATION; 429 } 430 mJpegStreamCount++; 431 break; 432 default: 433 if (mProcessedStreamCount >= kMaxProcessedStreamCount) { 434 ALOGE("%s: Cannot allocate another processed stream (%d already allocated)", 435 __FUNCTION__, mProcessedStreamCount); 436 return INVALID_OPERATION; 437 } 438 mProcessedStreamCount++; 439 } 440 441 Stream newStream; 442 newStream.ops = stream_ops; 443 newStream.width = width; 444 newStream.height = height; 445 newStream.format = format; 446 // TODO: Query stride from gralloc 447 newStream.stride = width; 448 449 mStreams.add(mNextStreamId, newStream); 450 451 *stream_id = mNextStreamId; 452 if (format_actual) *format_actual = format; 453 *usage = GRALLOC_USAGE_HW_CAMERA_WRITE; 454 *max_buffers = kMaxBufferCount; 455 456 ALOGV("Stream allocated: %d, %d x %d, 0x%x. U: %x, B: %d", 457 *stream_id, width, height, format, *usage, *max_buffers); 458 459 mNextStreamId++; 460 return NO_ERROR; 461 } 462 463 int EmulatedFakeCamera2::registerStreamBuffers( 464 uint32_t stream_id, 465 int num_buffers, 466 buffer_handle_t *buffers) { 467 Mutex::Autolock l(mMutex); 468 469 if (!mStatusPresent) { 470 ALOGW("%s: Camera was physically disconnected", __FUNCTION__); 471 return ERROR_CAMERA_NOT_PRESENT; 472 } 473 474 ALOGV("%s: Stream %d registering %d buffers", __FUNCTION__, 475 stream_id, num_buffers); 476 // Need to find out what the final concrete pixel format for our stream is 477 // Assumes that all buffers have the same format. 478 if (num_buffers < 1) { 479 ALOGE("%s: Stream %d only has %d buffers!", 480 __FUNCTION__, stream_id, num_buffers); 481 return BAD_VALUE; 482 } 483 const cb_handle_t *streamBuffer = 484 reinterpret_cast<const cb_handle_t*>(buffers[0]); 485 486 int finalFormat = streamBuffer->format; 487 488 if (finalFormat == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { 489 ALOGE("%s: Stream %d: Bad final pixel format " 490 "HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; " 491 "concrete pixel format required!", __FUNCTION__, stream_id); 492 return BAD_VALUE; 493 } 494 495 ssize_t streamIndex = mStreams.indexOfKey(stream_id); 496 if (streamIndex < 0) { 497 ALOGE("%s: Unknown stream id %d!", __FUNCTION__, stream_id); 498 return BAD_VALUE; 499 } 500 501 Stream &stream = mStreams.editValueAt(streamIndex); 502 503 ALOGV("%s: Stream %d format set to %x, previously %x", 504 __FUNCTION__, stream_id, finalFormat, stream.format); 505 506 stream.format = finalFormat; 507 508 return NO_ERROR; 509 } 510 511 int EmulatedFakeCamera2::releaseStream(uint32_t stream_id) { 512 Mutex::Autolock l(mMutex); 513 514 ssize_t streamIndex = mStreams.indexOfKey(stream_id); 515 if (streamIndex < 0) { 516 ALOGE("%s: Unknown stream id %d!", __FUNCTION__, stream_id); 517 return BAD_VALUE; 518 } 519 520 if (isStreamInUse(stream_id)) { 521 ALOGE("%s: Cannot release stream %d; in use!", __FUNCTION__, 522 stream_id); 523 return BAD_VALUE; 524 } 525 526 switch(mStreams.valueAt(streamIndex).format) { 527 case HAL_PIXEL_FORMAT_RAW_SENSOR: 528 mRawStreamCount--; 529 break; 530 case HAL_PIXEL_FORMAT_BLOB: 531 mJpegStreamCount--; 532 break; 533 default: 534 mProcessedStreamCount--; 535 break; 536 } 537 538 mStreams.removeItemsAt(streamIndex); 539 540 return NO_ERROR; 541 } 542 543 int EmulatedFakeCamera2::allocateReprocessStreamFromStream( 544 uint32_t output_stream_id, 545 const camera2_stream_in_ops_t *stream_ops, 546 uint32_t *stream_id) { 547 Mutex::Autolock l(mMutex); 548 549 if (!mStatusPresent) { 550 ALOGW("%s: Camera was physically disconnected", __FUNCTION__); 551 return ERROR_CAMERA_NOT_PRESENT; 552 } 553 554 ssize_t baseStreamIndex = mStreams.indexOfKey(output_stream_id); 555 if (baseStreamIndex < 0) { 556 ALOGE("%s: Unknown output stream id %d!", __FUNCTION__, output_stream_id); 557 return BAD_VALUE; 558 } 559 560 const Stream &baseStream = mStreams[baseStreamIndex]; 561 562 // We'll reprocess anything we produced 563 564 if (mReprocessStreamCount >= kMaxReprocessStreamCount) { 565 ALOGE("%s: Cannot allocate another reprocess stream (%d already allocated)", 566 __FUNCTION__, mReprocessStreamCount); 567 return INVALID_OPERATION; 568 } 569 mReprocessStreamCount++; 570 571 ReprocessStream newStream; 572 newStream.ops = stream_ops; 573 newStream.width = baseStream.width; 574 newStream.height = baseStream.height; 575 newStream.format = baseStream.format; 576 newStream.stride = baseStream.stride; 577 newStream.sourceStreamId = output_stream_id; 578 579 *stream_id = mNextReprocessStreamId; 580 mReprocessStreams.add(mNextReprocessStreamId, newStream); 581 582 ALOGV("Reprocess stream allocated: %d: %d, %d, 0x%x. Parent stream: %d", 583 *stream_id, newStream.width, newStream.height, newStream.format, 584 output_stream_id); 585 586 mNextReprocessStreamId++; 587 return NO_ERROR; 588 } 589 590 int EmulatedFakeCamera2::releaseReprocessStream(uint32_t stream_id) { 591 Mutex::Autolock l(mMutex); 592 593 ssize_t streamIndex = mReprocessStreams.indexOfKey(stream_id); 594 if (streamIndex < 0) { 595 ALOGE("%s: Unknown reprocess stream id %d!", __FUNCTION__, stream_id); 596 return BAD_VALUE; 597 } 598 599 if (isReprocessStreamInUse(stream_id)) { 600 ALOGE("%s: Cannot release reprocessing stream %d; in use!", __FUNCTION__, 601 stream_id); 602 return BAD_VALUE; 603 } 604 605 mReprocessStreamCount--; 606 mReprocessStreams.removeItemsAt(streamIndex); 607 608 return NO_ERROR; 609 } 610 611 int EmulatedFakeCamera2::triggerAction(uint32_t trigger_id, 612 int32_t ext1, 613 int32_t ext2) { 614 Mutex::Autolock l(mMutex); 615 616 if (trigger_id == CAMERA2_EXT_TRIGGER_TESTING_DISCONNECT) { 617 ALOGI("%s: Disconnect trigger - camera must be closed", __FUNCTION__); 618 mStatusPresent = false; 619 620 gEmulatedCameraFactory.onStatusChanged( 621 mCameraID, 622 CAMERA_DEVICE_STATUS_NOT_PRESENT); 623 } 624 625 if (!mStatusPresent) { 626 ALOGW("%s: Camera was physically disconnected", __FUNCTION__); 627 return ERROR_CAMERA_NOT_PRESENT; 628 } 629 630 return mControlThread->triggerAction(trigger_id, 631 ext1, ext2); 632 } 633 634 /** Custom tag definitions */ 635 636 // Emulator camera metadata sections 637 enum { 638 EMULATOR_SCENE = VENDOR_SECTION, 639 END_EMULATOR_SECTIONS 640 }; 641 642 enum { 643 EMULATOR_SCENE_START = EMULATOR_SCENE << 16, 644 }; 645 646 // Emulator camera metadata tags 647 enum { 648 // Hour of day to use for lighting calculations (0-23). Default: 12 649 EMULATOR_SCENE_HOUROFDAY = EMULATOR_SCENE_START, 650 EMULATOR_SCENE_END 651 }; 652 653 unsigned int emulator_metadata_section_bounds[END_EMULATOR_SECTIONS - 654 VENDOR_SECTION][2] = { 655 { EMULATOR_SCENE_START, EMULATOR_SCENE_END } 656 }; 657 658 const char *emulator_metadata_section_names[END_EMULATOR_SECTIONS - 659 VENDOR_SECTION] = { 660 "com.android.emulator.scene" 661 }; 662 663 typedef struct emulator_tag_info { 664 const char *tag_name; 665 uint8_t tag_type; 666 } emulator_tag_info_t; 667 668 emulator_tag_info_t emulator_scene[EMULATOR_SCENE_END - EMULATOR_SCENE_START] = { 669 { "hourOfDay", TYPE_INT32 } 670 }; 671 672 emulator_tag_info_t *tag_info[END_EMULATOR_SECTIONS - 673 VENDOR_SECTION] = { 674 emulator_scene 675 }; 676 677 const char* EmulatedFakeCamera2::getVendorSectionName(uint32_t tag) { 678 ALOGV("%s", __FUNCTION__); 679 uint32_t section = tag >> 16; 680 if (section < VENDOR_SECTION || section > END_EMULATOR_SECTIONS) return NULL; 681 return emulator_metadata_section_names[section - VENDOR_SECTION]; 682 } 683 684 const char* EmulatedFakeCamera2::getVendorTagName(uint32_t tag) { 685 ALOGV("%s", __FUNCTION__); 686 uint32_t section = tag >> 16; 687 if (section < VENDOR_SECTION || section > END_EMULATOR_SECTIONS) return NULL; 688 uint32_t section_index = section - VENDOR_SECTION; 689 if (tag >= emulator_metadata_section_bounds[section_index][1]) { 690 return NULL; 691 } 692 uint32_t tag_index = tag & 0xFFFF; 693 return tag_info[section_index][tag_index].tag_name; 694 } 695 696 int EmulatedFakeCamera2::getVendorTagType(uint32_t tag) { 697 ALOGV("%s", __FUNCTION__); 698 uint32_t section = tag >> 16; 699 if (section < VENDOR_SECTION || section > END_EMULATOR_SECTIONS) return -1; 700 uint32_t section_index = section - VENDOR_SECTION; 701 if (tag >= emulator_metadata_section_bounds[section_index][1]) { 702 return -1; 703 } 704 uint32_t tag_index = tag & 0xFFFF; 705 return tag_info[section_index][tag_index].tag_type; 706 } 707 708 /** Shutdown and debug methods */ 709 710 int EmulatedFakeCamera2::dump(int fd) { 711 String8 result; 712 713 result.appendFormat(" Camera HAL device: EmulatedFakeCamera2\n"); 714 result.appendFormat(" Streams:\n"); 715 for (size_t i = 0; i < mStreams.size(); i++) { 716 int id = mStreams.keyAt(i); 717 const Stream& s = mStreams.valueAt(i); 718 result.appendFormat( 719 " Stream %d: %d x %d, format 0x%x, stride %d\n", 720 id, s.width, s.height, s.format, s.stride); 721 } 722 723 write(fd, result.string(), result.size()); 724 725 return NO_ERROR; 726 } 727 728 void EmulatedFakeCamera2::signalError() { 729 // TODO: Let parent know so we can shut down cleanly 730 ALOGE("Worker thread is signaling a serious error"); 731 } 732 733 /** Pipeline control worker thread methods */ 734 735 EmulatedFakeCamera2::ConfigureThread::ConfigureThread(EmulatedFakeCamera2 *parent): 736 Thread(false), 737 mParent(parent), 738 mRequestCount(0), 739 mNextBuffers(NULL) { 740 mRunning = false; 741 } 742 743 EmulatedFakeCamera2::ConfigureThread::~ConfigureThread() { 744 } 745 746 status_t EmulatedFakeCamera2::ConfigureThread::readyToRun() { 747 Mutex::Autolock lock(mInputMutex); 748 749 ALOGV("Starting up ConfigureThread"); 750 mRequest = NULL; 751 mActive = false; 752 mRunning = true; 753 754 mInputSignal.signal(); 755 return NO_ERROR; 756 } 757 758 status_t EmulatedFakeCamera2::ConfigureThread::waitUntilRunning() { 759 Mutex::Autolock lock(mInputMutex); 760 if (!mRunning) { 761 ALOGV("Waiting for configure thread to start"); 762 mInputSignal.wait(mInputMutex); 763 } 764 return OK; 765 } 766 767 status_t EmulatedFakeCamera2::ConfigureThread::newRequestAvailable() { 768 waitUntilRunning(); 769 770 Mutex::Autolock lock(mInputMutex); 771 772 mActive = true; 773 mInputSignal.signal(); 774 775 return OK; 776 } 777 778 bool EmulatedFakeCamera2::ConfigureThread::isStreamInUse(uint32_t id) { 779 Mutex::Autolock lock(mInternalsMutex); 780 781 if (mNextBuffers == NULL) return false; 782 for (size_t i=0; i < mNextBuffers->size(); i++) { 783 if ((*mNextBuffers)[i].streamId == (int)id) return true; 784 } 785 return false; 786 } 787 788 int EmulatedFakeCamera2::ConfigureThread::getInProgressCount() { 789 Mutex::Autolock lock(mInputMutex); 790 return mRequestCount; 791 } 792 793 bool EmulatedFakeCamera2::ConfigureThread::threadLoop() { 794 status_t res; 795 796 // Check if we're currently processing or just waiting 797 { 798 Mutex::Autolock lock(mInputMutex); 799 if (!mActive) { 800 // Inactive, keep waiting until we've been signaled 801 status_t res; 802 res = mInputSignal.waitRelative(mInputMutex, kWaitPerLoop); 803 if (res != NO_ERROR && res != TIMED_OUT) { 804 ALOGE("%s: Error waiting for input requests: %d", 805 __FUNCTION__, res); 806 return false; 807 } 808 if (!mActive) return true; 809 ALOGV("New request available"); 810 } 811 // Active 812 } 813 814 if (mRequest == NULL) { 815 Mutex::Autolock il(mInternalsMutex); 816 817 ALOGV("Configure: Getting next request"); 818 res = mParent->mRequestQueueSrc->dequeue_request( 819 mParent->mRequestQueueSrc, 820 &mRequest); 821 if (res != NO_ERROR) { 822 ALOGE("%s: Error dequeuing next request: %d", __FUNCTION__, res); 823 mParent->signalError(); 824 return false; 825 } 826 if (mRequest == NULL) { 827 ALOGV("Configure: Request queue empty, going inactive"); 828 // No requests available, go into inactive mode 829 Mutex::Autolock lock(mInputMutex); 830 mActive = false; 831 return true; 832 } else { 833 Mutex::Autolock lock(mInputMutex); 834 mRequestCount++; 835 } 836 837 camera_metadata_entry_t type; 838 res = find_camera_metadata_entry(mRequest, 839 ANDROID_REQUEST_TYPE, 840 &type); 841 if (res != NO_ERROR) { 842 ALOGE("%s: error reading request type", __FUNCTION__); 843 mParent->signalError(); 844 return false; 845 } 846 bool success = false;; 847 switch (type.data.u8[0]) { 848 case ANDROID_REQUEST_TYPE_CAPTURE: 849 success = setupCapture(); 850 break; 851 case ANDROID_REQUEST_TYPE_REPROCESS: 852 success = setupReprocess(); 853 break; 854 default: 855 ALOGE("%s: Unexpected request type %d", 856 __FUNCTION__, type.data.u8[0]); 857 mParent->signalError(); 858 break; 859 } 860 if (!success) return false; 861 862 } 863 864 if (mWaitingForReadout) { 865 bool readoutDone; 866 readoutDone = mParent->mReadoutThread->waitForReady(kWaitPerLoop); 867 if (!readoutDone) return true; 868 869 if (mNextNeedsJpeg) { 870 ALOGV("Configure: Waiting for JPEG compressor"); 871 } else { 872 ALOGV("Configure: Waiting for sensor"); 873 } 874 mWaitingForReadout = false; 875 } 876 877 if (mNextNeedsJpeg) { 878 bool jpegDone; 879 jpegDone = mParent->mJpegCompressor->waitForDone(kWaitPerLoop); 880 if (!jpegDone) return true; 881 882 ALOGV("Configure: Waiting for sensor"); 883 mNextNeedsJpeg = false; 884 } 885 886 if (mNextIsCapture) { 887 return configureNextCapture(); 888 } else { 889 return configureNextReprocess(); 890 } 891 } 892 893 bool EmulatedFakeCamera2::ConfigureThread::setupCapture() { 894 status_t res; 895 896 mNextIsCapture = true; 897 // Get necessary parameters for sensor config 898 mParent->mControlThread->processRequest(mRequest); 899 900 camera_metadata_entry_t streams; 901 res = find_camera_metadata_entry(mRequest, 902 ANDROID_REQUEST_OUTPUT_STREAMS, 903 &streams); 904 if (res != NO_ERROR) { 905 ALOGE("%s: error reading output stream tag", __FUNCTION__); 906 mParent->signalError(); 907 return false; 908 } 909 910 mNextBuffers = new Buffers; 911 mNextNeedsJpeg = false; 912 ALOGV("Configure: Setting up buffers for capture"); 913 for (size_t i = 0; i < streams.count; i++) { 914 int streamId = streams.data.i32[i]; 915 const Stream &s = mParent->getStreamInfo(streamId); 916 if (s.format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { 917 ALOGE("%s: Stream %d does not have a concrete pixel format, but " 918 "is included in a request!", __FUNCTION__, streamId); 919 mParent->signalError(); 920 return false; 921 } 922 StreamBuffer b; 923 b.streamId = streams.data.u8[i]; 924 b.width = s.width; 925 b.height = s.height; 926 b.format = s.format; 927 b.stride = s.stride; 928 mNextBuffers->push_back(b); 929 ALOGV("Configure: Buffer %d: Stream %d, %d x %d, format 0x%x, " 930 "stride %d", 931 i, b.streamId, b.width, b.height, b.format, b.stride); 932 if (b.format == HAL_PIXEL_FORMAT_BLOB) { 933 mNextNeedsJpeg = true; 934 } 935 } 936 937 camera_metadata_entry_t e; 938 res = find_camera_metadata_entry(mRequest, 939 ANDROID_REQUEST_FRAME_COUNT, 940 &e); 941 if (res != NO_ERROR) { 942 ALOGE("%s: error reading frame count tag: %s (%d)", 943 __FUNCTION__, strerror(-res), res); 944 mParent->signalError(); 945 return false; 946 } 947 mNextFrameNumber = *e.data.i32; 948 949 res = find_camera_metadata_entry(mRequest, 950 ANDROID_SENSOR_EXPOSURE_TIME, 951 &e); 952 if (res != NO_ERROR) { 953 ALOGE("%s: error reading exposure time tag: %s (%d)", 954 __FUNCTION__, strerror(-res), res); 955 mParent->signalError(); 956 return false; 957 } 958 mNextExposureTime = *e.data.i64; 959 960 res = find_camera_metadata_entry(mRequest, 961 ANDROID_SENSOR_FRAME_DURATION, 962 &e); 963 if (res != NO_ERROR) { 964 ALOGE("%s: error reading frame duration tag", __FUNCTION__); 965 mParent->signalError(); 966 return false; 967 } 968 mNextFrameDuration = *e.data.i64; 969 970 if (mNextFrameDuration < 971 mNextExposureTime + Sensor::kMinVerticalBlank) { 972 mNextFrameDuration = mNextExposureTime + Sensor::kMinVerticalBlank; 973 } 974 res = find_camera_metadata_entry(mRequest, 975 ANDROID_SENSOR_SENSITIVITY, 976 &e); 977 if (res != NO_ERROR) { 978 ALOGE("%s: error reading sensitivity tag", __FUNCTION__); 979 mParent->signalError(); 980 return false; 981 } 982 mNextSensitivity = *e.data.i32; 983 984 res = find_camera_metadata_entry(mRequest, 985 EMULATOR_SCENE_HOUROFDAY, 986 &e); 987 if (res == NO_ERROR) { 988 ALOGV("Setting hour: %d", *e.data.i32); 989 mParent->mSensor->getScene().setHour(*e.data.i32); 990 } 991 992 // Start waiting on readout thread 993 mWaitingForReadout = true; 994 ALOGV("Configure: Waiting for readout thread"); 995 996 return true; 997 } 998 999 bool EmulatedFakeCamera2::ConfigureThread::configureNextCapture() { 1000 bool vsync = mParent->mSensor->waitForVSync(kWaitPerLoop); 1001 if (!vsync) return true; 1002 1003 Mutex::Autolock il(mInternalsMutex); 1004 ALOGV("Configure: Configuring sensor for capture %d", mNextFrameNumber); 1005 mParent->mSensor->setExposureTime(mNextExposureTime); 1006 mParent->mSensor->setFrameDuration(mNextFrameDuration); 1007 mParent->mSensor->setSensitivity(mNextSensitivity); 1008 1009 getBuffers(); 1010 1011 ALOGV("Configure: Done configure for capture %d", mNextFrameNumber); 1012 mParent->mReadoutThread->setNextOperation(true, mRequest, mNextBuffers); 1013 mParent->mSensor->setDestinationBuffers(mNextBuffers); 1014 1015 mRequest = NULL; 1016 mNextBuffers = NULL; 1017 1018 Mutex::Autolock lock(mInputMutex); 1019 mRequestCount--; 1020 1021 return true; 1022 } 1023 1024 bool EmulatedFakeCamera2::ConfigureThread::setupReprocess() { 1025 status_t res; 1026 1027 mNextNeedsJpeg = true; 1028 mNextIsCapture = false; 1029 1030 camera_metadata_entry_t reprocessStreams; 1031 res = find_camera_metadata_entry(mRequest, 1032 ANDROID_REQUEST_INPUT_STREAMS, 1033 &reprocessStreams); 1034 if (res != NO_ERROR) { 1035 ALOGE("%s: error reading output stream tag", __FUNCTION__); 1036 mParent->signalError(); 1037 return false; 1038 } 1039 1040 mNextBuffers = new Buffers; 1041 1042 ALOGV("Configure: Setting up input buffers for reprocess"); 1043 for (size_t i = 0; i < reprocessStreams.count; i++) { 1044 int streamId = reprocessStreams.data.i32[i]; 1045 const ReprocessStream &s = mParent->getReprocessStreamInfo(streamId); 1046 if (s.format != HAL_PIXEL_FORMAT_RGB_888) { 1047 ALOGE("%s: Only ZSL reprocessing supported!", 1048 __FUNCTION__); 1049 mParent->signalError(); 1050 return false; 1051 } 1052 StreamBuffer b; 1053 b.streamId = -streamId; 1054 b.width = s.width; 1055 b.height = s.height; 1056 b.format = s.format; 1057 b.stride = s.stride; 1058 mNextBuffers->push_back(b); 1059 } 1060 1061 camera_metadata_entry_t streams; 1062 res = find_camera_metadata_entry(mRequest, 1063 ANDROID_REQUEST_OUTPUT_STREAMS, 1064 &streams); 1065 if (res != NO_ERROR) { 1066 ALOGE("%s: error reading output stream tag", __FUNCTION__); 1067 mParent->signalError(); 1068 return false; 1069 } 1070 1071 ALOGV("Configure: Setting up output buffers for reprocess"); 1072 for (size_t i = 0; i < streams.count; i++) { 1073 int streamId = streams.data.i32[i]; 1074 const Stream &s = mParent->getStreamInfo(streamId); 1075 if (s.format != HAL_PIXEL_FORMAT_BLOB) { 1076 // TODO: Support reprocess to YUV 1077 ALOGE("%s: Non-JPEG output stream %d for reprocess not supported", 1078 __FUNCTION__, streamId); 1079 mParent->signalError(); 1080 return false; 1081 } 1082 StreamBuffer b; 1083 b.streamId = streams.data.u8[i]; 1084 b.width = s.width; 1085 b.height = s.height; 1086 b.format = s.format; 1087 b.stride = s.stride; 1088 mNextBuffers->push_back(b); 1089 ALOGV("Configure: Buffer %d: Stream %d, %d x %d, format 0x%x, " 1090 "stride %d", 1091 i, b.streamId, b.width, b.height, b.format, b.stride); 1092 } 1093 1094 camera_metadata_entry_t e; 1095 res = find_camera_metadata_entry(mRequest, 1096 ANDROID_REQUEST_FRAME_COUNT, 1097 &e); 1098 if (res != NO_ERROR) { 1099 ALOGE("%s: error reading frame count tag: %s (%d)", 1100 __FUNCTION__, strerror(-res), res); 1101 mParent->signalError(); 1102 return false; 1103 } 1104 mNextFrameNumber = *e.data.i32; 1105 1106 return true; 1107 } 1108 1109 bool EmulatedFakeCamera2::ConfigureThread::configureNextReprocess() { 1110 Mutex::Autolock il(mInternalsMutex); 1111 1112 getBuffers(); 1113 1114 ALOGV("Configure: Done configure for reprocess %d", mNextFrameNumber); 1115 mParent->mReadoutThread->setNextOperation(false, mRequest, mNextBuffers); 1116 1117 mRequest = NULL; 1118 mNextBuffers = NULL; 1119 1120 Mutex::Autolock lock(mInputMutex); 1121 mRequestCount--; 1122 1123 return true; 1124 } 1125 1126 bool EmulatedFakeCamera2::ConfigureThread::getBuffers() { 1127 status_t res; 1128 /** Get buffers to fill for this frame */ 1129 for (size_t i = 0; i < mNextBuffers->size(); i++) { 1130 StreamBuffer &b = mNextBuffers->editItemAt(i); 1131 1132 if (b.streamId > 0) { 1133 Stream s = mParent->getStreamInfo(b.streamId); 1134 ALOGV("Configure: Dequeing buffer from stream %d", b.streamId); 1135 res = s.ops->dequeue_buffer(s.ops, &(b.buffer) ); 1136 if (res != NO_ERROR || b.buffer == NULL) { 1137 ALOGE("%s: Unable to dequeue buffer from stream %d: %s (%d)", 1138 __FUNCTION__, b.streamId, strerror(-res), res); 1139 mParent->signalError(); 1140 return false; 1141 } 1142 1143 /* Lock the buffer from the perspective of the graphics mapper */ 1144 const Rect rect(s.width, s.height); 1145 1146 res = GraphicBufferMapper::get().lock(*(b.buffer), 1147 GRALLOC_USAGE_HW_CAMERA_WRITE, 1148 rect, (void**)&(b.img) ); 1149 1150 if (res != NO_ERROR) { 1151 ALOGE("%s: grbuffer_mapper.lock failure: %s (%d)", 1152 __FUNCTION__, strerror(-res), res); 1153 s.ops->cancel_buffer(s.ops, 1154 b.buffer); 1155 mParent->signalError(); 1156 return false; 1157 } 1158 } else { 1159 ReprocessStream s = mParent->getReprocessStreamInfo(-b.streamId); 1160 ALOGV("Configure: Acquiring buffer from reprocess stream %d", 1161 -b.streamId); 1162 res = s.ops->acquire_buffer(s.ops, &(b.buffer) ); 1163 if (res != NO_ERROR || b.buffer == NULL) { 1164 ALOGE("%s: Unable to acquire buffer from reprocess stream %d: " 1165 "%s (%d)", __FUNCTION__, -b.streamId, 1166 strerror(-res), res); 1167 mParent->signalError(); 1168 return false; 1169 } 1170 1171 /* Lock the buffer from the perspective of the graphics mapper */ 1172 const Rect rect(s.width, s.height); 1173 1174 res = GraphicBufferMapper::get().lock(*(b.buffer), 1175 GRALLOC_USAGE_HW_CAMERA_READ, 1176 rect, (void**)&(b.img) ); 1177 if (res != NO_ERROR) { 1178 ALOGE("%s: grbuffer_mapper.lock failure: %s (%d)", 1179 __FUNCTION__, strerror(-res), res); 1180 s.ops->release_buffer(s.ops, 1181 b.buffer); 1182 mParent->signalError(); 1183 return false; 1184 } 1185 } 1186 } 1187 return true; 1188 } 1189 1190 EmulatedFakeCamera2::ReadoutThread::ReadoutThread(EmulatedFakeCamera2 *parent): 1191 Thread(false), 1192 mParent(parent), 1193 mRunning(false), 1194 mActive(false), 1195 mRequestCount(0), 1196 mRequest(NULL), 1197 mBuffers(NULL) { 1198 mInFlightQueue = new InFlightQueue[kInFlightQueueSize]; 1199 mInFlightHead = 0; 1200 mInFlightTail = 0; 1201 } 1202 1203 EmulatedFakeCamera2::ReadoutThread::~ReadoutThread() { 1204 delete mInFlightQueue; 1205 } 1206 1207 status_t EmulatedFakeCamera2::ReadoutThread::readyToRun() { 1208 Mutex::Autolock lock(mInputMutex); 1209 ALOGV("Starting up ReadoutThread"); 1210 mRunning = true; 1211 mInputSignal.signal(); 1212 return NO_ERROR; 1213 } 1214 1215 status_t EmulatedFakeCamera2::ReadoutThread::waitUntilRunning() { 1216 Mutex::Autolock lock(mInputMutex); 1217 if (!mRunning) { 1218 ALOGV("Waiting for readout thread to start"); 1219 mInputSignal.wait(mInputMutex); 1220 } 1221 return OK; 1222 } 1223 1224 bool EmulatedFakeCamera2::ReadoutThread::waitForReady(nsecs_t timeout) { 1225 status_t res; 1226 Mutex::Autolock lock(mInputMutex); 1227 while (!readyForNextCapture()) { 1228 res = mReadySignal.waitRelative(mInputMutex, timeout); 1229 if (res == TIMED_OUT) return false; 1230 if (res != OK) { 1231 ALOGE("%s: Error waiting for ready: %s (%d)", __FUNCTION__, 1232 strerror(-res), res); 1233 return false; 1234 } 1235 } 1236 return true; 1237 } 1238 1239 bool EmulatedFakeCamera2::ReadoutThread::readyForNextCapture() { 1240 return (mInFlightTail + 1) % kInFlightQueueSize != mInFlightHead; 1241 } 1242 1243 void EmulatedFakeCamera2::ReadoutThread::setNextOperation( 1244 bool isCapture, 1245 camera_metadata_t *request, 1246 Buffers *buffers) { 1247 Mutex::Autolock lock(mInputMutex); 1248 if ( !readyForNextCapture() ) { 1249 ALOGE("In flight queue full, dropping captures"); 1250 mParent->signalError(); 1251 return; 1252 } 1253 mInFlightQueue[mInFlightTail].isCapture = isCapture; 1254 mInFlightQueue[mInFlightTail].request = request; 1255 mInFlightQueue[mInFlightTail].buffers = buffers; 1256 mInFlightTail = (mInFlightTail + 1) % kInFlightQueueSize; 1257 mRequestCount++; 1258 1259 if (!mActive) { 1260 mActive = true; 1261 mInputSignal.signal(); 1262 } 1263 } 1264 1265 bool EmulatedFakeCamera2::ReadoutThread::isStreamInUse(uint32_t id) { 1266 // acquire in same order as threadLoop 1267 Mutex::Autolock iLock(mInternalsMutex); 1268 Mutex::Autolock lock(mInputMutex); 1269 1270 size_t i = mInFlightHead; 1271 while (i != mInFlightTail) { 1272 for (size_t j = 0; j < mInFlightQueue[i].buffers->size(); j++) { 1273 if ( (*(mInFlightQueue[i].buffers))[j].streamId == (int)id ) 1274 return true; 1275 } 1276 i = (i + 1) % kInFlightQueueSize; 1277 } 1278 1279 1280 if (mBuffers != NULL) { 1281 for (i = 0; i < mBuffers->size(); i++) { 1282 if ( (*mBuffers)[i].streamId == (int)id) return true; 1283 } 1284 } 1285 1286 return false; 1287 } 1288 1289 int EmulatedFakeCamera2::ReadoutThread::getInProgressCount() { 1290 Mutex::Autolock lock(mInputMutex); 1291 1292 return mRequestCount; 1293 } 1294 1295 bool EmulatedFakeCamera2::ReadoutThread::threadLoop() { 1296 static const nsecs_t kWaitPerLoop = 10000000L; // 10 ms 1297 status_t res; 1298 int32_t frameNumber; 1299 1300 // Check if we're currently processing or just waiting 1301 { 1302 Mutex::Autolock lock(mInputMutex); 1303 if (!mActive) { 1304 // Inactive, keep waiting until we've been signaled 1305 res = mInputSignal.waitRelative(mInputMutex, kWaitPerLoop); 1306 if (res != NO_ERROR && res != TIMED_OUT) { 1307 ALOGE("%s: Error waiting for capture requests: %d", 1308 __FUNCTION__, res); 1309 mParent->signalError(); 1310 return false; 1311 } 1312 if (!mActive) return true; 1313 } 1314 // Active, see if we need a new request 1315 if (mRequest == NULL) { 1316 if (mInFlightHead == mInFlightTail) { 1317 // Go inactive 1318 ALOGV("Waiting for sensor data"); 1319 mActive = false; 1320 return true; 1321 } else { 1322 Mutex::Autolock iLock(mInternalsMutex); 1323 mReadySignal.signal(); 1324 mIsCapture = mInFlightQueue[mInFlightHead].isCapture; 1325 mRequest = mInFlightQueue[mInFlightHead].request; 1326 mBuffers = mInFlightQueue[mInFlightHead].buffers; 1327 mInFlightQueue[mInFlightHead].request = NULL; 1328 mInFlightQueue[mInFlightHead].buffers = NULL; 1329 mInFlightHead = (mInFlightHead + 1) % kInFlightQueueSize; 1330 ALOGV("Ready to read out request %p, %d buffers", 1331 mRequest, mBuffers->size()); 1332 } 1333 } 1334 } 1335 1336 // Active with request, wait on sensor to complete 1337 1338 nsecs_t captureTime; 1339 1340 if (mIsCapture) { 1341 bool gotFrame; 1342 gotFrame = mParent->mSensor->waitForNewFrame(kWaitPerLoop, 1343 &captureTime); 1344 1345 if (!gotFrame) return true; 1346 } 1347 1348 Mutex::Autolock iLock(mInternalsMutex); 1349 1350 camera_metadata_entry_t entry; 1351 if (!mIsCapture) { 1352 res = find_camera_metadata_entry(mRequest, 1353 ANDROID_SENSOR_TIMESTAMP, 1354 &entry); 1355 if (res != NO_ERROR) { 1356 ALOGE("%s: error reading reprocessing timestamp: %s (%d)", 1357 __FUNCTION__, strerror(-res), res); 1358 mParent->signalError(); 1359 return false; 1360 } 1361 captureTime = entry.data.i64[0]; 1362 } 1363 1364 res = find_camera_metadata_entry(mRequest, 1365 ANDROID_REQUEST_FRAME_COUNT, 1366 &entry); 1367 if (res != NO_ERROR) { 1368 ALOGE("%s: error reading frame count tag: %s (%d)", 1369 __FUNCTION__, strerror(-res), res); 1370 mParent->signalError(); 1371 return false; 1372 } 1373 frameNumber = *entry.data.i32; 1374 1375 res = find_camera_metadata_entry(mRequest, 1376 ANDROID_REQUEST_METADATA_MODE, 1377 &entry); 1378 if (res != NO_ERROR) { 1379 ALOGE("%s: error reading metadata mode tag: %s (%d)", 1380 __FUNCTION__, strerror(-res), res); 1381 mParent->signalError(); 1382 return false; 1383 } 1384 1385 // Got sensor data and request, construct frame and send it out 1386 ALOGV("Readout: Constructing metadata and frames for request %d", 1387 frameNumber); 1388 1389 if (*entry.data.u8 == ANDROID_REQUEST_METADATA_MODE_FULL) { 1390 ALOGV("Readout: Metadata requested, constructing"); 1391 1392 camera_metadata_t *frame = NULL; 1393 1394 size_t frame_entries = get_camera_metadata_entry_count(mRequest); 1395 size_t frame_data = get_camera_metadata_data_count(mRequest); 1396 1397 // TODO: Dynamically calculate based on enabled statistics, etc 1398 frame_entries += 10; 1399 frame_data += 100; 1400 1401 res = mParent->mFrameQueueDst->dequeue_frame(mParent->mFrameQueueDst, 1402 frame_entries, frame_data, &frame); 1403 1404 if (res != NO_ERROR || frame == NULL) { 1405 ALOGE("%s: Unable to dequeue frame metadata buffer", __FUNCTION__); 1406 mParent->signalError(); 1407 return false; 1408 } 1409 1410 res = append_camera_metadata(frame, mRequest); 1411 if (res != NO_ERROR) { 1412 ALOGE("Unable to append request metadata"); 1413 } 1414 1415 if (mIsCapture) { 1416 add_camera_metadata_entry(frame, 1417 ANDROID_SENSOR_TIMESTAMP, 1418 &captureTime, 1419 1); 1420 1421 int32_t hourOfDay = (int32_t)mParent->mSensor->getScene().getHour(); 1422 camera_metadata_entry_t requestedHour; 1423 res = find_camera_metadata_entry(frame, 1424 EMULATOR_SCENE_HOUROFDAY, 1425 &requestedHour); 1426 if (res == NAME_NOT_FOUND) { 1427 res = add_camera_metadata_entry(frame, 1428 EMULATOR_SCENE_HOUROFDAY, 1429 &hourOfDay, 1); 1430 if (res != NO_ERROR) { 1431 ALOGE("Unable to add vendor tag"); 1432 } 1433 } else if (res == OK) { 1434 *requestedHour.data.i32 = hourOfDay; 1435 } else { 1436 ALOGE("%s: Error looking up vendor tag", __FUNCTION__); 1437 } 1438 1439 collectStatisticsMetadata(frame); 1440 // TODO: Collect all final values used from sensor in addition to timestamp 1441 } 1442 1443 ALOGV("Readout: Enqueue frame %d", frameNumber); 1444 mParent->mFrameQueueDst->enqueue_frame(mParent->mFrameQueueDst, 1445 frame); 1446 } 1447 ALOGV("Readout: Free request"); 1448 res = mParent->mRequestQueueSrc->free_request(mParent->mRequestQueueSrc, mRequest); 1449 if (res != NO_ERROR) { 1450 ALOGE("%s: Unable to return request buffer to queue: %d", 1451 __FUNCTION__, res); 1452 mParent->signalError(); 1453 return false; 1454 } 1455 mRequest = NULL; 1456 1457 int compressedBufferIndex = -1; 1458 ALOGV("Readout: Processing %d buffers", mBuffers->size()); 1459 for (size_t i = 0; i < mBuffers->size(); i++) { 1460 const StreamBuffer &b = (*mBuffers)[i]; 1461 ALOGV("Readout: Buffer %d: Stream %d, %d x %d, format 0x%x, stride %d", 1462 i, b.streamId, b.width, b.height, b.format, b.stride); 1463 if (b.streamId > 0) { 1464 if (b.format == HAL_PIXEL_FORMAT_BLOB) { 1465 // Assumes only one BLOB buffer type per capture 1466 compressedBufferIndex = i; 1467 } else { 1468 ALOGV("Readout: Sending image buffer %d (%p) to output stream %d", 1469 i, (void*)*(b.buffer), b.streamId); 1470 GraphicBufferMapper::get().unlock(*(b.buffer)); 1471 const Stream &s = mParent->getStreamInfo(b.streamId); 1472 res = s.ops->enqueue_buffer(s.ops, captureTime, b.buffer); 1473 if (res != OK) { 1474 ALOGE("Error enqueuing image buffer %p: %s (%d)", b.buffer, 1475 strerror(-res), res); 1476 mParent->signalError(); 1477 } 1478 } 1479 } 1480 } 1481 1482 if (compressedBufferIndex == -1) { 1483 delete mBuffers; 1484 } else { 1485 ALOGV("Readout: Starting JPEG compression for buffer %d, stream %d", 1486 compressedBufferIndex, 1487 (*mBuffers)[compressedBufferIndex].streamId); 1488 mJpegTimestamp = captureTime; 1489 // Takes ownership of mBuffers 1490 mParent->mJpegCompressor->start(mBuffers, this); 1491 } 1492 mBuffers = NULL; 1493 1494 Mutex::Autolock l(mInputMutex); 1495 mRequestCount--; 1496 ALOGV("Readout: Done with request %d", frameNumber); 1497 return true; 1498 } 1499 1500 void EmulatedFakeCamera2::ReadoutThread::onJpegDone( 1501 const StreamBuffer &jpegBuffer, bool success) { 1502 status_t res; 1503 if (!success) { 1504 ALOGE("%s: Error queueing compressed image buffer %p", 1505 __FUNCTION__, jpegBuffer.buffer); 1506 mParent->signalError(); 1507 return; 1508 } 1509 1510 // Write to JPEG output stream 1511 ALOGV("%s: Compression complete, pushing to stream %d", __FUNCTION__, 1512 jpegBuffer.streamId); 1513 1514 GraphicBufferMapper::get().unlock(*(jpegBuffer.buffer)); 1515 const Stream &s = mParent->getStreamInfo(jpegBuffer.streamId); 1516 res = s.ops->enqueue_buffer(s.ops, mJpegTimestamp, jpegBuffer.buffer); 1517 } 1518 1519 void EmulatedFakeCamera2::ReadoutThread::onJpegInputDone( 1520 const StreamBuffer &inputBuffer) { 1521 status_t res; 1522 GraphicBufferMapper::get().unlock(*(inputBuffer.buffer)); 1523 const ReprocessStream &s = 1524 mParent->getReprocessStreamInfo(-inputBuffer.streamId); 1525 res = s.ops->release_buffer(s.ops, inputBuffer.buffer); 1526 if (res != OK) { 1527 ALOGE("Error releasing reprocess buffer %p: %s (%d)", 1528 inputBuffer.buffer, strerror(-res), res); 1529 mParent->signalError(); 1530 } 1531 } 1532 1533 status_t EmulatedFakeCamera2::ReadoutThread::collectStatisticsMetadata( 1534 camera_metadata_t *frame) { 1535 // Completely fake face rectangles, don't correspond to real faces in scene 1536 ALOGV("Readout: Collecting statistics metadata"); 1537 1538 status_t res; 1539 camera_metadata_entry_t entry; 1540 res = find_camera_metadata_entry(frame, 1541 ANDROID_STATISTICS_FACE_DETECT_MODE, 1542 &entry); 1543 if (res != OK) { 1544 ALOGE("%s: Unable to find face detect mode!", __FUNCTION__); 1545 return BAD_VALUE; 1546 } 1547 1548 if (entry.data.u8[0] == ANDROID_STATISTICS_FACE_DETECT_MODE_OFF) return OK; 1549 1550 // The coordinate system for the face regions is the raw sensor pixel 1551 // coordinates. Here, we map from the scene coordinates (0-19 in both axis) 1552 // to raw pixels, for the scene defined in fake-pipeline2/Scene.cpp. We 1553 // approximately place two faces on top of the windows of the house. No 1554 // actual faces exist there, but might one day. Note that this doesn't 1555 // account for the offsets used to account for aspect ratio differences, so 1556 // the rectangles don't line up quite right. 1557 const size_t numFaces = 2; 1558 int32_t rects[numFaces * 4] = { 1559 Sensor::kResolution[0] * 10 / 20, 1560 Sensor::kResolution[1] * 15 / 20, 1561 Sensor::kResolution[0] * 12 / 20, 1562 Sensor::kResolution[1] * 17 / 20, 1563 1564 Sensor::kResolution[0] * 16 / 20, 1565 Sensor::kResolution[1] * 15 / 20, 1566 Sensor::kResolution[0] * 18 / 20, 1567 Sensor::kResolution[1] * 17 / 20 1568 }; 1569 // To simulate some kind of real detection going on, we jitter the rectangles on 1570 // each frame by a few pixels in each dimension. 1571 for (size_t i = 0; i < numFaces * 4; i++) { 1572 rects[i] += (int32_t)(((float)rand() / RAND_MAX) * 6 - 3); 1573 } 1574 // The confidence scores (0-100) are similarly jittered. 1575 uint8_t scores[numFaces] = { 85, 95 }; 1576 for (size_t i = 0; i < numFaces; i++) { 1577 scores[i] += (int32_t)(((float)rand() / RAND_MAX) * 10 - 5); 1578 } 1579 1580 res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_RECTANGLES, 1581 rects, numFaces * 4); 1582 if (res != OK) { 1583 ALOGE("%s: Unable to add face rectangles!", __FUNCTION__); 1584 return BAD_VALUE; 1585 } 1586 1587 res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_SCORES, 1588 scores, numFaces); 1589 if (res != OK) { 1590 ALOGE("%s: Unable to add face scores!", __FUNCTION__); 1591 return BAD_VALUE; 1592 } 1593 1594 if (entry.data.u8[0] == ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE) return OK; 1595 1596 // Advanced face detection options - add eye/mouth coordinates. The 1597 // coordinates in order are (leftEyeX, leftEyeY, rightEyeX, rightEyeY, 1598 // mouthX, mouthY). The mapping is the same as the face rectangles. 1599 int32_t features[numFaces * 6] = { 1600 Sensor::kResolution[0] * 10.5 / 20, 1601 Sensor::kResolution[1] * 16 / 20, 1602 Sensor::kResolution[0] * 11.5 / 20, 1603 Sensor::kResolution[1] * 16 / 20, 1604 Sensor::kResolution[0] * 11 / 20, 1605 Sensor::kResolution[1] * 16.5 / 20, 1606 1607 Sensor::kResolution[0] * 16.5 / 20, 1608 Sensor::kResolution[1] * 16 / 20, 1609 Sensor::kResolution[0] * 17.5 / 20, 1610 Sensor::kResolution[1] * 16 / 20, 1611 Sensor::kResolution[0] * 17 / 20, 1612 Sensor::kResolution[1] * 16.5 / 20, 1613 }; 1614 // Jitter these a bit less than the rects 1615 for (size_t i = 0; i < numFaces * 6; i++) { 1616 features[i] += (int32_t)(((float)rand() / RAND_MAX) * 4 - 2); 1617 } 1618 // These are unique IDs that are used to identify each face while it's 1619 // visible to the detector (if a face went away and came back, it'd get a 1620 // new ID). 1621 int32_t ids[numFaces] = { 1622 100, 200 1623 }; 1624 1625 res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_LANDMARKS, 1626 features, numFaces * 6); 1627 if (res != OK) { 1628 ALOGE("%s: Unable to add face landmarks!", __FUNCTION__); 1629 return BAD_VALUE; 1630 } 1631 1632 res = add_camera_metadata_entry(frame, ANDROID_STATISTICS_FACE_IDS, 1633 ids, numFaces); 1634 if (res != OK) { 1635 ALOGE("%s: Unable to add face scores!", __FUNCTION__); 1636 return BAD_VALUE; 1637 } 1638 1639 return OK; 1640 } 1641 1642 EmulatedFakeCamera2::ControlThread::ControlThread(EmulatedFakeCamera2 *parent): 1643 Thread(false), 1644 mParent(parent) { 1645 mRunning = false; 1646 } 1647 1648 EmulatedFakeCamera2::ControlThread::~ControlThread() { 1649 } 1650 1651 status_t EmulatedFakeCamera2::ControlThread::readyToRun() { 1652 Mutex::Autolock lock(mInputMutex); 1653 1654 ALOGV("Starting up ControlThread"); 1655 mRunning = true; 1656 mStartAf = false; 1657 mCancelAf = false; 1658 mStartPrecapture = false; 1659 1660 mControlMode = ANDROID_CONTROL_MODE_AUTO; 1661 1662 mEffectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; 1663 mSceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; 1664 1665 mAfMode = ANDROID_CONTROL_AF_MODE_AUTO; 1666 mAfModeChange = false; 1667 1668 mAeMode = ANDROID_CONTROL_AE_MODE_ON; 1669 mAwbMode = ANDROID_CONTROL_AWB_MODE_AUTO; 1670 1671 mAfTriggerId = 0; 1672 mPrecaptureTriggerId = 0; 1673 1674 mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; 1675 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; 1676 mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; 1677 1678 mExposureTime = kNormalExposureTime; 1679 1680 mInputSignal.signal(); 1681 return NO_ERROR; 1682 } 1683 1684 status_t EmulatedFakeCamera2::ControlThread::waitUntilRunning() { 1685 Mutex::Autolock lock(mInputMutex); 1686 if (!mRunning) { 1687 ALOGV("Waiting for control thread to start"); 1688 mInputSignal.wait(mInputMutex); 1689 } 1690 return OK; 1691 } 1692 1693 // Override android.control.* fields with 3A values before sending request to sensor 1694 status_t EmulatedFakeCamera2::ControlThread::processRequest(camera_metadata_t *request) { 1695 Mutex::Autolock lock(mInputMutex); 1696 // TODO: Add handling for all android.control.* fields here 1697 camera_metadata_entry_t mode; 1698 status_t res; 1699 1700 #define READ_IF_OK(res, what, def) \ 1701 (((res) == OK) ? (what) : (uint8_t)(def)) 1702 1703 res = find_camera_metadata_entry(request, 1704 ANDROID_CONTROL_MODE, 1705 &mode); 1706 mControlMode = READ_IF_OK(res, mode.data.u8[0], ANDROID_CONTROL_MODE_OFF); 1707 1708 // disable all 3A 1709 if (mControlMode == ANDROID_CONTROL_MODE_OFF) { 1710 mEffectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; 1711 mSceneMode = ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED; 1712 mAfMode = ANDROID_CONTROL_AF_MODE_OFF; 1713 mAeLock = ANDROID_CONTROL_AE_LOCK_ON; 1714 mAeMode = ANDROID_CONTROL_AE_MODE_OFF; 1715 mAfModeChange = true; 1716 mStartAf = false; 1717 mCancelAf = true; 1718 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; 1719 mAwbMode = ANDROID_CONTROL_AWB_MODE_OFF; 1720 return res; 1721 } 1722 1723 res = find_camera_metadata_entry(request, 1724 ANDROID_CONTROL_EFFECT_MODE, 1725 &mode); 1726 mEffectMode = READ_IF_OK(res, mode.data.u8[0], 1727 ANDROID_CONTROL_EFFECT_MODE_OFF); 1728 1729 res = find_camera_metadata_entry(request, 1730 ANDROID_CONTROL_SCENE_MODE, 1731 &mode); 1732 mSceneMode = READ_IF_OK(res, mode.data.u8[0], 1733 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED); 1734 1735 res = find_camera_metadata_entry(request, 1736 ANDROID_CONTROL_AF_MODE, 1737 &mode); 1738 if (mAfMode != mode.data.u8[0]) { 1739 ALOGV("AF new mode: %d, old mode %d", mode.data.u8[0], mAfMode); 1740 mAfMode = mode.data.u8[0]; 1741 mAfModeChange = true; 1742 mStartAf = false; 1743 mCancelAf = false; 1744 } 1745 1746 res = find_camera_metadata_entry(request, 1747 ANDROID_CONTROL_AE_MODE, 1748 &mode); 1749 mAeMode = READ_IF_OK(res, mode.data.u8[0], 1750 ANDROID_CONTROL_AE_MODE_OFF); 1751 1752 res = find_camera_metadata_entry(request, 1753 ANDROID_CONTROL_AE_LOCK, 1754 &mode); 1755 uint8_t aeLockVal = READ_IF_OK(res, mode.data.u8[0], 1756 ANDROID_CONTROL_AE_LOCK_ON); 1757 bool aeLock = (aeLockVal == ANDROID_CONTROL_AE_LOCK_ON); 1758 if (mAeLock && !aeLock) { 1759 mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; 1760 } 1761 mAeLock = aeLock; 1762 1763 res = find_camera_metadata_entry(request, 1764 ANDROID_CONTROL_AWB_MODE, 1765 &mode); 1766 mAwbMode = READ_IF_OK(res, mode.data.u8[0], 1767 ANDROID_CONTROL_AWB_MODE_OFF); 1768 1769 // TODO: Override more control fields 1770 1771 if (mAeMode != ANDROID_CONTROL_AE_MODE_OFF) { 1772 camera_metadata_entry_t exposureTime; 1773 res = find_camera_metadata_entry(request, 1774 ANDROID_SENSOR_EXPOSURE_TIME, 1775 &exposureTime); 1776 if (res == OK) { 1777 exposureTime.data.i64[0] = mExposureTime; 1778 } 1779 } 1780 1781 #undef READ_IF_OK 1782 1783 return OK; 1784 } 1785 1786 status_t EmulatedFakeCamera2::ControlThread::triggerAction(uint32_t msgType, 1787 int32_t ext1, int32_t ext2) { 1788 ALOGV("%s: Triggering %d (%d, %d)", __FUNCTION__, msgType, ext1, ext2); 1789 Mutex::Autolock lock(mInputMutex); 1790 switch (msgType) { 1791 case CAMERA2_TRIGGER_AUTOFOCUS: 1792 mAfTriggerId = ext1; 1793 mStartAf = true; 1794 mCancelAf = false; 1795 break; 1796 case CAMERA2_TRIGGER_CANCEL_AUTOFOCUS: 1797 mAfTriggerId = ext1; 1798 mStartAf = false; 1799 mCancelAf = true; 1800 break; 1801 case CAMERA2_TRIGGER_PRECAPTURE_METERING: 1802 mPrecaptureTriggerId = ext1; 1803 mStartPrecapture = true; 1804 break; 1805 default: 1806 ALOGE("%s: Unknown action triggered: %d (arguments %d %d)", 1807 __FUNCTION__, msgType, ext1, ext2); 1808 return BAD_VALUE; 1809 } 1810 return OK; 1811 } 1812 1813 const nsecs_t EmulatedFakeCamera2::ControlThread::kControlCycleDelay = 100 * MSEC; 1814 const nsecs_t EmulatedFakeCamera2::ControlThread::kMinAfDuration = 500 * MSEC; 1815 const nsecs_t EmulatedFakeCamera2::ControlThread::kMaxAfDuration = 900 * MSEC; 1816 const float EmulatedFakeCamera2::ControlThread::kAfSuccessRate = 0.9; 1817 // Once every 5 seconds 1818 const float EmulatedFakeCamera2::ControlThread::kContinuousAfStartRate = 1819 kControlCycleDelay / 5.0 * SEC; 1820 const nsecs_t EmulatedFakeCamera2::ControlThread::kMinAeDuration = 500 * MSEC; 1821 const nsecs_t EmulatedFakeCamera2::ControlThread::kMaxAeDuration = 2 * SEC; 1822 const nsecs_t EmulatedFakeCamera2::ControlThread::kMinPrecaptureAeDuration = 100 * MSEC; 1823 const nsecs_t EmulatedFakeCamera2::ControlThread::kMaxPrecaptureAeDuration = 400 * MSEC; 1824 // Once every 3 seconds 1825 const float EmulatedFakeCamera2::ControlThread::kAeScanStartRate = 1826 kControlCycleDelay / 3000000000.0; 1827 1828 const nsecs_t EmulatedFakeCamera2::ControlThread::kNormalExposureTime = 10 * MSEC; 1829 const nsecs_t EmulatedFakeCamera2::ControlThread::kExposureJump = 2 * MSEC; 1830 const nsecs_t EmulatedFakeCamera2::ControlThread::kMinExposureTime = 1 * MSEC; 1831 1832 bool EmulatedFakeCamera2::ControlThread::threadLoop() { 1833 bool afModeChange = false; 1834 bool afTriggered = false; 1835 bool afCancelled = false; 1836 uint8_t afState; 1837 uint8_t afMode; 1838 int32_t afTriggerId; 1839 bool precaptureTriggered = false; 1840 uint8_t aeState; 1841 uint8_t aeMode; 1842 bool aeLock; 1843 int32_t precaptureTriggerId; 1844 nsecs_t nextSleep = kControlCycleDelay; 1845 1846 { 1847 Mutex::Autolock lock(mInputMutex); 1848 if (mStartAf) { 1849 ALOGD("Starting AF trigger processing"); 1850 afTriggered = true; 1851 mStartAf = false; 1852 } else if (mCancelAf) { 1853 ALOGD("Starting cancel AF trigger processing"); 1854 afCancelled = true; 1855 mCancelAf = false; 1856 } 1857 afState = mAfState; 1858 afMode = mAfMode; 1859 afModeChange = mAfModeChange; 1860 mAfModeChange = false; 1861 1862 afTriggerId = mAfTriggerId; 1863 1864 if(mStartPrecapture) { 1865 ALOGD("Starting precapture trigger processing"); 1866 precaptureTriggered = true; 1867 mStartPrecapture = false; 1868 } 1869 aeState = mAeState; 1870 aeMode = mAeMode; 1871 aeLock = mAeLock; 1872 precaptureTriggerId = mPrecaptureTriggerId; 1873 } 1874 1875 if (afCancelled || afModeChange) { 1876 ALOGV("Resetting AF state due to cancel/mode change"); 1877 afState = ANDROID_CONTROL_AF_STATE_INACTIVE; 1878 updateAfState(afState, afTriggerId); 1879 mAfScanDuration = 0; 1880 mLockAfterPassiveScan = false; 1881 } 1882 1883 uint8_t oldAfState = afState; 1884 1885 if (afTriggered) { 1886 afState = processAfTrigger(afMode, afState); 1887 } 1888 1889 afState = maybeStartAfScan(afMode, afState); 1890 afState = updateAfScan(afMode, afState, &nextSleep); 1891 updateAfState(afState, afTriggerId); 1892 1893 if (precaptureTriggered) { 1894 aeState = processPrecaptureTrigger(aeMode, aeState); 1895 } 1896 1897 aeState = maybeStartAeScan(aeMode, aeLock, aeState); 1898 aeState = updateAeScan(aeMode, aeLock, aeState, &nextSleep); 1899 updateAeState(aeState, precaptureTriggerId); 1900 1901 int ret; 1902 timespec t; 1903 t.tv_sec = 0; 1904 t.tv_nsec = nextSleep; 1905 do { 1906 ret = nanosleep(&t, &t); 1907 } while (ret != 0); 1908 1909 if (mAfScanDuration > 0) { 1910 mAfScanDuration -= nextSleep; 1911 } 1912 if (mAeScanDuration > 0) { 1913 mAeScanDuration -= nextSleep; 1914 } 1915 1916 return true; 1917 } 1918 1919 int EmulatedFakeCamera2::ControlThread::processAfTrigger(uint8_t afMode, 1920 uint8_t afState) { 1921 switch (afMode) { 1922 case ANDROID_CONTROL_AF_MODE_OFF: 1923 case ANDROID_CONTROL_AF_MODE_EDOF: 1924 // Do nothing 1925 break; 1926 case ANDROID_CONTROL_AF_MODE_MACRO: 1927 case ANDROID_CONTROL_AF_MODE_AUTO: 1928 switch (afState) { 1929 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1930 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1931 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1932 // Start new focusing cycle 1933 mAfScanDuration = ((double)rand() / RAND_MAX) * 1934 (kMaxAfDuration - kMinAfDuration) + kMinAfDuration; 1935 afState = ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN; 1936 ALOGV("%s: AF scan start, duration %lld ms", 1937 __FUNCTION__, mAfScanDuration / 1000000); 1938 break; 1939 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: 1940 // Ignore new request, already scanning 1941 break; 1942 default: 1943 ALOGE("Unexpected AF state in AUTO/MACRO AF mode: %d", 1944 afState); 1945 } 1946 break; 1947 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 1948 switch (afState) { 1949 // Picture mode waits for passive scan to complete 1950 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1951 mLockAfterPassiveScan = true; 1952 break; 1953 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1954 afState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 1955 break; 1956 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1957 afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; 1958 break; 1959 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1960 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1961 // Must cancel to get out of these states 1962 break; 1963 default: 1964 ALOGE("Unexpected AF state in CONTINUOUS_PICTURE AF mode: %d", 1965 afState); 1966 } 1967 break; 1968 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 1969 switch (afState) { 1970 // Video mode does not wait for passive scan to complete 1971 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1972 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1973 afState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 1974 break; 1975 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1976 afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; 1977 break; 1978 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1979 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1980 // Must cancel to get out of these states 1981 break; 1982 default: 1983 ALOGE("Unexpected AF state in CONTINUOUS_VIDEO AF mode: %d", 1984 afState); 1985 } 1986 break; 1987 default: 1988 break; 1989 } 1990 return afState; 1991 } 1992 1993 int EmulatedFakeCamera2::ControlThread::maybeStartAfScan(uint8_t afMode, 1994 uint8_t afState) { 1995 if ((afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO || 1996 afMode == ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE) && 1997 (afState == ANDROID_CONTROL_AF_STATE_INACTIVE || 1998 afState == ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED)) { 1999 2000 bool startScan = ((double)rand() / RAND_MAX) < kContinuousAfStartRate; 2001 if (startScan) { 2002 // Start new passive focusing cycle 2003 mAfScanDuration = ((double)rand() / RAND_MAX) * 2004 (kMaxAfDuration - kMinAfDuration) + kMinAfDuration; 2005 afState = ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN; 2006 ALOGV("%s: AF passive scan start, duration %lld ms", 2007 __FUNCTION__, mAfScanDuration / 1000000); 2008 } 2009 } 2010 return afState; 2011 } 2012 2013 int EmulatedFakeCamera2::ControlThread::updateAfScan(uint8_t afMode, 2014 uint8_t afState, nsecs_t *maxSleep) { 2015 if (! (afState == ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN || 2016 afState == ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN ) ) { 2017 return afState; 2018 } 2019 2020 if (mAfScanDuration <= 0) { 2021 ALOGV("%s: AF scan done", __FUNCTION__); 2022 switch (afMode) { 2023 case ANDROID_CONTROL_AF_MODE_MACRO: 2024 case ANDROID_CONTROL_AF_MODE_AUTO: { 2025 bool success = ((double)rand() / RAND_MAX) < kAfSuccessRate; 2026 if (success) { 2027 afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; 2028 } else { 2029 afState = ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED; 2030 } 2031 break; 2032 } 2033 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: 2034 if (mLockAfterPassiveScan) { 2035 afState = ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED; 2036 mLockAfterPassiveScan = false; 2037 } else { 2038 afState = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED; 2039 } 2040 break; 2041 case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: 2042 afState = ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED; 2043 break; 2044 default: 2045 ALOGE("Unexpected AF mode in scan state"); 2046 } 2047 } else { 2048 if (mAfScanDuration <= *maxSleep) { 2049 *maxSleep = mAfScanDuration; 2050 } 2051 } 2052 return afState; 2053 } 2054 2055 void EmulatedFakeCamera2::ControlThread::updateAfState(uint8_t newState, 2056 int32_t triggerId) { 2057 Mutex::Autolock lock(mInputMutex); 2058 if (mAfState != newState) { 2059 ALOGV("%s: Autofocus state now %d, id %d", __FUNCTION__, 2060 newState, triggerId); 2061 mAfState = newState; 2062 mParent->sendNotification(CAMERA2_MSG_AUTOFOCUS, 2063 newState, triggerId, 0); 2064 } 2065 } 2066 2067 int EmulatedFakeCamera2::ControlThread::processPrecaptureTrigger(uint8_t aeMode, 2068 uint8_t aeState) { 2069 switch (aeMode) { 2070 case ANDROID_CONTROL_AE_MODE_OFF: 2071 // Don't do anything for these 2072 return aeState; 2073 case ANDROID_CONTROL_AE_MODE_ON: 2074 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH: 2075 case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH: 2076 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE: 2077 // Trigger a precapture cycle 2078 aeState = ANDROID_CONTROL_AE_STATE_PRECAPTURE; 2079 mAeScanDuration = ((double)rand() / RAND_MAX) * 2080 (kMaxPrecaptureAeDuration - kMinPrecaptureAeDuration) + 2081 kMinPrecaptureAeDuration; 2082 ALOGD("%s: AE precapture scan start, duration %lld ms", 2083 __FUNCTION__, mAeScanDuration / 1000000); 2084 2085 } 2086 return aeState; 2087 } 2088 2089 int EmulatedFakeCamera2::ControlThread::maybeStartAeScan(uint8_t aeMode, 2090 bool aeLocked, 2091 uint8_t aeState) { 2092 if (aeLocked) return aeState; 2093 switch (aeMode) { 2094 case ANDROID_CONTROL_AE_MODE_OFF: 2095 break; 2096 case ANDROID_CONTROL_AE_MODE_ON: 2097 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH: 2098 case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH: 2099 case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE: { 2100 if (aeState != ANDROID_CONTROL_AE_STATE_INACTIVE && 2101 aeState != ANDROID_CONTROL_AE_STATE_CONVERGED) break; 2102 2103 bool startScan = ((double)rand() / RAND_MAX) < kAeScanStartRate; 2104 if (startScan) { 2105 mAeScanDuration = ((double)rand() / RAND_MAX) * 2106 (kMaxAeDuration - kMinAeDuration) + kMinAeDuration; 2107 aeState = ANDROID_CONTROL_AE_STATE_SEARCHING; 2108 ALOGV("%s: AE scan start, duration %lld ms", 2109 __FUNCTION__, mAeScanDuration / 1000000); 2110 } 2111 } 2112 } 2113 2114 return aeState; 2115 } 2116 2117 int EmulatedFakeCamera2::ControlThread::updateAeScan(uint8_t aeMode, 2118 bool aeLock, uint8_t aeState, nsecs_t *maxSleep) { 2119 if (aeLock && aeState != ANDROID_CONTROL_AE_STATE_PRECAPTURE) { 2120 mAeScanDuration = 0; 2121 aeState = ANDROID_CONTROL_AE_STATE_LOCKED; 2122 } else if ((aeState == ANDROID_CONTROL_AE_STATE_SEARCHING) || 2123 (aeState == ANDROID_CONTROL_AE_STATE_PRECAPTURE ) ) { 2124 if (mAeScanDuration <= 0) { 2125 ALOGV("%s: AE scan done", __FUNCTION__); 2126 aeState = aeLock ? 2127 ANDROID_CONTROL_AE_STATE_LOCKED :ANDROID_CONTROL_AE_STATE_CONVERGED; 2128 2129 Mutex::Autolock lock(mInputMutex); 2130 mExposureTime = kNormalExposureTime; 2131 } else { 2132 if (mAeScanDuration <= *maxSleep) { 2133 *maxSleep = mAeScanDuration; 2134 } 2135 2136 int64_t exposureDelta = 2137 ((double)rand() / RAND_MAX) * 2 * kExposureJump - 2138 kExposureJump; 2139 Mutex::Autolock lock(mInputMutex); 2140 mExposureTime = mExposureTime + exposureDelta; 2141 if (mExposureTime < kMinExposureTime) mExposureTime = kMinExposureTime; 2142 } 2143 } 2144 2145 return aeState; 2146 } 2147 2148 2149 void EmulatedFakeCamera2::ControlThread::updateAeState(uint8_t newState, 2150 int32_t triggerId) { 2151 Mutex::Autolock lock(mInputMutex); 2152 if (mAeState != newState) { 2153 ALOGV("%s: Autoexposure state now %d, id %d", __FUNCTION__, 2154 newState, triggerId); 2155 mAeState = newState; 2156 mParent->sendNotification(CAMERA2_MSG_AUTOEXPOSURE, 2157 newState, triggerId, 0); 2158 } 2159 } 2160 2161 /** Private methods */ 2162 2163 status_t EmulatedFakeCamera2::constructStaticInfo( 2164 camera_metadata_t **info, 2165 bool sizeRequest) const { 2166 2167 size_t entryCount = 0; 2168 size_t dataCount = 0; 2169 status_t ret; 2170 2171 #define ADD_OR_SIZE( tag, data, count ) \ 2172 if ( ( ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, \ 2173 tag, data, count) ) != OK ) return ret 2174 2175 // android.lens 2176 2177 // 5 cm min focus distance for back camera, infinity (fixed focus) for front 2178 const float minFocusDistance = mFacingBack ? 1.0/0.05 : 0.0; 2179 ADD_OR_SIZE(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 2180 &minFocusDistance, 1); 2181 // 5 m hyperfocal distance for back camera, infinity (fixed focus) for front 2182 const float hyperFocalDistance = mFacingBack ? 1.0/5.0 : 0.0; 2183 ADD_OR_SIZE(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, 2184 &minFocusDistance, 1); 2185 2186 static const float focalLength = 3.30f; // mm 2187 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, 2188 &focalLength, 1); 2189 static const float aperture = 2.8f; 2190 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_APERTURES, 2191 &aperture, 1); 2192 static const float filterDensity = 0; 2193 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, 2194 &filterDensity, 1); 2195 static const uint8_t availableOpticalStabilization = 2196 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; 2197 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, 2198 &availableOpticalStabilization, 1); 2199 2200 static const int32_t lensShadingMapSize[] = {1, 1}; 2201 ADD_OR_SIZE(ANDROID_LENS_INFO_SHADING_MAP_SIZE, lensShadingMapSize, 2202 sizeof(lensShadingMapSize)/sizeof(int32_t)); 2203 2204 // Identity transform 2205 static const int32_t geometricCorrectionMapSize[] = {2, 2}; 2206 ADD_OR_SIZE(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE, 2207 geometricCorrectionMapSize, 2208 sizeof(geometricCorrectionMapSize)/sizeof(int32_t)); 2209 2210 static const float geometricCorrectionMap[2 * 3 * 2 * 2] = { 2211 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 2212 1.f, 0.f, 1.f, 0.f, 1.f, 0.f, 2213 0.f, 1.f, 0.f, 1.f, 0.f, 1.f, 2214 1.f, 1.f, 1.f, 1.f, 1.f, 1.f}; 2215 ADD_OR_SIZE(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP, 2216 geometricCorrectionMap, 2217 sizeof(geometricCorrectionMap)/sizeof(float)); 2218 2219 int32_t lensFacing = mFacingBack ? 2220 ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT; 2221 ADD_OR_SIZE(ANDROID_LENS_FACING, &lensFacing, 1); 2222 2223 float lensPosition[3]; 2224 if (mFacingBack) { 2225 // Back-facing camera is center-top on device 2226 lensPosition[0] = 0; 2227 lensPosition[1] = 20; 2228 lensPosition[2] = -5; 2229 } else { 2230 // Front-facing camera is center-right on device 2231 lensPosition[0] = 20; 2232 lensPosition[1] = 20; 2233 lensPosition[2] = 0; 2234 } 2235 ADD_OR_SIZE(ANDROID_LENS_POSITION, lensPosition, sizeof(lensPosition)/ 2236 sizeof(float)); 2237 2238 // android.sensor 2239 2240 ADD_OR_SIZE(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, 2241 Sensor::kExposureTimeRange, 2); 2242 2243 ADD_OR_SIZE(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, 2244 &Sensor::kFrameDurationRange[1], 1); 2245 2246 ADD_OR_SIZE(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, 2247 Sensor::kSensitivityRange, 2248 sizeof(Sensor::kSensitivityRange) 2249 /sizeof(int32_t)); 2250 2251 ADD_OR_SIZE(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, 2252 &Sensor::kColorFilterArrangement, 1); 2253 2254 static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; // mm 2255 ADD_OR_SIZE(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, 2256 sensorPhysicalSize, 2); 2257 2258 ADD_OR_SIZE(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, 2259 Sensor::kResolution, 2); 2260 2261 ADD_OR_SIZE(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, 2262 Sensor::kResolution, 2); 2263 2264 ADD_OR_SIZE(ANDROID_SENSOR_INFO_WHITE_LEVEL, 2265 &Sensor::kMaxRawValue, 1); 2266 2267 static const int32_t blackLevelPattern[4] = { 2268 Sensor::kBlackLevel, Sensor::kBlackLevel, 2269 Sensor::kBlackLevel, Sensor::kBlackLevel 2270 }; 2271 ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, 2272 blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t)); 2273 2274 //TODO: sensor color calibration fields 2275 2276 // android.flash 2277 static const uint8_t flashAvailable = 0; 2278 ADD_OR_SIZE(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1); 2279 2280 static const int64_t flashChargeDuration = 0; 2281 ADD_OR_SIZE(ANDROID_FLASH_INFO_CHARGE_DURATION, &flashChargeDuration, 1); 2282 2283 // android.tonemap 2284 2285 static const int32_t tonemapCurvePoints = 128; 2286 ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1); 2287 2288 // android.scaler 2289 2290 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS, 2291 kAvailableFormats, 2292 sizeof(kAvailableFormats)/sizeof(uint32_t)); 2293 2294 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES, 2295 kAvailableRawSizes, 2296 sizeof(kAvailableRawSizes)/sizeof(uint32_t)); 2297 2298 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS, 2299 kAvailableRawMinDurations, 2300 sizeof(kAvailableRawMinDurations)/sizeof(uint64_t)); 2301 2302 if (mFacingBack) { 2303 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2304 kAvailableProcessedSizesBack, 2305 sizeof(kAvailableProcessedSizesBack)/sizeof(uint32_t)); 2306 } else { 2307 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2308 kAvailableProcessedSizesFront, 2309 sizeof(kAvailableProcessedSizesFront)/sizeof(uint32_t)); 2310 } 2311 2312 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS, 2313 kAvailableProcessedMinDurations, 2314 sizeof(kAvailableProcessedMinDurations)/sizeof(uint64_t)); 2315 2316 if (mFacingBack) { 2317 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2318 kAvailableJpegSizesBack, 2319 sizeof(kAvailableJpegSizesBack)/sizeof(uint32_t)); 2320 } else { 2321 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2322 kAvailableJpegSizesFront, 2323 sizeof(kAvailableJpegSizesFront)/sizeof(uint32_t)); 2324 } 2325 2326 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS, 2327 kAvailableJpegMinDurations, 2328 sizeof(kAvailableJpegMinDurations)/sizeof(uint64_t)); 2329 2330 static const float maxZoom = 10; 2331 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, 2332 &maxZoom, 1); 2333 2334 // android.jpeg 2335 2336 static const int32_t jpegThumbnailSizes[] = { 2337 0, 0, 2338 160, 120, 2339 320, 240 2340 }; 2341 ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 2342 jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t)); 2343 2344 static const int32_t jpegMaxSize = JpegCompressor::kMaxJpegSize; 2345 ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1); 2346 2347 // android.stats 2348 2349 static const uint8_t availableFaceDetectModes[] = { 2350 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF, 2351 ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE, 2352 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL 2353 }; 2354 2355 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, 2356 availableFaceDetectModes, 2357 sizeof(availableFaceDetectModes)); 2358 2359 static const int32_t maxFaceCount = 8; 2360 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, 2361 &maxFaceCount, 1); 2362 2363 static const int32_t histogramSize = 64; 2364 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT, 2365 &histogramSize, 1); 2366 2367 static const int32_t maxHistogramCount = 1000; 2368 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT, 2369 &maxHistogramCount, 1); 2370 2371 static const int32_t sharpnessMapSize[2] = {64, 64}; 2372 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE, 2373 sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t)); 2374 2375 static const int32_t maxSharpnessMapValue = 1000; 2376 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE, 2377 &maxSharpnessMapValue, 1); 2378 2379 // android.control 2380 2381 static const uint8_t availableSceneModes[] = { 2382 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED 2383 }; 2384 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 2385 availableSceneModes, sizeof(availableSceneModes)); 2386 2387 static const uint8_t availableEffects[] = { 2388 ANDROID_CONTROL_EFFECT_MODE_OFF 2389 }; 2390 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS, 2391 availableEffects, sizeof(availableEffects)); 2392 2393 int32_t max3aRegions = 0; 2394 ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS, 2395 &max3aRegions, 1); 2396 2397 static const uint8_t availableAeModes[] = { 2398 ANDROID_CONTROL_AE_MODE_OFF, 2399 ANDROID_CONTROL_AE_MODE_ON 2400 }; 2401 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES, 2402 availableAeModes, sizeof(availableAeModes)); 2403 2404 static const camera_metadata_rational exposureCompensationStep = { 2405 1, 3 2406 }; 2407 ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_STEP, 2408 &exposureCompensationStep, 1); 2409 2410 int32_t exposureCompensationRange[] = {-9, 9}; 2411 ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_RANGE, 2412 exposureCompensationRange, 2413 sizeof(exposureCompensationRange)/sizeof(int32_t)); 2414 2415 static const int32_t availableTargetFpsRanges[] = { 2416 5, 30, 15, 30 2417 }; 2418 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2419 availableTargetFpsRanges, 2420 sizeof(availableTargetFpsRanges)/sizeof(int32_t)); 2421 2422 static const uint8_t availableAntibandingModes[] = { 2423 ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF, 2424 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO 2425 }; 2426 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, 2427 availableAntibandingModes, sizeof(availableAntibandingModes)); 2428 2429 static const uint8_t availableAwbModes[] = { 2430 ANDROID_CONTROL_AWB_MODE_OFF, 2431 ANDROID_CONTROL_AWB_MODE_AUTO, 2432 ANDROID_CONTROL_AWB_MODE_INCANDESCENT, 2433 ANDROID_CONTROL_AWB_MODE_FLUORESCENT, 2434 ANDROID_CONTROL_AWB_MODE_DAYLIGHT, 2435 ANDROID_CONTROL_AWB_MODE_SHADE 2436 }; 2437 ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 2438 availableAwbModes, sizeof(availableAwbModes)); 2439 2440 static const uint8_t availableAfModesBack[] = { 2441 ANDROID_CONTROL_AF_MODE_OFF, 2442 ANDROID_CONTROL_AF_MODE_AUTO, 2443 ANDROID_CONTROL_AF_MODE_MACRO, 2444 ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, 2445 ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE 2446 }; 2447 2448 static const uint8_t availableAfModesFront[] = { 2449 ANDROID_CONTROL_AF_MODE_OFF 2450 }; 2451 2452 if (mFacingBack) { 2453 ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES, 2454 availableAfModesBack, sizeof(availableAfModesBack)); 2455 } else { 2456 ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES, 2457 availableAfModesFront, sizeof(availableAfModesFront)); 2458 } 2459 2460 static const uint8_t availableVstabModes[] = { 2461 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF 2462 }; 2463 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 2464 availableVstabModes, sizeof(availableVstabModes)); 2465 2466 #undef ADD_OR_SIZE 2467 /** Allocate metadata if sizing */ 2468 if (sizeRequest) { 2469 ALOGV("Allocating %d entries, %d extra bytes for " 2470 "static camera info", 2471 entryCount, dataCount); 2472 *info = allocate_camera_metadata(entryCount, dataCount); 2473 if (*info == NULL) { 2474 ALOGE("Unable to allocate camera static info" 2475 "(%d entries, %d bytes extra data)", 2476 entryCount, dataCount); 2477 return NO_MEMORY; 2478 } 2479 } 2480 return OK; 2481 } 2482 2483 status_t EmulatedFakeCamera2::constructDefaultRequest( 2484 int request_template, 2485 camera_metadata_t **request, 2486 bool sizeRequest) const { 2487 2488 size_t entryCount = 0; 2489 size_t dataCount = 0; 2490 status_t ret; 2491 2492 #define ADD_OR_SIZE( tag, data, count ) \ 2493 if ( ( ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, \ 2494 tag, data, count) ) != OK ) return ret 2495 2496 /** android.request */ 2497 2498 static const uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE; 2499 ADD_OR_SIZE(ANDROID_REQUEST_TYPE, &requestType, 1); 2500 2501 static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL; 2502 ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1); 2503 2504 static const int32_t id = 0; 2505 ADD_OR_SIZE(ANDROID_REQUEST_ID, &id, 1); 2506 2507 static const int32_t frameCount = 0; 2508 ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1); 2509 2510 // OUTPUT_STREAMS set by user 2511 entryCount += 1; 2512 dataCount += 5; // TODO: Should be maximum stream number 2513 2514 /** android.lens */ 2515 2516 static const float focusDistance = 0; 2517 ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1); 2518 2519 static const float aperture = 2.8f; 2520 ADD_OR_SIZE(ANDROID_LENS_APERTURE, &aperture, 1); 2521 2522 static const float focalLength = 5.0f; 2523 ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH, &focalLength, 1); 2524 2525 static const float filterDensity = 0; 2526 ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1); 2527 2528 static const uint8_t opticalStabilizationMode = 2529 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; 2530 ADD_OR_SIZE(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, 2531 &opticalStabilizationMode, 1); 2532 2533 // FOCUS_RANGE set only in frame 2534 2535 /** android.sensor */ 2536 2537 static const int64_t exposureTime = 10 * MSEC; 2538 ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime, 1); 2539 2540 static const int64_t frameDuration = 33333333L; // 1/30 s 2541 ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1); 2542 2543 static const int32_t sensitivity = 100; 2544 ADD_OR_SIZE(ANDROID_SENSOR_SENSITIVITY, &sensitivity, 1); 2545 2546 // TIMESTAMP set only in frame 2547 2548 /** android.flash */ 2549 2550 static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF; 2551 ADD_OR_SIZE(ANDROID_FLASH_MODE, &flashMode, 1); 2552 2553 static const uint8_t flashPower = 10; 2554 ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER, &flashPower, 1); 2555 2556 static const int64_t firingTime = 0; 2557 ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME, &firingTime, 1); 2558 2559 /** Processing block modes */ 2560 uint8_t hotPixelMode = 0; 2561 uint8_t demosaicMode = 0; 2562 uint8_t noiseMode = 0; 2563 uint8_t shadingMode = 0; 2564 uint8_t geometricMode = 0; 2565 uint8_t colorMode = 0; 2566 uint8_t tonemapMode = 0; 2567 uint8_t edgeMode = 0; 2568 switch (request_template) { 2569 case CAMERA2_TEMPLATE_STILL_CAPTURE: 2570 // fall-through 2571 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: 2572 // fall-through 2573 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: 2574 hotPixelMode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY; 2575 demosaicMode = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY; 2576 noiseMode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY; 2577 shadingMode = ANDROID_SHADING_MODE_HIGH_QUALITY; 2578 geometricMode = ANDROID_GEOMETRIC_MODE_HIGH_QUALITY; 2579 colorMode = ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY; 2580 tonemapMode = ANDROID_TONEMAP_MODE_HIGH_QUALITY; 2581 edgeMode = ANDROID_EDGE_MODE_HIGH_QUALITY; 2582 break; 2583 case CAMERA2_TEMPLATE_PREVIEW: 2584 // fall-through 2585 case CAMERA2_TEMPLATE_VIDEO_RECORD: 2586 // fall-through 2587 default: 2588 hotPixelMode = ANDROID_HOT_PIXEL_MODE_FAST; 2589 demosaicMode = ANDROID_DEMOSAIC_MODE_FAST; 2590 noiseMode = ANDROID_NOISE_REDUCTION_MODE_FAST; 2591 shadingMode = ANDROID_SHADING_MODE_FAST; 2592 geometricMode = ANDROID_GEOMETRIC_MODE_FAST; 2593 colorMode = ANDROID_COLOR_CORRECTION_MODE_FAST; 2594 tonemapMode = ANDROID_TONEMAP_MODE_FAST; 2595 edgeMode = ANDROID_EDGE_MODE_FAST; 2596 break; 2597 } 2598 ADD_OR_SIZE(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1); 2599 ADD_OR_SIZE(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1); 2600 ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_MODE, &noiseMode, 1); 2601 ADD_OR_SIZE(ANDROID_SHADING_MODE, &shadingMode, 1); 2602 ADD_OR_SIZE(ANDROID_GEOMETRIC_MODE, &geometricMode, 1); 2603 ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_MODE, &colorMode, 1); 2604 ADD_OR_SIZE(ANDROID_TONEMAP_MODE, &tonemapMode, 1); 2605 ADD_OR_SIZE(ANDROID_EDGE_MODE, &edgeMode, 1); 2606 2607 /** android.noise */ 2608 static const uint8_t noiseStrength = 5; 2609 ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_STRENGTH, &noiseStrength, 1); 2610 2611 /** android.color */ 2612 static const float colorTransform[9] = { 2613 1.0f, 0.f, 0.f, 2614 0.f, 1.f, 0.f, 2615 0.f, 0.f, 1.f 2616 }; 2617 ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_TRANSFORM, colorTransform, 9); 2618 2619 /** android.tonemap */ 2620 static const float tonemapCurve[4] = { 2621 0.f, 0.f, 2622 1.f, 1.f 2623 }; 2624 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 4); 2625 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 4); 2626 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 4); 2627 2628 /** android.edge */ 2629 static const uint8_t edgeStrength = 5; 2630 ADD_OR_SIZE(ANDROID_EDGE_STRENGTH, &edgeStrength, 1); 2631 2632 /** android.scaler */ 2633 static const int32_t cropRegion[3] = { 2634 0, 0, Sensor::kResolution[0] 2635 }; 2636 ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3); 2637 2638 /** android.jpeg */ 2639 static const int32_t jpegQuality = 80; 2640 ADD_OR_SIZE(ANDROID_JPEG_QUALITY, &jpegQuality, 1); 2641 2642 static const int32_t thumbnailSize[2] = { 2643 640, 480 2644 }; 2645 ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2); 2646 2647 static const int32_t thumbnailQuality = 80; 2648 ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1); 2649 2650 static const double gpsCoordinates[2] = { 2651 0, 0 2652 }; 2653 ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 2); 2654 2655 static const uint8_t gpsProcessingMethod[32] = "None"; 2656 ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32); 2657 2658 static const int64_t gpsTimestamp = 0; 2659 ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1); 2660 2661 static const int32_t jpegOrientation = 0; 2662 ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1); 2663 2664 /** android.stats */ 2665 2666 static const uint8_t faceDetectMode = 2667 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF; 2668 ADD_OR_SIZE(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1); 2669 2670 static const uint8_t histogramMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF; 2671 ADD_OR_SIZE(ANDROID_STATISTICS_HISTOGRAM_MODE, &histogramMode, 1); 2672 2673 static const uint8_t sharpnessMapMode = 2674 ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF; 2675 ADD_OR_SIZE(ANDROID_STATISTICS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1); 2676 2677 // faceRectangles, faceScores, faceLandmarks, faceIds, histogram, 2678 // sharpnessMap only in frames 2679 2680 /** android.control */ 2681 2682 uint8_t controlIntent = 0; 2683 switch (request_template) { 2684 case CAMERA2_TEMPLATE_PREVIEW: 2685 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; 2686 break; 2687 case CAMERA2_TEMPLATE_STILL_CAPTURE: 2688 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE; 2689 break; 2690 case CAMERA2_TEMPLATE_VIDEO_RECORD: 2691 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD; 2692 break; 2693 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: 2694 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT; 2695 break; 2696 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: 2697 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG; 2698 break; 2699 default: 2700 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM; 2701 break; 2702 } 2703 ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1); 2704 2705 static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO; 2706 ADD_OR_SIZE(ANDROID_CONTROL_MODE, &controlMode, 1); 2707 2708 static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; 2709 ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1); 2710 2711 static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; 2712 ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1); 2713 2714 static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH; 2715 ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE, &aeMode, 1); 2716 2717 static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF; 2718 ADD_OR_SIZE(ANDROID_CONTROL_AE_LOCK, &aeLock, 1); 2719 2720 static const int32_t controlRegions[5] = { 2721 0, 0, Sensor::kResolution[0], Sensor::kResolution[1], 1000 2722 }; 2723 ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5); 2724 2725 static const int32_t aeExpCompensation = 0; 2726 ADD_OR_SIZE(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExpCompensation, 1); 2727 2728 static const int32_t aeTargetFpsRange[2] = { 2729 10, 30 2730 }; 2731 ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2); 2732 2733 static const uint8_t aeAntibandingMode = 2734 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO; 2735 ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1); 2736 2737 static const uint8_t awbMode = 2738 ANDROID_CONTROL_AWB_MODE_AUTO; 2739 ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE, &awbMode, 1); 2740 2741 static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF; 2742 ADD_OR_SIZE(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1); 2743 2744 ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5); 2745 2746 uint8_t afMode = 0; 2747 switch (request_template) { 2748 case CAMERA2_TEMPLATE_PREVIEW: 2749 afMode = ANDROID_CONTROL_AF_MODE_AUTO; 2750 break; 2751 case CAMERA2_TEMPLATE_STILL_CAPTURE: 2752 afMode = ANDROID_CONTROL_AF_MODE_AUTO; 2753 break; 2754 case CAMERA2_TEMPLATE_VIDEO_RECORD: 2755 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO; 2756 break; 2757 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT: 2758 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO; 2759 break; 2760 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG: 2761 afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE; 2762 break; 2763 default: 2764 afMode = ANDROID_CONTROL_AF_MODE_AUTO; 2765 break; 2766 } 2767 ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE, &afMode, 1); 2768 2769 ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5); 2770 2771 static const uint8_t vstabMode = 2772 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF; 2773 ADD_OR_SIZE(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1); 2774 2775 // aeState, awbState, afState only in frame 2776 2777 /** Allocate metadata if sizing */ 2778 if (sizeRequest) { 2779 ALOGV("Allocating %d entries, %d extra bytes for " 2780 "request template type %d", 2781 entryCount, dataCount, request_template); 2782 *request = allocate_camera_metadata(entryCount, dataCount); 2783 if (*request == NULL) { 2784 ALOGE("Unable to allocate new request template type %d " 2785 "(%d entries, %d bytes extra data)", request_template, 2786 entryCount, dataCount); 2787 return NO_MEMORY; 2788 } 2789 } 2790 return OK; 2791 #undef ADD_OR_SIZE 2792 } 2793 2794 status_t EmulatedFakeCamera2::addOrSize(camera_metadata_t *request, 2795 bool sizeRequest, 2796 size_t *entryCount, 2797 size_t *dataCount, 2798 uint32_t tag, 2799 const void *entryData, 2800 size_t entryDataCount) { 2801 status_t res; 2802 if (!sizeRequest) { 2803 return add_camera_metadata_entry(request, tag, entryData, 2804 entryDataCount); 2805 } else { 2806 int type = get_camera_metadata_tag_type(tag); 2807 if (type < 0 ) return BAD_VALUE; 2808 (*entryCount)++; 2809 (*dataCount) += calculate_camera_metadata_entry_data_size(type, 2810 entryDataCount); 2811 return OK; 2812 } 2813 } 2814 2815 bool EmulatedFakeCamera2::isStreamInUse(uint32_t id) { 2816 // Assumes mMutex is locked; otherwise new requests could enter 2817 // configureThread while readoutThread is being checked 2818 2819 // Order of isStreamInUse calls matters 2820 if (mConfigureThread->isStreamInUse(id) || 2821 mReadoutThread->isStreamInUse(id) || 2822 mJpegCompressor->isStreamInUse(id) ) { 2823 ALOGE("%s: Stream %d is in use in active requests!", 2824 __FUNCTION__, id); 2825 return true; 2826 } 2827 return false; 2828 } 2829 2830 bool EmulatedFakeCamera2::isReprocessStreamInUse(uint32_t id) { 2831 // TODO: implement 2832 return false; 2833 } 2834 2835 const Stream& EmulatedFakeCamera2::getStreamInfo(uint32_t streamId) { 2836 Mutex::Autolock lock(mMutex); 2837 2838 return mStreams.valueFor(streamId); 2839 } 2840 2841 const ReprocessStream& EmulatedFakeCamera2::getReprocessStreamInfo(uint32_t streamId) { 2842 Mutex::Autolock lock(mMutex); 2843 2844 return mReprocessStreams.valueFor(streamId); 2845 } 2846 2847 }; /* namespace android */ 2848
