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