services/camera/libcameraservice/device3/Camera3StreamSplitter.cpp

/*
 * Copyright 2014,2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#define LOG_TAG "Camera3StreamSplitter"
#define ATRACE_TAG ATRACE_TAG_CAMERA
//#define LOG_NDEBUG 0

#include <binder/ProcessState.h>
#include <camera/StringUtils.h>
#include <com_android_graphics_libgui_flags.h>
#include <gui/BufferItem.h>
#include <gui/BufferItemConsumer.h>
#include <gui/BufferQueue.h>
#include <gui/IGraphicBufferConsumer.h>
#include <gui/IGraphicBufferProducer.h>
#include <gui/Surface.h>
#include <system/window.h>
#include <ui/GraphicBuffer.h>
#include <utils/Trace.h>

#include <cutils/atomic.h>
#include <inttypes.h>
#include <algorithm>
#include <cstdint>
#include <memory>

#include "Camera3Stream.h"
#include "Flags.h"

#include "Camera3StreamSplitter.h"

// We're relying on a large number of yet-to-be-fully-launched flag dependencies
// here. So instead of flagging each one, we flag the entire implementation to
// improve legibility.
#if USE_NEW_STREAM_SPLITTER

namespace android {

status_t Camera3StreamSplitter::connect(const std::unordered_map<size_t, sp<Surface>> &surfaces,
        uint64_t consumerUsage, uint64_t producerUsage, size_t halMaxBuffers, uint32_t width,
        uint32_t height, android::PixelFormat format, sp<Surface>* consumer,
        int64_t dynamicRangeProfile) {
    ATRACE_CALL();
    if (consumer == nullptr) {
        SP_LOGE("%s: consumer pointer is NULL", __FUNCTION__);
        return BAD_VALUE;
    }

    Mutex::Autolock lock(mMutex);
    status_t res = OK;

    if (mOutputSurfaces.size() > 0 || mBufferItemConsumer != nullptr) {
        SP_LOGE("%s: already connected", __FUNCTION__);
        return BAD_VALUE;
    }
    if (mBuffers.size() > 0) {
        SP_LOGE("%s: still has %zu pending buffers", __FUNCTION__, mBuffers.size());
        return BAD_VALUE;
    }

    mMaxHalBuffers = halMaxBuffers;
    mConsumerName = getUniqueConsumerName();
    mDynamicRangeProfile = dynamicRangeProfile;
    // Add output surfaces. This has to be before creating internal buffer queue
    // in order to get max consumer side buffers.
    for (auto &it : surfaces) {
        if (it.second == nullptr) {
            SP_LOGE("%s: Fatal: surface is NULL", __FUNCTION__);
            return BAD_VALUE;
        }
        res = addOutputLocked(it.first, it.second);
        if (res != OK) {
            SP_LOGE("%s: Failed to add output surface: %s(%d)",
                    __FUNCTION__, strerror(-res), res);
            return res;
        }
    }

    // Allocate 1 extra buffer to handle the case where all buffers are detached
    // from input, and attached to the outputs. In this case, the input queue's
    // dequeueBuffer can still allocate 1 extra buffer before being blocked by
    // the output's attachBuffer().
    mMaxConsumerBuffers++;

#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
    mBufferItemConsumer = sp<BufferItemConsumer>::make(consumerUsage, mMaxConsumerBuffers);
    mSurface = mBufferItemConsumer->getSurface();
#else
    // Create BufferQueue for input
    sp<IGraphicBufferProducer> bqProducer;
    sp<IGraphicBufferConsumer> bqConsumer;
    BufferQueue::createBufferQueue(&bqProducer, &bqConsumer);

    mBufferItemConsumer = new BufferItemConsumer(bqConsumer, consumerUsage, mMaxConsumerBuffers);
    mSurface = new Surface(bqProducer);
#endif  // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)

    if (mBufferItemConsumer == nullptr) {
        return NO_MEMORY;
    }
    mBufferItemConsumer->setName(toString8(mConsumerName));

    *consumer = mSurface;
    if (*consumer == nullptr) {
        return NO_MEMORY;
    }

    res = mSurface->setAsyncMode(true);
    if (res != OK) {
        SP_LOGE("%s: Failed to enable input queue async mode: %s(%d)", __FUNCTION__,
                strerror(-res), res);
        return res;
    }

    mBufferItemConsumer->setFrameAvailableListener(this);

    mWidth = width;
    mHeight = height;
    mFormat = format;
    mProducerUsage = producerUsage;
    mAcquiredInputBuffers = 0;

    SP_LOGV("%s: connected", __FUNCTION__);
    return res;
}

status_t Camera3StreamSplitter::getOnFrameAvailableResult() {
    ATRACE_CALL();
    return mOnFrameAvailableRes.load();
}

void Camera3StreamSplitter::disconnect() {
    ATRACE_CALL();
    Mutex::Autolock lock(mMutex);

    mNotifiers.clear();

    for (auto& output : mOutputSurfaces) {
        if (output.second != nullptr) {
            output.second->disconnect(NATIVE_WINDOW_API_CAMERA);
        }
    }
    mOutputSurfaces.clear();
    mHeldBuffers.clear();
    mConsumerBufferCount.clear();

    if (mBufferItemConsumer != nullptr) {
        mBufferItemConsumer->abandon();
    }

    if (mBuffers.size() > 0) {
        SP_LOGW("%zu buffers still being tracked", mBuffers.size());
        mBuffers.clear();
    }

    mMaxHalBuffers = 0;
    mMaxConsumerBuffers = 0;
    mAcquiredInputBuffers = 0;
    SP_LOGV("%s: Disconnected", __FUNCTION__);
}

Camera3StreamSplitter::Camera3StreamSplitter(bool useHalBufManager) :
        mUseHalBufManager(useHalBufManager) {}

Camera3StreamSplitter::~Camera3StreamSplitter() {
    disconnect();
}

status_t Camera3StreamSplitter::addOutput(size_t surfaceId, const sp<Surface>& outputQueue) {
    ATRACE_CALL();
    Mutex::Autolock lock(mMutex);
    status_t res = addOutputLocked(surfaceId, outputQueue);

    if (res != OK) {
        SP_LOGE("%s: addOutputLocked failed %d", __FUNCTION__, res);
        return res;
    }

    if (mMaxConsumerBuffers > mAcquiredInputBuffers) {
        res = mBufferItemConsumer->setMaxAcquiredBufferCount(mMaxConsumerBuffers);
    }

    return res;
}

void Camera3StreamSplitter::setHalBufferManager(bool enabled) {
    Mutex::Autolock lock(mMutex);
    mUseHalBufManager = enabled;
}

status_t Camera3StreamSplitter::setTransform(size_t surfaceId, int transform) {
    Mutex::Autolock lock(mMutex);
    if (!mOutputSurfaces.contains(surfaceId) || mOutputSurfaces[surfaceId] == nullptr) {
        SP_LOGE("%s: No surface at id %zu", __FUNCTION__, surfaceId);
        return BAD_VALUE;
    }

    mOutputTransforms[surfaceId] = transform;
    return OK;
}

status_t Camera3StreamSplitter::addOutputLocked(size_t surfaceId, const sp<Surface>& outputQueue) {
    ATRACE_CALL();
    if (outputQueue == nullptr) {
        SP_LOGE("addOutput: outputQueue must not be NULL");
        return BAD_VALUE;
    }

    if (mOutputSurfaces[surfaceId] != nullptr) {
        SP_LOGE("%s: surfaceId: %u already taken!", __FUNCTION__, (unsigned) surfaceId);
        return BAD_VALUE;
    }

    status_t res = native_window_set_buffers_dimensions(outputQueue.get(),
            mWidth, mHeight);
    if (res != NO_ERROR) {
        SP_LOGE("addOutput: failed to set buffer dimensions (%d)", res);
        return res;
    }
    res = native_window_set_buffers_format(outputQueue.get(),
            mFormat);
    if (res != OK) {
        ALOGE("%s: Unable to configure stream buffer format %#x for surfaceId %zu",
                __FUNCTION__, mFormat, surfaceId);
        return res;
    }

    // Connect to the buffer producer
    sp<OutputListener> listener = sp<OutputListener>::make(this, outputQueue);
    res = outputQueue->connect(NATIVE_WINDOW_API_CAMERA, listener, /* reportBufferRemoval */ false);
    if (res != NO_ERROR) {
        SP_LOGE("addOutput: failed to connect (%d)", res);
        return res;
    }

    // Query consumer side buffer count, and update overall buffer count
    int maxConsumerBuffers = 0;
    res = static_cast<ANativeWindow*>(outputQueue.get())->query(
            outputQueue.get(),
            NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &maxConsumerBuffers);
    if (res != OK) {
        SP_LOGE("%s: Unable to query consumer undequeued buffer count"
              " for surface", __FUNCTION__);
        return res;
    }

    SP_LOGV("%s: Consumer wants %d buffers, Producer wants %zu", __FUNCTION__,
            maxConsumerBuffers, mMaxHalBuffers);
    // The output slot count requirement can change depending on the current amount
    // of outputs and incoming buffer consumption rate. To avoid any issues with
    // insufficient slots, set their count to the maximum supported. The output
    // surface buffer allocation is disabled so no real buffers will get allocated.
    size_t totalBufferCount = BufferQueue::NUM_BUFFER_SLOTS;
    res = native_window_set_buffer_count(outputQueue.get(),
            totalBufferCount);
    if (res != OK) {
        SP_LOGE("%s: Unable to set buffer count for surface %p",
                __FUNCTION__, outputQueue.get());
        return res;
    }

    // Set dequeueBuffer/attachBuffer timeout if the consumer is not hw composer or hw texture.
    // We need skip these cases as timeout will disable the non-blocking (async) mode.
    uint64_t usage = 0;
    res = native_window_get_consumer_usage(static_cast<ANativeWindow*>(outputQueue.get()), &usage);
    if (!(usage & (GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_TEXTURE))) {
        nsecs_t timeout = mUseHalBufManager ?
                kHalBufMgrDequeueBufferTimeout : kNormalDequeueBufferTimeout;
        outputQueue->setDequeueTimeout(timeout);
    }

    res = outputQueue->allowAllocation(false);
    if (res != OK) {
        SP_LOGE("%s: Failed to turn off allocation for outputQueue", __FUNCTION__);
        return res;
    }

    // Add new entry into mOutputs
    mOutputSurfaces[surfaceId] = outputQueue;
    mConsumerBufferCount[surfaceId] = maxConsumerBuffers;
    if (mConsumerBufferCount[surfaceId] > mMaxHalBuffers) {
        SP_LOGW("%s: Consumer buffer count %zu larger than max. Hal buffers: %zu", __FUNCTION__,
                mConsumerBufferCount[surfaceId], mMaxHalBuffers);
    }
    mNotifiers[outputQueue] = listener;
    mHeldBuffers[outputQueue] = std::make_unique<HeldBuffers>(totalBufferCount);

    mMaxConsumerBuffers += maxConsumerBuffers;
    return NO_ERROR;
}

