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-StreamingProcessor" 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 <utils/Log.h> 29 #include <utils/Trace.h> 30 #include <gui/Surface.h> 31 #include <media/hardware/MetadataBufferType.h> 32 33 #include "StreamingProcessor.h" 34 #include "Camera2Heap.h" 35 #include "../Camera2Client.h" 36 #include "../CameraDeviceBase.h" 37 38 namespace android { 39 namespace camera2 { 40 41 StreamingProcessor::StreamingProcessor(sp<Camera2Client> client): 42 mClient(client), 43 mDevice(client->getCameraDevice()), 44 mId(client->getCameraId()), 45 mActiveRequest(NONE), 46 mPaused(false), 47 mPreviewRequestId(Camera2Client::kPreviewRequestIdStart), 48 mPreviewStreamId(NO_STREAM), 49 mRecordingRequestId(Camera2Client::kRecordingRequestIdStart), 50 mRecordingStreamId(NO_STREAM), 51 mRecordingFrameAvailable(false), 52 mRecordingHeapCount(kDefaultRecordingHeapCount), 53 mRecordingHeapFree(kDefaultRecordingHeapCount) 54 { 55 } 56 57 StreamingProcessor::~StreamingProcessor() { 58 deletePreviewStream(); 59 deleteRecordingStream(); 60 } 61 62 status_t StreamingProcessor::setPreviewWindow(sp<ANativeWindow> window) { 63 ATRACE_CALL(); 64 status_t res; 65 66 res = deletePreviewStream(); 67 if (res != OK) return res; 68 69 Mutex::Autolock m(mMutex); 70 71 mPreviewWindow = window; 72 73 return OK; 74 } 75 76 bool StreamingProcessor::haveValidPreviewWindow() const { 77 Mutex::Autolock m(mMutex); 78 return mPreviewWindow != 0; 79 } 80 81 status_t StreamingProcessor::updatePreviewRequest(const Parameters ¶ms) { 82 ATRACE_CALL(); 83 status_t res; 84 sp<CameraDeviceBase> device = mDevice.promote(); 85 if (device == 0) { 86 ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId); 87 return INVALID_OPERATION; 88 } 89 90 Mutex::Autolock m(mMutex); 91 if (mPreviewRequest.entryCount() == 0) { 92 res = device->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW, 93 &mPreviewRequest); 94 if (res != OK) { 95 ALOGE("%s: Camera %d: Unable to create default preview request: " 96 "%s (%d)", __FUNCTION__, mId, strerror(-res), res); 97 return res; 98 } 99 } 100 101 res = params.updateRequest(&mPreviewRequest); 102 if (res != OK) { 103 ALOGE("%s: Camera %d: Unable to update common entries of preview " 104 "request: %s (%d)", __FUNCTION__, mId, 105 strerror(-res), res); 106 return res; 107 } 108 109 res = mPreviewRequest.update(ANDROID_REQUEST_ID, 110 &mPreviewRequestId, 1); 111 if (res != OK) { 112 ALOGE("%s: Camera %d: Unable to update request id for preview: %s (%d)", 113 __FUNCTION__, mId, strerror(-res), res); 114 return res; 115 } 116 117 return OK; 118 } 119 120 status_t StreamingProcessor::updatePreviewStream(const Parameters ¶ms) { 121 ATRACE_CALL(); 122 Mutex::Autolock m(mMutex); 123 124 status_t res; 125 sp<CameraDeviceBase> device = mDevice.promote(); 126 if (device == 0) { 127 ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId); 128 return INVALID_OPERATION; 129 } 130 131 if (mPreviewStreamId != NO_STREAM) { 132 // Check if stream parameters have to change 133 uint32_t currentWidth, currentHeight; 134 res = device->getStreamInfo(mPreviewStreamId, 135 ¤tWidth, ¤tHeight, 0); 136 if (res != OK) { 137 ALOGE("%s: Camera %d: Error querying preview stream info: " 138 "%s (%d)", __FUNCTION__, mId, strerror(-res), res); 139 return res; 140 } 141 if (currentWidth != (uint32_t)params.previewWidth || 142 currentHeight != (uint32_t)params.previewHeight) { 143 ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d", 144 __FUNCTION__, mId, currentWidth, currentHeight, 145 params.previewWidth, params.previewHeight); 146 res = device->waitUntilDrained(); 147 if (res != OK) { 148 ALOGE("%s: Camera %d: Error waiting for preview to drain: " 149 "%s (%d)", __FUNCTION__, mId, strerror(-res), res); 150 return res; 151 } 152 res = device->deleteStream(mPreviewStreamId); 153 if (res != OK) { 154 ALOGE("%s: Camera %d: Unable to delete old output stream " 155 "for preview: %s (%d)", __FUNCTION__, mId, 156 strerror(-res), res); 157 return res; 158 } 159 mPreviewStreamId = NO_STREAM; 160 } 161 } 162 163 if (mPreviewStreamId == NO_STREAM) { 164 res = device->createStream(mPreviewWindow, 165 params.previewWidth, params.previewHeight, 166 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, 167 &mPreviewStreamId); 168 if (res != OK) { 169 ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)", 170 __FUNCTION__, mId, strerror(-res), res); 171 return res; 172 } 173 } 174 175 res = device->setStreamTransform(mPreviewStreamId, 176 params.previewTransform); 177 if (res != OK) { 178 ALOGE("%s: Camera %d: Unable to set preview stream transform: " 179 "%s (%d)", __FUNCTION__, mId, strerror(-res), res); 180 return res; 181 } 182 183 return OK; 184 } 185 186 status_t StreamingProcessor::deletePreviewStream() { 187 ATRACE_CALL(); 188 status_t res; 189 190 Mutex::Autolock m(mMutex); 191 192 if (mPreviewStreamId != NO_STREAM) { 193 sp<CameraDeviceBase> device = mDevice.promote(); 194 if (device == 0) { 195 ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId); 196 return INVALID_OPERATION; 197 } 198 199 ALOGV("%s: for cameraId %d on streamId %d", 200 __FUNCTION__, mId, mPreviewStreamId); 201 202 res = device->waitUntilDrained(); 203 if (res != OK) { 204 ALOGE("%s: Error waiting for preview to drain: %s (%d)", 205 __FUNCTION__, strerror(-res), res); 206 return res; 207 } 208 res = device->deleteStream(mPreviewStreamId); 209 if (res != OK) { 210 ALOGE("%s: Unable to delete old preview stream: %s (%d)", 211 __FUNCTION__, strerror(-res), res); 212 return res; 213 } 214 mPreviewStreamId = NO_STREAM; 215 } 216 return OK; 217 } 218 219 int StreamingProcessor::getPreviewStreamId() const { 220 Mutex::Autolock m(mMutex); 221 return mPreviewStreamId; 222 } 223 224 status_t StreamingProcessor::setRecordingBufferCount(size_t count) { 225 ATRACE_CALL(); 226 // Make sure we can support this many buffer slots 227 if (count > BufferQueue::NUM_BUFFER_SLOTS) { 228 ALOGE("%s: Camera %d: Too many recording buffers requested: %d, max %d", 229 __FUNCTION__, mId, count, BufferQueue::NUM_BUFFER_SLOTS); 230 return BAD_VALUE; 231 } 232 233 Mutex::Autolock m(mMutex); 234 235 ALOGV("%s: Camera %d: New recording buffer count from encoder: %d", 236 __FUNCTION__, mId, count); 237 238 // Need to re-size consumer and heap 239 if (mRecordingHeapCount != count) { 240 ALOGV("%s: Camera %d: Resetting recording heap and consumer", 241 __FUNCTION__, mId); 242 243 if (isStreamActive(mActiveStreamIds, mRecordingStreamId)) { 244 ALOGE("%s: Camera %d: Setting recording buffer count when " 245 "recording stream is already active!", __FUNCTION__, 246 mId); 247 return INVALID_OPERATION; 248 } 249 250 releaseAllRecordingFramesLocked(); 251 252 if (mRecordingHeap != 0) { 253 mRecordingHeap.clear(); 254 } 255 mRecordingHeapCount = count; 256 mRecordingHeapFree = count; 257 258 mRecordingConsumer.clear(); 259 } 260 261 return OK; 262 } 263 264 status_t StreamingProcessor::updateRecordingRequest(const Parameters ¶ms) { 265 ATRACE_CALL(); 266 status_t res; 267 Mutex::Autolock m(mMutex); 268 269 sp<CameraDeviceBase> device = mDevice.promote(); 270 if (device == 0) { 271 ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId); 272 return INVALID_OPERATION; 273 } 274 275 if (mRecordingRequest.entryCount() == 0) { 276 res = device->createDefaultRequest(CAMERA2_TEMPLATE_VIDEO_RECORD, 277 &mRecordingRequest); 278 if (res != OK) { 279 ALOGE("%s: Camera %d: Unable to create default recording request:" 280 " %s (%d)", __FUNCTION__, mId, strerror(-res), res); 281 return res; 282 } 283 } 284 285 res = params.updateRequest(&mRecordingRequest); 286 if (res != OK) { 287 ALOGE("%s: Camera %d: Unable to update common entries of recording " 288 "request: %s (%d)", __FUNCTION__, mId, 289 strerror(-res), res); 290 return res; 291 } 292 293 res = mRecordingRequest.update(ANDROID_REQUEST_ID, 294 &mRecordingRequestId, 1); 295 if (res != OK) { 296 ALOGE("%s: Camera %d: Unable to update request id for request: %s (%d)", 297 __FUNCTION__, mId, strerror(-res), res); 298 return res; 299 } 300 301 return OK; 302 } 303 304 status_t StreamingProcessor::updateRecordingStream(const Parameters ¶ms) { 305 ATRACE_CALL(); 306 status_t res; 307 Mutex::Autolock m(mMutex); 308 309 sp<CameraDeviceBase> device = mDevice.promote(); 310 if (device == 0) { 311 ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId); 312 return INVALID_OPERATION; 313 } 314 315 bool newConsumer = false; 316 if (mRecordingConsumer == 0) { 317 ALOGV("%s: Camera %d: Creating recording consumer with %d + 1 " 318 "consumer-side buffers", __FUNCTION__, mId, mRecordingHeapCount); 319 // Create CPU buffer queue endpoint. We need one more buffer here so that we can 320 // always acquire and free a buffer when the heap is full; otherwise the consumer 321 // will have buffers in flight we'll never clear out. 322 mRecordingConsumer = new BufferItemConsumer( 323 GRALLOC_USAGE_HW_VIDEO_ENCODER, 324 mRecordingHeapCount + 1, 325 true); 326 mRecordingConsumer->setFrameAvailableListener(this); 327 mRecordingConsumer->setName(String8("Camera2-RecordingConsumer")); 328 mRecordingWindow = new Surface( 329 mRecordingConsumer->getProducerInterface()); 330 newConsumer = true; 331 // Allocate memory later, since we don't know buffer size until receipt 332 } 333 334 if (mRecordingStreamId != NO_STREAM) { 335 // Check if stream parameters have to change 336 uint32_t currentWidth, currentHeight; 337 res = device->getStreamInfo(mRecordingStreamId, 338 ¤tWidth, ¤tHeight, 0); 339 if (res != OK) { 340 ALOGE("%s: Camera %d: Error querying recording output stream info: " 341 "%s (%d)", __FUNCTION__, mId, 342 strerror(-res), res); 343 return res; 344 } 345 if (currentWidth != (uint32_t)params.videoWidth || 346 currentHeight != (uint32_t)params.videoHeight || newConsumer) { 347 // TODO: Should wait to be sure previous recording has finished 348 res = device->deleteStream(mRecordingStreamId); 349 350 if (res == -EBUSY) { 351 ALOGV("%s: Camera %d: Device is busy, call " 352 "updateRecordingStream after it becomes idle", 353 __FUNCTION__, mId); 354 return res; 355 } else if (res != OK) { 356 ALOGE("%s: Camera %d: Unable to delete old output stream " 357 "for recording: %s (%d)", __FUNCTION__, 358 mId, strerror(-res), res); 359 return res; 360 } 361 mRecordingStreamId = NO_STREAM; 362 } 363 } 364 365 if (mRecordingStreamId == NO_STREAM) { 366 mRecordingFrameCount = 0; 367 res = device->createStream(mRecordingWindow, 368 params.videoWidth, params.videoHeight, 369 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, &mRecordingStreamId); 370 if (res != OK) { 371 ALOGE("%s: Camera %d: Can't create output stream for recording: " 372 "%s (%d)", __FUNCTION__, mId, 373 strerror(-res), res); 374 return res; 375 } 376 } 377 378 return OK; 379 } 380 381 status_t StreamingProcessor::deleteRecordingStream() { 382 ATRACE_CALL(); 383 status_t res; 384 385 Mutex::Autolock m(mMutex); 386 387 if (mRecordingStreamId != NO_STREAM) { 388 sp<CameraDeviceBase> device = mDevice.promote(); 389 if (device == 0) { 390 ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId); 391 return INVALID_OPERATION; 392 } 393 394 res = device->waitUntilDrained(); 395 if (res != OK) { 396 ALOGE("%s: Error waiting for HAL to drain: %s (%d)", 397 __FUNCTION__, strerror(-res), res); 398 return res; 399 } 400 res = device->deleteStream(mRecordingStreamId); 401 if (res != OK) { 402 ALOGE("%s: Unable to delete recording stream: %s (%d)", 403 __FUNCTION__, strerror(-res), res); 404 return res; 405 } 406 mRecordingStreamId = NO_STREAM; 407 } 408 return OK; 409 } 410 411 int StreamingProcessor::getRecordingStreamId() const { 412 return mRecordingStreamId; 413 } 414 415 status_t StreamingProcessor::startStream(StreamType type, 416 const Vector<uint8_t> &outputStreams) { 417 ATRACE_CALL(); 418 status_t res; 419 420 if (type == NONE) return INVALID_OPERATION; 421 422 sp<CameraDeviceBase> device = mDevice.promote(); 423 if (device == 0) { 424 ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId); 425 return INVALID_OPERATION; 426 } 427 428 ALOGV("%s: Camera %d: type = %d", __FUNCTION__, mId, type); 429 430 Mutex::Autolock m(mMutex); 431 432 // If a recording stream is being started up, free up any 433 // outstanding buffers left from the previous recording session. 434 // There should never be any, so if there are, warn about it. 435 if (isStreamActive(outputStreams, mRecordingStreamId)) { 436 releaseAllRecordingFramesLocked(); 437 } 438 439 ALOGV("%s: Camera %d: %s started, recording heap has %d free of %d", 440 __FUNCTION__, mId, (type == PREVIEW) ? "preview" : "recording", 441 mRecordingHeapFree, mRecordingHeapCount); 442 443 CameraMetadata &request = (type == PREVIEW) ? 444 mPreviewRequest : mRecordingRequest; 445 446 res = request.update( 447 ANDROID_REQUEST_OUTPUT_STREAMS, 448 outputStreams); 449 if (res != OK) { 450 ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)", 451 __FUNCTION__, mId, strerror(-res), res); 452 return res; 453 } 454 455 res = request.sort(); 456 if (res != OK) { 457 ALOGE("%s: Camera %d: Error sorting preview request: %s (%d)", 458 __FUNCTION__, mId, strerror(-res), res); 459 return res; 460 } 461 462 res = device->setStreamingRequest(request); 463 if (res != OK) { 464 ALOGE("%s: Camera %d: Unable to set preview request to start preview: " 465 "%s (%d)", 466 __FUNCTION__, mId, strerror(-res), res); 467 return res; 468 } 469 mActiveRequest = type; 470 mPaused = false; 471 mActiveStreamIds = outputStreams; 472 return OK; 473 } 474 475 status_t StreamingProcessor::togglePauseStream(bool pause) { 476 ATRACE_CALL(); 477 status_t res; 478 479 sp<CameraDeviceBase> device = mDevice.promote(); 480 if (device == 0) { 481 ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId); 482 return INVALID_OPERATION; 483 } 484 485 ALOGV("%s: Camera %d: toggling pause to %d", __FUNCTION__, mId, pause); 486 487 Mutex::Autolock m(mMutex); 488 489 if (mActiveRequest == NONE) { 490 ALOGE("%s: Camera %d: Can't toggle pause, streaming was not started", 491 __FUNCTION__, mId); 492 return INVALID_OPERATION; 493 } 494 495 if (mPaused == pause) { 496 return OK; 497 } 498 499 if (pause) { 500 res = device->clearStreamingRequest(); 501 if (res != OK) { 502 ALOGE("%s: Camera %d: Can't clear stream request: %s (%d)", 503 __FUNCTION__, mId, strerror(-res), res); 504 return res; 505 } 506 } else { 507 CameraMetadata &request = 508 (mActiveRequest == PREVIEW) ? mPreviewRequest 509 : mRecordingRequest; 510 res = device->setStreamingRequest(request); 511 if (res != OK) { 512 ALOGE("%s: Camera %d: Unable to set preview request to resume: " 513 "%s (%d)", 514 __FUNCTION__, mId, strerror(-res), res); 515 return res; 516 } 517 } 518 519 mPaused = pause; 520 return OK; 521 } 522 523 status_t StreamingProcessor::stopStream() { 524 ATRACE_CALL(); 525 status_t res; 526 527 Mutex::Autolock m(mMutex); 528 529 sp<CameraDeviceBase> device = mDevice.promote(); 530 if (device == 0) { 531 ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId); 532 return INVALID_OPERATION; 533 } 534 535 res = device->clearStreamingRequest(); 536 if (res != OK) { 537 ALOGE("%s: Camera %d: Can't clear stream request: %s (%d)", 538 __FUNCTION__, mId, strerror(-res), res); 539 return res; 540 } 541 542 mActiveRequest = NONE; 543 mActiveStreamIds.clear(); 544 mPaused = false; 545 546 return OK; 547 } 548 549 int32_t StreamingProcessor::getActiveRequestId() const { 550 Mutex::Autolock m(mMutex); 551 switch (mActiveRequest) { 552 case NONE: 553 return 0; 554 case PREVIEW: 555 return mPreviewRequestId; 556 case RECORD: 557 return mRecordingRequestId; 558 default: 559 ALOGE("%s: Unexpected mode %d", __FUNCTION__, mActiveRequest); 560 return 0; 561 } 562 } 563 564 status_t StreamingProcessor::incrementStreamingIds() { 565 ATRACE_CALL(); 566 Mutex::Autolock m(mMutex); 567 568 mPreviewRequestId++; 569 if (mPreviewRequestId >= Camera2Client::kPreviewRequestIdEnd) { 570 mPreviewRequestId = Camera2Client::kPreviewRequestIdStart; 571 } 572 mRecordingRequestId++; 573 if (mRecordingRequestId >= Camera2Client::kRecordingRequestIdEnd) { 574 mRecordingRequestId = Camera2Client::kRecordingRequestIdStart; 575 } 576 return OK; 577 } 578 579 void StreamingProcessor::onFrameAvailable() { 580 ATRACE_CALL(); 581 Mutex::Autolock l(mMutex); 582 if (!mRecordingFrameAvailable) { 583 mRecordingFrameAvailable = true; 584 mRecordingFrameAvailableSignal.signal(); 585 } 586 587 } 588 589 bool StreamingProcessor::threadLoop() { 590 status_t res; 591 592 { 593 Mutex::Autolock l(mMutex); 594 while (!mRecordingFrameAvailable) { 595 res = mRecordingFrameAvailableSignal.waitRelative( 596 mMutex, kWaitDuration); 597 if (res == TIMED_OUT) return true; 598 } 599 mRecordingFrameAvailable = false; 600 } 601 602 do { 603 res = processRecordingFrame(); 604 } while (res == OK); 605 606 return true; 607 } 608 609 status_t StreamingProcessor::processRecordingFrame() { 610 ATRACE_CALL(); 611 status_t res; 612 sp<Camera2Heap> recordingHeap; 613 size_t heapIdx = 0; 614 nsecs_t timestamp; 615 616 sp<Camera2Client> client = mClient.promote(); 617 if (client == 0) { 618 // Discard frames during shutdown 619 BufferItemConsumer::BufferItem imgBuffer; 620 res = mRecordingConsumer->acquireBuffer(&imgBuffer); 621 if (res != OK) { 622 if (res != BufferItemConsumer::NO_BUFFER_AVAILABLE) { 623 ALOGE("%s: Camera %d: Can't acquire recording buffer: %s (%d)", 624 __FUNCTION__, mId, strerror(-res), res); 625 } 626 return res; 627 } 628 mRecordingConsumer->releaseBuffer(imgBuffer); 629 return OK; 630 } 631 632 { 633 /* acquire SharedParameters before mMutex so we don't dead lock 634 with Camera2Client code calling into StreamingProcessor */ 635 SharedParameters::Lock l(client->getParameters()); 636 Mutex::Autolock m(mMutex); 637 BufferItemConsumer::BufferItem imgBuffer; 638 res = mRecordingConsumer->acquireBuffer(&imgBuffer); 639 if (res != OK) { 640 if (res != BufferItemConsumer::NO_BUFFER_AVAILABLE) { 641 ALOGE("%s: Camera %d: Can't acquire recording buffer: %s (%d)", 642 __FUNCTION__, mId, strerror(-res), res); 643 } 644 return res; 645 } 646 timestamp = imgBuffer.mTimestamp; 647 648 mRecordingFrameCount++; 649 ALOGVV("OnRecordingFrame: Frame %d", mRecordingFrameCount); 650 651 if (l.mParameters.state != Parameters::RECORD && 652 l.mParameters.state != Parameters::VIDEO_SNAPSHOT) { 653 ALOGV("%s: Camera %d: Discarding recording image buffers " 654 "received after recording done", __FUNCTION__, 655 mId); 656 mRecordingConsumer->releaseBuffer(imgBuffer); 657 return INVALID_OPERATION; 658 } 659 660 if (mRecordingHeap == 0) { 661 const size_t bufferSize = 4 + sizeof(buffer_handle_t); 662 ALOGV("%s: Camera %d: Creating recording heap with %d buffers of " 663 "size %d bytes", __FUNCTION__, mId, 664 mRecordingHeapCount, bufferSize); 665 666 mRecordingHeap = new Camera2Heap(bufferSize, mRecordingHeapCount, 667 "Camera2Client::RecordingHeap"); 668 if (mRecordingHeap->mHeap->getSize() == 0) { 669 ALOGE("%s: Camera %d: Unable to allocate memory for recording", 670 __FUNCTION__, mId); 671 mRecordingConsumer->releaseBuffer(imgBuffer); 672 return NO_MEMORY; 673 } 674 for (size_t i = 0; i < mRecordingBuffers.size(); i++) { 675 if (mRecordingBuffers[i].mBuf != 676 BufferItemConsumer::INVALID_BUFFER_SLOT) { 677 ALOGE("%s: Camera %d: Non-empty recording buffers list!", 678 __FUNCTION__, mId); 679 } 680 } 681 mRecordingBuffers.clear(); 682 mRecordingBuffers.setCapacity(mRecordingHeapCount); 683 mRecordingBuffers.insertAt(0, mRecordingHeapCount); 684 685 mRecordingHeapHead = 0; 686 mRecordingHeapFree = mRecordingHeapCount; 687 } 688 689 if ( mRecordingHeapFree == 0) { 690 ALOGE("%s: Camera %d: No free recording buffers, dropping frame", 691 __FUNCTION__, mId); 692 mRecordingConsumer->releaseBuffer(imgBuffer); 693 return NO_MEMORY; 694 } 695 696 heapIdx = mRecordingHeapHead; 697 mRecordingHeapHead = (mRecordingHeapHead + 1) % mRecordingHeapCount; 698 mRecordingHeapFree--; 699 700 ALOGVV("%s: Camera %d: Timestamp %lld", 701 __FUNCTION__, mId, timestamp); 702 703 ssize_t offset; 704 size_t size; 705 sp<IMemoryHeap> heap = 706 mRecordingHeap->mBuffers[heapIdx]->getMemory(&offset, 707 &size); 708 709 uint8_t *data = (uint8_t*)heap->getBase() + offset; 710 uint32_t type = kMetadataBufferTypeGrallocSource; 711 *((uint32_t*)data) = type; 712 *((buffer_handle_t*)(data + 4)) = imgBuffer.mGraphicBuffer->handle; 713 ALOGVV("%s: Camera %d: Sending out buffer_handle_t %p", 714 __FUNCTION__, mId, 715 imgBuffer.mGraphicBuffer->handle); 716 mRecordingBuffers.replaceAt(imgBuffer, heapIdx); 717 recordingHeap = mRecordingHeap; 718 } 719 720 // Call outside locked parameters to allow re-entrancy from notification 721 Camera2Client::SharedCameraCallbacks::Lock l(client->mSharedCameraCallbacks); 722 if (l.mRemoteCallback != 0) { 723 l.mRemoteCallback->dataCallbackTimestamp(timestamp, 724 CAMERA_MSG_VIDEO_FRAME, 725 recordingHeap->mBuffers[heapIdx]); 726 } else { 727 ALOGW("%s: Camera %d: Remote callback gone", __FUNCTION__, mId); 728 } 729 730 return OK; 731 } 732 733 void StreamingProcessor::releaseRecordingFrame(const sp<IMemory>& mem) { 734 ATRACE_CALL(); 735 status_t res; 736 737 Mutex::Autolock m(mMutex); 738 // Make sure this is for the current heap 739 ssize_t offset; 740 size_t size; 741 sp<IMemoryHeap> heap = mem->getMemory(&offset, &size); 742 if (heap->getHeapID() != mRecordingHeap->mHeap->getHeapID()) { 743 ALOGW("%s: Camera %d: Mismatched heap ID, ignoring release " 744 "(got %x, expected %x)", __FUNCTION__, mId, 745 heap->getHeapID(), mRecordingHeap->mHeap->getHeapID()); 746 return; 747 } 748 uint8_t *data = (uint8_t*)heap->getBase() + offset; 749 uint32_t type = *(uint32_t*)data; 750 if (type != kMetadataBufferTypeGrallocSource) { 751 ALOGE("%s: Camera %d: Recording frame type invalid (got %x, expected %x)", 752 __FUNCTION__, mId, type, 753 kMetadataBufferTypeGrallocSource); 754 return; 755 } 756 757 // Release the buffer back to the recording queue 758 759 buffer_handle_t imgHandle = *(buffer_handle_t*)(data + 4); 760 761 size_t itemIndex; 762 for (itemIndex = 0; itemIndex < mRecordingBuffers.size(); itemIndex++) { 763 const BufferItemConsumer::BufferItem item = 764 mRecordingBuffers[itemIndex]; 765 if (item.mBuf != BufferItemConsumer::INVALID_BUFFER_SLOT && 766 item.mGraphicBuffer->handle == imgHandle) { 767 break; 768 } 769 } 770 if (itemIndex == mRecordingBuffers.size()) { 771 ALOGE("%s: Camera %d: Can't find buffer_handle_t %p in list of " 772 "outstanding buffers", __FUNCTION__, mId, 773 imgHandle); 774 return; 775 } 776 777 ALOGVV("%s: Camera %d: Freeing buffer_handle_t %p", __FUNCTION__, 778 mId, imgHandle); 779 780 res = mRecordingConsumer->releaseBuffer(mRecordingBuffers[itemIndex]); 781 if (res != OK) { 782 ALOGE("%s: Camera %d: Unable to free recording frame " 783 "(buffer_handle_t: %p): %s (%d)", __FUNCTION__, 784 mId, imgHandle, strerror(-res), res); 785 return; 786 } 787 mRecordingBuffers.replaceAt(itemIndex); 788 789 mRecordingHeapFree++; 790 ALOGV_IF(mRecordingHeapFree == mRecordingHeapCount, 791 "%s: Camera %d: All %d recording buffers returned", 792 __FUNCTION__, mId, mRecordingHeapCount); 793 } 794 795 void StreamingProcessor::releaseAllRecordingFramesLocked() { 796 ATRACE_CALL(); 797 status_t res; 798 799 if (mRecordingConsumer == 0) { 800 return; 801 } 802 803 ALOGV("%s: Camera %d: Releasing all recording buffers", __FUNCTION__, 804 mId); 805 806 size_t releasedCount = 0; 807 for (size_t itemIndex = 0; itemIndex < mRecordingBuffers.size(); itemIndex++) { 808 const BufferItemConsumer::BufferItem item = 809 mRecordingBuffers[itemIndex]; 810 if (item.mBuf != BufferItemConsumer::INVALID_BUFFER_SLOT) { 811 res = mRecordingConsumer->releaseBuffer(mRecordingBuffers[itemIndex]); 812 if (res != OK) { 813 ALOGE("%s: Camera %d: Unable to free recording frame " 814 "(buffer_handle_t: %p): %s (%d)", __FUNCTION__, 815 mId, item.mGraphicBuffer->handle, strerror(-res), res); 816 } 817 mRecordingBuffers.replaceAt(itemIndex); 818 releasedCount++; 819 } 820 } 821 822 if (releasedCount > 0) { 823 ALOGW("%s: Camera %d: Force-freed %d outstanding buffers " 824 "from previous recording session", __FUNCTION__, mId, releasedCount); 825 ALOGE_IF(releasedCount != mRecordingHeapCount - mRecordingHeapFree, 826 "%s: Camera %d: Force-freed %d buffers, but expected %d", 827 __FUNCTION__, mId, releasedCount, mRecordingHeapCount - mRecordingHeapFree); 828 } 829 830 mRecordingHeapHead = 0; 831 mRecordingHeapFree = mRecordingHeapCount; 832 } 833 834 bool StreamingProcessor::isStreamActive(const Vector<uint8_t> &streams, 835 uint8_t recordingStreamId) { 836 for (size_t i = 0; i < streams.size(); i++) { 837 if (streams[i] == recordingStreamId) { 838 return true; 839 } 840 } 841 return false; 842 } 843 844 845 status_t StreamingProcessor::dump(int fd, const Vector<String16>& /*args*/) { 846 String8 result; 847 848 result.append(" Current requests:\n"); 849 if (mPreviewRequest.entryCount() != 0) { 850 result.append(" Preview request:\n"); 851 write(fd, result.string(), result.size()); 852 mPreviewRequest.dump(fd, 2, 6); 853 result.clear(); 854 } else { 855 result.append(" Preview request: undefined\n"); 856 } 857 858 if (mRecordingRequest.entryCount() != 0) { 859 result = " Recording request:\n"; 860 write(fd, result.string(), result.size()); 861 mRecordingRequest.dump(fd, 2, 6); 862 result.clear(); 863 } else { 864 result = " Recording request: undefined\n"; 865 } 866 867 const char* streamTypeString[] = { 868 "none", "preview", "record" 869 }; 870 result.append(String8::format(" Active request: %s (paused: %s)\n", 871 streamTypeString[mActiveRequest], 872 mPaused ? "yes" : "no")); 873 874 write(fd, result.string(), result.size()); 875 876 return OK; 877 } 878 879 }; // namespace camera2 880 }; // namespace android 881