Merge "Remove ConsumerBase inheritance from RingBufferConsumer." into main (222fd4c6) · Commits · e / os / android_frameworks_av

services/camera/libcameraservice/gui/RingBufferConsumer.cpp

+5 −359

Original line number	Diff line number	Diff line
		@@ -14,364 +14,10 @@
		* limitations under the License.
		*/

		//#define LOG_NDEBUG 0
		#define LOG_TAG "RingBufferConsumer"
		#define ATRACE_TAG ATRACE_TAG_GRAPHICS
		#include <gui/Flags.h>

		#include <inttypes.h>

		#include <utils/Log.h>

		#include <camera/StringUtils.h>
		#include <com_android_graphics_libgui_flags.h>
		#include <gui/RingBufferConsumer.h>

		#define BI_LOGV(x, ...) ALOGV("[%s] " x, mName.c_str(), ##__VA_ARGS__)
		#define BI_LOGD(x, ...) ALOGD("[%s] " x, mName.c_str(), ##__VA_ARGS__)
		#define BI_LOGI(x, ...) ALOGI("[%s] " x, mName.c_str(), ##__VA_ARGS__)
		#define BI_LOGW(x, ...) ALOGW("[%s] " x, mName.c_str(), ##__VA_ARGS__)
		#define BI_LOGE(x, ...) ALOGE("[%s] " x, mName.c_str(), ##__VA_ARGS__)

		#undef assert
		#define assert(x) ALOG_ASSERT((x), #x)

		typedef android::RingBufferConsumer::PinnedBufferItem PinnedBufferItem;

		namespace android {

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		RingBufferConsumer::RingBufferConsumer(uint64_t consumerUsage, int bufferCount)
		: ConsumerBase(), mBufferCount(bufferCount), mLatestTimestamp(0) {
		#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		#include "flagged_files/RingBufferConsumer.inc"
		#else
		RingBufferConsumer::RingBufferConsumer(const sp<IGraphicBufferConsumer>& consumer,
		uint64_t consumerUsage, int bufferCount)
		: ConsumerBase(consumer), mBufferCount(bufferCount), mLatestTimestamp(0) {
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		mConsumer->setConsumerUsageBits(consumerUsage);
		mConsumer->setMaxAcquiredBufferCount(bufferCount);

		assert(bufferCount > 0);
		}

		RingBufferConsumer::~RingBufferConsumer() {
		}

		void RingBufferConsumer::setName(const std::string& name) {
		Mutex::Autolock _l(mMutex);
		mName = toString8(name);
		mConsumer->setConsumerName(mName);
		}

		sp<PinnedBufferItem> RingBufferConsumer::pinSelectedBuffer(
		const RingBufferComparator& filter,
		bool waitForFence) {

		sp<PinnedBufferItem> pinnedBuffer;

		{
		List<RingBufferItem>::iterator it, end, accIt;
		BufferInfo acc, cur;
		BufferInfo* accPtr = NULL;

		Mutex::Autolock _l(mMutex);

		for (it = mBufferItemList.begin(), end = mBufferItemList.end();
		it != end;
		++it) {

		const RingBufferItem& item = *it;

		cur.mCrop = item.mCrop;
		cur.mTransform = item.mTransform;
		cur.mScalingMode = item.mScalingMode;
		cur.mTimestamp = item.mTimestamp;
		cur.mFrameNumber = item.mFrameNumber;
		cur.mPinned = item.mPinCount > 0;

		int ret = filter.compare(accPtr, &cur);

		if (ret == 0) {
		accPtr = NULL;
		} else if (ret > 0) {
		acc = cur;
		accPtr = &acc;
		accIt = it;
		} // else acc = acc
		}

		if (!accPtr) {
		return NULL;
		}

		pinnedBuffer = new PinnedBufferItem(this, *accIt);
		pinBufferLocked(pinnedBuffer->getBufferItem());

		} // end scope of mMutex autolock

		if (waitForFence) {
		status_t err = pinnedBuffer->getBufferItem().mFence->waitForever(
		"RingBufferConsumer::pinSelectedBuffer");
		if (err != OK) {
		BI_LOGE("Failed to wait for fence of acquired buffer: %s (%d)",
		strerror(-err), err);
		}
		}

		return pinnedBuffer;
		}

		status_t RingBufferConsumer::clear() {

		status_t err;
		Mutex::Autolock _l(mMutex);

		BI_LOGV("%s", __FUNCTION__);

		// Avoid annoying log warnings by returning early
		if (mBufferItemList.size() == 0) {
		return OK;
		}

		do {
		size_t pinnedFrames = 0;
		err = releaseOldestBufferLocked(&pinnedFrames);

		if (err == NO_BUFFER_AVAILABLE) {
		assert(pinnedFrames == mBufferItemList.size());
		break;
		}

		if (err == NOT_ENOUGH_DATA) {
		// Fine. Empty buffer item list.
		break;
		}

		if (err != OK) {
		BI_LOGE("Clear failed, could not release buffer");
		return err;
		}

		} while(true);

		return OK;
		}

		nsecs_t RingBufferConsumer::getLatestTimestamp() {
		Mutex::Autolock _l(mMutex);
		if (mBufferItemList.size() == 0) {
		return 0;
		}
		return mLatestTimestamp;
		}

		void RingBufferConsumer::pinBufferLocked(const BufferItem& item) {
		List<RingBufferItem>::iterator it, end;

		for (it = mBufferItemList.begin(), end = mBufferItemList.end();
		it != end;
		++it) {

		RingBufferItem& find = *it;
		if (item.mGraphicBuffer == find.mGraphicBuffer) {
		find.mPinCount++;
		break;
		}
		}

		if (it == end) {
		BI_LOGE("Failed to pin buffer (timestamp %" PRId64 ", framenumber %" PRIu64 ")",
		item.mTimestamp, item.mFrameNumber);
		} else {
		BI_LOGV("Pinned buffer (frame %" PRIu64 ", timestamp %" PRId64 ")",
		item.mFrameNumber, item.mTimestamp);
		}
		}

		status_t RingBufferConsumer::releaseOldestBufferLocked(size_t* pinnedFrames) {
		status_t err = OK;

		List<RingBufferItem>::iterator it, end, accIt;

		it = mBufferItemList.begin();
		end = mBufferItemList.end();
		accIt = end;

		if (it == end) {
		/**
		* This is fine. We really care about being able to acquire a buffer
		* successfully after this function completes, not about it releasing
		* some buffer.
		*/
		BI_LOGV("%s: No buffers yet acquired, can't release anything",
		__FUNCTION__);
		return NOT_ENOUGH_DATA;
		}

		for (; it != end; ++it) {
		RingBufferItem& find = *it;

		if (find.mPinCount > 0) {
		if (pinnedFrames != NULL) {
		++(*pinnedFrames);
		}
		// Filter out pinned frame when searching for buffer to release
		continue;
		}

		if (find.mTimestamp < accIt->mTimestamp \|\| accIt == end) {
		accIt = it;
		}
		}

		if (accIt != end) {
		RingBufferItem& item = *accIt;

		// In case the object was never pinned, pass the acquire fence
		// back to the release fence. If the fence was already waited on,
		// it'll just be a no-op to wait on it again.

		// item.mGraphicBuffer was populated with the proper graphic-buffer
		// at acquire even if it was previously acquired
		err = addReleaseFenceLocked(item.mSlot,
		item.mGraphicBuffer, item.mFence);

		if (err != OK) {
		BI_LOGE("Failed to add release fence to buffer "
		"(timestamp %" PRId64 ", framenumber %" PRIu64,
		item.mTimestamp, item.mFrameNumber);
		return err;
		}

		BI_LOGV("Attempting to release buffer timestamp %" PRId64 ", frame %" PRIu64,
		item.mTimestamp, item.mFrameNumber);

		// item.mGraphicBuffer was populated with the proper graphic-buffer
		// at acquire even if it was previously acquired
		err = releaseBufferLocked(item.mSlot, item.mGraphicBuffer);
		if (err != OK) {
		BI_LOGE("Failed to release buffer: %s (%d)",
		strerror(-err), err);
		return err;
		}

		BI_LOGV("Buffer timestamp %" PRId64 ", frame %" PRIu64 " evicted",
		item.mTimestamp, item.mFrameNumber);

		mBufferItemList.erase(accIt);
		} else {
		BI_LOGW("All buffers pinned, could not find any to release");
		return NO_BUFFER_AVAILABLE;

		}

		return OK;
		}

		void RingBufferConsumer::onFrameAvailable(const BufferItem& item) {
		status_t err;

		{
		Mutex::Autolock _l(mMutex);

		/**
		* Release oldest frame
		*/
		if (mBufferItemList.size() >= (size_t)mBufferCount) {
		err = releaseOldestBufferLocked(/pinnedFrames/NULL);
		assert(err != NOT_ENOUGH_DATA);

		// TODO: implement the case for NO_BUFFER_AVAILABLE
		assert(err != NO_BUFFER_AVAILABLE);
		if (err != OK) {
		return;
		}
		// TODO: in unpinBuffer rerun this routine if we had buffers
		// we could've locked but didn't because there was no space
		}

		RingBufferItem& item = *mBufferItemList.insert(mBufferItemList.end(),
		RingBufferItem());

		/**
		* Acquire new frame
		*/
		err = acquireBufferLocked(&item, 0);
		if (err != OK) {
		if (err != NO_BUFFER_AVAILABLE) {
		BI_LOGE("Error acquiring buffer: %s (%d)", strerror(err), err);
		}

		mBufferItemList.erase(--mBufferItemList.end());
		return;
		}

		BI_LOGV("New buffer acquired (timestamp %" PRId64 "), "
		"buffer items %zu out of %d",
		item.mTimestamp,
		mBufferItemList.size(), mBufferCount);

		if (item.mTimestamp < mLatestTimestamp) {
		BI_LOGE("Timestamp decreases from %" PRId64 " to %" PRId64,
		mLatestTimestamp, item.mTimestamp);
		}

		mLatestTimestamp = item.mTimestamp;

		item.mGraphicBuffer = mSlots[item.mSlot].mGraphicBuffer;
		} // end of mMutex lock

		ConsumerBase::onFrameAvailable(item);
		}

		void RingBufferConsumer::unpinBuffer(const BufferItem& item) {
		Mutex::Autolock _l(mMutex);

		List<RingBufferItem>::iterator it, end, accIt;

		for (it = mBufferItemList.begin(), end = mBufferItemList.end();
		it != end;
		++it) {

		RingBufferItem& find = *it;
		if (item.mGraphicBuffer == find.mGraphicBuffer) {
		status_t res = addReleaseFenceLocked(item.mSlot,
		item.mGraphicBuffer, item.mFence);

		if (res != OK) {
		BI_LOGE("Failed to add release fence to buffer "
		"(timestamp %" PRId64 ", framenumber %" PRIu64,
		item.mTimestamp, item.mFrameNumber);
		return;
		}

		find.mPinCount--;
		break;
		}
		}

		if (it == end) {
		// This should never happen. If it happens, we have a bug.
		BI_LOGE("Failed to unpin buffer (timestamp %" PRId64 ", framenumber %" PRIu64 ")",
		item.mTimestamp, item.mFrameNumber);
		} else {
		BI_LOGV("Unpinned buffer (timestamp %" PRId64 ", framenumber %" PRIu64 ")",
		item.mTimestamp, item.mFrameNumber);
		}
		}

		status_t RingBufferConsumer::setDefaultBufferSize(uint32_t w, uint32_t h) {
		Mutex::Autolock _l(mMutex);
		return mConsumer->setDefaultBufferSize(w, h);
		}

		status_t RingBufferConsumer::setDefaultBufferFormat(uint32_t defaultFormat) {
		Mutex::Autolock _l(mMutex);
		return mConsumer->setDefaultBufferFormat(defaultFormat);
		}

		status_t RingBufferConsumer::setConsumerUsage(uint64_t usage) {
		Mutex::Autolock _l(mMutex);
		return mConsumer->setConsumerUsageBits(usage);
		}

		} // namespace android
		#include "flagged_files/DeprecatedRingBufferConsumer.inc"
		#endif
		No newline at end of file

services/camera/libcameraservice/gui/RingBufferConsumer.h

+20 −2

Original line number	Diff line number	Diff line
		@@ -21,6 +21,10 @@
		#include <gui/BufferItem.h>
		#include <gui/BufferQueue.h>
		#include <gui/ConsumerBase.h>
		#include <gui/Flags.h> // remove with WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		#include <gui/BufferItemConsumer.h>
		#endif

		#include <utils/List.h>

		@@ -46,8 +50,13 @@ namespace android {
		* - If all the buffers get filled or pinned then there will be no empty
		* buffers left, so the producer will block on dequeue.
		*/
		class RingBufferConsumer : public ConsumerBase,
		class RingBufferConsumer
		#if not WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		: public ConsumerBase,
		public ConsumerBase::FrameAvailableListener
		#else
		: public BufferItemConsumer::FrameAvailableListener
		#endif
		{
		public:
		typedef ConsumerBase::FrameAvailableListener FrameAvailableListener;
		@@ -161,11 +170,20 @@ class RingBufferConsumer : public ConsumerBase,

		// Return 0 if RingBuffer is empty, otherwise return timestamp of latest buffer.
		nsecs_t getLatestTimestamp();
		#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		sp<Surface> getSurface() const;
		#endif

		private:

		#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
		Mutex mMutex;

		sp<BufferItemConsumer> mBufferItemConsumer;
		#endif

		// Override ConsumerBase::onFrameAvailable
		virtual void onFrameAvailable(const BufferItem& item);
		virtual void onFrameAvailable(const BufferItem& item) override;

		void pinBufferLocked(const BufferItem& item);
		void unpinBuffer(const BufferItem& item);

services/camera/libcameraservice/gui/flagged_files/DeprecatedRingBufferConsumer.inc

0 → 100644

+380 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 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_NDEBUG 0
		#define LOG_TAG "RingBufferConsumer"
		#define ATRACE_TAG ATRACE_TAG_GRAPHICS

		#include <com_android_graphics_libgui_flags.h>
		#include <inttypes.h>

		#include <utils/Log.h>

		#include <camera/StringUtils.h>
		#include <com_android_graphics_libgui_flags.h>
		#include <gui/RingBufferConsumer.h>
		#include <gui/Flags.h>

		#define BI_LOGV(x, ...) ALOGV("[%s] " x, mName.c_str(), ##__VA_ARGS__)
		#define BI_LOGD(x, ...) ALOGD("[%s] " x, mName.c_str(), ##__VA_ARGS__)
		#define BI_LOGI(x, ...) ALOGI("[%s] " x, mName.c_str(), ##__VA_ARGS__)
		#define BI_LOGW(x, ...) ALOGW("[%s] " x, mName.c_str(), ##__VA_ARGS__)
		#define BI_LOGE(x, ...) ALOGE("[%s] " x, mName.c_str(), ##__VA_ARGS__)

		#undef assert
		#define assert(x) ALOG_ASSERT((x), #x)

		typedef android::RingBufferConsumer::PinnedBufferItem PinnedBufferItem;

		namespace android {

		#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		RingBufferConsumer::RingBufferConsumer(uint64_t consumerUsage, int bufferCount)
		:
		ConsumerBase(), mBufferCount(bufferCount), mLatestTimestamp(0) {
		#else
		RingBufferConsumer::RingBufferConsumer(const sp<IGraphicBufferConsumer>& consumer,
		uint64_t consumerUsage, int bufferCount)
		:
		ConsumerBase(consumer), mBufferCount(bufferCount), mLatestTimestamp(0) {
		#endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_CONSUMER_BASE_OWNS_BQ)
		mConsumer->setConsumerUsageBits(consumerUsage);
		mConsumer->setMaxAcquiredBufferCount(bufferCount);
		assert(bufferCount > 0);
		}

		RingBufferConsumer::~RingBufferConsumer() {
		}

		void RingBufferConsumer::setName(const std::string& name) {
		Mutex::Autolock _l(mMutex);
		mName = toString8(name);
		mConsumer->setConsumerName(mName);
		}

		sp<PinnedBufferItem> RingBufferConsumer::pinSelectedBuffer(
		const RingBufferComparator& filter,
		bool waitForFence) {

		sp<PinnedBufferItem> pinnedBuffer;

		{
		List<RingBufferItem>::iterator it, end, accIt;
		BufferInfo acc, cur;
		BufferInfo* accPtr = NULL;

		Mutex::Autolock _l(mMutex);

		for (it = mBufferItemList.begin(), end = mBufferItemList.end();
		it != end;
		++it) {

		const RingBufferItem& item = *it;

		cur.mCrop = item.mCrop;
		cur.mTransform = item.mTransform;
		cur.mScalingMode = item.mScalingMode;
		cur.mTimestamp = item.mTimestamp;
		cur.mFrameNumber = item.mFrameNumber;
		cur.mPinned = item.mPinCount > 0;

		int ret = filter.compare(accPtr, &cur);

		if (ret == 0) {
		accPtr = NULL;
		} else if (ret > 0) {
		acc = cur;
		accPtr = &acc;
		accIt = it;
		} // else acc = acc
		}

		if (!accPtr) {
		return NULL;
		}

		pinnedBuffer = new PinnedBufferItem(this, *accIt);
		pinBufferLocked(pinnedBuffer->getBufferItem());

		} // end scope of mMutex autolock

		if (waitForFence) {
		status_t err = pinnedBuffer->getBufferItem().mFence->waitForever(
		"RingBufferConsumer::pinSelectedBuffer");
		if (err != OK) {
		BI_LOGE("Failed to wait for fence of acquired buffer: %s (%d)",
		strerror(-err), err);
		}
		}

		return pinnedBuffer;
		}

		status_t RingBufferConsumer::clear() {

		status_t err;
		Mutex::Autolock _l(mMutex);

		BI_LOGV("%s", __FUNCTION__);

		// Avoid annoying log warnings by returning early
		if (mBufferItemList.size() == 0) {
		return OK;
		}

		do {
		size_t pinnedFrames = 0;
		err = releaseOldestBufferLocked(&pinnedFrames);

		if (err == NO_BUFFER_AVAILABLE) {
		assert(pinnedFrames == mBufferItemList.size());
		break;
		}

		if (err == NOT_ENOUGH_DATA) {
		// Fine. Empty buffer item list.
		break;
		}

		if (err != OK) {
		BI_LOGE("Clear failed, could not release buffer");
		return err;
		}

		} while(true);

		return OK;
		}

		nsecs_t RingBufferConsumer::getLatestTimestamp() {
		Mutex::Autolock _l(mMutex);
		if (mBufferItemList.size() == 0) {
		return 0;
		}
		return mLatestTimestamp;
		}

		void RingBufferConsumer::pinBufferLocked(const BufferItem& item) {
		List<RingBufferItem>::iterator it, end;

		for (it = mBufferItemList.begin(), end = mBufferItemList.end();
		it != end;
		++it) {

		RingBufferItem& find = *it;
		if (item.mGraphicBuffer == find.mGraphicBuffer) {
		find.mPinCount++;
		break;
		}
		}

		if (it == end) {
		BI_LOGE("Failed to pin buffer (timestamp %" PRId64 ", framenumber %" PRIu64 ")",
		item.mTimestamp, item.mFrameNumber);
		} else {
		BI_LOGV("Pinned buffer (frame %" PRIu64 ", timestamp %" PRId64 ")",
		item.mFrameNumber, item.mTimestamp);
		}
		}

		status_t RingBufferConsumer::releaseOldestBufferLocked(size_t* pinnedFrames) {
		status_t err = OK;

		List<RingBufferItem>::iterator it, end, accIt;

		it = mBufferItemList.begin();
		end = mBufferItemList.end();
		accIt = end;

		if (it == end) {
		/**
		* This is fine. We really care about being able to acquire a buffer
		* successfully after this function completes, not about it releasing
		* some buffer.
		*/
		BI_LOGV("%s: No buffers yet acquired, can't release anything",
		__FUNCTION__);
		return NOT_ENOUGH_DATA;
		}

		for (; it != end; ++it) {
		RingBufferItem& find = *it;

		if (find.mPinCount > 0) {
		if (pinnedFrames != NULL) {
		++(*pinnedFrames);
		}
		// Filter out pinned frame when searching for buffer to release
		continue;
		}

		if (find.mTimestamp < accIt->mTimestamp \|\| accIt == end) {
		accIt = it;
		}
		}

		if (accIt != end) {
		RingBufferItem& item = *accIt;

		// In case the object was never pinned, pass the acquire fence
		// back to the release fence. If the fence was already waited on,
		// it'll just be a no-op to wait on it again.

		// item.mGraphicBuffer was populated with the proper graphic-buffer
		// at acquire even if it was previously acquired
		err = addReleaseFenceLocked(item.mSlot,
		item.mGraphicBuffer, item.mFence);

		if (err != OK) {
		BI_LOGE("Failed to add release fence to buffer "
		"(timestamp %" PRId64 ", framenumber %" PRIu64,
		item.mTimestamp, item.mFrameNumber);
		return err;
		}

		BI_LOGV("Attempting to release buffer timestamp %" PRId64 ", frame %" PRIu64,
		item.mTimestamp, item.mFrameNumber);

		// item.mGraphicBuffer was populated with the proper graphic-buffer
		// at acquire even if it was previously acquired
		err = releaseBufferLocked(item.mSlot, item.mGraphicBuffer);
		if (err != OK) {
		BI_LOGE("Failed to release buffer: %s (%d)",
		strerror(-err), err);
		return err;
		}

		BI_LOGV("Buffer timestamp %" PRId64 ", frame %" PRIu64 " evicted",
		item.mTimestamp, item.mFrameNumber);

		mBufferItemList.erase(accIt);
		} else {
		BI_LOGW("All buffers pinned, could not find any to release");
		return NO_BUFFER_AVAILABLE;

		}

		return OK;
		}

		void RingBufferConsumer::onFrameAvailable(const BufferItem& item) {
		status_t err;

		{
		Mutex::Autolock _l(mMutex);

		/**
		* Release oldest frame
		*/
		if (mBufferItemList.size() >= (size_t)mBufferCount) {
		err = releaseOldestBufferLocked(/pinnedFrames/NULL);
		assert(err != NOT_ENOUGH_DATA);

		// TODO: implement the case for NO_BUFFER_AVAILABLE
		assert(err != NO_BUFFER_AVAILABLE);
		if (err != OK) {
		return;
		}
		// TODO: in unpinBuffer rerun this routine if we had buffers
		// we could've locked but didn't because there was no space
		}

		RingBufferItem& item = *mBufferItemList.insert(mBufferItemList.end(),
		RingBufferItem());

		/**
		* Acquire new frame
		*/
		err = acquireBufferLocked(&item, 0);
		if (err != OK) {
		if (err != NO_BUFFER_AVAILABLE) {
		BI_LOGE("Error acquiring buffer: %s (%d)", strerror(err), err);
		}

		mBufferItemList.erase(--mBufferItemList.end());
		return;
		}

		BI_LOGV("New buffer acquired (timestamp %" PRId64 "), "
		"buffer items %zu out of %d",
		item.mTimestamp,
		mBufferItemList.size(), mBufferCount);

		if (item.mTimestamp < mLatestTimestamp) {
		BI_LOGE("Timestamp decreases from %" PRId64 " to %" PRId64,
		mLatestTimestamp, item.mTimestamp);
		}

		mLatestTimestamp = item.mTimestamp;

		item.mGraphicBuffer = mSlots[item.mSlot].mGraphicBuffer;
		} // end of mMutex lock

		ConsumerBase::onFrameAvailable(item);
		}

		void RingBufferConsumer::unpinBuffer(const BufferItem& item) {
		Mutex::Autolock _l(mMutex);

		List<RingBufferItem>::iterator it, end, accIt;

		for (it = mBufferItemList.begin(), end = mBufferItemList.end();
		it != end;
		++it) {

		RingBufferItem& find = *it;
		if (item.mGraphicBuffer == find.mGraphicBuffer) {
		status_t res = addReleaseFenceLocked(item.mSlot,
		item.mGraphicBuffer, item.mFence);

		if (res != OK) {
		BI_LOGE("Failed to add release fence to buffer "
		"(timestamp %" PRId64 ", framenumber %" PRIu64,
		item.mTimestamp, item.mFrameNumber);
		return;
		}

		find.mPinCount--;
		break;
		}
		}

		if (it == end) {
		// This should never happen. If it happens, we have a bug.
		BI_LOGE("Failed to unpin buffer (timestamp %" PRId64 ", framenumber %" PRIu64 ")",
		item.mTimestamp, item.mFrameNumber);
		} else {
		BI_LOGV("Unpinned buffer (timestamp %" PRId64 ", framenumber %" PRIu64 ")",
		item.mTimestamp, item.mFrameNumber);
		}
		}

		status_t RingBufferConsumer::setDefaultBufferSize(uint32_t w, uint32_t h) {
		Mutex::Autolock _l(mMutex);
		return mConsumer->setDefaultBufferSize(w, h);
		}

		status_t RingBufferConsumer::setDefaultBufferFormat(uint32_t defaultFormat) {
		Mutex::Autolock _l(mMutex);
		return mConsumer->setDefaultBufferFormat(defaultFormat);
		}

		status_t RingBufferConsumer::setConsumerUsage(uint64_t usage) {
		Mutex::Autolock _l(mMutex);
		return mConsumer->setConsumerUsageBits(usage);
		}

		} // namespace android
		No newline at end of file

services/camera/libcameraservice/gui/flagged_files/RingBufferConsumer.inc

0 → 100644

+355 −0

File added.

Preview size limit exceeded, changes collapsed.