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