Merge "codec2: Add android fence implementation for C2Fence" into tm-dev am: f949df5eb5 (31d3bcb9) · Commits · e / os / android_frameworks_av

media/codec2/hidl/1.0/utils/types.cpp

+9 −12

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include <C2BlockInternal.h>
		#include <C2Buffer.h>
		#include <C2Component.h>
		#include <C2FenceFactory.h>
		#include <C2Param.h>
		#include <C2ParamInternal.h>
		#include <C2PlatformSupport.h>
		@@ -759,17 +760,14 @@ bool addBaseBlock(
		// Note: File descriptors are not duplicated. The original file descriptor must
		// not be closed before the transaction is complete.
		bool objcpy(hidl_handle* d, const C2Fence& s) {
		(void)s; // TODO: implement s.fd()
		int fenceFd = -1;
		d->setTo(nullptr);
		if (fenceFd >= 0) {
		native_handle_t *handle = native_handle_create(1, 0);
		if (!handle) {
		LOG(ERROR) << "Failed to create a native handle.";
		return false;
		}
		handle->data[0] = fenceFd;
		native_handle_t* handle = _C2FenceFactory::CreateNativeHandle(s);
		if (handle) {
		d->setTo(handle, true /* owns */);
		// } else if (!s.ready()) {
		// // TODO: we should wait for unmarshallable fences but this may not be
		// // the best place for it. We can safely ignore here as at this time
		// // all fences used here are marshallable.
		}
		return true;
		}
		@@ -1184,9 +1182,8 @@ struct C2BaseBlock {
		// Note: File descriptors are not duplicated. The original file descriptor must
		// not be closed before the transaction is complete.
		bool objcpy(C2Fence* d, const hidl_handle& s) {
		// TODO: Implement.
		(void)s;
		*d = C2Fence();
		const native_handle_t* handle = s.getNativeHandle();
		*d = _C2FenceFactory::CreateFromNativeHandle(handle);
		return true;
		}

media/codec2/sfplugin/CCodecBufferChannel.cpp

+14 −1

Original line number	Diff line number	Diff line
		@@ -880,6 +880,19 @@ status_t CCodecBufferChannel::renderOutputBuffer(
		return UNKNOWN_ERROR;
		}
		const C2ConstGraphicBlock &block = blocks.front();
		C2Fence c2fence = block.fence();
		sp<Fence> fence = Fence::NO_FENCE;
		// TODO: it's not sufficient to just check isHW() and then construct android::fence from it.
		// Once C2Fence::type() is added, check the exact C2Fence type
		if (c2fence.isHW()) {
		int fenceFd = c2fence.fd();
		fence = sp<Fence>::make(fenceFd);
		if (!fence) {
		ALOGE("[%s] Failed to allocate a fence", mName);
		close(fenceFd);
		return NO_MEMORY;
		}
		}

		// TODO: revisit this after C2Fence implementation.
		android::IGraphicBufferProducer::QueueBufferInput qbi(
		@@ -892,7 +905,7 @@ status_t CCodecBufferChannel::renderOutputBuffer(
		blocks.front().crop().bottom()),
		videoScalingMode,
		transform,
		Fence::NO_FENCE, 0);
		fence, 0);
		if (hdrStaticInfo \|\| hdrDynamicInfo) {
		HdrMetadata hdr;
		if (hdrStaticInfo) {

media/codec2/vndk/C2Fence.cpp

+153 −0

Original line number	Diff line number	Diff line
		@@ -16,13 +16,24 @@

		//#define LOG_NDEBUG 0
		#define LOG_TAG "C2FenceFactory"
		#include <cutils/native_handle.h>
		#include <utils/Log.h>
		#include <ui/Fence.h>

		#include <C2FenceFactory.h>
		#include <C2SurfaceSyncObj.h>

		#define MAX_FENCE_FDS 1

		class C2Fence::Impl {
		public:
		enum type_t : uint32_t {
		INVALID_FENCE,
		NULL_FENCE,
		SURFACE_FENCE,
		SYNC_FENCE,
		};

		virtual c2_status_t wait(c2_nsecs_t timeoutNs) = 0;

		virtual bool valid() const = 0;
		@@ -33,9 +44,26 @@ public:

		virtual bool isHW() const = 0;

		virtual type_t type() const = 0;

		/**
		* Create a native handle for the fence so it can be marshalled.
		* The native handle must store fence type in the first integer.
		*
		* \return a valid native handle if the fence can be marshalled, otherwise return null.
		*/
		virtual native_handle_t *createNativeHandle() const = 0;

		virtual ~Impl() = default;

		Impl() = default;

		static type_t GetTypeFromNativeHandle(const native_handle_t* nh) {
		if (nh && nh->numFds >= 0 && nh->numFds <= MAX_FENCE_FDS && nh->numInts > 0) {
		return static_cast<type_t>(nh->data[nh->numFds]);
		}
		return INVALID_FENCE;
		}
		};

		c2_status_t C2Fence::wait(c2_nsecs_t timeoutNs) {
		@@ -115,6 +143,15 @@ public:
		return false;
		}

		virtual type_t type() const {
		return SURFACE_FENCE;
		}

		virtual native_handle_t *createNativeHandle() const {
		ALOG_ASSERT(false, "Cannot create native handle from surface fence");
		return nullptr;
		}

		virtual ~SurfaceFenceImpl() {};

		SurfaceFenceImpl(std::shared_ptr<C2SurfaceSyncMemory> syncMem, uint32_t waitId) :
		@@ -143,3 +180,119 @@ C2Fence _C2FenceFactory::CreateSurfaceFence(
		}
		return C2Fence();
		}

		using namespace android;

		class _C2FenceFactory::SyncFenceImpl : public C2Fence::Impl {
		public:
		virtual c2_status_t wait(c2_nsecs_t timeoutNs) {
		c2_nsecs_t timeoutMs = timeoutNs / 1000;
		if (timeoutMs > INT_MAX) {
		timeoutMs = INT_MAX;
		}

		switch (mFence->wait((int)timeoutMs)) {
		case NO_ERROR:
		return C2_OK;
		case -ETIME:
		return C2_TIMED_OUT;
		default:
		return C2_CORRUPTED;
		}
		}

		virtual bool valid() const {
		return mFence->getStatus() != Fence::Status::Invalid;
		}

		virtual bool ready() const {
		return mFence->getStatus() == Fence::Status::Signaled;
		}

		virtual int fd() const {
		return mFence->dup();
		}

		virtual bool isHW() const {
		return true;
		}

		virtual type_t type() const {
		return SYNC_FENCE;
		}

		virtual native_handle_t *createNativeHandle() const {
		native_handle_t* nh = native_handle_create(1, 1);
		if (!nh) {
		ALOGE("Failed to allocate native handle for sync fence");
		return nullptr;
		}
		nh->data[0] = fd();
		nh->data[1] = type();
		return nh;
		}

		virtual ~SyncFenceImpl() {};

		SyncFenceImpl(int fenceFd) :
		mFence(sp<Fence>::make(fenceFd)) {}

		static std::shared_ptr<SyncFenceImpl> CreateFromNativeHandle(const native_handle_t* nh) {
		if (!nh \|\| nh->numFds != 1 \|\| nh->numInts != 1) {
		ALOGE("Invalid handle for sync fence");
		return nullptr;
		}
		int fd = dup(nh->data[0]);
		std::shared_ptr<SyncFenceImpl> p = std::make_shared<SyncFenceImpl>(fd);
		if (!p) {
		ALOGE("Failed to allocate sync fence impl");
		close(fd);
		}
		return p;
		}

		private:
		const sp<Fence> mFence;
		};

		C2Fence _C2FenceFactory::CreateSyncFence(int fenceFd) {
		std::shared_ptr<C2Fence::Impl> p;
		if (fenceFd >= 0) {
		p = std::make_shared<_C2FenceFactory::SyncFenceImpl>(fenceFd);
		if (!p) {
		ALOGE("Failed to allocate sync fence impl");
		close(fenceFd);
		}
		if (!p->valid()) {
		p.reset();
		}
		} else {
		ALOGE("Create sync fence from invalid fd");
		}
		return C2Fence(p);
		}

		native_handle_t* _C2FenceFactory::CreateNativeHandle(const C2Fence& fence) {
		return fence.mImpl? fence.mImpl->createNativeHandle() : nullptr;
		}

		C2Fence _C2FenceFactory::CreateFromNativeHandle(const native_handle_t* handle) {
		if (!handle) {
		return C2Fence();
		}
		C2Fence::Impl::type_t type = C2Fence::Impl::GetTypeFromNativeHandle(handle);
		std::shared_ptr<C2Fence::Impl> p;
		switch (type) {
		case C2Fence::Impl::SYNC_FENCE:
		p = SyncFenceImpl::CreateFromNativeHandle(handle);
		break;
		default:
		ALOG_ASSERT(false, "Unsupported fence type %d", type);
		break;
		}
		if (p && !p->valid()) {
		p.reset();
		}
		return C2Fence(p);
		}

media/codec2/vndk/include/C2FenceFactory.h

+25 −0

Original line number	Diff line number	Diff line
		@@ -28,6 +28,7 @@ class C2SurfaceSyncMemory;
		struct _C2FenceFactory {

		class SurfaceFenceImpl;
		class SyncFenceImpl;

		/*
		* Create C2Fence for BufferQueueBased blockpool.
		@@ -38,6 +39,30 @@ struct _C2FenceFactory {
		static C2Fence CreateSurfaceFence(
		std::shared_ptr<C2SurfaceSyncMemory> syncMem,
		uint32_t waitId);

		/*
		* Create C2Fence from a fence file fd.
		*
		* \param fenceFd Fence file descriptor.
		* It will be owned and closed by the returned fence object.
		*/
		static C2Fence CreateSyncFence(int fenceFd);

		/**
		* Create a native handle from fence for marshalling
		*
		* \return a non-null pointer if the fence can be marshalled, otherwise return nullptr
		*/
		static native_handle_t* CreateNativeHandle(const C2Fence& fence);

		/*
		* Create C2Fence from a native handle.

		* \param handle A native handle representing a fence
		* The fd in the native handle will be duplicated, so the caller will
		* still own the handle and have to close it.
		*/
		static C2Fence CreateFromNativeHandle(const native_handle_t* handle);
		};