codec2/hidl/1.0/utils/InputSurfaceConnection.cpp - platform/hardware/google/av - Git at Google

 /*
  * Copyright (C) 2018 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 "Codec2-InputSurfaceConnection"
 #include <log/log.h>

 #include <codec2/hidl/1.0/InputSurfaceConnection.h>

 #include <media/stagefright/bqhelper/ComponentWrapper.h>

 #include <C2BlockInternal.h>
 #include <C2PlatformSupport.h>
 #include <C2AllocatorGralloc.h>

 #include <C2Debug.h>
 #include <C2Config.h>
 #include <C2Component.h>
 #include <C2Work.h>
 #include <C2Buffer.h>
 #include <C2.h>

 #include <ui/GraphicBuffer.h>
 #include <system/graphics.h>
 #include <utils/Errors.h>

 #include <memory>
 #include <list>
 #include <mutex>
 #include <atomic>

 namespace /* unnamed */ {

 class Buffer2D : public C2Buffer {
 public:
     explicit Buffer2D(C2ConstGraphicBlock block) : C2Buffer({ block }) {
     }
 };

 constexpr int32_t kBufferCount = 16;

 } // unnamed namespace

 namespace hardware {
 namespace google {
 namespace media {
 namespace c2 {
 namespace V1_0 {
 namespace utils {

 using namespace ::android;

 struct InputSurfaceConnection::Impl : public ComponentWrapper {
     Impl(
             const sp<GraphicBufferSource>& source,
             const std::shared_ptr<C2Component>& comp) :
         mSource(source), mComp(comp), mFrameIndex(0) {
     }

     virtual ~Impl() = default;

     bool init() {
         sp<GraphicBufferSource> source = mSource.promote();
         if (source == nullptr) {
             return false;
         }
         status_t err = source->initCheck();
         if (err != OK) {
             ALOGE("Impl::init -- GBS init failed: %d", err);
             return false;
         }

         // Query necessary information for GraphicBufferSource::configure() from
         // the component interface.
         std::shared_ptr<C2Component> comp = mComp.lock();
         if (!comp) {
             ALOGE("Impl::init -- component died.");
             return false;
         }
         std::shared_ptr<C2ComponentInterface> intf = comp->intf();
         if (!intf) {
             ALOGE("Impl::init -- null component interface.");
             return false;
         }

         // TODO: read settings properly from the interface
         C2VideoSizeStreamTuning::input inputSize;
         C2StreamUsageTuning::input usage;
         c2_status_t c2Status = intf->query_vb(
                 { &inputSize, &usage },
                 {},
                 C2_MAY_BLOCK,
                 nullptr);
         if (c2Status != C2_OK) {
             ALOGD("Impl::init -- cannot query information from "
                     "the component interface: %s.", asString(c2Status));
             return false;
         }

         // TODO: proper color aspect & dataspace
         android_dataspace dataSpace = HAL_DATASPACE_BT709;

         // TODO: use the usage read from intf
         // uint32_t grallocUsage =
         //         C2AndroidMemoryUsage(C2MemoryUsage(usage.value)).
         //         asGrallocUsage();
         uint32_t grallocUsage =
                 strncmp(intf->getName().c_str(), "c2.android.", 11) == 0 ?
                 GRALLOC_USAGE_SW_READ_OFTEN :
                 GRALLOC_USAGE_HW_VIDEO_ENCODER;

         err = source->configure(
                 this, dataSpace, kBufferCount,
                 inputSize.width, inputSize.height,
                 grallocUsage);
         if (err != OK) {
             ALOGE("Impl::init -- GBS configure failed: %d", err);
             return false;
         }
         for (int32_t i = 0; i < kBufferCount; ++i) {
             if (!source->onInputBufferAdded(i).isOk()) {
                 ALOGE("Impl::init: populating GBS slots failed");
                 return false;
             }
         }
         if (!source->start().isOk()) {
             ALOGE("Impl::init -- GBS start failed");
             return false;
         }
         mAllocatorMutex.lock();
         c2_status_t c2err = GetCodec2PlatformAllocatorStore()->fetchAllocator(
                 C2AllocatorStore::PLATFORM_START + 1,  // GRALLOC
                 &mAllocator);
         mAllocatorMutex.unlock();
         if (c2err != OK) {
             ALOGE("Impl::init -- failed to fetch gralloc allocator: %d", c2err);
             return false;
         }
         return true;
     }

     // From ComponentWrapper
     virtual status_t submitBuffer(
             int32_t bufferId,
             const sp<GraphicBuffer>& buffer,
             int64_t timestamp,
             int fenceFd) override {
         ALOGV("Impl::submitBuffer -- bufferId = %d", bufferId);
         // TODO: Use fd to construct fence
         (void)fenceFd;

         std::shared_ptr<C2Component> comp = mComp.lock();
         if (!comp) {
             ALOGW("Impl::submitBuffer -- component died.");
             return NO_INIT;
         }

         std::shared_ptr<C2GraphicAllocation> alloc;
         C2Handle* handle = WrapNativeCodec2GrallocHandle(
                 native_handle_clone(buffer->handle),
                 buffer->width, buffer->height,
                 buffer->format, buffer->usage, buffer->stride);
         mAllocatorMutex.lock();
         c2_status_t err = mAllocator->priorGraphicAllocation(handle, &alloc);
         mAllocatorMutex.unlock();
         if (err != OK) {
             return UNKNOWN_ERROR;
         }
         std::shared_ptr<C2GraphicBlock> block =
                 _C2BlockFactory::CreateGraphicBlock(alloc);

         std::unique_ptr<C2Work> work(new C2Work);
         work->input.flags = (C2FrameData::flags_t)0;
         work->input.ordinal.timestamp = timestamp;
         work->input.ordinal.frameIndex = mFrameIndex.fetch_add(
                 1, std::memory_order_relaxed);
         work->input.buffers.clear();
         std::shared_ptr<C2Buffer> c2Buffer(
                 // TODO: fence
                 new Buffer2D(block->share(
                         C2Rect(block->width(), block->height()), ::C2Fence())),
                 [bufferId, src = mSource](C2Buffer* ptr) {
                     delete ptr;
                     sp<GraphicBufferSource> source = src.promote();
                     if (source != nullptr) {
                         // TODO: fence
                         (void)source->onInputBufferEmptied(bufferId, -1);
                     }
                 });
         work->input.buffers.push_back(c2Buffer);
         work->worklets.clear();
         work->worklets.emplace_back(new C2Worklet);
         std::list<std::unique_ptr<C2Work>> items;
         items.push_back(std::move(work));

         err = comp->queue_nb(&items);
         return (err == C2_OK) ? OK : UNKNOWN_ERROR;
     }

     virtual status_t submitEos(int32_t /* bufferId */) override {
         ALOGV("Impl::submitEos");
         std::shared_ptr<C2Component> comp = mComp.lock();
         if (!comp) {
             ALOGW("Impl::submitEos -- component died.");
             return NO_INIT;
         }

         std::unique_ptr<C2Work> work(new C2Work);
         work->input.flags = (C2FrameData::flags_t)0;
         work->input.ordinal.frameIndex = mFrameIndex.fetch_add(
                 1, std::memory_order_relaxed);
         work->input.buffers.clear();
         work->worklets.clear();
         work->worklets.emplace_back(new C2Worklet);
         std::list<std::unique_ptr<C2Work>> items;
         items.push_back(std::move(work));

         c2_status_t err = comp->queue_nb(&items);
         return (err == C2_OK) ? OK : UNKNOWN_ERROR;
     }

     void dispatchDataSpaceChanged(
             int32_t dataSpace, int32_t aspects, int32_t pixelFormat) override {
         // TODO
         (void)dataSpace;
         (void)aspects;
         (void)pixelFormat;
     }

 private:
     wp<GraphicBufferSource> mSource;
     std::weak_ptr<C2Component> mComp;

     // Needed for ComponentWrapper implementation
     std::mutex mAllocatorMutex;
     std::shared_ptr<C2Allocator> mAllocator;
     std::atomic_uint64_t mFrameIndex;
 };

 InputSurfaceConnection::InputSurfaceConnection(
         const sp<GraphicBufferSource>& source,
         const std::shared_ptr<C2Component>& comp) :
     mSource(source),
     mImpl(new Impl(source, comp)) {
 }

 InputSurfaceConnection::~InputSurfaceConnection() {
     if (mSource) {
         (void)mSource->stop();
         (void)mSource->release();
         mSource.clear();
     }
     mImpl.clear();
 }

 bool InputSurfaceConnection::init() {
     std::lock_guard<std::mutex> lock(mMutex);
     if (!mImpl) {
         return false;
     }
     return mImpl->init();
 }

 Return<Status> InputSurfaceConnection::disconnect() {
     ALOGV("disconnect");
     mMutex.lock();
     if (mSource) {
         (void)mSource->stop();
         (void)mSource->release();
         mSource.clear();
     }
     mImpl.clear();
     mMutex.unlock();
     ALOGV("disconnected");
     return Status::OK;
 }

 }  // namespace utils
 }  // namespace V1_0
 }  // namespace c2
 }  // namespace media
 }  // namespace google
 }  // namespace hardware
	/*
	* Copyright (C) 2018 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 "Codec2-InputSurfaceConnection"
	#include <log/log.h>

	#include <codec2/hidl/1.0/InputSurfaceConnection.h>

	#include <media/stagefright/bqhelper/ComponentWrapper.h>

	#include <C2BlockInternal.h>
	#include <C2PlatformSupport.h>
	#include <C2AllocatorGralloc.h>

	#include <C2Debug.h>
	#include <C2Config.h>
	#include <C2Component.h>
	#include <C2Work.h>
	#include <C2Buffer.h>
	#include <C2.h>

	#include <ui/GraphicBuffer.h>
	#include <system/graphics.h>
	#include <utils/Errors.h>

	#include <memory>
	#include <list>
	#include <mutex>
	#include <atomic>

	namespace /* unnamed */ {

	class Buffer2D : public C2Buffer {
	public:
	explicit Buffer2D(C2ConstGraphicBlock block) : C2Buffer({ block }) {
	}
	};

	constexpr int32_t kBufferCount = 16;

	} // unnamed namespace

	namespace hardware {
	namespace google {
	namespace media {
	namespace c2 {
	namespace V1_0 {
	namespace utils {

	using namespace ::android;

	struct InputSurfaceConnection::Impl : public ComponentWrapper {
	Impl(
	const sp<GraphicBufferSource>& source,
	const std::shared_ptr<C2Component>& comp) :
	mSource(source), mComp(comp), mFrameIndex(0) {
	}

	virtual ~Impl() = default;

	bool init() {
	sp<GraphicBufferSource> source = mSource.promote();
	if (source == nullptr) {
	return false;
	}
	status_t err = source->initCheck();
	if (err != OK) {
	ALOGE("Impl::init -- GBS init failed: %d", err);
	return false;
	}

	// Query necessary information for GraphicBufferSource::configure() from
	// the component interface.
	std::shared_ptr<C2Component> comp = mComp.lock();
	if (!comp) {
	ALOGE("Impl::init -- component died.");
	return false;
	}
	std::shared_ptr<C2ComponentInterface> intf = comp->intf();
	if (!intf) {
	ALOGE("Impl::init -- null component interface.");
	return false;
	}

	// TODO: read settings properly from the interface
	C2VideoSizeStreamTuning::input inputSize;
	C2StreamUsageTuning::input usage;
	c2_status_t c2Status = intf->query_vb(
	{ &inputSize, &usage },
	{},
	C2_MAY_BLOCK,
	nullptr);
	if (c2Status != C2_OK) {
	ALOGD("Impl::init -- cannot query information from "
	"the component interface: %s.", asString(c2Status));
	return false;
	}

	// TODO: proper color aspect & dataspace
	android_dataspace dataSpace = HAL_DATASPACE_BT709;

	// TODO: use the usage read from intf
	// uint32_t grallocUsage =
	// C2AndroidMemoryUsage(C2MemoryUsage(usage.value)).
	// asGrallocUsage();
	uint32_t grallocUsage =
	strncmp(intf->getName().c_str(), "c2.android.", 11) == 0 ?
	GRALLOC_USAGE_SW_READ_OFTEN :
	GRALLOC_USAGE_HW_VIDEO_ENCODER;

	err = source->configure(
	this, dataSpace, kBufferCount,
	inputSize.width, inputSize.height,
	grallocUsage);
	if (err != OK) {
	ALOGE("Impl::init -- GBS configure failed: %d", err);
	return false;
	}
	for (int32_t i = 0; i < kBufferCount; ++i) {
	if (!source->onInputBufferAdded(i).isOk()) {
	ALOGE("Impl::init: populating GBS slots failed");
	return false;
	}
	}
	if (!source->start().isOk()) {
	ALOGE("Impl::init -- GBS start failed");
	return false;
	}
	mAllocatorMutex.lock();
	c2_status_t c2err = GetCodec2PlatformAllocatorStore()->fetchAllocator(
	C2AllocatorStore::PLATFORM_START + 1, // GRALLOC
	&mAllocator);
	mAllocatorMutex.unlock();
	if (c2err != OK) {
	ALOGE("Impl::init -- failed to fetch gralloc allocator: %d", c2err);
	return false;
	}
	return true;
	}

	// From ComponentWrapper
	virtual status_t submitBuffer(
	int32_t bufferId,
	const sp<GraphicBuffer>& buffer,
	int64_t timestamp,
	int fenceFd) override {
	ALOGV("Impl::submitBuffer -- bufferId = %d", bufferId);
	// TODO: Use fd to construct fence
	(void)fenceFd;

	std::shared_ptr<C2Component> comp = mComp.lock();
	if (!comp) {
	ALOGW("Impl::submitBuffer -- component died.");
	return NO_INIT;
	}

	std::shared_ptr<C2GraphicAllocation> alloc;
	C2Handle* handle = WrapNativeCodec2GrallocHandle(
	native_handle_clone(buffer->handle),
	buffer->width, buffer->height,
	buffer->format, buffer->usage, buffer->stride);
	mAllocatorMutex.lock();
	c2_status_t err = mAllocator->priorGraphicAllocation(handle, &alloc);
	mAllocatorMutex.unlock();
	if (err != OK) {
	return UNKNOWN_ERROR;
	}
	std::shared_ptr<C2GraphicBlock> block =
	_C2BlockFactory::CreateGraphicBlock(alloc);

	std::unique_ptr<C2Work> work(new C2Work);
	work->input.flags = (C2FrameData::flags_t)0;
	work->input.ordinal.timestamp = timestamp;
	work->input.ordinal.frameIndex = mFrameIndex.fetch_add(
	1, std::memory_order_relaxed);
	work->input.buffers.clear();
	std::shared_ptr<C2Buffer> c2Buffer(
	// TODO: fence
	new Buffer2D(block->share(
	C2Rect(block->width(), block->height()), ::C2Fence())),
	[bufferId, src = mSource](C2Buffer* ptr) {
	delete ptr;
	sp<GraphicBufferSource> source = src.promote();
	if (source != nullptr) {
	// TODO: fence
	(void)source->onInputBufferEmptied(bufferId, -1);
	}
	});
	work->input.buffers.push_back(c2Buffer);
	work->worklets.clear();
	work->worklets.emplace_back(new C2Worklet);
	std::list<std::unique_ptr<C2Work>> items;
	items.push_back(std::move(work));

	err = comp->queue_nb(&items);
	return (err == C2_OK) ? OK : UNKNOWN_ERROR;
	}

	virtual status_t submitEos(int32_t /* bufferId */) override {
	ALOGV("Impl::submitEos");
	std::shared_ptr<C2Component> comp = mComp.lock();
	if (!comp) {
	ALOGW("Impl::submitEos -- component died.");
	return NO_INIT;
	}

	std::unique_ptr<C2Work> work(new C2Work);
	work->input.flags = (C2FrameData::flags_t)0;
	work->input.ordinal.frameIndex = mFrameIndex.fetch_add(
	1, std::memory_order_relaxed);
	work->input.buffers.clear();
	work->worklets.clear();
	work->worklets.emplace_back(new C2Worklet);
	std::list<std::unique_ptr<C2Work>> items;
	items.push_back(std::move(work));

	c2_status_t err = comp->queue_nb(&items);
	return (err == C2_OK) ? OK : UNKNOWN_ERROR;
	}

	void dispatchDataSpaceChanged(
	int32_t dataSpace, int32_t aspects, int32_t pixelFormat) override {
	// TODO
	(void)dataSpace;
	(void)aspects;
	(void)pixelFormat;
	}

	private:
	wp<GraphicBufferSource> mSource;
	std::weak_ptr<C2Component> mComp;

	// Needed for ComponentWrapper implementation
	std::mutex mAllocatorMutex;
	std::shared_ptr<C2Allocator> mAllocator;
	std::atomic_uint64_t mFrameIndex;
	};

	InputSurfaceConnection::InputSurfaceConnection(
	const sp<GraphicBufferSource>& source,
	const std::shared_ptr<C2Component>& comp) :
	mSource(source),
	mImpl(new Impl(source, comp)) {
	}

	InputSurfaceConnection::~InputSurfaceConnection() {
	if (mSource) {
	(void)mSource->stop();
	(void)mSource->release();
	mSource.clear();
	}
	mImpl.clear();
	}

	bool InputSurfaceConnection::init() {
	std::lock_guard<std::mutex> lock(mMutex);
	if (!mImpl) {
	return false;
	}
	return mImpl->init();
	}

	Return<Status> InputSurfaceConnection::disconnect() {
	ALOGV("disconnect");
	mMutex.lock();
	if (mSource) {
	(void)mSource->stop();
	(void)mSource->release();
	mSource.clear();
	}
	mImpl.clear();
	mMutex.unlock();
	ALOGV("disconnected");
	return Status::OK;
	}

	} // namespace utils
	} // namespace V1_0
	} // namespace c2
	} // namespace media
	} // namespace google
	} // namespace hardware