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 #define LOG_TAG "Camera2-Device" 18 #define ATRACE_TAG ATRACE_TAG_CAMERA 19 //#define LOG_NDEBUG 0 20 //#define LOG_NNDEBUG 0 // Per-frame verbose logging 21 22 #ifdef LOG_NNDEBUG 23 #define ALOGVV(...) ALOGV(__VA_ARGS__) 24 #else 25 #define ALOGVV(...) ((void)0) 26 #endif 27 28 #include <inttypes.h> 29 #include <utils/Log.h> 30 #include <utils/Trace.h> 31 #include <utils/Timers.h> 32 #include "Camera2Device.h" 33 #include "CameraService.h" 34 35 namespace android { 36 37 Camera2Device::Camera2Device(int id): 38 mId(id), 39 mHal2Device(NULL) 40 { 41 ATRACE_CALL(); 42 ALOGV("%s: Created device for camera %d", __FUNCTION__, id); 43 } 44 45 Camera2Device::~Camera2Device() 46 { 47 ATRACE_CALL(); 48 ALOGV("%s: Tearing down for camera id %d", __FUNCTION__, mId); 49 disconnect(); 50 } 51 52 int Camera2Device::getId() const { 53 return mId; 54 } 55 56 status_t Camera2Device::initialize(camera_module_t *module) 57 { 58 ATRACE_CALL(); 59 ALOGV("%s: Initializing device for camera %d", __FUNCTION__, mId); 60 if (mHal2Device != NULL) { 61 ALOGE("%s: Already initialized!", __FUNCTION__); 62 return INVALID_OPERATION; 63 } 64 65 status_t res; 66 char name[10]; 67 snprintf(name, sizeof(name), "%d", mId); 68 69 camera2_device_t *device; 70 71 res = CameraService::filterOpenErrorCode(module->common.methods->open( 72 &module->common, name, reinterpret_cast<hw_device_t**>(&device))); 73 74 if (res != OK) { 75 ALOGE("%s: Could not open camera %d: %s (%d)", __FUNCTION__, 76 mId, strerror(-res), res); 77 return res; 78 } 79 80 if (device->common.version != CAMERA_DEVICE_API_VERSION_2_0) { 81 ALOGE("%s: Could not open camera %d: " 82 "Camera device is not version %x, reports %x instead", 83 __FUNCTION__, mId, CAMERA_DEVICE_API_VERSION_2_0, 84 device->common.version); 85 device->common.close(&device->common); 86 return BAD_VALUE; 87 } 88 89 camera_info info; 90 res = module->get_camera_info(mId, &info); 91 if (res != OK ) return res; 92 93 if (info.device_version != device->common.version) { 94 ALOGE("%s: HAL reporting mismatched camera_info version (%x)" 95 " and device version (%x).", __FUNCTION__, 96 device->common.version, info.device_version); 97 device->common.close(&device->common); 98 return BAD_VALUE; 99 } 100 101 res = mRequestQueue.setConsumerDevice(device); 102 if (res != OK) { 103 ALOGE("%s: Camera %d: Unable to connect request queue to device: %s (%d)", 104 __FUNCTION__, mId, strerror(-res), res); 105 device->common.close(&device->common); 106 return res; 107 } 108 res = mFrameQueue.setProducerDevice(device); 109 if (res != OK) { 110 ALOGE("%s: Camera %d: Unable to connect frame queue to device: %s (%d)", 111 __FUNCTION__, mId, strerror(-res), res); 112 device->common.close(&device->common); 113 return res; 114 } 115 116 res = device->ops->set_notify_callback(device, notificationCallback, 117 NULL); 118 if (res != OK) { 119 ALOGE("%s: Camera %d: Unable to initialize notification callback!", 120 __FUNCTION__, mId); 121 device->common.close(&device->common); 122 return res; 123 } 124 125 mDeviceInfo = info.static_camera_characteristics; 126 mHal2Device = device; 127 mDeviceVersion = device->common.version; 128 129 return OK; 130 } 131 132 status_t Camera2Device::disconnect() { 133 ATRACE_CALL(); 134 status_t res = OK; 135 if (mHal2Device) { 136 ALOGV("%s: Closing device for camera %d", __FUNCTION__, mId); 137 138 int inProgressCount = mHal2Device->ops->get_in_progress_count(mHal2Device); 139 if (inProgressCount > 0) { 140 ALOGW("%s: Closing camera device %d with %d requests in flight!", 141 __FUNCTION__, mId, inProgressCount); 142 } 143 mReprocessStreams.clear(); 144 mStreams.clear(); 145 res = mHal2Device->common.close(&mHal2Device->common); 146 if (res != OK) { 147 ALOGE("%s: Could not close camera %d: %s (%d)", 148 __FUNCTION__, 149 mId, strerror(-res), res); 150 } 151 mHal2Device = NULL; 152 ALOGV("%s: Shutdown complete", __FUNCTION__); 153 } 154 return res; 155 } 156 157 status_t Camera2Device::dump(int fd, const Vector<String16>& args) { 158 ATRACE_CALL(); 159 String8 result; 160 int detailLevel = 0; 161 int n = args.size(); 162 String16 detailOption("-d"); 163 for (int i = 0; i + 1 < n; i++) { 164 if (args[i] == detailOption) { 165 String8 levelStr(args[i+1]); 166 detailLevel = atoi(levelStr.string()); 167 } 168 } 169 170 result.appendFormat(" Camera2Device[%d] dump (detail level %d):\n", 171 mId, detailLevel); 172 173 if (detailLevel > 0) { 174 result = " Request queue contents:\n"; 175 write(fd, result.string(), result.size()); 176 mRequestQueue.dump(fd, args); 177 178 result = " Frame queue contents:\n"; 179 write(fd, result.string(), result.size()); 180 mFrameQueue.dump(fd, args); 181 } 182 183 result = " Active streams:\n"; 184 write(fd, result.string(), result.size()); 185 for (StreamList::iterator s = mStreams.begin(); s != mStreams.end(); s++) { 186 (*s)->dump(fd, args); 187 } 188 189 result = " HAL device dump:\n"; 190 write(fd, result.string(), result.size()); 191 192 status_t res; 193 res = mHal2Device->ops->dump(mHal2Device, fd); 194 195 return res; 196 } 197 198 const CameraMetadata& Camera2Device::info() const { 199 ALOGVV("%s: E", __FUNCTION__); 200 201 return mDeviceInfo; 202 } 203 204 status_t Camera2Device::capture(CameraMetadata &request, int64_t* /*lastFrameNumber*/) { 205 ATRACE_CALL(); 206 ALOGV("%s: E", __FUNCTION__); 207 208 mRequestQueue.enqueue(request.release()); 209 return OK; 210 } 211 212 status_t Camera2Device::captureList(const List<const CameraMetadata> &requests, 213 int64_t* /*lastFrameNumber*/) { 214 ATRACE_CALL(); 215 ALOGE("%s: Camera2Device burst capture not implemented", __FUNCTION__); 216 return INVALID_OPERATION; 217 } 218 219 status_t Camera2Device::setStreamingRequest(const CameraMetadata &request, 220 int64_t* /*lastFrameNumber*/) { 221 ATRACE_CALL(); 222 ALOGV("%s: E", __FUNCTION__); 223 CameraMetadata streamRequest(request); 224 return mRequestQueue.setStreamSlot(streamRequest.release()); 225 } 226 227 status_t Camera2Device::setStreamingRequestList(const List<const CameraMetadata> &requests, 228 int64_t* /*lastFrameNumber*/) { 229 ATRACE_CALL(); 230 ALOGE("%s, Camera2Device streaming burst not implemented", __FUNCTION__); 231 return INVALID_OPERATION; 232 } 233 234 status_t Camera2Device::clearStreamingRequest(int64_t* /*lastFrameNumber*/) { 235 ATRACE_CALL(); 236 return mRequestQueue.setStreamSlot(NULL); 237 } 238 239 status_t Camera2Device::waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) { 240 ATRACE_CALL(); 241 return mRequestQueue.waitForDequeue(requestId, timeout); 242 } 243 244 status_t Camera2Device::createStream(sp<ANativeWindow> consumer, 245 uint32_t width, uint32_t height, int format, int *id) { 246 ATRACE_CALL(); 247 status_t res; 248 ALOGV("%s: E", __FUNCTION__); 249 250 sp<StreamAdapter> stream = new StreamAdapter(mHal2Device); 251 size_t size = 0; 252 if (format == HAL_PIXEL_FORMAT_BLOB) { 253 size = getJpegBufferSize(width, height); 254 } 255 res = stream->connectToDevice(consumer, width, height, format, size); 256 if (res != OK) { 257 ALOGE("%s: Camera %d: Unable to create stream (%d x %d, format %x):" 258 "%s (%d)", 259 __FUNCTION__, mId, width, height, format, strerror(-res), res); 260 return res; 261 } 262 263 *id = stream->getId(); 264 265 mStreams.push_back(stream); 266 return OK; 267 } 268 269 ssize_t Camera2Device::getJpegBufferSize(uint32_t width, uint32_t height) const { 270 // Always give the max jpeg buffer size regardless of the actual jpeg resolution. 271 camera_metadata_ro_entry jpegBufMaxSize = mDeviceInfo.find(ANDROID_JPEG_MAX_SIZE); 272 if (jpegBufMaxSize.count == 0) { 273 ALOGE("%s: Camera %d: Can't find maximum JPEG size in static metadata!", __FUNCTION__, mId); 274 return BAD_VALUE; 275 } 276 277 return jpegBufMaxSize.data.i32[0]; 278 } 279 280 status_t Camera2Device::createReprocessStreamFromStream(int outputId, int *id) { 281 ATRACE_CALL(); 282 status_t res; 283 ALOGV("%s: E", __FUNCTION__); 284 285 bool found = false; 286 StreamList::iterator streamI; 287 for (streamI = mStreams.begin(); 288 streamI != mStreams.end(); streamI++) { 289 if ((*streamI)->getId() == outputId) { 290 found = true; 291 break; 292 } 293 } 294 if (!found) { 295 ALOGE("%s: Camera %d: Output stream %d doesn't exist; can't create " 296 "reprocess stream from it!", __FUNCTION__, mId, outputId); 297 return BAD_VALUE; 298 } 299 300 sp<ReprocessStreamAdapter> stream = new ReprocessStreamAdapter(mHal2Device); 301 302 res = stream->connectToDevice((*streamI)); 303 if (res != OK) { 304 ALOGE("%s: Camera %d: Unable to create reprocessing stream from "\ 305 "stream %d: %s (%d)", __FUNCTION__, mId, outputId, 306 strerror(-res), res); 307 return res; 308 } 309 310 *id = stream->getId(); 311 312 mReprocessStreams.push_back(stream); 313 return OK; 314 } 315 316 317 status_t Camera2Device::getStreamInfo(int id, 318 uint32_t *width, uint32_t *height, uint32_t *format) { 319 ATRACE_CALL(); 320 ALOGV("%s: E", __FUNCTION__); 321 bool found = false; 322 StreamList::iterator streamI; 323 for (streamI = mStreams.begin(); 324 streamI != mStreams.end(); streamI++) { 325 if ((*streamI)->getId() == id) { 326 found = true; 327 break; 328 } 329 } 330 if (!found) { 331 ALOGE("%s: Camera %d: Stream %d does not exist", 332 __FUNCTION__, mId, id); 333 return BAD_VALUE; 334 } 335 336 if (width) *width = (*streamI)->getWidth(); 337 if (height) *height = (*streamI)->getHeight(); 338 if (format) *format = (*streamI)->getFormat(); 339 340 return OK; 341 } 342 343 status_t Camera2Device::setStreamTransform(int id, 344 int transform) { 345 ATRACE_CALL(); 346 ALOGV("%s: E", __FUNCTION__); 347 bool found = false; 348 StreamList::iterator streamI; 349 for (streamI = mStreams.begin(); 350 streamI != mStreams.end(); streamI++) { 351 if ((*streamI)->getId() == id) { 352 found = true; 353 break; 354 } 355 } 356 if (!found) { 357 ALOGE("%s: Camera %d: Stream %d does not exist", 358 __FUNCTION__, mId, id); 359 return BAD_VALUE; 360 } 361 362 return (*streamI)->setTransform(transform); 363 } 364 365 status_t Camera2Device::deleteStream(int id) { 366 ATRACE_CALL(); 367 ALOGV("%s: E", __FUNCTION__); 368 bool found = false; 369 for (StreamList::iterator streamI = mStreams.begin(); 370 streamI != mStreams.end(); streamI++) { 371 if ((*streamI)->getId() == id) { 372 status_t res = (*streamI)->release(); 373 if (res != OK) { 374 ALOGE("%s: Unable to release stream %d from HAL device: " 375 "%s (%d)", __FUNCTION__, id, strerror(-res), res); 376 return res; 377 } 378 mStreams.erase(streamI); 379 found = true; 380 break; 381 } 382 } 383 if (!found) { 384 ALOGE("%s: Camera %d: Unable to find stream %d to delete", 385 __FUNCTION__, mId, id); 386 return BAD_VALUE; 387 } 388 return OK; 389 } 390 391 status_t Camera2Device::deleteReprocessStream(int id) { 392 ATRACE_CALL(); 393 ALOGV("%s: E", __FUNCTION__); 394 bool found = false; 395 for (ReprocessStreamList::iterator streamI = mReprocessStreams.begin(); 396 streamI != mReprocessStreams.end(); streamI++) { 397 if ((*streamI)->getId() == id) { 398 status_t res = (*streamI)->release(); 399 if (res != OK) { 400 ALOGE("%s: Unable to release reprocess stream %d from " 401 "HAL device: %s (%d)", __FUNCTION__, id, 402 strerror(-res), res); 403 return res; 404 } 405 mReprocessStreams.erase(streamI); 406 found = true; 407 break; 408 } 409 } 410 if (!found) { 411 ALOGE("%s: Camera %d: Unable to find stream %d to delete", 412 __FUNCTION__, mId, id); 413 return BAD_VALUE; 414 } 415 return OK; 416 } 417 418 status_t Camera2Device::configureStreams() { 419 ATRACE_CALL(); 420 ALOGV("%s: E", __FUNCTION__); 421 422 /** 423 * HAL2 devices do not need to configure streams; 424 * streams are created on the fly. 425 */ 426 ALOGW("%s: No-op for HAL2 devices", __FUNCTION__); 427 428 return OK; 429 } 430 431 432 status_t Camera2Device::createDefaultRequest(int templateId, 433 CameraMetadata *request) { 434 ATRACE_CALL(); 435 status_t err; 436 ALOGV("%s: E", __FUNCTION__); 437 camera_metadata_t *rawRequest; 438 err = mHal2Device->ops->construct_default_request( 439 mHal2Device, templateId, &rawRequest); 440 request->acquire(rawRequest); 441 return err; 442 } 443 444 status_t Camera2Device::waitUntilDrained() { 445 ATRACE_CALL(); 446 static const uint32_t kSleepTime = 50000; // 50 ms 447 static const uint32_t kMaxSleepTime = 10000000; // 10 s 448 ALOGV("%s: Camera %d: Starting wait", __FUNCTION__, mId); 449 if (mRequestQueue.getBufferCount() == 450 CAMERA2_REQUEST_QUEUE_IS_BOTTOMLESS) return INVALID_OPERATION; 451 452 // TODO: Set up notifications from HAL, instead of sleeping here 453 uint32_t totalTime = 0; 454 while (mHal2Device->ops->get_in_progress_count(mHal2Device) > 0) { 455 usleep(kSleepTime); 456 totalTime += kSleepTime; 457 if (totalTime > kMaxSleepTime) { 458 ALOGE("%s: Waited %d us, %d requests still in flight", __FUNCTION__, 459 totalTime, mHal2Device->ops->get_in_progress_count(mHal2Device)); 460 return TIMED_OUT; 461 } 462 } 463 ALOGV("%s: Camera %d: HAL is idle", __FUNCTION__, mId); 464 return OK; 465 } 466 467 status_t Camera2Device::setNotifyCallback(NotificationListener *listener) { 468 ATRACE_CALL(); 469 status_t res; 470 res = mHal2Device->ops->set_notify_callback(mHal2Device, notificationCallback, 471 reinterpret_cast<void*>(listener) ); 472 if (res != OK) { 473 ALOGE("%s: Unable to set notification callback!", __FUNCTION__); 474 } 475 return res; 476 } 477 478 bool Camera2Device::willNotify3A() { 479 return true; 480 } 481 482 void Camera2Device::notificationCallback(int32_t msg_type, 483 int32_t ext1, 484 int32_t ext2, 485 int32_t ext3, 486 void *user) { 487 ATRACE_CALL(); 488 NotificationListener *listener = reinterpret_cast<NotificationListener*>(user); 489 ALOGV("%s: Notification %d, arguments %d, %d, %d", __FUNCTION__, msg_type, 490 ext1, ext2, ext3); 491 if (listener != NULL) { 492 switch (msg_type) { 493 case CAMERA2_MSG_ERROR: 494 // TODO: This needs to be fixed. ext2 and ext3 need to be considered. 495 listener->notifyError( 496 ((ext1 == CAMERA2_MSG_ERROR_DEVICE) 497 || (ext1 == CAMERA2_MSG_ERROR_HARDWARE)) ? 498 ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE : 499 ICameraDeviceCallbacks::ERROR_CAMERA_SERVICE, 500 CaptureResultExtras()); 501 break; 502 case CAMERA2_MSG_SHUTTER: { 503 // TODO: Only needed for camera2 API, which is unsupported 504 // by HAL2 directly. 505 // nsecs_t timestamp = (nsecs_t)ext2 | ((nsecs_t)(ext3) << 32 ); 506 // listener->notifyShutter(requestId, timestamp); 507 break; 508 } 509 case CAMERA2_MSG_AUTOFOCUS: 510 listener->notifyAutoFocus(ext1, ext2); 511 break; 512 case CAMERA2_MSG_AUTOEXPOSURE: 513 listener->notifyAutoExposure(ext1, ext2); 514 break; 515 case CAMERA2_MSG_AUTOWB: 516 listener->notifyAutoWhitebalance(ext1, ext2); 517 break; 518 default: 519 ALOGE("%s: Unknown notification %d (arguments %d, %d, %d)!", 520 __FUNCTION__, msg_type, ext1, ext2, ext3); 521 } 522 } 523 } 524 525 status_t Camera2Device::waitForNextFrame(nsecs_t timeout) { 526 return mFrameQueue.waitForBuffer(timeout); 527 } 528 529 status_t Camera2Device::getNextResult(CaptureResult *result) { 530 ATRACE_CALL(); 531 ALOGV("%s: get CaptureResult", __FUNCTION__); 532 if (result == NULL) { 533 ALOGE("%s: result pointer is NULL", __FUNCTION__); 534 return BAD_VALUE; 535 } 536 status_t res; 537 camera_metadata_t *rawFrame; 538 res = mFrameQueue.dequeue(&rawFrame); 539 if (rawFrame == NULL) { 540 return NOT_ENOUGH_DATA; 541 } else if (res == OK) { 542 result->mMetadata.acquire(rawFrame); 543 } 544 545 return res; 546 } 547 548 status_t Camera2Device::triggerAutofocus(uint32_t id) { 549 ATRACE_CALL(); 550 status_t res; 551 ALOGV("%s: Triggering autofocus, id %d", __FUNCTION__, id); 552 res = mHal2Device->ops->trigger_action(mHal2Device, 553 CAMERA2_TRIGGER_AUTOFOCUS, id, 0); 554 if (res != OK) { 555 ALOGE("%s: Error triggering autofocus (id %d)", 556 __FUNCTION__, id); 557 } 558 return res; 559 } 560 561 status_t Camera2Device::triggerCancelAutofocus(uint32_t id) { 562 ATRACE_CALL(); 563 status_t res; 564 ALOGV("%s: Canceling autofocus, id %d", __FUNCTION__, id); 565 res = mHal2Device->ops->trigger_action(mHal2Device, 566 CAMERA2_TRIGGER_CANCEL_AUTOFOCUS, id, 0); 567 if (res != OK) { 568 ALOGE("%s: Error canceling autofocus (id %d)", 569 __FUNCTION__, id); 570 } 571 return res; 572 } 573 574 status_t Camera2Device::triggerPrecaptureMetering(uint32_t id) { 575 ATRACE_CALL(); 576 status_t res; 577 ALOGV("%s: Triggering precapture metering, id %d", __FUNCTION__, id); 578 res = mHal2Device->ops->trigger_action(mHal2Device, 579 CAMERA2_TRIGGER_PRECAPTURE_METERING, id, 0); 580 if (res != OK) { 581 ALOGE("%s: Error triggering precapture metering (id %d)", 582 __FUNCTION__, id); 583 } 584 return res; 585 } 586 587 status_t Camera2Device::pushReprocessBuffer(int reprocessStreamId, 588 buffer_handle_t *buffer, wp<BufferReleasedListener> listener) { 589 ATRACE_CALL(); 590 ALOGV("%s: E", __FUNCTION__); 591 bool found = false; 592 status_t res = OK; 593 for (ReprocessStreamList::iterator streamI = mReprocessStreams.begin(); 594 streamI != mReprocessStreams.end(); streamI++) { 595 if ((*streamI)->getId() == reprocessStreamId) { 596 res = (*streamI)->pushIntoStream(buffer, listener); 597 if (res != OK) { 598 ALOGE("%s: Unable to push buffer to reprocess stream %d: %s (%d)", 599 __FUNCTION__, reprocessStreamId, strerror(-res), res); 600 return res; 601 } 602 found = true; 603 break; 604 } 605 } 606 if (!found) { 607 ALOGE("%s: Camera %d: Unable to find reprocess stream %d", 608 __FUNCTION__, mId, reprocessStreamId); 609 res = BAD_VALUE; 610 } 611 return res; 612 } 613 614 status_t Camera2Device::flush(int64_t* /*lastFrameNumber*/) { 615 ATRACE_CALL(); 616 617 mRequestQueue.clear(); 618 return waitUntilDrained(); 619 } 620 621 uint32_t Camera2Device::getDeviceVersion() { 622 ATRACE_CALL(); 623 return mDeviceVersion; 624 } 625 626 /** 627 * Camera2Device::MetadataQueue 628 */ 629 630 Camera2Device::MetadataQueue::MetadataQueue(): 631 mHal2Device(NULL), 632 mFrameCount(0), 633 mLatestRequestId(0), 634 mCount(0), 635 mStreamSlotCount(0), 636 mSignalConsumer(true) 637 { 638 ATRACE_CALL(); 639 camera2_request_queue_src_ops::dequeue_request = consumer_dequeue; 640 camera2_request_queue_src_ops::request_count = consumer_buffer_count; 641 camera2_request_queue_src_ops::free_request = consumer_free; 642 643 camera2_frame_queue_dst_ops::dequeue_frame = producer_dequeue; 644 camera2_frame_queue_dst_ops::cancel_frame = producer_cancel; 645 camera2_frame_queue_dst_ops::enqueue_frame = producer_enqueue; 646 } 647 648 Camera2Device::MetadataQueue::~MetadataQueue() { 649 ATRACE_CALL(); 650 clear(); 651 } 652 653 // Connect to camera2 HAL as consumer (input requests/reprocessing) 654 status_t Camera2Device::MetadataQueue::setConsumerDevice(camera2_device_t *d) { 655 ATRACE_CALL(); 656 status_t res; 657 res = d->ops->set_request_queue_src_ops(d, 658 this); 659 if (res != OK) return res; 660 mHal2Device = d; 661 return OK; 662 } 663 664 status_t Camera2Device::MetadataQueue::setProducerDevice(camera2_device_t *d) { 665 ATRACE_CALL(); 666 status_t res; 667 res = d->ops->set_frame_queue_dst_ops(d, 668 this); 669 return res; 670 } 671 672 // Real interfaces 673 status_t Camera2Device::MetadataQueue::enqueue(camera_metadata_t *buf) { 674 ATRACE_CALL(); 675 ALOGVV("%s: E", __FUNCTION__); 676 Mutex::Autolock l(mMutex); 677 678 mCount++; 679 mEntries.push_back(buf); 680 681 return signalConsumerLocked(); 682 } 683 684 int Camera2Device::MetadataQueue::getBufferCount() { 685 ATRACE_CALL(); 686 Mutex::Autolock l(mMutex); 687 if (mStreamSlotCount > 0) { 688 return CAMERA2_REQUEST_QUEUE_IS_BOTTOMLESS; 689 } 690 return mCount; 691 } 692 693 status_t Camera2Device::MetadataQueue::dequeue(camera_metadata_t **buf, 694 bool incrementCount) 695 { 696 ATRACE_CALL(); 697 ALOGVV("%s: E", __FUNCTION__); 698 status_t res; 699 Mutex::Autolock l(mMutex); 700 701 if (mCount == 0) { 702 if (mStreamSlotCount == 0) { 703 ALOGVV("%s: Empty", __FUNCTION__); 704 *buf = NULL; 705 mSignalConsumer = true; 706 return OK; 707 } 708 ALOGVV("%s: Streaming %d frames to queue", __FUNCTION__, 709 mStreamSlotCount); 710 711 for (List<camera_metadata_t*>::iterator slotEntry = mStreamSlot.begin(); 712 slotEntry != mStreamSlot.end(); 713 slotEntry++ ) { 714 size_t entries = get_camera_metadata_entry_count(*slotEntry); 715 size_t dataBytes = get_camera_metadata_data_count(*slotEntry); 716 717 camera_metadata_t *copy = 718 allocate_camera_metadata(entries, dataBytes); 719 append_camera_metadata(copy, *slotEntry); 720 mEntries.push_back(copy); 721 } 722 mCount = mStreamSlotCount; 723 } 724 ALOGVV("MetadataQueue: deque (%d buffers)", mCount); 725 camera_metadata_t *b = *(mEntries.begin()); 726 mEntries.erase(mEntries.begin()); 727 728 if (incrementCount) { 729 ATRACE_INT("cam2_request", mFrameCount); 730 camera_metadata_entry_t frameCount; 731 res = find_camera_metadata_entry(b, 732 ANDROID_REQUEST_FRAME_COUNT, 733 &frameCount); 734 if (res != OK) { 735 ALOGE("%s: Unable to add frame count: %s (%d)", 736 __FUNCTION__, strerror(-res), res); 737 } else { 738 *frameCount.data.i32 = mFrameCount; 739 } 740 mFrameCount++; 741 } 742 743 // Check for request ID, and if present, signal waiters. 744 camera_metadata_entry_t requestId; 745 res = find_camera_metadata_entry(b, 746 ANDROID_REQUEST_ID, 747 &requestId); 748 if (res == OK) { 749 mLatestRequestId = requestId.data.i32[0]; 750 mNewRequestId.signal(); 751 } 752 753 *buf = b; 754 mCount--; 755 756 return OK; 757 } 758 759 status_t Camera2Device::MetadataQueue::waitForBuffer(nsecs_t timeout) 760 { 761 Mutex::Autolock l(mMutex); 762 status_t res; 763 while (mCount == 0) { 764 res = notEmpty.waitRelative(mMutex,timeout); 765 if (res != OK) return res; 766 } 767 return OK; 768 } 769 770 status_t Camera2Device::MetadataQueue::waitForDequeue(int32_t id, 771 nsecs_t timeout) { 772 Mutex::Autolock l(mMutex); 773 status_t res; 774 while (mLatestRequestId != id) { 775 nsecs_t startTime = systemTime(); 776 777 res = mNewRequestId.waitRelative(mMutex, timeout); 778 if (res != OK) return res; 779 780 timeout -= (systemTime() - startTime); 781 } 782 783 return OK; 784 } 785 786 status_t Camera2Device::MetadataQueue::setStreamSlot(camera_metadata_t *buf) 787 { 788 ATRACE_CALL(); 789 ALOGV("%s: E", __FUNCTION__); 790 Mutex::Autolock l(mMutex); 791 if (buf == NULL) { 792 freeBuffers(mStreamSlot.begin(), mStreamSlot.end()); 793 mStreamSlotCount = 0; 794 return OK; 795 } 796 camera_metadata_t *buf2 = clone_camera_metadata(buf); 797 if (!buf2) { 798 ALOGE("%s: Unable to clone metadata buffer!", __FUNCTION__); 799 return NO_MEMORY; 800 } 801 802 if (mStreamSlotCount > 1) { 803 List<camera_metadata_t*>::iterator deleter = ++mStreamSlot.begin(); 804 freeBuffers(++mStreamSlot.begin(), mStreamSlot.end()); 805 mStreamSlotCount = 1; 806 } 807 if (mStreamSlotCount == 1) { 808 free_camera_metadata( *(mStreamSlot.begin()) ); 809 *(mStreamSlot.begin()) = buf2; 810 } else { 811 mStreamSlot.push_front(buf2); 812 mStreamSlotCount = 1; 813 } 814 return signalConsumerLocked(); 815 } 816 817 status_t Camera2Device::MetadataQueue::setStreamSlot( 818 const List<camera_metadata_t*> &bufs) 819 { 820 ATRACE_CALL(); 821 ALOGV("%s: E", __FUNCTION__); 822 Mutex::Autolock l(mMutex); 823 824 if (mStreamSlotCount > 0) { 825 freeBuffers(mStreamSlot.begin(), mStreamSlot.end()); 826 } 827 mStreamSlotCount = 0; 828 for (List<camera_metadata_t*>::const_iterator r = bufs.begin(); 829 r != bufs.end(); r++) { 830 camera_metadata_t *r2 = clone_camera_metadata(*r); 831 if (!r2) { 832 ALOGE("%s: Unable to clone metadata buffer!", __FUNCTION__); 833 return NO_MEMORY; 834 } 835 mStreamSlot.push_back(r2); 836 mStreamSlotCount++; 837 } 838 return signalConsumerLocked(); 839 } 840 841 status_t Camera2Device::MetadataQueue::clear() 842 { 843 ATRACE_CALL(); 844 ALOGV("%s: E", __FUNCTION__); 845 846 Mutex::Autolock l(mMutex); 847 848 // Clear streaming slot 849 freeBuffers(mStreamSlot.begin(), mStreamSlot.end()); 850 mStreamSlotCount = 0; 851 852 // Clear request queue 853 freeBuffers(mEntries.begin(), mEntries.end()); 854 mCount = 0; 855 return OK; 856 } 857 858 status_t Camera2Device::MetadataQueue::dump(int fd, 859 const Vector<String16>& /*args*/) { 860 ATRACE_CALL(); 861 String8 result; 862 status_t notLocked; 863 notLocked = mMutex.tryLock(); 864 if (notLocked) { 865 result.append(" (Unable to lock queue mutex)\n"); 866 } 867 result.appendFormat(" Current frame number: %d\n", mFrameCount); 868 if (mStreamSlotCount == 0) { 869 result.append(" Stream slot: Empty\n"); 870 write(fd, result.string(), result.size()); 871 } else { 872 result.appendFormat(" Stream slot: %zu entries\n", 873 mStreamSlot.size()); 874 int i = 0; 875 for (List<camera_metadata_t*>::iterator r = mStreamSlot.begin(); 876 r != mStreamSlot.end(); r++) { 877 result = String8::format(" Stream slot buffer %d:\n", i); 878 write(fd, result.string(), result.size()); 879 dump_indented_camera_metadata(*r, fd, 2, 10); 880 i++; 881 } 882 } 883 if (mEntries.size() == 0) { 884 result = " Main queue is empty\n"; 885 write(fd, result.string(), result.size()); 886 } else { 887 result = String8::format(" Main queue has %zu entries:\n", 888 mEntries.size()); 889 int i = 0; 890 for (List<camera_metadata_t*>::iterator r = mEntries.begin(); 891 r != mEntries.end(); r++) { 892 result = String8::format(" Queue entry %d:\n", i); 893 write(fd, result.string(), result.size()); 894 dump_indented_camera_metadata(*r, fd, 2, 10); 895 i++; 896 } 897 } 898 899 if (notLocked == 0) { 900 mMutex.unlock(); 901 } 902 903 return OK; 904 } 905 906 status_t Camera2Device::MetadataQueue::signalConsumerLocked() { 907 ATRACE_CALL(); 908 status_t res = OK; 909 notEmpty.signal(); 910 if (mSignalConsumer && mHal2Device != NULL) { 911 mSignalConsumer = false; 912 913 mMutex.unlock(); 914 ALOGV("%s: Signaling consumer", __FUNCTION__); 915 res = mHal2Device->ops->notify_request_queue_not_empty(mHal2Device); 916 mMutex.lock(); 917 } 918 return res; 919 } 920 921 status_t Camera2Device::MetadataQueue::freeBuffers( 922 List<camera_metadata_t*>::iterator start, 923 List<camera_metadata_t*>::iterator end) 924 { 925 ATRACE_CALL(); 926 while (start != end) { 927 free_camera_metadata(*start); 928 start = mStreamSlot.erase(start); 929 } 930 return OK; 931 } 932 933 Camera2Device::MetadataQueue* Camera2Device::MetadataQueue::getInstance( 934 const camera2_request_queue_src_ops_t *q) 935 { 936 const MetadataQueue* cmq = static_cast<const MetadataQueue*>(q); 937 return const_cast<MetadataQueue*>(cmq); 938 } 939 940 Camera2Device::MetadataQueue* Camera2Device::MetadataQueue::getInstance( 941 const camera2_frame_queue_dst_ops_t *q) 942 { 943 const MetadataQueue* cmq = static_cast<const MetadataQueue*>(q); 944 return const_cast<MetadataQueue*>(cmq); 945 } 946 947 int Camera2Device::MetadataQueue::consumer_buffer_count( 948 const camera2_request_queue_src_ops_t *q) 949 { 950 MetadataQueue *queue = getInstance(q); 951 return queue->getBufferCount(); 952 } 953 954 int Camera2Device::MetadataQueue::consumer_dequeue( 955 const camera2_request_queue_src_ops_t *q, 956 camera_metadata_t **buffer) 957 { 958 MetadataQueue *queue = getInstance(q); 959 return queue->dequeue(buffer, true); 960 } 961 962 int Camera2Device::MetadataQueue::consumer_free( 963 const camera2_request_queue_src_ops_t *q, 964 camera_metadata_t *old_buffer) 965 { 966 ATRACE_CALL(); 967 MetadataQueue *queue = getInstance(q); 968 (void)queue; 969 free_camera_metadata(old_buffer); 970 return OK; 971 } 972 973 int Camera2Device::MetadataQueue::producer_dequeue( 974 const camera2_frame_queue_dst_ops_t * /*q*/, 975 size_t entries, size_t bytes, 976 camera_metadata_t **buffer) 977 { 978 ATRACE_CALL(); 979 camera_metadata_t *new_buffer = 980 allocate_camera_metadata(entries, bytes); 981 if (new_buffer == NULL) return NO_MEMORY; 982 *buffer = new_buffer; 983 return OK; 984 } 985 986 int Camera2Device::MetadataQueue::producer_cancel( 987 const camera2_frame_queue_dst_ops_t * /*q*/, 988 camera_metadata_t *old_buffer) 989 { 990 ATRACE_CALL(); 991 free_camera_metadata(old_buffer); 992 return OK; 993 } 994 995 int Camera2Device::MetadataQueue::producer_enqueue( 996 const camera2_frame_queue_dst_ops_t *q, 997 camera_metadata_t *filled_buffer) 998 { 999 MetadataQueue *queue = getInstance(q); 1000 return queue->enqueue(filled_buffer); 1001 } 1002 1003 /** 1004 * Camera2Device::StreamAdapter 1005 */ 1006 1007 #ifndef container_of 1008 #define container_of(ptr, type, member) \ 1009 (type *)((char*)(ptr) - offsetof(type, member)) 1010 #endif 1011 1012 Camera2Device::StreamAdapter::StreamAdapter(camera2_device_t *d): 1013 mState(RELEASED), 1014 mHal2Device(d), 1015 mId(-1), 1016 mWidth(0), mHeight(0), mFormat(0), mSize(0), mUsage(0), 1017 mMaxProducerBuffers(0), mMaxConsumerBuffers(0), 1018 mTotalBuffers(0), 1019 mFormatRequested(0), 1020 mActiveBuffers(0), 1021 mFrameCount(0), 1022 mLastTimestamp(0) 1023 { 1024 camera2_stream_ops::dequeue_buffer = dequeue_buffer; 1025 camera2_stream_ops::enqueue_buffer = enqueue_buffer; 1026 camera2_stream_ops::cancel_buffer = cancel_buffer; 1027 camera2_stream_ops::set_crop = set_crop; 1028 } 1029 1030 Camera2Device::StreamAdapter::~StreamAdapter() { 1031 ATRACE_CALL(); 1032 if (mState != RELEASED) { 1033 release(); 1034 } 1035 } 1036 1037 status_t Camera2Device::StreamAdapter::connectToDevice( 1038 sp<ANativeWindow> consumer, 1039 uint32_t width, uint32_t height, int format, size_t size) { 1040 ATRACE_CALL(); 1041 status_t res; 1042 ALOGV("%s: E", __FUNCTION__); 1043 1044 if (mState != RELEASED) return INVALID_OPERATION; 1045 if (consumer == NULL) { 1046 ALOGE("%s: Null consumer passed to stream adapter", __FUNCTION__); 1047 return BAD_VALUE; 1048 } 1049 1050 ALOGV("%s: New stream parameters %d x %d, format 0x%x, size %zu", 1051 __FUNCTION__, width, height, format, size); 1052 1053 mConsumerInterface = consumer; 1054 mWidth = width; 1055 mHeight = height; 1056 mSize = (format == HAL_PIXEL_FORMAT_BLOB) ? size : 0; 1057 mFormatRequested = format; 1058 1059 // Allocate device-side stream interface 1060 1061 uint32_t id; 1062 uint32_t formatActual; 1063 uint32_t usage; 1064 uint32_t maxBuffers = 2; 1065 res = mHal2Device->ops->allocate_stream(mHal2Device, 1066 mWidth, mHeight, mFormatRequested, getStreamOps(), 1067 &id, &formatActual, &usage, &maxBuffers); 1068 if (res != OK) { 1069 ALOGE("%s: Device stream allocation failed: %s (%d)", 1070 __FUNCTION__, strerror(-res), res); 1071 return res; 1072 } 1073 1074 ALOGV("%s: Allocated stream id %d, actual format 0x%x, " 1075 "usage 0x%x, producer wants %d buffers", __FUNCTION__, 1076 id, formatActual, usage, maxBuffers); 1077 1078 mId = id; 1079 mFormat = formatActual; 1080 mUsage = usage; 1081 mMaxProducerBuffers = maxBuffers; 1082 1083 mState = ALLOCATED; 1084 1085 // Configure consumer-side ANativeWindow interface 1086 res = native_window_api_connect(mConsumerInterface.get(), 1087 NATIVE_WINDOW_API_CAMERA); 1088 if (res != OK) { 1089 ALOGE("%s: Unable to connect to native window for stream %d", 1090 __FUNCTION__, mId); 1091 1092 return res; 1093 } 1094 1095 mState = CONNECTED; 1096 1097 res = native_window_set_usage(mConsumerInterface.get(), mUsage); 1098 if (res != OK) { 1099 ALOGE("%s: Unable to configure usage %08x for stream %d", 1100 __FUNCTION__, mUsage, mId); 1101 return res; 1102 } 1103 1104 res = native_window_set_scaling_mode(mConsumerInterface.get(), 1105 NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); 1106 if (res != OK) { 1107 ALOGE("%s: Unable to configure stream scaling: %s (%d)", 1108 __FUNCTION__, strerror(-res), res); 1109 return res; 1110 } 1111 1112 res = setTransform(0); 1113 if (res != OK) { 1114 return res; 1115 } 1116 1117 if (mFormat == HAL_PIXEL_FORMAT_BLOB) { 1118 res = native_window_set_buffers_dimensions(mConsumerInterface.get(), 1119 mSize, 1); 1120 if (res != OK) { 1121 ALOGE("%s: Unable to configure compressed stream buffer dimensions" 1122 " %d x %d, size %zu for stream %d", 1123 __FUNCTION__, mWidth, mHeight, mSize, mId); 1124 return res; 1125 } 1126 } else { 1127 res = native_window_set_buffers_dimensions(mConsumerInterface.get(), 1128 mWidth, mHeight); 1129 if (res != OK) { 1130 ALOGE("%s: Unable to configure stream buffer dimensions" 1131 " %d x %d for stream %d", 1132 __FUNCTION__, mWidth, mHeight, mId); 1133 return res; 1134 } 1135 } 1136 1137 res = native_window_set_buffers_format(mConsumerInterface.get(), mFormat); 1138 if (res != OK) { 1139 ALOGE("%s: Unable to configure stream buffer format" 1140 " %#x for stream %d", 1141 __FUNCTION__, mFormat, mId); 1142 return res; 1143 } 1144 1145 int maxConsumerBuffers; 1146 res = mConsumerInterface->query(mConsumerInterface.get(), 1147 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &maxConsumerBuffers); 1148 if (res != OK) { 1149 ALOGE("%s: Unable to query consumer undequeued" 1150 " buffer count for stream %d", __FUNCTION__, mId); 1151 return res; 1152 } 1153 mMaxConsumerBuffers = maxConsumerBuffers; 1154 1155 ALOGV("%s: Consumer wants %d buffers", __FUNCTION__, 1156 mMaxConsumerBuffers); 1157 1158 mTotalBuffers = mMaxConsumerBuffers + mMaxProducerBuffers; 1159 mActiveBuffers = 0; 1160 mFrameCount = 0; 1161 mLastTimestamp = 0; 1162 1163 res = native_window_set_buffer_count(mConsumerInterface.get(), 1164 mTotalBuffers); 1165 if (res != OK) { 1166 ALOGE("%s: Unable to set buffer count for stream %d", 1167 __FUNCTION__, mId); 1168 return res; 1169 } 1170 1171 // Register allocated buffers with HAL device 1172 buffer_handle_t *buffers = new buffer_handle_t[mTotalBuffers]; 1173 ANativeWindowBuffer **anwBuffers = new ANativeWindowBuffer*[mTotalBuffers]; 1174 uint32_t bufferIdx = 0; 1175 for (; bufferIdx < mTotalBuffers; bufferIdx++) { 1176 res = native_window_dequeue_buffer_and_wait(mConsumerInterface.get(), 1177 &anwBuffers[bufferIdx]); 1178 if (res != OK) { 1179 ALOGE("%s: Unable to dequeue buffer %d for initial registration for " 1180 "stream %d", __FUNCTION__, bufferIdx, mId); 1181 goto cleanUpBuffers; 1182 } 1183 1184 buffers[bufferIdx] = anwBuffers[bufferIdx]->handle; 1185 ALOGV("%s: Buffer %p allocated", __FUNCTION__, (void*)buffers[bufferIdx]); 1186 } 1187 1188 ALOGV("%s: Registering %d buffers with camera HAL", __FUNCTION__, mTotalBuffers); 1189 res = mHal2Device->ops->register_stream_buffers(mHal2Device, 1190 mId, 1191 mTotalBuffers, 1192 buffers); 1193 if (res != OK) { 1194 ALOGE("%s: Unable to register buffers with HAL device for stream %d", 1195 __FUNCTION__, mId); 1196 } else { 1197 mState = ACTIVE; 1198 } 1199 1200 cleanUpBuffers: 1201 ALOGV("%s: Cleaning up %d buffers", __FUNCTION__, bufferIdx); 1202 for (uint32_t i = 0; i < bufferIdx; i++) { 1203 res = mConsumerInterface->cancelBuffer(mConsumerInterface.get(), 1204 anwBuffers[i], -1); 1205 if (res != OK) { 1206 ALOGE("%s: Unable to cancel buffer %d after registration", 1207 __FUNCTION__, i); 1208 } 1209 } 1210 delete[] anwBuffers; 1211 delete[] buffers; 1212 1213 return res; 1214 } 1215 1216 status_t Camera2Device::StreamAdapter::release() { 1217 ATRACE_CALL(); 1218 status_t res; 1219 ALOGV("%s: Releasing stream %d (%d x %d, format %d)", __FUNCTION__, mId, 1220 mWidth, mHeight, mFormat); 1221 if (mState >= ALLOCATED) { 1222 res = mHal2Device->ops->release_stream(mHal2Device, mId); 1223 if (res != OK) { 1224 ALOGE("%s: Unable to release stream %d", 1225 __FUNCTION__, mId); 1226 return res; 1227 } 1228 } 1229 if (mState >= CONNECTED) { 1230 res = native_window_api_disconnect(mConsumerInterface.get(), 1231 NATIVE_WINDOW_API_CAMERA); 1232 1233 /* this is not an error. if client calling process dies, 1234 the window will also die and all calls to it will return 1235 DEAD_OBJECT, thus it's already "disconnected" */ 1236 if (res == DEAD_OBJECT) { 1237 ALOGW("%s: While disconnecting stream %d from native window, the" 1238 " native window died from under us", __FUNCTION__, mId); 1239 } 1240 else if (res != OK) { 1241 ALOGE("%s: Unable to disconnect stream %d from native window (error %d %s)", 1242 __FUNCTION__, mId, res, strerror(-res)); 1243 return res; 1244 } 1245 } 1246 mId = -1; 1247 mState = RELEASED; 1248 return OK; 1249 } 1250 1251 status_t Camera2Device::StreamAdapter::setTransform(int transform) { 1252 ATRACE_CALL(); 1253 status_t res; 1254 if (mState < CONNECTED) { 1255 ALOGE("%s: Cannot set transform on unconnected stream", __FUNCTION__); 1256 return INVALID_OPERATION; 1257 } 1258 res = native_window_set_buffers_transform(mConsumerInterface.get(), 1259 transform); 1260 if (res != OK) { 1261 ALOGE("%s: Unable to configure stream transform to %x: %s (%d)", 1262 __FUNCTION__, transform, strerror(-res), res); 1263 } 1264 return res; 1265 } 1266 1267 status_t Camera2Device::StreamAdapter::dump(int fd, 1268 const Vector<String16>& /*args*/) { 1269 ATRACE_CALL(); 1270 String8 result = String8::format(" Stream %d: %d x %d, format 0x%x\n", 1271 mId, mWidth, mHeight, mFormat); 1272 result.appendFormat(" size %zu, usage 0x%x, requested format 0x%x\n", 1273 mSize, mUsage, mFormatRequested); 1274 result.appendFormat(" total buffers: %d, dequeued buffers: %d\n", 1275 mTotalBuffers, mActiveBuffers); 1276 result.appendFormat(" frame count: %d, last timestamp %" PRId64 "\n", 1277 mFrameCount, mLastTimestamp); 1278 write(fd, result.string(), result.size()); 1279 return OK; 1280 } 1281 1282 const camera2_stream_ops *Camera2Device::StreamAdapter::getStreamOps() { 1283 return static_cast<camera2_stream_ops *>(this); 1284 } 1285 1286 ANativeWindow* Camera2Device::StreamAdapter::toANW( 1287 const camera2_stream_ops_t *w) { 1288 return static_cast<const StreamAdapter*>(w)->mConsumerInterface.get(); 1289 } 1290 1291 int Camera2Device::StreamAdapter::dequeue_buffer(const camera2_stream_ops_t *w, 1292 buffer_handle_t** buffer) { 1293 ATRACE_CALL(); 1294 int res; 1295 StreamAdapter* stream = 1296 const_cast<StreamAdapter*>(static_cast<const StreamAdapter*>(w)); 1297 if (stream->mState != ACTIVE) { 1298 ALOGE("%s: Called when in bad state: %d", __FUNCTION__, stream->mState); 1299 return INVALID_OPERATION; 1300 } 1301 1302 ANativeWindow *a = toANW(w); 1303 ANativeWindowBuffer* anb; 1304 res = native_window_dequeue_buffer_and_wait(a, &anb); 1305 if (res != OK) { 1306 ALOGE("Stream %d dequeue: Error from native_window: %s (%d)", stream->mId, 1307 strerror(-res), res); 1308 return res; 1309 } 1310 1311 *buffer = &(anb->handle); 1312 stream->mActiveBuffers++; 1313 1314 ALOGVV("Stream %d dequeue: Buffer %p dequeued", stream->mId, (void*)(**buffer)); 1315 return res; 1316 } 1317 1318 int Camera2Device::StreamAdapter::enqueue_buffer(const camera2_stream_ops_t* w, 1319 int64_t timestamp, 1320 buffer_handle_t* buffer) { 1321 ATRACE_CALL(); 1322 StreamAdapter *stream = 1323 const_cast<StreamAdapter*>(static_cast<const StreamAdapter*>(w)); 1324 stream->mFrameCount++; 1325 ALOGVV("Stream %d enqueue: Frame %d (%p) captured at %lld ns", 1326 stream->mId, stream->mFrameCount, (void*)(*buffer), timestamp); 1327 int state = stream->mState; 1328 if (state != ACTIVE) { 1329 ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state); 1330 return INVALID_OPERATION; 1331 } 1332 ANativeWindow *a = toANW(w); 1333 status_t err; 1334 1335 err = native_window_set_buffers_timestamp(a, timestamp); 1336 if (err != OK) { 1337 ALOGE("%s: Error setting timestamp on native window: %s (%d)", 1338 __FUNCTION__, strerror(-err), err); 1339 return err; 1340 } 1341 err = a->queueBuffer(a, 1342 container_of(buffer, ANativeWindowBuffer, handle), -1); 1343 if (err != OK) { 1344 ALOGE("%s: Error queueing buffer to native window: %s (%d)", 1345 __FUNCTION__, strerror(-err), err); 1346 return err; 1347 } 1348 1349 stream->mActiveBuffers--; 1350 stream->mLastTimestamp = timestamp; 1351 return OK; 1352 } 1353 1354 int Camera2Device::StreamAdapter::cancel_buffer(const camera2_stream_ops_t* w, 1355 buffer_handle_t* buffer) { 1356 ATRACE_CALL(); 1357 StreamAdapter *stream = 1358 const_cast<StreamAdapter*>(static_cast<const StreamAdapter*>(w)); 1359 ALOGVV("Stream %d cancel: Buffer %p", 1360 stream->mId, (void*)(*buffer)); 1361 if (stream->mState != ACTIVE) { 1362 ALOGE("%s: Called when in bad state: %d", __FUNCTION__, stream->mState); 1363 return INVALID_OPERATION; 1364 } 1365 1366 ANativeWindow *a = toANW(w); 1367 int err = a->cancelBuffer(a, 1368 container_of(buffer, ANativeWindowBuffer, handle), -1); 1369 if (err != OK) { 1370 ALOGE("%s: Error canceling buffer to native window: %s (%d)", 1371 __FUNCTION__, strerror(-err), err); 1372 return err; 1373 } 1374 1375 stream->mActiveBuffers--; 1376 return OK; 1377 } 1378 1379 int Camera2Device::StreamAdapter::set_crop(const camera2_stream_ops_t* w, 1380 int left, int top, int right, int bottom) { 1381 ATRACE_CALL(); 1382 int state = static_cast<const StreamAdapter*>(w)->mState; 1383 if (state != ACTIVE) { 1384 ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state); 1385 return INVALID_OPERATION; 1386 } 1387 ANativeWindow *a = toANW(w); 1388 android_native_rect_t crop = { left, top, right, bottom }; 1389 return native_window_set_crop(a, &crop); 1390 } 1391 1392 /** 1393 * Camera2Device::ReprocessStreamAdapter 1394 */ 1395 1396 #ifndef container_of 1397 #define container_of(ptr, type, member) \ 1398 (type *)((char*)(ptr) - offsetof(type, member)) 1399 #endif 1400 1401 Camera2Device::ReprocessStreamAdapter::ReprocessStreamAdapter(camera2_device_t *d): 1402 mState(RELEASED), 1403 mHal2Device(d), 1404 mId(-1), 1405 mWidth(0), mHeight(0), mFormat(0), 1406 mActiveBuffers(0), 1407 mFrameCount(0) 1408 { 1409 ATRACE_CALL(); 1410 camera2_stream_in_ops::acquire_buffer = acquire_buffer; 1411 camera2_stream_in_ops::release_buffer = release_buffer; 1412 } 1413 1414 Camera2Device::ReprocessStreamAdapter::~ReprocessStreamAdapter() { 1415 ATRACE_CALL(); 1416 if (mState != RELEASED) { 1417 release(); 1418 } 1419 } 1420 1421 status_t Camera2Device::ReprocessStreamAdapter::connectToDevice( 1422 const sp<StreamAdapter> &outputStream) { 1423 ATRACE_CALL(); 1424 status_t res; 1425 ALOGV("%s: E", __FUNCTION__); 1426 1427 if (mState != RELEASED) return INVALID_OPERATION; 1428 if (outputStream == NULL) { 1429 ALOGE("%s: Null base stream passed to reprocess stream adapter", 1430 __FUNCTION__); 1431 return BAD_VALUE; 1432 } 1433 1434 mBaseStream = outputStream; 1435 mWidth = outputStream->getWidth(); 1436 mHeight = outputStream->getHeight(); 1437 mFormat = outputStream->getFormat(); 1438 1439 ALOGV("%s: New reprocess stream parameters %d x %d, format 0x%x", 1440 __FUNCTION__, mWidth, mHeight, mFormat); 1441 1442 // Allocate device-side stream interface 1443 1444 uint32_t id; 1445 res = mHal2Device->ops->allocate_reprocess_stream_from_stream(mHal2Device, 1446 outputStream->getId(), getStreamOps(), 1447 &id); 1448 if (res != OK) { 1449 ALOGE("%s: Device reprocess stream allocation failed: %s (%d)", 1450 __FUNCTION__, strerror(-res), res); 1451 return res; 1452 } 1453 1454 ALOGV("%s: Allocated reprocess stream id %d based on stream %d", 1455 __FUNCTION__, id, outputStream->getId()); 1456 1457 mId = id; 1458 1459 mState = ACTIVE; 1460 1461 return OK; 1462 } 1463 1464 status_t Camera2Device::ReprocessStreamAdapter::release() { 1465 ATRACE_CALL(); 1466 status_t res; 1467 ALOGV("%s: Releasing stream %d", __FUNCTION__, mId); 1468 if (mState >= ACTIVE) { 1469 res = mHal2Device->ops->release_reprocess_stream(mHal2Device, mId); 1470 if (res != OK) { 1471 ALOGE("%s: Unable to release stream %d", 1472 __FUNCTION__, mId); 1473 return res; 1474 } 1475 } 1476 1477 List<QueueEntry>::iterator s; 1478 for (s = mQueue.begin(); s != mQueue.end(); s++) { 1479 sp<BufferReleasedListener> listener = s->releaseListener.promote(); 1480 if (listener != 0) listener->onBufferReleased(s->handle); 1481 } 1482 for (s = mInFlightQueue.begin(); s != mInFlightQueue.end(); s++) { 1483 sp<BufferReleasedListener> listener = s->releaseListener.promote(); 1484 if (listener != 0) listener->onBufferReleased(s->handle); 1485 } 1486 mQueue.clear(); 1487 mInFlightQueue.clear(); 1488 1489 mState = RELEASED; 1490 return OK; 1491 } 1492 1493 status_t Camera2Device::ReprocessStreamAdapter::pushIntoStream( 1494 buffer_handle_t *handle, const wp<BufferReleasedListener> &releaseListener) { 1495 ATRACE_CALL(); 1496 // TODO: Some error checking here would be nice 1497 ALOGV("%s: Pushing buffer %p to stream", __FUNCTION__, (void*)(*handle)); 1498 1499 QueueEntry entry; 1500 entry.handle = handle; 1501 entry.releaseListener = releaseListener; 1502 mQueue.push_back(entry); 1503 return OK; 1504 } 1505 1506 status_t Camera2Device::ReprocessStreamAdapter::dump(int fd, 1507 const Vector<String16>& /*args*/) { 1508 ATRACE_CALL(); 1509 String8 result = 1510 String8::format(" Reprocess stream %d: %d x %d, fmt 0x%x\n", 1511 mId, mWidth, mHeight, mFormat); 1512 result.appendFormat(" acquired buffers: %d\n", 1513 mActiveBuffers); 1514 result.appendFormat(" frame count: %d\n", 1515 mFrameCount); 1516 write(fd, result.string(), result.size()); 1517 return OK; 1518 } 1519 1520 const camera2_stream_in_ops *Camera2Device::ReprocessStreamAdapter::getStreamOps() { 1521 return static_cast<camera2_stream_in_ops *>(this); 1522 } 1523 1524 int Camera2Device::ReprocessStreamAdapter::acquire_buffer( 1525 const camera2_stream_in_ops_t *w, 1526 buffer_handle_t** buffer) { 1527 ATRACE_CALL(); 1528 1529 ReprocessStreamAdapter* stream = 1530 const_cast<ReprocessStreamAdapter*>( 1531 static_cast<const ReprocessStreamAdapter*>(w)); 1532 if (stream->mState != ACTIVE) { 1533 ALOGE("%s: Called when in bad state: %d", __FUNCTION__, stream->mState); 1534 return INVALID_OPERATION; 1535 } 1536 1537 if (stream->mQueue.empty()) { 1538 *buffer = NULL; 1539 return OK; 1540 } 1541 1542 QueueEntry &entry = *(stream->mQueue.begin()); 1543 1544 *buffer = entry.handle; 1545 1546 stream->mInFlightQueue.push_back(entry); 1547 stream->mQueue.erase(stream->mQueue.begin()); 1548 1549 stream->mActiveBuffers++; 1550 1551 ALOGV("Stream %d acquire: Buffer %p acquired", stream->mId, 1552 (void*)(**buffer)); 1553 return OK; 1554 } 1555 1556 int Camera2Device::ReprocessStreamAdapter::release_buffer( 1557 const camera2_stream_in_ops_t* w, 1558 buffer_handle_t* buffer) { 1559 ATRACE_CALL(); 1560 ReprocessStreamAdapter *stream = 1561 const_cast<ReprocessStreamAdapter*>( 1562 static_cast<const ReprocessStreamAdapter*>(w) ); 1563 stream->mFrameCount++; 1564 ALOGV("Reprocess stream %d release: Frame %d (%p)", 1565 stream->mId, stream->mFrameCount, (void*)*buffer); 1566 int state = stream->mState; 1567 if (state != ACTIVE) { 1568 ALOGE("%s: Called when in bad state: %d", __FUNCTION__, state); 1569 return INVALID_OPERATION; 1570 } 1571 stream->mActiveBuffers--; 1572 1573 List<QueueEntry>::iterator s; 1574 for (s = stream->mInFlightQueue.begin(); s != stream->mInFlightQueue.end(); s++) { 1575 if ( s->handle == buffer ) break; 1576 } 1577 if (s == stream->mInFlightQueue.end()) { 1578 ALOGE("%s: Can't find buffer %p in in-flight list!", __FUNCTION__, 1579 buffer); 1580 return INVALID_OPERATION; 1581 } 1582 1583 sp<BufferReleasedListener> listener = s->releaseListener.promote(); 1584 if (listener != 0) { 1585 listener->onBufferReleased(s->handle); 1586 } else { 1587 ALOGE("%s: Can't free buffer - missing listener", __FUNCTION__); 1588 } 1589 stream->mInFlightQueue.erase(s); 1590 1591 return OK; 1592 } 1593 1594 }; // namespace android 1595