status_t Camera3StreamSplitter::removeOutput(size_t surfaceId) {
    ATRACE_CALL();
    Mutex::Autolock lock(mMutex);

    status_t res = removeOutputLocked(surfaceId);
    if (res != OK) {
        SP_LOGE("%s: removeOutputLocked failed %d", __FUNCTION__, res);
        return res;
    }

    if (mAcquiredInputBuffers < mMaxConsumerBuffers) {
        res = mBufferItemConsumer->setMaxAcquiredBufferCount(mMaxConsumerBuffers);
        if (res != OK) {
            SP_LOGE("%s: setMaxAcquiredBufferCount failed %d", __FUNCTION__, res);
            return res;
        }
    }

    return res;
}

status_t Camera3StreamSplitter::removeOutputLocked(size_t surfaceId) {
    if (mOutputSurfaces[surfaceId] == nullptr) {
        SP_LOGE("%s: output surface is not present!", __FUNCTION__);
        return BAD_VALUE;
    }

    sp<Surface> surface = mOutputSurfaces[surfaceId];
    //Search and decrement the ref. count of any buffers that are
    //still attached to the removed surface.
    std::vector<uint64_t> pendingBufferIds;

    // TODO: can we simplify this to just use the tracker?
    for (const auto& buffer : (*mHeldBuffers[surface])) {
        pendingBufferIds.push_back(buffer->getId());
        auto rc = surface->detachBuffer(buffer);
        if (rc != NO_ERROR) {
            // Buffers that fail to detach here will be scheduled for detach in the
            // input buffer queue and the rest of the registered outputs instead.
            // This will help ensure that camera stops accessing buffers that still
            // can get referenced by the disconnected output.
            mDetachedBuffers.emplace(buffer->getId());
        }
    }
    mOutputSurfaces[surfaceId] = nullptr;
    mHeldBuffers[surface] = nullptr;
    for (const auto &id : pendingBufferIds) {
        decrementBufRefCountLocked(id, surfaceId);
    }

    status_t res = surface->disconnect(NATIVE_WINDOW_API_CAMERA);
    if (res != OK) {
        SP_LOGE("%s: Unable disconnect from producer interface: %d ", __FUNCTION__, res);
        return res;
    }

    mNotifiers[surface] = nullptr;
    mMaxConsumerBuffers -= mConsumerBufferCount[surfaceId];
    mConsumerBufferCount[surfaceId] = 0;

    return res;
}

