Merge changes from topic "c2aidl-hidl-token" into main am: 7b0acc5b00 (0bddb068) · Commits · e / os / android_frameworks_av

media/codec2/hal/client/client.cpp

+4 −0

Original line number	Diff line number	Diff line
		@@ -1868,6 +1868,10 @@ std::shared_ptr<Codec2Client::InputSurface> Codec2Client::CreateInputSurface(
		return nullptr;
		}

		bool Codec2Client::IsAidlSelected() {
		return c2_aidl::utils::IsSelected();
		}

		// Codec2Client::Interface
		Codec2Client::Interface::Interface(const sp<HidlBase>& base)
		: Configurable{

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

+3 −0

Original line number	Diff line number	Diff line
		@@ -270,6 +270,9 @@ struct Codec2Client : public Codec2ConfigurableClient {
		static std::shared_ptr<InputSurface> CreateInputSurface(
		char const* serviceName = nullptr);

		// Whether AIDL is selected.
		static bool IsAidlSelected();

		// base and/or configurable cannot be null.
		Codec2Client(
		sp<HidlBase> const& base,

media/codec2/sfplugin/CCodec.cpp

+345 −55

Original line number	Diff line number	Diff line
		@@ -26,6 +26,9 @@
		#include <C2ParamInternal.h>
		#include <C2PlatformSupport.h>

		#include <aidl/android/hardware/graphics/common/Dataspace.h>
		#include <aidl/android/media/IAidlGraphicBufferSource.h>
		#include <aidl/android/media/IAidlBufferSource.h>
		#include <android/IOMXBufferSource.h>
		#include <android/hardware/media/c2/1.0/IInputSurface.h>
		#include <android/hardware/media/omx/1.0/IGraphicBufferSource.h>
		@@ -41,6 +44,10 @@
		#include <media/openmax/OMX_IndexExt.h>
		#include <media/stagefright/foundation/avc_utils.h>
		#include <media/stagefright/foundation/AUtils.h>
		#include <media/stagefright/aidlpersistentsurface/AidlGraphicBufferSource.h>
		#include <media/stagefright/aidlpersistentsurface/C2NodeDef.h>
		#include <media/stagefright/aidlpersistentsurface/wrapper/Conversion.h>
		#include <media/stagefright/aidlpersistentsurface/wrapper/WAidlGraphicBufferSource.h>
		#include <media/stagefright/omx/1.0/WGraphicBufferSource.h>
		#include <media/stagefright/omx/OmxGraphicBufferSource.h>
		#include <media/stagefright/CCodec.h>
		@@ -51,6 +58,7 @@
		#include <media/stagefright/RenderedFrameInfo.h>
		#include <utils/NativeHandle.h>

		#include "C2AidlNode.h"
		#include "C2OMXNode.h"
		#include "CCodecBufferChannel.h"
		#include "CCodecConfig.h"
		@@ -65,8 +73,14 @@ using namespace std::chrono_literals;
		using ::android::hardware::graphics::bufferqueue::V1_0::utils::H2BGraphicBufferProducer;
		using android::base::StringPrintf;
		using ::android::hardware::media::c2::V1_0::IInputSurface;
		using ::aidl::android::media::IAidlBufferSource;
		using ::aidl::android::media::IAidlNode;
		using ::android::media::AidlGraphicBufferSource;
		using ::android::media::WAidlGraphicBufferSource;
		using ::android::media::aidl_conversion::fromAidlStatus;

		typedef hardware::media::omx::V1_0::IGraphicBufferSource HGraphicBufferSource;
		typedef aidl::android::media::IAidlGraphicBufferSource AGraphicBufferSource;
		typedef CCodecConfig Config;

		namespace {
		@@ -190,11 +204,11 @@ private:
		std::shared_ptr<Codec2Client::InputSurfaceConnection> mConnection;
		};

		class GraphicBufferSourceWrapper : public InputSurfaceWrapper {
		class HGraphicBufferSourceWrapper : public InputSurfaceWrapper {
		public:
		typedef hardware::media::omx::V1_0::Status OmxStatus;

		GraphicBufferSourceWrapper(
		HGraphicBufferSourceWrapper(
		const sp<HGraphicBufferSource> &source,
		uint32_t width,
		uint32_t height,
		@@ -203,7 +217,7 @@ public:
		mDataSpace = HAL_DATASPACE_BT709;
		mConfig.mUsage = usage;
		}
		~GraphicBufferSourceWrapper() override = default;
		~HGraphicBufferSourceWrapper() override = default;

		status_t connect(const std::shared_ptr<Codec2Client::Component> &comp) override {
		mNode = new C2OMXNode(comp);
		@@ -445,6 +459,224 @@ private:
		Config mConfig;
		};

		class AGraphicBufferSourceWrapper : public InputSurfaceWrapper {
		public:
		AGraphicBufferSourceWrapper(
		const std::shared_ptr<AGraphicBufferSource> &source,
		uint32_t width,
		uint32_t height,
		uint64_t usage)
		: mSource(source), mWidth(width), mHeight(height) {
		mDataSpace = HAL_DATASPACE_BT709;
		mConfig.mUsage = usage;
		}
		~AGraphicBufferSourceWrapper() override = default;

		status_t connect(const std::shared_ptr<Codec2Client::Component> &comp) override {
		mNode = ::ndk::SharedRefBase::make<C2AidlNode>(comp);
		mNode->setFrameSize(mWidth, mHeight);
		// Usage is queried during configure(), so setting it beforehand.
		uint64_t usage = mConfig.mUsage;
		(void)mNode->setConsumerUsage((int64_t)usage);

		return fromAidlStatus(mSource->configure(
		mNode, static_cast<::aidl::android::hardware::graphics::common::Dataspace>(
		mDataSpace)));
		}

		void disconnect() override {
		if (mNode == nullptr) {
		return;
		}
		std::shared_ptr<IAidlBufferSource> source = mNode->getSource();
		if (source == nullptr) {
		ALOGD("GBSWrapper::disconnect: node is not configured with OMXBufferSource.");
		return;
		}
		(void)source->onStop();
		(void)source->onRelease();
		mNode.reset();
		}

		status_t start() override {
		std::shared_ptr<IAidlBufferSource> source = mNode->getSource();
		if (source == nullptr) {
		return NO_INIT;
		}

		size_t numSlots = 16;

		IAidlNode::InputBufferParams param;
		status_t err = fromAidlStatus(mNode->getInputBufferParams(&param));
		if (err == OK) {
		numSlots = param.bufferCountActual;
		}

		for (size_t i = 0; i < numSlots; ++i) {
		(void)source->onInputBufferAdded(i);
		}

		(void)source->onStart();
		return OK;
		}

		status_t signalEndOfInputStream() override {
		return fromAidlStatus(mSource->signalEndOfInputStream());
		}

		status_t configure(Config &config) {
		std::stringstream status;
		status_t err = OK;

		// handle each configuration granually, in case we need to handle part of the configuration
		// elsewhere

		// TRICKY: we do not unset frame delay repeating
		if (config.mMinFps > 0 && config.mMinFps != mConfig.mMinFps) {
		int64_t us = 1e6 / config.mMinFps + 0.5;
		status_t res = fromAidlStatus(mSource->setRepeatPreviousFrameDelayUs(us));
		status << " minFps=" << config.mMinFps << " => repeatDelayUs=" << us;
		if (res != OK) {
		status << " (=> " << asString(res) << ")";
		err = res;
		}
		mConfig.mMinFps = config.mMinFps;
		}

		// pts gap
		if (config.mMinAdjustedFps > 0 \|\| config.mFixedAdjustedFps > 0) {
		if (mNode != nullptr) {
		float gap = (config.mMinAdjustedFps > 0)
		? c2_min(INT32_MAX + 0., 1e6 / config.mMinAdjustedFps + 0.5)
		: c2_max(0. - INT32_MAX, -1e6 / config.mFixedAdjustedFps - 0.5);
		// float -> uint32_t is undefined if the value is negative.
		// First convert to int32_t to ensure the expected behavior.
		int32_t gapUs = int32_t(gap);
		(void)mNode->setAdjustTimestampGapUs(gapUs);
		}
		}

		// max fps
		// TRICKY: we do not unset max fps to 0 unless using fixed fps
		if ((config.mMaxFps > 0 \|\| (config.mFixedAdjustedFps > 0 && config.mMaxFps == -1))
		&& config.mMaxFps != mConfig.mMaxFps) {
		status_t res = fromAidlStatus(mSource->setMaxFps(config.mMaxFps));
		status << " maxFps=" << config.mMaxFps;
		if (res != OK) {
		status << " (=> " << asString(res) << ")";
		err = res;
		}
		mConfig.mMaxFps = config.mMaxFps;
		}

		if (config.mTimeOffsetUs != mConfig.mTimeOffsetUs) {
		status_t res = fromAidlStatus(mSource->setTimeOffsetUs(config.mTimeOffsetUs));
		status << " timeOffset " << config.mTimeOffsetUs << "us";
		if (res != OK) {
		status << " (=> " << asString(res) << ")";
		err = res;
		}
		mConfig.mTimeOffsetUs = config.mTimeOffsetUs;
		}

		if (config.mCaptureFps != mConfig.mCaptureFps \|\| config.mCodedFps != mConfig.mCodedFps) {
		status_t res =
		fromAidlStatus(mSource->setTimeLapseConfig(config.mCodedFps, config.mCaptureFps));
		status << " timeLapse " << config.mCaptureFps << "fps as " << config.mCodedFps << "fps";
		if (res != OK) {
		status << " (=> " << asString(res) << ")";
		err = res;
		}
		mConfig.mCaptureFps = config.mCaptureFps;
		mConfig.mCodedFps = config.mCodedFps;
		}

		if (config.mStartAtUs != mConfig.mStartAtUs
		\|\| (config.mStopped != mConfig.mStopped && !config.mStopped)) {
		status_t res = fromAidlStatus(mSource->setStartTimeUs(config.mStartAtUs));
		status << " start at " << config.mStartAtUs << "us";
		if (res != OK) {
		status << " (=> " << asString(res) << ")";
		err = res;
		}
		mConfig.mStartAtUs = config.mStartAtUs;
		mConfig.mStopped = config.mStopped;
		}

		// suspend-resume
		if (config.mSuspended != mConfig.mSuspended) {
		status_t res = fromAidlStatus(mSource->setSuspend(
		config.mSuspended, config.mSuspendAtUs));
		status << " " << (config.mSuspended ? "suspend" : "resume")
		<< " at " << config.mSuspendAtUs << "us";
		if (res != OK) {
		status << " (=> " << asString(res) << ")";
		err = res;
		}
		mConfig.mSuspended = config.mSuspended;
		mConfig.mSuspendAtUs = config.mSuspendAtUs;
		}

		if (config.mStopped != mConfig.mStopped && config.mStopped) {
		status_t res = fromAidlStatus(mSource->setStopTimeUs(config.mStopAtUs));
		status << " stop at " << config.mStopAtUs << "us";
		if (res != OK) {
		status << " (=> " << asString(res) << ")";
		err = res;
		} else {
		status << " delayUs";
		res = fromAidlStatus(mSource->getStopTimeOffsetUs(&config.mInputDelayUs));
		if (res != OK) {
		status << " (=> " << asString(res) << ")";
		} else {
		status << "=" << config.mInputDelayUs << "us";
		}
		mConfig.mInputDelayUs = config.mInputDelayUs;
		}
		mConfig.mStopAtUs = config.mStopAtUs;
		mConfig.mStopped = config.mStopped;
		}

		// color aspects (android._color-aspects)

		// consumer usage is queried earlier.

		// priority
		if (mConfig.mPriority != config.mPriority) {
		if (config.mPriority != INT_MAX) {
		mNode->setPriority(config.mPriority);
		}
		mConfig.mPriority = config.mPriority;
		}

		if (status.str().empty()) {
		ALOGD("ISConfig not changed");
		} else {
		ALOGD("ISConfig%s", status.str().c_str());
		}
		return err;
		}

		void onInputBufferDone(c2_cntr64_t index) override {
		mNode->onInputBufferDone(index);
		}

		android_dataspace getDataspace() override {
		return mNode->getDataspace();
		}

		uint32_t getPixelFormat() override {
		return mNode->getPixelFormat();
		}

		private:
		std::shared_ptr<AGraphicBufferSource> mSource;
		std::shared_ptr<C2AidlNode> mNode;
		uint32_t mWidth;
		uint32_t mHeight;
		Config mConfig;
		};

		class Codec2ClientInterfaceWrapper : public C2ComponentStore {
		std::shared_ptr<Codec2Client> mClient;

		@@ -1629,6 +1861,23 @@ void CCodec::createInputSurface() {
		}

		sp<PersistentSurface> persistentSurface = CreateCompatibleInputSurface();
		if (persistentSurface->isTargetAidl()) {
		::ndk::SpAIBinder aidlTarget = persistentSurface->getAidlTarget();
		std::shared_ptr<AGraphicBufferSource> gbs = AGraphicBufferSource::fromBinder(aidlTarget);
		if (gbs) {
		int32_t width = 0;
		(void)outputFormat->findInt32("width", &width);
		int32_t height = 0;
		(void)outputFormat->findInt32("height", &height);
		err = setupInputSurface(std::make_shared<AGraphicBufferSourceWrapper>(
		gbs, width, height, usage));
		bufferProducer = persistentSurface->getBufferProducer();
		} else {
		ALOGE("Corrupted input surface(aidl)");
		mCallback->onInputSurfaceCreationFailed(UNKNOWN_ERROR);
		return;
		}
		} else {
		sp<hidl::base::V1_0::IBase> hidlTarget = persistentSurface->getHidlTarget();
		sp<IInputSurface> hidlInputSurface = IInputSurface::castFrom(hidlTarget);
		sp<HGraphicBufferSource> gbs = HGraphicBufferSource::castFrom(hidlTarget);
		@@ -1644,7 +1893,7 @@ void CCodec::createInputSurface() {
		(void)outputFormat->findInt32("width", &width);
		int32_t height = 0;
		(void)outputFormat->findInt32("height", &height);
		err = setupInputSurface(std::make_shared<GraphicBufferSourceWrapper>(
		err = setupInputSurface(std::make_shared<HGraphicBufferSourceWrapper>(
		gbs, width, height, usage));
		bufferProducer = persistentSurface->getBufferProducer();
		} else {
		@@ -1652,6 +1901,7 @@ void CCodec::createInputSurface() {
		mCallback->onInputSurfaceCreationFailed(UNKNOWN_ERROR);
		return;
		}
		}

		if (err != OK) {
		ALOGE("Failed to set up input surface: %d", err);
		@@ -1745,6 +1995,28 @@ void CCodec::setInputSurface(const sp<PersistentSurface> &surface) {
		outputFormat = config->mOutputFormat;
		usage = config->mISConfig ? config->mISConfig->mUsage : 0;
		}
		if (surface->isTargetAidl()) {
		::ndk::SpAIBinder aidlTarget = surface->getAidlTarget();
		std::shared_ptr<AGraphicBufferSource> gbs = AGraphicBufferSource::fromBinder(aidlTarget);
		if (gbs) {
		int32_t width = 0;
		(void)outputFormat->findInt32("width", &width);
		int32_t height = 0;
		(void)outputFormat->findInt32("height", &height);

		status_t err = setupInputSurface(std::make_shared<AGraphicBufferSourceWrapper>(
		gbs, width, height, usage));
		if (err != OK) {
		ALOGE("Failed to set up input surface(aidl): %d", err);
		mCallback->onInputSurfaceDeclined(err);
		return;
		}
		} else {
		ALOGE("Failed to set input surface(aidl): Corrupted surface.");
		mCallback->onInputSurfaceDeclined(UNKNOWN_ERROR);
		return;
		}
		} else {
		sp<hidl::base::V1_0::IBase> hidlTarget = surface->getHidlTarget();
		sp<IInputSurface> inputSurface = IInputSurface::castFrom(hidlTarget);
		sp<HGraphicBufferSource> gbs = HGraphicBufferSource::castFrom(hidlTarget);
		@@ -1761,7 +2033,7 @@ void CCodec::setInputSurface(const sp<PersistentSurface> &surface) {
		(void)outputFormat->findInt32("width", &width);
		int32_t height = 0;
		(void)outputFormat->findInt32("height", &height);
		status_t err = setupInputSurface(std::make_shared<GraphicBufferSourceWrapper>(
		status_t err = setupInputSurface(std::make_shared<HGraphicBufferSourceWrapper>(
		gbs, width, height, usage));
		if (err != OK) {
		ALOGE("Failed to set up input surface: %d", err);
		@@ -1773,6 +2045,7 @@ void CCodec::setInputSurface(const sp<PersistentSurface> &surface) {
		mCallback->onInputSurfaceDeclined(UNKNOWN_ERROR);
		return;
		}
		}
		// Formats can change after setupInputSurface
		sp<AMessage> inputFormat;
		{
		@@ -2663,6 +2936,21 @@ PersistentSurface *CCodec::CreateInputSurface() {
		Codec2Client::CreateInputSurface();
		if (!inputSurface) {
		if (property_get_int32("debug.stagefright.c2inputsurface", 0) == -1) {
		if (Codec2Client::IsAidlSelected()) {
		sp<IGraphicBufferProducer> gbp;
		sp<AidlGraphicBufferSource> gbs = new AidlGraphicBufferSource();
		status_t err = gbs->initCheck();
		if (err != OK) {
		ALOGE("Failed to create persistent input surface: error %d", err);
		return nullptr;
		}
		ALOGD("aidl based PersistentSurface created");
		std::shared_ptr<WAidlGraphicBufferSource> wrapper =
		::ndk::SharedRefBase::make<WAidlGraphicBufferSource>(gbs);

		return new PersistentSurface(
		gbs->getIGraphicBufferProducer(), wrapper->asBinder());
		} else {
		sp<IGraphicBufferProducer> gbp;
		sp<OmxGraphicBufferSource> gbs = new OmxGraphicBufferSource();
		status_t err = gbs->initCheck();
		@@ -2670,8 +2958,10 @@ PersistentSurface *CCodec::CreateInputSurface() {
		ALOGE("Failed to create persistent input surface: error %d", err);
		return nullptr;
		}
		ALOGD("hidl based PersistentSurface created");
		return new PersistentSurface(
		gbs->getIGraphicBufferProducer(), new TWGraphicBufferSource(gbs));
		}
		} else {
		return nullptr;
		}