Merge "media.c2 aidl: connect CCodec, Codec2Client and HAL" into main am: 56629b45ef am: c314f63df4 (a966e793) · Commits · e / os / android_frameworks_av

media/codec2/hal/aidl/Component.cpp

+30 −27

Original line number	Diff line number	Diff line
		@@ -294,47 +294,50 @@ ScopedAStatus Component::createBlockPool(
		static constexpr IComponent::BlockPoolAllocator::Tag IGBA =
		IComponent::BlockPoolAllocator::allocator;
		c2_status_t status = C2_OK;
		::android::C2PlatformAllocatorDesc allocatorParam;
		switch (allocator.getTag()) {
		case ALLOCATOR_ID:
		case ALLOCATOR_ID: {
		allocatorParam.allocatorId =
		allocator.get<IComponent::BlockPoolAllocator::allocatorId>();
		}
		break;
		case IGBA: {
		allocatorParam.allocatorId = ::android::C2PlatformAllocatorStore::IGBA;
		allocatorParam.igba =
		allocator.get<IComponent::BlockPoolAllocator::allocator>().igba;
		allocatorParam.waitableFd.reset(
		allocator.get<IComponent::BlockPoolAllocator::allocator>()
		.waitableFd.dup().release());
		}
		break;
		default:
		return ScopedAStatus::fromServiceSpecificError(C2_CORRUPTED);
		}
		#ifdef __ANDROID_APEX__
		status = ::android::CreateCodec2BlockPool(
		static_cast<::android::C2PlatformAllocatorStore::id_t>(
		allocator.get<ALLOCATOR_ID>()),
		allocatorParam,
		mComponent,
		&c2BlockPool);
		#else
		status = ComponentStore::GetFilterWrapper()->createBlockPool(
		static_cast<::android::C2PlatformAllocatorStore::id_t>(
		allocator.get<ALLOCATOR_ID>()),
		allocatorParam,
		mComponent,
		&c2BlockPool);
		#endif
		if (status != C2_OK) {
		blockPool = nullptr;
		}
		break;
		case IGBA:
		// FIXME
		break;
		default:
		break;
		return ScopedAStatus::fromServiceSpecificError(status);
		}
		if (blockPool) {
		{
		mBlockPoolsMutex.lock();
		mBlockPools.emplace(c2BlockPool->getLocalId(), c2BlockPool);
		mBlockPoolsMutex.unlock();
		} else if (status == C2_OK) {
		status = C2_CORRUPTED;
		}

		blockPool->blockPoolId = c2BlockPool ? c2BlockPool->getLocalId() : 0;
		blockPool->configurable = SharedRefBase::make<CachedConfigurable>(
		std::make_unique<BlockPoolIntf>(c2BlockPool));
		if (status == C2_OK) {
		return ScopedAStatus::ok();
		}
		return ScopedAStatus::fromServiceSpecificError(status);
		}

		ScopedAStatus Component::destroyBlockPool(int64_t blockPoolId) {
		std::lock_guard<std::mutex> lock(mBlockPoolsMutex);

media/codec2/hal/client/client.cpp

+216 −17

Original line number	Diff line number	Diff line
		@@ -19,6 +19,8 @@
		#define ATRACE_TAG ATRACE_TAG_VIDEO
		#include <android-base/logging.h>
		#include <utils/Trace.h>

		#include <codec2/aidl/GraphicBufferAllocator.h>
		#include <codec2/hidl/client.h>
		#include <C2Debug.h>
		#include <C2BufferPriv.h>
		@@ -74,6 +76,7 @@
		#include <limits>
		#include <map>
		#include <mutex>
		#include <optional>
		#include <sstream>
		#include <thread>
		#include <type_traits>
		@@ -96,6 +99,9 @@ using H2BGraphicBufferProducer2 = ::android::hardware::graphics::bufferqueue::
		V2_0::utils::H2BGraphicBufferProducer;
		using ::android::hardware::media::c2::V1_2::SurfaceSyncObj;

		using AidlGraphicBufferAllocator = ::aidl::android::hardware::media::c2::
		implementation::GraphicBufferAllocator;

		namespace bufferpool2_aidl = ::aidl::android::hardware::media::bufferpool2;
		namespace bufferpool_hidl = ::android::hardware::media::bufferpool::V2_0;
		namespace c2_aidl = ::aidl::android::hardware::media::c2;
		@@ -1041,6 +1047,85 @@ struct Codec2Client::Component::OutputBufferQueue :
		}
		};

		// The class holds GraphicBufferAllocator and the associated id of
		// HAL side BlockPool.
		// This is tightly coupled with BlockPool creation and destruction.
		// The life cycle inside class will be as follows.
		//
		// On createBlockPool client request.
		// 1. this::create() creates a GraphicBufferAllocator and set it as
		// the current.
		// 2. C2AIDL_HAL::createBlockPool() creates a C2BlockPool using
		// the GraphicBufferAllocator created in #1.
		// 3. this::setCurrentId() associates the id returned in #2 to the current
		//
		// On destroyBlockPool cliet request
		// 1. C2AIDL_HAL::destroyBlockPool() destroys the block pool
		// from HAL process.
		// 2. this::remove() destroys GraphicBufferAllocator which is associatted
		// with the C2BlockPool in #1.
		//
		struct Codec2Client::Component::GraphicBufferAllocators {
		private:
		std::optional<C2BlockPool::local_id_t> mCurrentId;
		std::shared_ptr<AidlGraphicBufferAllocator> mCurrent;

		// A new BlockPool is created before the old BlockPool is destroyed.
		// This holds the reference of the old BlockPool when a new BlockPool is
		// created until the old BlockPool is explicitly requested for destruction.
		std::map<C2BlockPool::local_id_t, std::shared_ptr<AidlGraphicBufferAllocator>> mOlds;
		std::mutex mMutex;

		public:
		// Creates a GraphicBufferAllocator which will be passed to HAL
		// for creating C2BlockPool. And the created GraphicBufferAllocator
		// will be used afterwards by current().
		std::shared_ptr<AidlGraphicBufferAllocator> create() {
		std::unique_lock<std::mutex> l(mMutex);
		if (mCurrent) {
		// If this is not stopped.
		mCurrent->reset();
		if (mCurrentId.has_value()) {
		mOlds.emplace(mCurrentId.value(), mCurrent);
		}
		mCurrentId.reset();
		mCurrent.reset();
		}
		// TODO: integrate initial value with CCodec/CCodecBufferChannel
		mCurrent =
		AidlGraphicBufferAllocator::CreateGraphicBufferAllocator(3 /* maxDequeueCount */);
		ALOGD("GraphicBufferAllocator created");
		return mCurrent;
		}

		// Associates the blockpool Id returned from HAL to the
		// current GraphicBufferAllocator.
		void setCurrentId(C2BlockPool::local_id_t id) {
		std::unique_lock<std::mutex> l(mMutex);
		CHECK(!mCurrentId.has_value());
		mCurrentId = id;
		}

		// Returns the current GraphicBufferAllocator.
		std::shared_ptr<AidlGraphicBufferAllocator> current() {
		std::unique_lock<std::mutex> l(mMutex);
		return mCurrent;
		}

		// Removes the GraphicBufferAllocator associated with given \p id.
		void remove(C2BlockPool::local_id_t id) {
		std::unique_lock<std::mutex> l(mMutex);
		mOlds.erase(id);
		if (mCurrentId == id) {
		if (mCurrent) {
		mCurrent->reset();
		mCurrent.reset();
		}
		mCurrentId.reset();
		}
		}
		};

		// Codec2Client
		Codec2Client::Codec2Client(sp<HidlBase> const& base,
		sp<c2_hidl::IConfigurable> const& configurable,
		@@ -1125,6 +1210,7 @@ c2_status_t Codec2Client::createComponent(
		<< status << ".";
		}
		(*component)->mAidlBufferPoolSender->setReceiver(mAidlHostPoolManager);
		aidlListener->component = *component;
		return status;
		}

		@@ -1951,7 +2037,7 @@ Codec2Client::Component::Component(const std::shared_ptr<AidlBase> &base)
		},
		mAidlBase{base},
		mAidlBufferPoolSender{std::make_unique<AidlBufferPoolSender>()},
		mOutputBufferQueue{std::make_unique<OutputBufferQueue>()} {
		mGraphicBufferAllocators{std::make_unique<GraphicBufferAllocators>()} {
		}

		Codec2Client::Component::~Component() {
		@@ -1966,12 +2052,43 @@ c2_status_t Codec2Client::Component::createBlockPool(
		std::shared_ptr<Codec2Client::Configurable>* configurable) {
		if (mAidlBase) {
		c2_aidl::IComponent::BlockPool aidlBlockPool;
		::ndk::ScopedAStatus transStatus = mAidlBase->createBlockPool(static_cast<int32_t>(id),
		&aidlBlockPool);
		c2_status_t status = GetC2Status(transStatus, "createBlockPool");
		c2_status_t status = C2_OK;

		// TODO: Temporary mapping for the current CCodecBufferChannel.
		// Handle this properly and remove this temporary allocator mapping.
		id = id == C2PlatformAllocatorStore::BUFFERQUEUE ?
		C2PlatformAllocatorStore::IGBA : id;

		if (id == C2PlatformAllocatorStore::IGBA) {
		std::shared_ptr<AidlGraphicBufferAllocator> gba =
		mGraphicBufferAllocators->create();
		::ndk::ScopedFileDescriptor waitableFd;
		::ndk::ScopedAStatus ret = gba->getWaitableFd(&waitableFd);
		status = GetC2Status(ret, "Gba::getWaitableFd");
		if (status != C2_OK) {
		return status;
		}
		c2_aidl::IComponent::BlockPoolAllocator allocator;
		allocator.set<c2_aidl::IComponent::BlockPoolAllocator::allocator>();
		allocator.get<c2_aidl::IComponent::BlockPoolAllocator::allocator>().igba =
		c2_aidl::IGraphicBufferAllocator::fromBinder(gba->asBinder());
		allocator.get<c2_aidl::IComponent::BlockPoolAllocator::allocator>().waitableFd =
		std::move(waitableFd);
		::ndk::ScopedAStatus transStatus = mAidlBase->createBlockPool(
		allocator, &aidlBlockPool);
		status = GetC2Status(transStatus, "createBlockPool");
		if (status != C2_OK) {
		return status;
		}
		mGraphicBufferAllocators->setCurrentId(aidlBlockPool.blockPoolId);
		} else {
		::ndk::ScopedAStatus transStatus = mAidlBase->createBlockPool(
		static_cast<int32_t>(id), &aidlBlockPool);
		status = GetC2Status(transStatus, "createBlockPool");
		if (status != C2_OK) {
		return status;
		}
		}
		*blockPoolId = aidlBlockPool.blockPoolId;
		*configurable = std::make_shared<Configurable>(aidlBlockPool.configurable);
		return C2_OK;
		@@ -2003,6 +2120,7 @@ c2_status_t Codec2Client::Component::createBlockPool(
		c2_status_t Codec2Client::Component::destroyBlockPool(
		C2BlockPool::local_id_t localId) {
		if (mAidlBase) {
		mGraphicBufferAllocators->remove(localId);
		::ndk::ScopedAStatus transStatus = mAidlBase->destroyBlockPool(localId);
		return GetC2Status(transStatus, "destroyBlockPool");
		}
		@@ -2017,9 +2135,13 @@ c2_status_t Codec2Client::Component::destroyBlockPool(

		void Codec2Client::Component::handleOnWorkDone(
		const std::list<std::unique_ptr<C2Work>> &workItems) {
		if (mAidlBase) {
		holdIgbaBlocks(workItems);
		} else {
		// Output bufferqueue-based blocks' lifetime management
		mOutputBufferQueue->holdBufferQueueBlocks(workItems);
		}
		}

		c2_status_t Codec2Client::Component::queue(
		std::list<std::unique_ptr<C2Work>>* const items) {
		@@ -2102,8 +2224,12 @@ c2_status_t Codec2Client::Component::flush(
		}
		}

		if (mAidlBase) {
		holdIgbaBlocks(*flushedWork);
		} else {
		// Output bufferqueue-based blocks' lifetime management
		mOutputBufferQueue->holdBufferQueueBlocks(*flushedWork);
		}

		return status;
		}
		@@ -2242,6 +2368,17 @@ c2_status_t Codec2Client::Component::setOutputSurface(
		const sp<IGraphicBufferProducer>& surface,
		uint32_t generation,
		int maxDequeueCount) {
		if (mAidlBase) {
		std::shared_ptr<AidlGraphicBufferAllocator> gba =
		mGraphicBufferAllocators->current();
		if (!gba) {
		LOG(ERROR) << "setOutputSurface for AIDL -- "
		"GraphicBufferAllocator was not created.";
		return C2_CORRUPTED;
		}
		bool ret = gba->configure(surface, generation, maxDequeueCount);
		return ret ? C2_OK : C2_CORRUPTED;
		}
		uint64_t bqId = 0;
		sp<IGraphicBufferProducer> nullIgbp;
		sp<HGraphicBufferProducer2> nullHgbp;
		@@ -2303,10 +2440,6 @@ c2_status_t Codec2Client::Component::setOutputSurface(
		ALOGD("setOutputSurface -- generation=%u consumer usage=%#llx%s",
		generation, (long long)consumerUsage, syncObj ? " sync" : "");

		if (mAidlBase) {
		// FIXME
		return C2_OMITTED;
		}
		Return<c2_hidl::Status> transStatus = syncObj ?
		mHidlBase1_2->setOutputSurfaceWithSyncObj(
		static_cast<uint64_t>(blockPoolId),
		@@ -2335,26 +2468,51 @@ status_t Codec2Client::Component::queueToOutputSurface(
		const QueueBufferInput& input,
		QueueBufferOutput* output) {
		ScopedTrace trace(ATRACE_TAG,"Codec2Client::Component::queueToOutputSurface");
		if (mAidlBase) {
		std::shared_ptr<AidlGraphicBufferAllocator> gba =
		mGraphicBufferAllocators->current();
		if (gba) {
		return gba->displayBuffer(block, input, output);
		} else {
		return C2_NOT_FOUND;
		}
		}
		return mOutputBufferQueue->outputBuffer(block, input, output);
		}

		void Codec2Client::Component::pollForRenderedFrames(FrameEventHistoryDelta* delta) {
		if (mAidlBase) {
		// TODO b/311348680
		return;
		}
		mOutputBufferQueue->pollForRenderedFrames(delta);
		}

		void Codec2Client::Component::setOutputSurfaceMaxDequeueCount(
		int maxDequeueCount) {
		if (mAidlBase) {
		std::shared_ptr<AidlGraphicBufferAllocator> gba =
		mGraphicBufferAllocators->current();
		if (gba) {
		gba->updateMaxDequeueBufferCount(maxDequeueCount);
		}
		return;
		}
		mOutputBufferQueue->updateMaxDequeueBufferCount(maxDequeueCount);
		}

		void Codec2Client::Component::stopUsingOutputSurface(
		C2BlockPool::local_id_t blockPoolId) {
		std::scoped_lock lock(mOutputMutex);
		mOutputBufferQueue->stop();
		if (mAidlBase) {
		// FIXME
		std::shared_ptr<AidlGraphicBufferAllocator> gba =
		mGraphicBufferAllocators->current();
		if (gba) {
		gba->reset();
		}
		return;
		}
		std::scoped_lock lock(mOutputMutex);
		mOutputBufferQueue->stop();
		Return<c2_hidl::Status> transStatus = mHidlBase1_0->setOutputSurface(
		static_cast<uint64_t>(blockPoolId), nullptr);
		if (!transStatus.isOk()) {
		@@ -2372,9 +2530,50 @@ void Codec2Client::Component::stopUsingOutputSurface(

		void Codec2Client::Component::onBufferReleasedFromOutputSurface(
		uint32_t generation) {
		if (mAidlBase) {
		std::shared_ptr<AidlGraphicBufferAllocator> gba =
		mGraphicBufferAllocators->current();
		if (gba) {
		gba->onBufferReleased(generation);
		}
		return;
		}
		mOutputBufferQueue->onBufferReleased(generation);
		}

		void Codec2Client::Component::holdIgbaBlocks(
		const std::list<std::unique_ptr<C2Work>>& workList) {
		if (!mAidlBase) {
		return;
		}
		std::shared_ptr<AidlGraphicBufferAllocator> gba =
		mGraphicBufferAllocators->current();
		if (!gba) {
		return;
		}
		std::shared_ptr<c2_aidl::IGraphicBufferAllocator> igba =
		c2_aidl::IGraphicBufferAllocator::fromBinder(gba->asBinder());
		for (const std::unique_ptr<C2Work>& work : workList) {
		if (!work) [[unlikely]] {
		continue;
		}
		for (const std::unique_ptr<C2Worklet>& worklet : work->worklets) {
		if (!worklet) {
		continue;
		}
		for (const std::shared_ptr<C2Buffer>& buffer : worklet->output.buffers) {
		if (buffer) {
		for (const C2ConstGraphicBlock& block : buffer->data().graphicBlocks()) {
		std::shared_ptr<_C2BlockPoolData> poolData =
		_C2BlockFactory::GetGraphicBlockPoolData(block);
		_C2BlockFactory::RegisterIgba(poolData, igba);
		}
		}
		}
		}
		}
		}

		c2_status_t Codec2Client::Component::connectToInputSurface(
		const std::shared_ptr<InputSurface>& inputSurface,
		std::shared_ptr<InputSurfaceConnection>* connection) {

media/codec2/hal/client/include/codec2/hidl/client.h

+11 −0

Original line number	Diff line number	Diff line
		@@ -478,6 +478,14 @@ struct Codec2Client::Component : public Codec2Client::Configurable {
		void onBufferReleasedFromOutputSurface(
		uint32_t generation);

		// When the client received \p workList and the blocks inside
		// \p workList are IGBA based graphic blocks, specify the owner
		// as the current IGBA for the future operations.
		// Future operations could be rendering the blocks to the surface
		// or deallocating blocks to the surface.
		void holdIgbaBlocks(
		const std::list<std::unique_ptr<C2Work>>& workList);

		// Connect to a given InputSurface.
		c2_status_t connectToInputSurface(
		const std::shared_ptr<InputSurface>& inputSurface,
		@@ -517,6 +525,9 @@ protected:
		// In order to prevent the race condition mutex is added.
		std::mutex mOutputMutex;

		struct GraphicBufferAllocators;
		std::unique_ptr<GraphicBufferAllocators> mGraphicBufferAllocators;

		class AidlDeathManager;
		static AidlDeathManager *GetAidlDeathManager();
		std::optional<size_t> mAidlDeathSeq;

media/codec2/hal/plugin/FilterWrapper.cpp

+11 −2

Original line number	Diff line number	Diff line
		@@ -969,6 +969,15 @@ c2_status_t FilterWrapper::createBlockPool(
		C2PlatformAllocatorStore::id_t allocatorId,
		std::shared_ptr<const C2Component> component,
		std::shared_ptr<C2BlockPool> *pool) {
		C2PlatformAllocatorDesc allocatorParam;
		allocatorParam.allocatorId = allocatorId;
		return createBlockPool(allocatorParam, component, pool);
		}

		c2_status_t FilterWrapper::createBlockPool(
		C2PlatformAllocatorDesc &allocatorParam,
		std::shared_ptr<const C2Component> component,
		std::shared_ptr<C2BlockPool> *pool) {
		std::unique_lock lock(mWrappedComponentsMutex);
		for (auto it = mWrappedComponents.begin(); it != mWrappedComponents.end(); ) {
		std::shared_ptr<const C2Component> comp = it->front().lock();
		@@ -983,13 +992,13 @@ c2_status_t FilterWrapper::createBlockPool(
		[](const std::weak_ptr<const C2Component> &el) {
		return el.lock();
		});
		if (C2_OK == CreateCodec2BlockPool(allocatorId, components, pool)) {
		if (C2_OK == CreateCodec2BlockPool(allocatorParam, components, pool)) {
		return C2_OK;
		}
		}
		++it;
		}
		return CreateCodec2BlockPool(allocatorId, component, pool);
		return CreateCodec2BlockPool(allocatorParam, component, pool);
		}

		c2_status_t FilterWrapper::queryParamsForPreviousComponent(

media/codec2/hal/plugin/FilterWrapperStub.cpp

+10 −1

Original line number	Diff line number	Diff line
		@@ -45,7 +45,16 @@ c2_status_t FilterWrapper::createBlockPool(
		C2PlatformAllocatorStore::id_t allocatorId,
		std::shared_ptr<const C2Component> component,
		std::shared_ptr<C2BlockPool> *pool) {
		return CreateCodec2BlockPool(allocatorId, component, pool);
		C2PlatformAllocatorDesc allocatorParam;
		allocatorParam.allocatorId = allocatorId;
		return createBlockPool(allocatorParam, component, pool);
		}

		c2_status_t FilterWrapper::createBlockPool(
		C2PlatformAllocatorDesc &allocatorParam,
		std::shared_ptr<const C2Component> component,
		std::shared_ptr<C2BlockPool> *pool) {
		return CreateCodec2BlockPool(allocatorParam, component, pool);
		}

		} // namespace android