status_t Camera3StreamSplitter::outputBufferLocked(const sp<Surface>& output,
        const BufferItem& bufferItem, size_t surfaceId) {
    ATRACE_CALL();
    status_t res;

    uint64_t bufferId = bufferItem.mGraphicBuffer->getId();
    const BufferTracker& tracker = *(mBuffers[bufferId]);

    if (mOutputSurfaces[surfaceId] != nullptr) {
        sp<ANativeWindow> anw = mOutputSurfaces[surfaceId];
        camera3::Camera3Stream::queueHDRMetadata(
                bufferItem.mGraphicBuffer->getNativeBuffer()->handle, anw, mDynamicRangeProfile);
    } else {
        SP_LOGE("%s: Invalid surface id: %zu!", __FUNCTION__, surfaceId);
    }

    output->setBuffersTimestamp(bufferItem.mTimestamp);
    output->setBuffersDataSpace(static_cast<ui::Dataspace>(bufferItem.mDataSpace));
    output->setCrop(&bufferItem.mCrop);
    output->setScalingMode(bufferItem.mScalingMode);

    int transform = bufferItem.mTransform;
    if (mOutputTransforms.contains(surfaceId)) {
        transform = mOutputTransforms[surfaceId];
    }
    output->setBuffersTransform(transform);

    // In case the output BufferQueue has its own lock, if we hold splitter lock while calling
    // queueBuffer (which will try to acquire the output lock), the output could be holding its
    // own lock calling releaseBuffer (which  will try to acquire the splitter lock), running into
    // circular lock situation.
    mMutex.unlock();
    SurfaceQueueBufferOutput queueBufferOutput;
    res = output->queueBuffer(bufferItem.mGraphicBuffer, bufferItem.mFence, &queueBufferOutput);
    mMutex.lock();

    SP_LOGV("%s: Queuing buffer to buffer queue %p bufferId %" PRIu64 " returns %d", __FUNCTION__,
            output.get(), bufferId, res);
    // During buffer queue 'mMutex' is not held which makes the removal of
    // "output" possible. Check whether this is the case and return.
    if (mOutputSurfaces[surfaceId] == nullptr) {
        return res;
    }
    if (res != OK) {
        if (res != NO_INIT && res != DEAD_OBJECT) {
            SP_LOGE("Queuing buffer to output failed (%d)", res);
        }
        // If we just discovered that this output has been abandoned, note
        // that, increment the release count so that we still release this
        // buffer eventually, and move on to the next output
        onAbandonedLocked();
        decrementBufRefCountLocked(bufferItem.mGraphicBuffer->getId(), surfaceId);
        return res;
    }

    // If the queued buffer replaces a pending buffer in the async
    // queue, no onBufferReleased is called by the buffer queue.
    // Proactively trigger the callback to avoid buffer loss.
    if (queueBufferOutput.bufferReplaced) {
        onBufferReplacedLocked(output, surfaceId);
    }

    return res;
}

