| /* |
| * 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. |
| */ |
| |
| #include <inttypes.h> |
| |
| #define LOG_TAG "Camera3StreamSplitter" |
| #define ATRACE_TAG ATRACE_TAG_CAMERA |
| //#define LOG_NDEBUG 0 |
| |
| #include <gui/BufferItem.h> |
| #include <gui/IGraphicBufferConsumer.h> |
| #include <gui/IGraphicBufferProducer.h> |
| #include <gui/BufferQueue.h> |
| #include <gui/Surface.h> |
| #include <camera/StringUtils.h> |
| |
| #include <ui/GraphicBuffer.h> |
| |
| #include <binder/ProcessState.h> |
| |
| #include <utils/Trace.h> |
| |
| #include <cutils/atomic.h> |
| |
| #include "Camera3Stream.h" |
| |
| #include "Camera3StreamSplitter.h" |
| |
| 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 (mOutputs.size() > 0 || mConsumer != 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; |
| } |
| } |
| |
| // Create BufferQueue for input |
| BufferQueue::createBufferQueue(&mProducer, &mConsumer); |
| |
| // 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++; |
| mBufferItemConsumer = new BufferItemConsumer(mConsumer, consumerUsage, mMaxConsumerBuffers); |
| if (mBufferItemConsumer == nullptr) { |
| return NO_MEMORY; |
| } |
| mConsumer->setConsumerName(toString8(mConsumerName)); |
| |
| *consumer = new Surface(mProducer); |
| if (*consumer == nullptr) { |
| return NO_MEMORY; |
| } |
| |
| res = mProducer->setAsyncMode(true); |
| if (res != OK) { |
| SP_LOGE("%s: Failed to enable input queue async mode: %s(%d)", __FUNCTION__, |
| strerror(-res), res); |
| return res; |
| } |
| |
| res = mConsumer->consumerConnect(this, /* controlledByApp */ false); |
| |
| 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); |
| |
| for (auto& notifier : mNotifiers) { |
| sp<IGraphicBufferProducer> producer = notifier.first; |
| sp<OutputListener> listener = notifier.second; |
| IInterface::asBinder(producer)->unlinkToDeath(listener); |
| } |
| mNotifiers.clear(); |
| |
| for (auto& output : mOutputs) { |
| if (output.second != nullptr) { |
| output.second->disconnect(NATIVE_WINDOW_API_CAMERA); |
| } |
| } |
| mOutputs.clear(); |
| mOutputSurfaces.clear(); |
| mOutputSlots.clear(); |
| mConsumerBufferCount.clear(); |
| |
| if (mConsumer.get() != nullptr) { |
| mConsumer->consumerDisconnect(); |
| } |
| |
| 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 = mConsumer->setMaxAcquiredBufferCount(mMaxConsumerBuffers); |
| } |
| |
| return res; |
| } |
| |
| void Camera3StreamSplitter::setHalBufferManager(bool enabled) { |
| Mutex::Autolock lock(mMutex); |
| mUseHalBufManager = enabled; |
| } |
| |
| 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 (mOutputs[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; |
| } |
| |
| sp<IGraphicBufferProducer> gbp = outputQueue->getIGraphicBufferProducer(); |
| // Connect to the buffer producer |
| sp<OutputListener> listener(new OutputListener(this, gbp)); |
| IInterface::asBinder(gbp)->linkToDeath(listener); |
| res = outputQueue->connect(NATIVE_WINDOW_API_CAMERA, listener); |
| 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 = gbp->allowAllocation(false); |
| if (res != OK) { |
| SP_LOGE("%s: Failed to turn off allocation for outputQueue", __FUNCTION__); |
| return res; |
| } |
| |
| // Add new entry into mOutputs |
| mOutputs[surfaceId] = gbp; |
| 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[gbp] = listener; |
| mOutputSlots[gbp] = std::make_unique<OutputSlots>(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 = mConsumer->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 (mOutputs[surfaceId] == nullptr) { |
| SP_LOGE("%s: output surface is not present!", __FUNCTION__); |
| return BAD_VALUE; |
| } |
| |
| sp<IGraphicBufferProducer> gbp = mOutputs[surfaceId]; |
| //Search and decrement the ref. count of any buffers that are |
| //still attached to the removed surface. |
| std::vector<uint64_t> pendingBufferIds; |
| auto& outputSlots = *mOutputSlots[gbp]; |
| for (size_t i = 0; i < outputSlots.size(); i++) { |
| if (outputSlots[i] != nullptr) { |
| pendingBufferIds.push_back(outputSlots[i]->getId()); |
| auto rc = gbp->detachBuffer(i); |
| 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(outputSlots[i]->getId()); |
| } |
| } |
| } |
| mOutputs[surfaceId] = nullptr; |
| mOutputSurfaces[surfaceId] = nullptr; |
| mOutputSlots[gbp] = nullptr; |
| for (const auto &id : pendingBufferIds) { |
| decrementBufRefCountLocked(id, surfaceId); |
| } |
| |
| auto res = IInterface::asBinder(gbp)->unlinkToDeath(mNotifiers[gbp]); |
| if (res != OK) { |
| SP_LOGE("%s: Failed to unlink producer death listener: %d ", __FUNCTION__, res); |
| return res; |
| } |
| |
| res = gbp->disconnect(NATIVE_WINDOW_API_CAMERA); |
| if (res != OK) { |
| SP_LOGE("%s: Unable disconnect from producer interface: %d ", __FUNCTION__, res); |
| return res; |
| } |
| |
| mNotifiers[gbp] = nullptr; |
| mMaxConsumerBuffers -= mConsumerBufferCount[surfaceId]; |
| mConsumerBufferCount[surfaceId] = 0; |
| |
| return res; |
| } |
| |
| status_t Camera3StreamSplitter::outputBufferLocked(const sp<IGraphicBufferProducer>& output, |
| const BufferItem& bufferItem, size_t surfaceId) { |
| ATRACE_CALL(); |
| status_t res; |
| IGraphicBufferProducer::QueueBufferInput queueInput( |
| bufferItem.mTimestamp, bufferItem.mIsAutoTimestamp, |
| bufferItem.mDataSpace, bufferItem.mCrop, |
| static_cast<int32_t>(bufferItem.mScalingMode), |
| bufferItem.mTransform, bufferItem.mFence); |
| |
| IGraphicBufferProducer::QueueBufferOutput queueOutput; |
| |
| uint64_t bufferId = bufferItem.mGraphicBuffer->getId(); |
| const BufferTracker& tracker = *(mBuffers[bufferId]); |
| int slot = getSlotForOutputLocked(output, tracker.getBuffer()); |
| |
| 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); |
| } |
| |
| // 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(); |
| res = output->queueBuffer(slot, queueInput, &queueOutput); |
| mMutex.lock(); |
| |
| SP_LOGV("%s: Queuing buffer to buffer queue %p slot %d returns %d", |
| __FUNCTION__, output.get(), slot, res); |
| //During buffer queue 'mMutex' is not held which makes the removal of |
| //"output" possible. Check whether this is the case and return. |
| if (mOutputSlots[output] == 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 (queueOutput.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<IGraphicBufferProducer>& gbp = mOutputs[surface_id]; |
| if (gbp.get() == nullptr) { |
| //Output surface got likely removed by client. |
| continue; |
| } |
| int slot = getSlotForOutputLocked(gbp, gb); |
| if (slot != BufferItem::INVALID_BUFFER_SLOT) { |
| //Buffer is already attached to this output surface. |
| 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 = gbp->attachBuffer(&slot, gb); |
| mMutex.lock(); |
| if (res != OK) { |
| SP_LOGE("%s: Cannot attachBuffer from GraphicBufferProducer %p: %s (%d)", |
| __FUNCTION__, gbp.get(), strerror(-res), res); |
| // TODO: might need to detach/cleanup the already attached buffers before return? |
| return res; |
| } |
| if ((slot < 0) || (slot > BufferQueue::NUM_BUFFER_SLOTS)) { |
| SP_LOGE("%s: Slot received %d either bigger than expected maximum %d or negative!", |
| __FUNCTION__, slot, BufferQueue::NUM_BUFFER_SLOTS); |
| return BAD_VALUE; |
| } |
| //During buffer attach 'mMutex' is not held which makes the removal of |
| //"gbp" possible. Check whether this is the case and continue. |
| if (mOutputSlots[gbp] == nullptr) { |
| continue; |
| } |
| auto& outputSlots = *mOutputSlots[gbp]; |
| if (static_cast<size_t> (slot + 1) > outputSlots.size()) { |
| outputSlots.resize(slot + 1); |
| } |
| if (outputSlots[slot] != nullptr) { |
| // If the buffer is attached to a slot which already contains a buffer, |
| // the previous buffer will be removed from the output queue. Decrement |
| // the reference count accordingly. |
| decrementBufRefCountLocked(outputSlots[slot]->getId(), surface_id); |
| } |
| SP_LOGV("%s: Attached buffer %p to slot %d on output %p.",__FUNCTION__, gb.get(), |
| slot, gbp.get()); |
| outputSlots[slot] = gb; |
| } |
| |
| 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 = mConsumer->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; |
| if (bufferItem.mGraphicBuffer != nullptr) { |
| mInputSlots[bufferItem.mSlot] = bufferItem; |
| } else if (bufferItem.mAcquireCalled) { |
| bufferItem.mGraphicBuffer = mInputSlots[bufferItem.mSlot].mGraphicBuffer; |
| mInputSlots[bufferItem.mSlot].mFrameNumber = bufferItem.mFrameNumber; |
| } else { |
| SP_LOGE("%s: Invalid input graphic buffer!", __FUNCTION__); |
| mOnFrameAvailableRes.store(BAD_VALUE); |
| return; |
| } |
| 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 (mOutputs[id] == nullptr) { |
| //Output surface got likely removed by client. |
| continue; |
| } |
| |
| res = outputBufferLocked(mOutputs[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(); |
| int consumerSlot = -1; |
| uint64_t frameNumber; |
| auto inputSlot = mInputSlots.begin(); |
| for (; inputSlot != mInputSlots.end(); inputSlot++) { |
| if (inputSlot->second.mGraphicBuffer->getId() == bufferId) { |
| consumerSlot = inputSlot->second.mSlot; |
| frameNumber = inputSlot->second.mFrameNumber; |
| break; |
| } |
| } |
| if (consumerSlot == -1) { |
| SP_LOGE("%s: Buffer missing inside input slots!", __FUNCTION__); |
| return; |
| } |
| |
| auto detachBuffer = mDetachedBuffers.find(bufferId); |
| bool detach = (detachBuffer != mDetachedBuffers.end()); |
| if (detach) { |
| mDetachedBuffers.erase(detachBuffer); |
| mInputSlots.erase(inputSlot); |
| } |
| // 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. |
| sp<IGraphicBufferConsumer> consumer(mConsumer); |
| mMutex.unlock(); |
| int res = NO_ERROR; |
| if (consumer != nullptr) { |
| if (detach) { |
| res = consumer->detachBuffer(consumerSlot); |
| } else { |
| res = consumer->releaseBuffer(consumerSlot, frameNumber, |
| EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, 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<IGraphicBufferProducer>& from) { |
| ATRACE_CALL(); |
| sp<Fence> fence; |
| |
| int slot = BufferItem::INVALID_BUFFER_SLOT; |
| auto res = from->dequeueBuffer(&slot, &fence, mWidth, mHeight, mFormat, mProducerUsage, |
| nullptr, nullptr); |
| Mutex::Autolock lock(mMutex); |
| handleOutputDequeueStatusLocked(res, slot); |
| if (res != OK) { |
| return; |
| } |
| |
| size_t surfaceId = 0; |
| bool found = false; |
| for (const auto& it : mOutputs) { |
| 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, slot); |
| } |
| |
| void Camera3StreamSplitter::onBufferReplacedLocked( |
| const sp<IGraphicBufferProducer>& from, size_t surfaceId) { |
| ATRACE_CALL(); |
| sp<Fence> fence; |
| |
| int slot = BufferItem::INVALID_BUFFER_SLOT; |
| auto res = from->dequeueBuffer(&slot, &fence, mWidth, mHeight, mFormat, mProducerUsage, |
| nullptr, nullptr); |
| handleOutputDequeueStatusLocked(res, slot); |
| if (res != OK) { |
| return; |
| } |
| |
| returnOutputBufferLocked(fence, from, surfaceId, slot); |
| } |
| |
| void Camera3StreamSplitter::returnOutputBufferLocked(const sp<Fence>& fence, |
| const sp<IGraphicBufferProducer>& from, size_t surfaceId, int slot) { |
| sp<GraphicBuffer> buffer; |
| |
| if (mOutputSlots[from] == nullptr) { |
| //Output surface got likely removed by client. |
| return; |
| } |
| |
| auto outputSlots = *mOutputSlots[from]; |
| buffer = outputSlots[slot]; |
| 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(slot); |
| if (res == NO_ERROR) { |
| outputSlots[slot] = nullptr; |
| } 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, int slot) { |
| 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 == IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) { |
| SP_LOGE("%s: Producer needs to re-allocate buffer!", __FUNCTION__); |
| SP_LOGE("%s: This should not happen with buffer allocation disabled!", __FUNCTION__); |
| } else if (res == IGraphicBufferProducer::RELEASE_ALL_BUFFERS) { |
| SP_LOGE("%s: All slot->buffer mapping should be released!", __FUNCTION__); |
| SP_LOGE("%s: This should not happen with buffer allocation disabled!", __FUNCTION__); |
| } 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 || (slot == BufferItem::INVALID_BUFFER_SLOT)) { |
| 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"); |
| } |
| |
| int Camera3StreamSplitter::getSlotForOutputLocked(const sp<IGraphicBufferProducer>& gbp, |
| const sp<GraphicBuffer>& gb) { |
| auto& outputSlots = *mOutputSlots[gbp]; |
| |
| for (size_t i = 0; i < outputSlots.size(); i++) { |
| if (outputSlots[i] == gb) { |
| return (int)i; |
| } |
| } |
| |
| SP_LOGV("%s: Cannot find slot for gb %p on output %p", __FUNCTION__, gb.get(), |
| gbp.get()); |
| return BufferItem::INVALID_BUFFER_SLOT; |
| } |
| |
| Camera3StreamSplitter::OutputListener::OutputListener( |
| wp<Camera3StreamSplitter> splitter, |
| wp<IGraphicBufferProducer> output) |
| : mSplitter(splitter), mOutput(output) {} |
| |
| void Camera3StreamSplitter::OutputListener::onBufferReleased() { |
| ATRACE_CALL(); |
| sp<Camera3StreamSplitter> splitter = mSplitter.promote(); |
| sp<IGraphicBufferProducer> output = mOutput.promote(); |
| if (splitter != nullptr && output != nullptr) { |
| splitter->onBufferReleasedByOutput(output); |
| } |
| } |
| |
| void Camera3StreamSplitter::OutputListener::binderDied(const wp<IBinder>& /* who */) { |
| 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 |
