Home | History | Annotate | Download | only in device3 
      1 /*
      2  * Copyright (C) 2013-2018 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 "Camera3-Stream"
     18 #define ATRACE_TAG ATRACE_TAG_CAMERA
     19 //#define LOG_NDEBUG 0
     20 
     21 #include <utils/Log.h>
     22 #include <utils/Trace.h>
     23 #include "device3/Camera3Stream.h"
     24 #include "device3/StatusTracker.h"
     25 
     26 #include <cutils/properties.h>
     27 
     28 namespace android {
     29 
     30 namespace camera3 {
     31 
     32 Camera3Stream::~Camera3Stream() {
     33     sp<StatusTracker> statusTracker = mStatusTracker.promote();
     34     if (statusTracker != 0 && mStatusId != StatusTracker::NO_STATUS_ID) {
     35         statusTracker->removeComponent(mStatusId);
     36     }
     37 }
     38 
     39 Camera3Stream* Camera3Stream::cast(camera3_stream *stream) {
     40     return static_cast<Camera3Stream*>(stream);
     41 }
     42 
     43 const Camera3Stream* Camera3Stream::cast(const camera3_stream *stream) {
     44     return static_cast<const Camera3Stream*>(stream);
     45 }
     46 
     47 Camera3Stream::Camera3Stream(int id,
     48         camera3_stream_type type,
     49         uint32_t width, uint32_t height, size_t maxSize, int format,
     50         android_dataspace dataSpace, camera3_stream_rotation_t rotation,
     51         const String8& physicalCameraId, int setId) :
     52     camera3_stream(),
     53     mId(id),
     54     mSetId(setId),
     55     mName(String8::format("Camera3Stream[%d]", id)),
     56     mMaxSize(maxSize),
     57     mState(STATE_CONSTRUCTED),
     58     mStatusId(StatusTracker::NO_STATUS_ID),
     59     mStreamUnpreparable(true),
     60     mUsage(0),
     61     mOldUsage(0),
     62     mOldMaxBuffers(0),
     63     mPrepared(false),
     64     mPreparedBufferIdx(0),
     65     mLastMaxCount(Camera3StreamInterface::ALLOCATE_PIPELINE_MAX),
     66     mBufferLimitLatency(kBufferLimitLatencyBinSize),
     67     mFormatOverridden(false),
     68     mOriginalFormat(-1),
     69     mPhysicalCameraId(physicalCameraId) {
     70 
     71     camera3_stream::stream_type = type;
     72     camera3_stream::width = width;
     73     camera3_stream::height = height;
     74     camera3_stream::format = format;
     75     camera3_stream::data_space = dataSpace;
     76     camera3_stream::rotation = rotation;
     77     camera3_stream::max_buffers = 0;
     78     camera3_stream::priv = NULL;
     79     camera3_stream::physical_camera_id = mPhysicalCameraId.string();
     80 
     81     if ((format == HAL_PIXEL_FORMAT_BLOB || format == HAL_PIXEL_FORMAT_RAW_OPAQUE) &&
     82             maxSize == 0) {
     83         ALOGE("%s: BLOB or RAW_OPAQUE format with size == 0", __FUNCTION__);
     84         mState = STATE_ERROR;
     85     }
     86 }
     87 
     88 int Camera3Stream::getId() const {
     89     return mId;
     90 }
     91 
     92 int Camera3Stream::getStreamSetId() const {
     93     return mSetId;
     94 }
     95 
     96 uint32_t Camera3Stream::getWidth() const {
     97     return camera3_stream::width;
     98 }
     99 
    100 uint32_t Camera3Stream::getHeight() const {
    101     return camera3_stream::height;
    102 }
    103 
    104 int Camera3Stream::getFormat() const {
    105     return camera3_stream::format;
    106 }
    107 
    108 android_dataspace Camera3Stream::getDataSpace() const {
    109     return camera3_stream::data_space;
    110 }
    111 
    112 uint64_t Camera3Stream::getUsage() const {
    113     return mUsage;
    114 }
    115 
    116 void Camera3Stream::setUsage(uint64_t usage) {
    117     mUsage = usage;
    118 }
    119 
    120 void Camera3Stream::setFormatOverride(bool formatOverridden) {
    121     mFormatOverridden = formatOverridden;
    122     if (formatOverridden) mOriginalFormat = camera3_stream::format;
    123 }
    124 
    125 bool Camera3Stream::isFormatOverridden() const {
    126     return mFormatOverridden;
    127 }
    128 
    129 int Camera3Stream::getOriginalFormat() const {
    130     return mOriginalFormat;
    131 }
    132 
    133 void Camera3Stream::setDataSpaceOverride(bool dataSpaceOverridden) {
    134     mDataSpaceOverridden = dataSpaceOverridden;
    135     if (dataSpaceOverridden) mOriginalDataSpace = camera3_stream::data_space;
    136 }
    137 
    138 bool Camera3Stream::isDataSpaceOverridden() const {
    139     return mDataSpaceOverridden;
    140 }
    141 
    142 android_dataspace Camera3Stream::getOriginalDataSpace() const {
    143     return mOriginalDataSpace;
    144 }
    145 
    146 const String8& Camera3Stream::physicalCameraId() const {
    147     return mPhysicalCameraId;
    148 }
    149 
    150 status_t Camera3Stream::forceToIdle() {
    151     ATRACE_CALL();
    152     Mutex::Autolock l(mLock);
    153     status_t res;
    154 
    155     switch (mState) {
    156         case STATE_ERROR:
    157         case STATE_CONSTRUCTED:
    158         case STATE_IN_CONFIG:
    159         case STATE_PREPARING:
    160         case STATE_IN_RECONFIG:
    161             ALOGE("%s: Invalid state: %d", __FUNCTION__, mState);
    162             res = NO_INIT;
    163             break;
    164         case STATE_CONFIGURED:
    165             if (hasOutstandingBuffersLocked()) {
    166                 sp<StatusTracker> statusTracker = mStatusTracker.promote();
    167                 if (statusTracker != 0) {
    168                     statusTracker->markComponentIdle(mStatusId, Fence::NO_FENCE);
    169                 }
    170             }
    171 
    172             mState = STATE_IN_IDLE;
    173             res = OK;
    174 
    175             break;
    176         default:
    177             ALOGE("%s: Unknown state %d", __FUNCTION__, mState);
    178             res = NO_INIT;
    179     }
    180 
    181     return res;
    182 }
    183 
    184 status_t Camera3Stream::restoreConfiguredState() {
    185     ATRACE_CALL();
    186     Mutex::Autolock l(mLock);
    187     status_t res;
    188 
    189     switch (mState) {
    190         case STATE_ERROR:
    191         case STATE_CONSTRUCTED:
    192         case STATE_IN_CONFIG:
    193         case STATE_PREPARING:
    194         case STATE_IN_RECONFIG:
    195         case STATE_CONFIGURED:
    196             ALOGE("%s: Invalid state: %d", __FUNCTION__, mState);
    197             res = NO_INIT;
    198             break;
    199         case STATE_IN_IDLE:
    200             if (hasOutstandingBuffersLocked()) {
    201                 sp<StatusTracker> statusTracker = mStatusTracker.promote();
    202                 if (statusTracker != 0) {
    203                     statusTracker->markComponentActive(mStatusId);
    204                 }
    205             }
    206 
    207             mState = STATE_CONFIGURED;
    208             res = OK;
    209 
    210             break;
    211         default:
    212             ALOGE("%s: Unknown state %d", __FUNCTION__, mState);
    213             res = NO_INIT;
    214     }
    215 
    216     return res;
    217 }
    218 
    219 camera3_stream* Camera3Stream::startConfiguration() {
    220     ATRACE_CALL();
    221     Mutex::Autolock l(mLock);
    222     status_t res;
    223 
    224     switch (mState) {
    225         case STATE_ERROR:
    226             ALOGE("%s: In error state", __FUNCTION__);
    227             return NULL;
    228         case STATE_CONSTRUCTED:
    229         case STATE_IN_IDLE:
    230             // OK
    231             break;
    232         case STATE_IN_CONFIG:
    233         case STATE_IN_RECONFIG:
    234             // Can start config again with no trouble; but don't redo
    235             // mOldUsage/mOldMaxBuffers
    236             return this;
    237         case STATE_CONFIGURED:
    238             if (hasOutstandingBuffersLocked()) {
    239                 ALOGE("%s: Cannot configure stream; has outstanding buffers",
    240                         __FUNCTION__);
    241                 return NULL;
    242             }
    243             break;
    244         default:
    245             ALOGE("%s: Unknown state %d", __FUNCTION__, mState);
    246             return NULL;
    247     }
    248 
    249     mOldUsage = mUsage;
    250     mOldMaxBuffers = camera3_stream::max_buffers;
    251 
    252     res = getEndpointUsage(&mUsage);
    253     if (res != OK) {
    254         ALOGE("%s: Cannot query consumer endpoint usage!",
    255                 __FUNCTION__);
    256         return NULL;
    257     }
    258 
    259     if (mState == STATE_IN_IDLE) {
    260         // Skip configuration.
    261         return this;
    262     }
    263 
    264     // Stop tracking if currently doing so
    265     if (mStatusId != StatusTracker::NO_STATUS_ID) {
    266         sp<StatusTracker> statusTracker = mStatusTracker.promote();
    267         if (statusTracker != 0) {
    268             statusTracker->removeComponent(mStatusId);
    269         }
    270         mStatusId = StatusTracker::NO_STATUS_ID;
    271     }
    272 
    273     if (mState == STATE_CONSTRUCTED) {
    274         mState = STATE_IN_CONFIG;
    275     } else { // mState == STATE_CONFIGURED
    276         LOG_ALWAYS_FATAL_IF(mState != STATE_CONFIGURED, "Invalid state: 0x%x", mState);
    277         mState = STATE_IN_RECONFIG;
    278     }
    279 
    280     return this;
    281 }
    282 
    283 bool Camera3Stream::isConfiguring() const {
    284     Mutex::Autolock l(mLock);
    285     return (mState == STATE_IN_CONFIG) || (mState == STATE_IN_RECONFIG);
    286 }
    287 
    288 status_t Camera3Stream::finishConfiguration() {
    289     ATRACE_CALL();
    290     Mutex::Autolock l(mLock);
    291     switch (mState) {
    292         case STATE_ERROR:
    293             ALOGE("%s: In error state", __FUNCTION__);
    294             return INVALID_OPERATION;
    295         case STATE_IN_CONFIG:
    296         case STATE_IN_RECONFIG:
    297             // OK
    298             break;
    299         case STATE_CONSTRUCTED:
    300         case STATE_CONFIGURED:
    301             ALOGE("%s: Cannot finish configuration that hasn't been started",
    302                     __FUNCTION__);
    303             return INVALID_OPERATION;
    304         case STATE_IN_IDLE:
    305             //Skip configuration in this state
    306             return OK;
    307         default:
    308             ALOGE("%s: Unknown state", __FUNCTION__);
    309             return INVALID_OPERATION;
    310     }
    311 
    312     // Register for idle tracking
    313     sp<StatusTracker> statusTracker = mStatusTracker.promote();
    314     if (statusTracker != 0) {
    315         mStatusId = statusTracker->addComponent();
    316     }
    317 
    318     // Check if the stream configuration is unchanged, and skip reallocation if
    319     // so. As documented in hardware/camera3.h:configure_streams().
    320     if (mState == STATE_IN_RECONFIG &&
    321             mOldUsage == mUsage &&
    322             mOldMaxBuffers == camera3_stream::max_buffers) {
    323         mState = STATE_CONFIGURED;
    324         return OK;
    325     }
    326 
    327     // Reset prepared state, since buffer config has changed, and existing
    328     // allocations are no longer valid
    329     mPrepared = false;
    330     mStreamUnpreparable = false;
    331 
    332     status_t res;
    333     res = configureQueueLocked();
    334     if (res != OK) {
    335         ALOGE("%s: Unable to configure stream %d queue: %s (%d)",
    336                 __FUNCTION__, mId, strerror(-res), res);
    337         mState = STATE_ERROR;
    338         return res;
    339     }
    340 
    341     mState = STATE_CONFIGURED;
    342 
    343     return res;
    344 }
    345 
    346 status_t Camera3Stream::cancelConfiguration() {
    347     ATRACE_CALL();
    348     Mutex::Autolock l(mLock);
    349     switch (mState) {
    350         case STATE_ERROR:
    351             ALOGE("%s: In error state", __FUNCTION__);
    352             return INVALID_OPERATION;
    353         case STATE_IN_CONFIG:
    354         case STATE_IN_RECONFIG:
    355         case STATE_IN_IDLE:
    356             // OK
    357             break;
    358         case STATE_CONSTRUCTED:
    359         case STATE_CONFIGURED:
    360             ALOGE("%s: Cannot cancel configuration that hasn't been started",
    361                     __FUNCTION__);
    362             return INVALID_OPERATION;
    363         default:
    364             ALOGE("%s: Unknown state", __FUNCTION__);
    365             return INVALID_OPERATION;
    366     }
    367 
    368     mUsage = mOldUsage;
    369     camera3_stream::max_buffers = mOldMaxBuffers;
    370 
    371     mState = ((mState == STATE_IN_RECONFIG) || (mState == STATE_IN_IDLE)) ? STATE_CONFIGURED :
    372             STATE_CONSTRUCTED;
    373 
    374     return OK;
    375 }
    376 
    377 bool Camera3Stream::isUnpreparable() {
    378     ATRACE_CALL();
    379 
    380     Mutex::Autolock l(mLock);
    381     return mStreamUnpreparable;
    382 }
    383 
    384 status_t Camera3Stream::startPrepare(int maxCount) {
    385     ATRACE_CALL();
    386 
    387     Mutex::Autolock l(mLock);
    388 
    389     if (maxCount < 0) {
    390         ALOGE("%s: Stream %d: Can't prepare stream if max buffer count (%d) is < 0",
    391                 __FUNCTION__, mId, maxCount);
    392         return BAD_VALUE;
    393     }
    394 
    395     // This function should be only called when the stream is configured already.
    396     if (mState != STATE_CONFIGURED) {
    397         ALOGE("%s: Stream %d: Can't prepare stream if stream is not in CONFIGURED "
    398                 "state %d", __FUNCTION__, mId, mState);
    399         return INVALID_OPERATION;
    400     }
    401 
    402     // This function can't be called if the stream has already received filled
    403     // buffers
    404     if (mStreamUnpreparable) {
    405         ALOGE("%s: Stream %d: Can't prepare stream that's already in use",
    406                 __FUNCTION__, mId);
    407         return INVALID_OPERATION;
    408     }
    409 
    410     if (getHandoutOutputBufferCountLocked() > 0) {
    411         ALOGE("%s: Stream %d: Can't prepare stream that has outstanding buffers",
    412                 __FUNCTION__, mId);
    413         return INVALID_OPERATION;
    414     }
    415 
    416 
    417 
    418     size_t pipelineMax = getBufferCountLocked();
    419     size_t clampedCount = (pipelineMax < static_cast<size_t>(maxCount)) ?
    420             pipelineMax : static_cast<size_t>(maxCount);
    421     size_t bufferCount = (maxCount == Camera3StreamInterface::ALLOCATE_PIPELINE_MAX) ?
    422             pipelineMax : clampedCount;
    423 
    424     mPrepared = bufferCount <= mLastMaxCount;
    425 
    426     if (mPrepared) return OK;
    427 
    428     mLastMaxCount = bufferCount;
    429 
    430     mPreparedBuffers.insertAt(camera3_stream_buffer_t(), /*index*/0, bufferCount);
    431     mPreparedBufferIdx = 0;
    432 
    433     mState = STATE_PREPARING;
    434 
    435     return NOT_ENOUGH_DATA;
    436 }
    437 
    438 bool Camera3Stream::isPreparing() const {
    439     Mutex::Autolock l(mLock);
    440     return mState == STATE_PREPARING;
    441 }
    442 
    443 bool Camera3Stream::isAbandoned() const {
    444     Mutex::Autolock l(mLock);
    445     return mState == STATE_ABANDONED;
    446 }
    447 
    448 status_t Camera3Stream::prepareNextBuffer() {
    449     ATRACE_CALL();
    450 
    451     Mutex::Autolock l(mLock);
    452     status_t res = OK;
    453 
    454     // This function should be only called when the stream is preparing
    455     if (mState != STATE_PREPARING) {
    456         ALOGE("%s: Stream %d: Can't prepare buffer if stream is not in PREPARING "
    457                 "state %d", __FUNCTION__, mId, mState);
    458         return INVALID_OPERATION;
    459     }
    460 
    461     // Get next buffer - this may allocate, and take a while for large buffers
    462     res = getBufferLocked( &mPreparedBuffers.editItemAt(mPreparedBufferIdx) );
    463     if (res != OK) {
    464         ALOGE("%s: Stream %d: Unable to allocate buffer %zu during preparation",
    465                 __FUNCTION__, mId, mPreparedBufferIdx);
    466         return NO_INIT;
    467     }
    468 
    469     mPreparedBufferIdx++;
    470 
    471     // Check if we still have buffers left to allocate
    472     if (mPreparedBufferIdx < mPreparedBuffers.size()) {
    473         return NOT_ENOUGH_DATA;
    474     }
    475 
    476     // Done with prepare - mark stream as such, and return all buffers
    477     // via cancelPrepare
    478     mPrepared = true;
    479 
    480     return cancelPrepareLocked();
    481 }
    482 
    483 status_t Camera3Stream::cancelPrepare() {
    484     ATRACE_CALL();
    485 
    486     Mutex::Autolock l(mLock);
    487 
    488     return cancelPrepareLocked();
    489 }
    490 
    491 status_t Camera3Stream::cancelPrepareLocked() {
    492     status_t res = OK;
    493 
    494     // This function should be only called when the stream is mid-preparing.
    495     if (mState != STATE_PREPARING) {
    496         ALOGE("%s: Stream %d: Can't cancel prepare stream if stream is not in "
    497                 "PREPARING state %d", __FUNCTION__, mId, mState);
    498         return INVALID_OPERATION;
    499     }
    500 
    501     // Return all valid buffers to stream, in ERROR state to indicate
    502     // they weren't filled.
    503     for (size_t i = 0; i < mPreparedBufferIdx; i++) {
    504         mPreparedBuffers.editItemAt(i).release_fence = -1;
    505         mPreparedBuffers.editItemAt(i).status = CAMERA3_BUFFER_STATUS_ERROR;
    506         returnBufferLocked(mPreparedBuffers[i], 0);
    507     }
    508     mPreparedBuffers.clear();
    509     mPreparedBufferIdx = 0;
    510 
    511     mState = STATE_CONFIGURED;
    512 
    513     return res;
    514 }
    515 
    516 status_t Camera3Stream::tearDown() {
    517     ATRACE_CALL();
    518     Mutex::Autolock l(mLock);
    519 
    520     status_t res = OK;
    521 
    522     // This function should be only called when the stream is configured.
    523     if (mState != STATE_CONFIGURED) {
    524         ALOGE("%s: Stream %d: Can't tear down stream if stream is not in "
    525                 "CONFIGURED state %d", __FUNCTION__, mId, mState);
    526         return INVALID_OPERATION;
    527     }
    528 
    529     // If any buffers have been handed to the HAL, the stream cannot be torn down.
    530     if (getHandoutOutputBufferCountLocked() > 0) {
    531         ALOGE("%s: Stream %d: Can't tear down a stream that has outstanding buffers",
    532                 __FUNCTION__, mId);
    533         return INVALID_OPERATION;
    534     }
    535 
    536     // Free buffers by disconnecting and then reconnecting to the buffer queue
    537     // Only unused buffers will be dropped immediately; buffers that have been filled
    538     // and are waiting to be acquired by the consumer and buffers that are currently
    539     // acquired will be freed once they are released by the consumer.
    540 
    541     res = disconnectLocked();
    542     if (res != OK) {
    543         if (res == -ENOTCONN) {
    544             // queue has been disconnected, nothing left to do, so exit with success
    545             return OK;
    546         }
    547         ALOGE("%s: Stream %d: Unable to disconnect to tear down buffers: %s (%d)",
    548                 __FUNCTION__, mId, strerror(-res), res);
    549         return res;
    550     }
    551 
    552     mState = STATE_IN_CONFIG;
    553 
    554     res = configureQueueLocked();
    555     if (res != OK) {
    556         ALOGE("%s: Unable to configure stream %d queue: %s (%d)",
    557                 __FUNCTION__, mId, strerror(-res), res);
    558         mState = STATE_ERROR;
    559         return res;
    560     }
    561 
    562     // Reset prepared state, since we've reconnected to the queue and can prepare again.
    563     mPrepared = false;
    564     mStreamUnpreparable = false;
    565 
    566     mState = STATE_CONFIGURED;
    567 
    568     return OK;
    569 }
    570 
    571 status_t Camera3Stream::getBuffer(camera3_stream_buffer *buffer,
    572         const std::vector<size_t>& surface_ids) {
    573     ATRACE_CALL();
    574     Mutex::Autolock l(mLock);
    575     status_t res = OK;
    576 
    577     // This function should be only called when the stream is configured already.
    578     if (mState != STATE_CONFIGURED) {
    579         ALOGE("%s: Stream %d: Can't get buffers if stream is not in CONFIGURED state %d",
    580                 __FUNCTION__, mId, mState);
    581         return INVALID_OPERATION;
    582     }
    583 
    584     // Wait for new buffer returned back if we are running into the limit.
    585     if (getHandoutOutputBufferCountLocked() == camera3_stream::max_buffers) {
    586         ALOGV("%s: Already dequeued max output buffers (%d), wait for next returned one.",
    587                         __FUNCTION__, camera3_stream::max_buffers);
    588         nsecs_t waitStart = systemTime(SYSTEM_TIME_MONOTONIC);
    589         res = mOutputBufferReturnedSignal.waitRelative(mLock, kWaitForBufferDuration);
    590         nsecs_t waitEnd = systemTime(SYSTEM_TIME_MONOTONIC);
    591         mBufferLimitLatency.add(waitStart, waitEnd);
    592         if (res != OK) {
    593             if (res == TIMED_OUT) {
    594                 ALOGE("%s: wait for output buffer return timed out after %lldms (max_buffers %d)",
    595                         __FUNCTION__, kWaitForBufferDuration / 1000000LL,
    596                         camera3_stream::max_buffers);
    597             }
    598             return res;
    599         }
    600     }
    601 
    602     res = getBufferLocked(buffer, surface_ids);
    603     if (res == OK) {
    604         fireBufferListenersLocked(*buffer, /*acquired*/true, /*output*/true);
    605         if (buffer->buffer) {
    606             Mutex::Autolock l(mOutstandingBuffersLock);
    607             mOutstandingBuffers.push_back(*buffer->buffer);
    608         }
    609     }
    610 
    611     return res;
    612 }
    613 
    614 bool Camera3Stream::isOutstandingBuffer(const camera3_stream_buffer &buffer) const{
    615     if (buffer.buffer == nullptr) {
    616         return false;
    617     }
    618 
    619     Mutex::Autolock l(mOutstandingBuffersLock);
    620 
    621     for (auto b : mOutstandingBuffers) {
    622         if (b == *buffer.buffer) {
    623             return true;
    624         }
    625     }
    626     return false;
    627 }
    628 
    629 void Camera3Stream::removeOutstandingBuffer(const camera3_stream_buffer &buffer) {
    630     if (buffer.buffer == nullptr) {
    631         return;
    632     }
    633 
    634     Mutex::Autolock l(mOutstandingBuffersLock);
    635 
    636     for (auto b = mOutstandingBuffers.begin(); b != mOutstandingBuffers.end(); b++) {
    637         if (*b == *buffer.buffer) {
    638             mOutstandingBuffers.erase(b);
    639             return;
    640         }
    641     }
    642 }
    643 
    644 status_t Camera3Stream::returnBuffer(const camera3_stream_buffer &buffer,
    645         nsecs_t timestamp) {
    646     ATRACE_CALL();
    647     Mutex::Autolock l(mLock);
    648 
    649     // Check if this buffer is outstanding.
    650     if (!isOutstandingBuffer(buffer)) {
    651         ALOGE("%s: Stream %d: Returning an unknown buffer.", __FUNCTION__, mId);
    652         return BAD_VALUE;
    653     }
    654 
    655     removeOutstandingBuffer(buffer);
    656 
    657     /**
    658      * TODO: Check that the state is valid first.
    659      *
    660      * <HAL3.2 IN_CONFIG and IN_RECONFIG in addition to CONFIGURED.
    661      * >= HAL3.2 CONFIGURED only
    662      *
    663      * Do this for getBuffer as well.
    664      */
    665     status_t res = returnBufferLocked(buffer, timestamp);
    666     if (res == OK) {
    667         fireBufferListenersLocked(buffer, /*acquired*/false, /*output*/true);
    668     }
    669 
    670     // Even if returning the buffer failed, we still want to signal whoever is waiting for the
    671     // buffer to be returned.
    672     mOutputBufferReturnedSignal.signal();
    673 
    674     return res;
    675 }
    676 
    677 status_t Camera3Stream::getInputBuffer(camera3_stream_buffer *buffer, bool respectHalLimit) {
    678     ATRACE_CALL();
    679     Mutex::Autolock l(mLock);
    680     status_t res = OK;
    681 
    682     // This function should be only called when the stream is configured already.
    683     if (mState != STATE_CONFIGURED) {
    684         ALOGE("%s: Stream %d: Can't get input buffers if stream is not in CONFIGURED state %d",
    685                 __FUNCTION__, mId, mState);
    686         return INVALID_OPERATION;
    687     }
    688 
    689     // Wait for new buffer returned back if we are running into the limit.
    690     if (getHandoutInputBufferCountLocked() == camera3_stream::max_buffers && respectHalLimit) {
    691         ALOGV("%s: Already dequeued max input buffers (%d), wait for next returned one.",
    692                 __FUNCTION__, camera3_stream::max_buffers);
    693         res = mInputBufferReturnedSignal.waitRelative(mLock, kWaitForBufferDuration);
    694         if (res != OK) {
    695             if (res == TIMED_OUT) {
    696                 ALOGE("%s: wait for input buffer return timed out after %lldms", __FUNCTION__,
    697                         kWaitForBufferDuration / 1000000LL);
    698             }
    699             return res;
    700         }
    701     }
    702 
    703     res = getInputBufferLocked(buffer);
    704     if (res == OK) {
    705         fireBufferListenersLocked(*buffer, /*acquired*/true, /*output*/false);
    706         if (buffer->buffer) {
    707             Mutex::Autolock l(mOutstandingBuffersLock);
    708             mOutstandingBuffers.push_back(*buffer->buffer);
    709         }
    710     }
    711 
    712     return res;
    713 }
    714 
    715 status_t Camera3Stream::returnInputBuffer(const camera3_stream_buffer &buffer) {
    716     ATRACE_CALL();
    717     Mutex::Autolock l(mLock);
    718 
    719     // Check if this buffer is outstanding.
    720     if (!isOutstandingBuffer(buffer)) {
    721         ALOGE("%s: Stream %d: Returning an unknown buffer.", __FUNCTION__, mId);
    722         return BAD_VALUE;
    723     }
    724 
    725     removeOutstandingBuffer(buffer);
    726 
    727     status_t res = returnInputBufferLocked(buffer);
    728     if (res == OK) {
    729         fireBufferListenersLocked(buffer, /*acquired*/false, /*output*/false);
    730         mInputBufferReturnedSignal.signal();
    731     }
    732 
    733     return res;
    734 }
    735 
    736 status_t Camera3Stream::getInputBufferProducer(sp<IGraphicBufferProducer> *producer) {
    737     ATRACE_CALL();
    738     Mutex::Autolock l(mLock);
    739 
    740     return getInputBufferProducerLocked(producer);
    741 }
    742 
    743 void Camera3Stream::fireBufferListenersLocked(
    744         const camera3_stream_buffer& buffer, bool acquired, bool output) {
    745     List<wp<Camera3StreamBufferListener> >::iterator it, end;
    746 
    747     // TODO: finish implementing
    748 
    749     Camera3StreamBufferListener::BufferInfo info =
    750         Camera3StreamBufferListener::BufferInfo();
    751     info.mOutput = output;
    752     info.mError = (buffer.status == CAMERA3_BUFFER_STATUS_ERROR);
    753     // TODO: rest of fields
    754 
    755     for (it = mBufferListenerList.begin(), end = mBufferListenerList.end();
    756          it != end;
    757          ++it) {
    758 
    759         sp<Camera3StreamBufferListener> listener = it->promote();
    760         if (listener != 0) {
    761             if (acquired) {
    762                 listener->onBufferAcquired(info);
    763             } else {
    764                 listener->onBufferReleased(info);
    765             }
    766         }
    767     }
    768 }
    769 
    770 bool Camera3Stream::hasOutstandingBuffers() const {
    771     ATRACE_CALL();
    772     Mutex::Autolock l(mLock);
    773     return hasOutstandingBuffersLocked();
    774 }
    775 
    776 status_t Camera3Stream::setStatusTracker(sp<StatusTracker> statusTracker) {
    777     Mutex::Autolock l(mLock);
    778     sp<StatusTracker> oldTracker = mStatusTracker.promote();
    779     if (oldTracker != 0 && mStatusId != StatusTracker::NO_STATUS_ID) {
    780         oldTracker->removeComponent(mStatusId);
    781     }
    782     mStatusId = StatusTracker::NO_STATUS_ID;
    783     mStatusTracker = statusTracker;
    784 
    785     return OK;
    786 }
    787 
    788 status_t Camera3Stream::disconnect() {
    789     ATRACE_CALL();
    790     Mutex::Autolock l(mLock);
    791     ALOGV("%s: Stream %d: Disconnecting...", __FUNCTION__, mId);
    792     status_t res = disconnectLocked();
    793 
    794     mBufferLimitLatency.log("Stream %d latency histogram for wait on max_buffers", mId);
    795     mBufferLimitLatency.reset();
    796 
    797     if (res == -ENOTCONN) {
    798         // "Already disconnected" -- not an error
    799         return OK;
    800     } else {
    801         return res;
    802     }
    803 }
    804 
    805 void Camera3Stream::dump(int fd, const Vector<String16> &args) const
    806 {
    807     (void)args;
    808     mBufferLimitLatency.dump(fd,
    809             "      Latency histogram for wait on max_buffers");
    810 }
    811 
    812 status_t Camera3Stream::getBufferLocked(camera3_stream_buffer *,
    813         const std::vector<size_t>&) {
    814     ALOGE("%s: This type of stream does not support output", __FUNCTION__);
    815     return INVALID_OPERATION;
    816 }
    817 status_t Camera3Stream::returnBufferLocked(const camera3_stream_buffer &,
    818                                            nsecs_t) {
    819     ALOGE("%s: This type of stream does not support output", __FUNCTION__);
    820     return INVALID_OPERATION;
    821 }
    822 status_t Camera3Stream::getInputBufferLocked(camera3_stream_buffer *) {
    823     ALOGE("%s: This type of stream does not support input", __FUNCTION__);
    824     return INVALID_OPERATION;
    825 }
    826 status_t Camera3Stream::returnInputBufferLocked(
    827         const camera3_stream_buffer &) {
    828     ALOGE("%s: This type of stream does not support input", __FUNCTION__);
    829     return INVALID_OPERATION;
    830 }
    831 status_t Camera3Stream::getInputBufferProducerLocked(sp<IGraphicBufferProducer>*) {
    832     ALOGE("%s: This type of stream does not support input", __FUNCTION__);
    833     return INVALID_OPERATION;
    834 }
    835 
    836 void Camera3Stream::addBufferListener(
    837         wp<Camera3StreamBufferListener> listener) {
    838     Mutex::Autolock l(mLock);
    839 
    840     List<wp<Camera3StreamBufferListener> >::iterator it, end;
    841     for (it = mBufferListenerList.begin(), end = mBufferListenerList.end();
    842          it != end;
    843          ) {
    844         if (*it == listener) {
    845             ALOGE("%s: Try to add the same listener twice, ignoring...", __FUNCTION__);
    846             return;
    847         }
    848         it++;
    849     }
    850 
    851     mBufferListenerList.push_back(listener);
    852 }
    853 
    854 void Camera3Stream::removeBufferListener(
    855         const sp<Camera3StreamBufferListener>& listener) {
    856     Mutex::Autolock l(mLock);
    857 
    858     bool erased = true;
    859     List<wp<Camera3StreamBufferListener> >::iterator it, end;
    860     for (it = mBufferListenerList.begin(), end = mBufferListenerList.end();
    861          it != end;
    862          ) {
    863 
    864         if (*it == listener) {
    865             it = mBufferListenerList.erase(it);
    866             erased = true;
    867         } else {
    868             ++it;
    869         }
    870     }
    871 
    872     if (!erased) {
    873         ALOGW("%s: Could not find listener to remove, already removed",
    874               __FUNCTION__);
    875     }
    876 }
    877 
    878 void Camera3Stream::setBufferFreedListener(
    879         wp<Camera3StreamBufferFreedListener> listener) {
    880     Mutex::Autolock l(mLock);
    881     // Only allow set listener during stream configuration because stream is guaranteed to be IDLE
    882     // at this state, so setBufferFreedListener won't collide with onBufferFreed callbacks
    883     if (mState != STATE_IN_CONFIG && mState != STATE_IN_RECONFIG) {
    884         ALOGE("%s: listener must be set during stream configuration!",__FUNCTION__);
    885         return;
    886     }
    887     mBufferFreedListener = listener;
    888 }
    889 
    890 }; // namespace camera3
    891 
    892 }; // namespace android
    893