std::string Camera3StreamSplitter::getUniqueConsumerName() {
    static volatile int32_t counter = 0;
    return fmt::sprintf("Camera3StreamSplitter-%d", android_atomic_inc(&counter));
}

status_t Camera3StreamSplitter::notifyBufferReleased(const sp<GraphicBuffer>& buffer) {
    ATRACE_CALL();

    Mutex::Autolock lock(mMutex);

    uint64_t bufferId = buffer->getId();
    std::unique_ptr<BufferTracker> tracker_ptr = std::move(mBuffers[bufferId]);
    mBuffers.erase(bufferId);

    return OK;
}

status_t Camera3StreamSplitter::attachBufferToOutputs(ANativeWindowBuffer* anb,
        const std::vector<size_t>& surface_ids) {
    ATRACE_CALL();
    status_t res = OK;

    Mutex::Autolock lock(mMutex);

    sp<GraphicBuffer> gb(static_cast<GraphicBuffer*>(anb));
    uint64_t bufferId = gb->getId();

    // Initialize buffer tracker for this input buffer
    auto tracker = std::make_unique<BufferTracker>(gb, surface_ids);

    for (auto& surface_id : surface_ids) {
        sp<Surface>& surface = mOutputSurfaces[surface_id];
        if (surface.get() == nullptr) {
            //Output surface got likely removed by client.
            continue;
        }

        //Temporarly Unlock the mutex when trying to attachBuffer to the output
        //queue, because attachBuffer could block in case of a slow consumer. If
        //we block while holding the lock, onFrameAvailable and onBufferReleased
        //will block as well because they need to acquire the same lock.
        mMutex.unlock();
        res = surface->attachBuffer(anb);
        mMutex.lock();
        if (res != OK) {
            SP_LOGE("%s: Cannot attachBuffer from GraphicBufferProducer %p: %s (%d)", __FUNCTION__,
                    surface.get(), strerror(-res), res);
            // TODO: might need to detach/cleanup the already attached buffers before return?
            return res;
        }
        //During buffer attach 'mMutex' is not held which makes the removal of
        //"gbp" possible. Check whether this is the case and continue.
        if (mHeldBuffers[surface] == nullptr) {
            continue;
        }
        mHeldBuffers[surface]->insert(gb);
        SP_LOGV("%s: Attached buffer %p on output %p.", __FUNCTION__, gb.get(), surface.get());
    }

    mBuffers[bufferId] = std::move(tracker);

    return res;
}

void Camera3StreamSplitter::onFrameAvailable(const BufferItem& /*item*/) {
    ATRACE_CALL();
    Mutex::Autolock lock(mMutex);

    // Acquire and detach the buffer from the input
    BufferItem bufferItem;
    status_t res = mBufferItemConsumer->acquireBuffer(&bufferItem, /* presentWhen */ 0);
    if (res != NO_ERROR) {
        SP_LOGE("%s: Acquiring buffer from input failed (%d)", __FUNCTION__, res);
        mOnFrameAvailableRes.store(res);
        return;
    }

    uint64_t bufferId = bufferItem.mGraphicBuffer->getId();

    if (mBuffers.find(bufferId) == mBuffers.end()) {
        SP_LOGE("%s: Acquired buffer doesn't exist in attached buffer map",
                __FUNCTION__);
        mOnFrameAvailableRes.store(INVALID_OPERATION);
        return;
    }

    mAcquiredInputBuffers++;
    SP_LOGV("acquired buffer %" PRId64 " from input at slot %d",
            bufferItem.mGraphicBuffer->getId(), bufferItem.mSlot);

    if (bufferItem.mTransformToDisplayInverse) {
        bufferItem.mTransform |= NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY;
    }

    // Attach and queue the buffer to each of the outputs
    BufferTracker& tracker = *(mBuffers[bufferId]);

    SP_LOGV("%s: BufferTracker for buffer %" PRId64 ", number of requests %zu",
           __FUNCTION__, bufferItem.mGraphicBuffer->getId(), tracker.requestedSurfaces().size());
    for (const auto id : tracker.requestedSurfaces()) {
        if (mOutputSurfaces[id] == nullptr) {
            //Output surface got likely removed by client.
            continue;
        }

        res = outputBufferLocked(mOutputSurfaces[id], bufferItem, id);
        if (res != OK) {
            SP_LOGE("%s: outputBufferLocked failed %d", __FUNCTION__, res);
            mOnFrameAvailableRes.store(res);
            // If we fail to send buffer to certain output, keep sending to
            // other outputs.
            continue;
        }
    }

    mOnFrameAvailableRes.store(res);
}

void Camera3StreamSplitter::onFrameReplaced(const BufferItem& item) {
    ATRACE_CALL();
    onFrameAvailable(item);
}

void Camera3StreamSplitter::decrementBufRefCountLocked(uint64_t id, size_t surfaceId) {
    ATRACE_CALL();

    if (mBuffers[id] == nullptr) {
        return;
    }

    size_t referenceCount = mBuffers[id]->decrementReferenceCountLocked(surfaceId);
    if (referenceCount > 0) {
        return;
    }

    // We no longer need to track the buffer now that it is being returned to the
    // input. Note that this should happen before we unlock the mutex and call
    // releaseBuffer, to avoid the case where the same bufferId is acquired in
    // attachBufferToOutputs resulting in a new BufferTracker with same bufferId
    // overwrites the current one.
    std::unique_ptr<BufferTracker> tracker_ptr = std::move(mBuffers[id]);
    mBuffers.erase(id);

    uint64_t bufferId = tracker_ptr->getBuffer()->getId();

    auto detachBuffer = mDetachedBuffers.find(bufferId);
    bool detach = (detachBuffer != mDetachedBuffers.end());
    if (detach) {
        mDetachedBuffers.erase(detachBuffer);
    }
    // Temporarily unlock mutex to avoid circular lock:
    // 1. This function holds splitter lock, calls releaseBuffer which triggers
    // onBufferReleased in Camera3OutputStream. onBufferReleased waits on the
    // OutputStream lock
    // 2. Camera3SharedOutputStream::getBufferLocked calls
    // attachBufferToOutputs, which holds the stream lock, and waits for the
    // splitter lock.
    mMutex.unlock();
    int res = NO_ERROR;
    if (mBufferItemConsumer != nullptr) {
        if (detach) {
            res = mBufferItemConsumer->detachBuffer(tracker_ptr->getBuffer());
        } else {
            res = mBufferItemConsumer->releaseBuffer(tracker_ptr->getBuffer(),
                                                     tracker_ptr->getMergedFence());
        }
    } else {
        SP_LOGE("%s: consumer has become null!", __FUNCTION__);
    }
    mMutex.lock();

    if (res != NO_ERROR) {
        if (detach) {
            SP_LOGE("%s: detachBuffer returns %d", __FUNCTION__, res);
        } else {
            SP_LOGE("%s: releaseBuffer returns %d", __FUNCTION__, res);
        }
    } else {
        if (mAcquiredInputBuffers == 0) {
            ALOGW("%s: Acquired input buffer count already at zero!", __FUNCTION__);
        } else {
            mAcquiredInputBuffers--;
        }
    }
}

void Camera3StreamSplitter::onBufferReleasedByOutput(const sp<Surface>& from) {
    ATRACE_CALL();

    from->setBuffersDimensions(mWidth, mHeight);
    from->setBuffersFormat(mFormat);
    from->setUsage(mProducerUsage);

    sp<GraphicBuffer> buffer;
    sp<Fence> fence;
    auto res = from->dequeueBuffer(&buffer, &fence);
    Mutex::Autolock lock(mMutex);
    handleOutputDequeueStatusLocked(res, buffer);
    if (res != OK) {
        return;
    }

    size_t surfaceId = 0;
    bool found = false;
    for (const auto& it : mOutputSurfaces) {
        if (it.second == from) {
            found = true;
            surfaceId = it.first;
            break;
        }
    }
    if (!found) {
        SP_LOGV("%s: output surface not registered anymore!", __FUNCTION__);
        return;
    }

    returnOutputBufferLocked(fence, from, surfaceId, buffer);
}

void Camera3StreamSplitter::onBufferReplacedLocked(const sp<Surface>& from, size_t surfaceId) {
    ATRACE_CALL();

    from->setBuffersDimensions(mWidth, mHeight);
    from->setBuffersFormat(mFormat);
    from->setUsage(mProducerUsage);

    sp<GraphicBuffer> buffer;
    sp<Fence> fence;
    auto res = from->dequeueBuffer(&buffer, &fence);
    handleOutputDequeueStatusLocked(res, buffer);
    if (res != OK) {
        return;
    }

    returnOutputBufferLocked(fence, from, surfaceId, buffer);
}

void Camera3StreamSplitter::returnOutputBufferLocked(const sp<Fence>& fence,
        const sp<Surface>& from, size_t surfaceId, const sp<GraphicBuffer>& buffer) {
    BufferTracker& tracker = *(mBuffers[buffer->getId()]);
    // Merge the release fence of the incoming buffer so that the fence we send
    // back to the input includes all of the outputs' fences
    if (fence != nullptr && fence->isValid()) {
        tracker.mergeFence(fence);
    }

    auto detachBuffer = mDetachedBuffers.find(buffer->getId());
    bool detach = (detachBuffer != mDetachedBuffers.end());
    if (detach) {
        auto res = from->detachBuffer(buffer);
        if (res == NO_ERROR) {
            if (mHeldBuffers.contains(from)) {
                mHeldBuffers[from]->erase(buffer);
            } else {
                uint64_t surfaceId = 0;
                from->getUniqueId(&surfaceId);
                SP_LOGW("%s: buffer %" PRIu64 " not found in held buffers of surface %" PRIu64,
                        __FUNCTION__, buffer->getId(), surfaceId);
            }
        } else {
            SP_LOGE("%s: detach buffer from output failed (%d)", __FUNCTION__, res);
        }
    }

    // Check to see if this is the last outstanding reference to this buffer
    decrementBufRefCountLocked(buffer->getId(), surfaceId);
}

void Camera3StreamSplitter::handleOutputDequeueStatusLocked(status_t res,
        const sp<GraphicBuffer>& buffer) {
    if (res == NO_INIT) {
        // If we just discovered that this output has been abandoned, note that,
        // but we can't do anything else, since buffer is invalid
        onAbandonedLocked();
    } else if (res == NO_MEMORY) {
        SP_LOGE("%s: No free buffers", __FUNCTION__);
    } else if (res == WOULD_BLOCK) {
        SP_LOGE("%s: Dequeue call will block", __FUNCTION__);
    } else if (res != OK || buffer == nullptr) {
        SP_LOGE("%s: dequeue buffer from output failed (%d)", __FUNCTION__, res);
    }
}

void Camera3StreamSplitter::onAbandonedLocked() {
    // If this is called from binderDied callback, it means the app process
    // holding the binder has died. CameraService will be notified of the binder
    // death, and camera device will be closed, which in turn calls
    // disconnect().
    //
    // If this is called from onBufferReleasedByOutput or onFrameAvailable, one
    // consumer being abanoned shouldn't impact the other consumer. So we won't
    // stop the buffer flow.
    //
    // In both cases, we don't need to do anything here.
    SP_LOGV("One of my outputs has abandoned me");
}

Camera3StreamSplitter::OutputListener::OutputListener(wp<Camera3StreamSplitter> splitter,
        wp<Surface> output)
    : mSplitter(splitter), mOutput(output) {}

void Camera3StreamSplitter::OutputListener::onBufferReleased() {
    ATRACE_CALL();
    sp<Camera3StreamSplitter> splitter = mSplitter.promote();
    sp<Surface> output = mOutput.promote();
    if (splitter != nullptr && output != nullptr) {
        splitter->onBufferReleasedByOutput(output);
    }
}

void Camera3StreamSplitter::OutputListener::onRemoteDied() {
    sp<Camera3StreamSplitter> splitter = mSplitter.promote();
    if (splitter != nullptr) {
        Mutex::Autolock lock(splitter->mMutex);
        splitter->onAbandonedLocked();
    }
}

Camera3StreamSplitter::BufferTracker::BufferTracker(
        const sp<GraphicBuffer>& buffer, const std::vector<size_t>& requestedSurfaces)
      : mBuffer(buffer), mMergedFence(Fence::NO_FENCE), mRequestedSurfaces(requestedSurfaces),
        mReferenceCount(requestedSurfaces.size()) {}

void Camera3StreamSplitter::BufferTracker::mergeFence(const sp<Fence>& with) {
    mMergedFence = Fence::merge(String8("Camera3StreamSplitter"), mMergedFence, with);
}

size_t Camera3StreamSplitter::BufferTracker::decrementReferenceCountLocked(size_t surfaceId) {
    const auto& it = std::find(mRequestedSurfaces.begin(), mRequestedSurfaces.end(), surfaceId);
    if (it == mRequestedSurfaces.end()) {
        return mReferenceCount;
    } else {
        mRequestedSurfaces.erase(it);
    }

    if (mReferenceCount > 0)
        --mReferenceCount;
    return mReferenceCount;
}

} // namespace android

#endif  // USE_NEW_STREAM_SPLITTER