Merge "Upstream changes from hardware/google/av" (59c920b7) · Commits · e / os / android_frameworks_av

media/codec2/components/base/SimpleC2Component.cpp

+7 −0

Original line number	Diff line number	Diff line
		@@ -489,6 +489,13 @@ bool SimpleC2Component::processQueue() {
		}

		ALOGV("start processing frame #%" PRIu64, work->input.ordinal.frameIndex.peeku());
		// If input buffer list is not empty, it means we have some input to process on.
		// However, input could be a null buffer. In such case, clear the buffer list
		// before making call to process().
		if (!work->input.buffers.empty() && !work->input.buffers[0]) {
		ALOGD("Encountered null input buffer. Clearing the input buffer");
		work->input.buffers.clear();
		}
		process(work, mOutputBlockPool);
		ALOGV("processed frame #%" PRIu64, work->input.ordinal.frameIndex.peeku());
		{

media/codec2/components/raw/C2SoftRawDec.cpp

+13 −0

Original line number	Diff line number	Diff line
		@@ -83,6 +83,18 @@ public:
		DefineParam(mInputMaxBufSize, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE)
		.withConstValue(new C2StreamMaxBufferSizeInfo::input(0u, 64 * 1024))
		.build());

		addParameter(
		DefineParam(mPcmEncodingInfo, C2_PARAMKEY_PCM_ENCODING)
		.withDefault(new C2StreamPcmEncodingInfo::output(0u, C2Config::PCM_16))
		.withFields({C2F(mPcmEncodingInfo, value).oneOf({
		C2Config::PCM_16,
		C2Config::PCM_8,
		C2Config::PCM_FLOAT})
		})
		.withSetter((Setter<decltype(*mPcmEncodingInfo)>::StrictValueWithNoDeps))
		.build());

		}

		private:
		@@ -94,6 +106,7 @@ private:
		std::shared_ptr<C2StreamChannelCountInfo::output> mChannelCount;
		std::shared_ptr<C2BitrateTuning::input> mBitrate;
		std::shared_ptr<C2StreamMaxBufferSizeInfo::input> mInputMaxBufSize;
		std::shared_ptr<C2StreamPcmEncodingInfo::output> mPcmEncodingInfo;
		};

		C2SoftRawDec::C2SoftRawDec(

media/codec2/components/vpx/C2SoftVpxDec.cpp

+58 −1

Original line number	Diff line number	Diff line
		@@ -97,6 +97,26 @@ public:
		.withSetter(ProfileLevelSetter, mSize)
		.build());

		mHdr10PlusInfoInput = C2StreamHdr10PlusInfo::input::AllocShared(0);
		addParameter(
		DefineParam(mHdr10PlusInfoInput, C2_PARAMKEY_INPUT_HDR10_PLUS_INFO)
		.withDefault(mHdr10PlusInfoInput)
		.withFields({
		C2F(mHdr10PlusInfoInput, m.value).any(),
		})
		.withSetter(Hdr10PlusInfoInputSetter)
		.build());

		mHdr10PlusInfoOutput = C2StreamHdr10PlusInfo::output::AllocShared(0);
		addParameter(
		DefineParam(mHdr10PlusInfoOutput, C2_PARAMKEY_OUTPUT_HDR10_PLUS_INFO)
		.withDefault(mHdr10PlusInfoOutput)
		.withFields({
		C2F(mHdr10PlusInfoOutput, m.value).any(),
		})
		.withSetter(Hdr10PlusInfoOutputSetter)
		.build());

		#if 0
		// sample BT.2020 static info
		mHdrStaticInfo = std::make_shared<C2StreamHdrStaticInfo::output>();
		@@ -217,6 +237,18 @@ public:
		return C2R::Ok();
		}

		static C2R Hdr10PlusInfoInputSetter(bool mayBlock, C2P<C2StreamHdr10PlusInfo::input> &me) {
		(void)mayBlock;
		(void)me; // TODO: validate
		return C2R::Ok();
		}

		static C2R Hdr10PlusInfoOutputSetter(bool mayBlock, C2P<C2StreamHdr10PlusInfo::output> &me) {
		(void)mayBlock;
		(void)me; // TODO: validate
		return C2R::Ok();
		}

		private:
		std::shared_ptr<C2StreamProfileLevelInfo::input> mProfileLevel;
		std::shared_ptr<C2StreamPictureSizeInfo::output> mSize;
		@@ -228,6 +260,8 @@ private:
		#if 0
		std::shared_ptr<C2StreamHdrStaticInfo::output> mHdrStaticInfo;
		#endif
		std::shared_ptr<C2StreamHdr10PlusInfo::input> mHdr10PlusInfoInput;
		std::shared_ptr<C2StreamHdr10PlusInfo::output> mHdr10PlusInfoOutput;
		#endif
		};

		@@ -370,7 +404,8 @@ void C2SoftVpxDec::finishWork(uint64_t index, const std::unique_ptr<C2Work> &wor
		const std::shared_ptr<C2GraphicBlock> &block) {
		std::shared_ptr<C2Buffer> buffer = createGraphicBuffer(block,
		C2Rect(mWidth, mHeight));
		auto fillWork = [buffer, index](const std::unique_ptr<C2Work> &work) {
		auto fillWork = [buffer, index, intf = this->mIntf](
		const std::unique_ptr<C2Work> &work) {
		uint32_t flags = 0;
		if ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) &&
		(c2_cntr64_t(index) == work->input.ordinal.frameIndex)) {
		@@ -382,6 +417,28 @@ void C2SoftVpxDec::finishWork(uint64_t index, const std::unique_ptr<C2Work> &wor
		work->worklets.front()->output.buffers.push_back(buffer);
		work->worklets.front()->output.ordinal = work->input.ordinal;
		work->workletsProcessed = 1u;

		for (const std::unique_ptr<C2Param> &param: work->input.configUpdate) {
		if (param) {
		C2StreamHdr10PlusInfo::input *hdr10PlusInfo =
		C2StreamHdr10PlusInfo::input::From(param.get());

		if (hdr10PlusInfo != nullptr) {
		std::vector<std::unique_ptr<C2SettingResult>> failures;
		std::unique_ptr<C2Param> outParam = C2Param::CopyAsStream(
		param.get(), true /output*/, param->stream());
		c2_status_t err = intf->config(
		{ outParam.get() }, C2_MAY_BLOCK, &failures);
		if (err == C2_OK) {
		work->worklets.front()->output.configUpdate.push_back(
		C2Param::Copy(*outParam.get()));
		} else {
		ALOGE("finishWork: Config update size failed");
		}
		break;
		}
		}
		}
		};
		if (work && c2_cntr64_t(index) == work->input.ordinal.frameIndex) {
		fillWork(work);

media/codec2/sfplugin/CCodec.cpp

+3 −11

Original line number	Diff line number	Diff line
		@@ -1348,9 +1348,7 @@ void CCodec::signalResume() {
		}

		void CCodec::signalSetParameters(const sp<AMessage> &params) {
		sp<AMessage> msg = new AMessage(kWhatSetParameters, this);
		msg->setMessage("params", params);
		msg->post();
		setParameters(params);
		}

		void CCodec::setParameters(const sp<AMessage> &params) {
		@@ -1515,13 +1513,6 @@ void CCodec::onMessageReceived(const sp<AMessage> &msg) {
		setInputSurface(surface);
		break;
		}
		case kWhatSetParameters: {
		setDeadline(now, 50ms, "setParameters");
		sp<AMessage> params;
		CHECK(msg->findMessage("params", &params));
		setParameters(params);
		break;
		}
		case kWhatWorkDone: {
		std::unique_ptr<C2Work> work;
		size_t numDiscardedInputBuffers;
		@@ -1594,6 +1585,7 @@ void CCodec::onMessageReceived(const sp<AMessage> &msg) {
		C2StreamColorAspectsInfo::output::PARAM_TYPE,
		C2StreamDataSpaceInfo::output::PARAM_TYPE,
		C2StreamHdrStaticInfo::output::PARAM_TYPE,
		C2StreamHdr10PlusInfo::output::PARAM_TYPE,
		C2StreamPixelAspectRatioInfo::output::PARAM_TYPE,
		C2StreamSurfaceScalingInfo::output::PARAM_TYPE
		};
		@@ -1677,7 +1669,7 @@ void CCodec::onWorkQueued(bool eos) {
		deadline->set(std::chrono::steady_clock::now() + 3s, "eos");
		}
		// TODO: query and use input/pipeline/output delay combined
		if (count >= 8) {
		if (count >= 4) {
		CCodecWatchdog::getInstance()->watch(this);
		Mutexed<NamedTimePoint>::Locked deadline(mQueueDeadline);
		deadline->set(std::chrono::steady_clock::now() + 3s, "queue");

media/codec2/sfplugin/CCodecBufferChannel.cpp

+63 −31

Original line number	Diff line number	Diff line
		@@ -787,8 +787,13 @@ public:
		std::unique_ptr<CCodecBufferChannel::InputBuffers> toArrayMode(
		size_t size) final {
		int32_t capacity = kLinearBufferSize;
		(void)mFormat->findInt32(C2_NAME_STREAM_MAX_BUFFER_SIZE_SETTING, &capacity);

		(void)mFormat->findInt32(KEY_MAX_INPUT_SIZE, &capacity);
		if ((size_t)capacity > kMaxLinearBufferSize) {
		ALOGD("client requested %d, capped to %zu", capacity, kMaxLinearBufferSize);
		capacity = kMaxLinearBufferSize;
		}
		// TODO: proper max input size
		// TODO: read usage from intf
		std::unique_ptr<InputBuffersArray> array(
		new InputBuffersArray(mComponentName.c_str(), "1D-Input[N]"));
		array->setPool(mPool);
		@@ -1807,17 +1812,29 @@ void CCodecBufferChannel::feedInputBufferIfAvailableInternal() {

		status_t CCodecBufferChannel::renderOutputBuffer(
		const sp<MediaCodecBuffer> &buffer, int64_t timestampNs) {
		ALOGV("[%s] renderOutputBuffer: %p", mName, buffer.get());
		std::shared_ptr<C2Buffer> c2Buffer;
		bool released = false;
		{
		Mutexed<std::unique_ptr<OutputBuffers>>::Locked buffers(mOutputBuffers);
		if (*buffers) {
		(*buffers)->releaseBuffer(buffer, &c2Buffer);
		released = (*buffers)->releaseBuffer(buffer, &c2Buffer);
		}
		}
		// NOTE: some apps try to releaseOutputBuffer() with timestamp and/or render
		// set to true.
		sendOutputBuffers();
		// input buffer feeding may have been gated by pending output buffers
		feedInputBufferIfAvailable();
		if (!c2Buffer) {
		if (released) {
		ALOGD("[%s] The app is calling releaseOutputBuffer() with "
		"timestamp or render=true with non-video buffers. Apps should "
		"call releaseOutputBuffer() with render=false for those.",
		mName);
		}
		return INVALID_OPERATION;
		}
		sendOutputBuffers();

		#if 0
		const std::vector<std::shared_ptr<const C2Info>> infoParams = c2Buffer->info();
		@@ -1871,6 +1888,11 @@ status_t CCodecBufferChannel::renderOutputBuffer(
		std::static_pointer_cast<const C2StreamHdrStaticInfo::output>(
		c2Buffer->getInfo(C2StreamHdrStaticInfo::output::PARAM_TYPE));

		// HDR10 plus info
		std::shared_ptr<const C2StreamHdr10PlusInfo::output> hdr10PlusInfo =
		std::static_pointer_cast<const C2StreamHdr10PlusInfo::output>(
		c2Buffer->getInfo(C2StreamHdr10PlusInfo::output::PARAM_TYPE));

		{
		Mutexed<OutputSurface>::Locked output(mOutputSurface);
		if (output->surface == nullptr) {
		@@ -1898,6 +1920,8 @@ status_t CCodecBufferChannel::renderOutputBuffer(
		videoScalingMode,
		transform,
		Fence::NO_FENCE, 0);
		if (hdrStaticInfo \|\| hdr10PlusInfo) {
		HdrMetadata hdr;
		if (hdrStaticInfo) {
		struct android_smpte2086_metadata smpte2086_meta = {
		.displayPrimaryRed = {
		@@ -1921,12 +1945,20 @@ status_t CCodecBufferChannel::renderOutputBuffer(
		.maxFrameAverageLightLevel = hdrStaticInfo->maxFall,
		};

		HdrMetadata hdr;
		hdr.validTypes = HdrMetadata::SMPTE2086 \| HdrMetadata::CTA861_3;
		hdr.smpte2086 = smpte2086_meta;
		hdr.cta8613 = cta861_meta;
		}
		if (hdr10PlusInfo) {
		hdr.validTypes \|= HdrMetadata::HDR10PLUS;
		hdr.hdr10plus.assign(
		hdr10PlusInfo->m.value,
		hdr10PlusInfo->m.value + hdr10PlusInfo->flexCount());
		}
		qbi.setHdrMetadata(hdr);
		}
		// we don't have dirty regions
		qbi.setSurfaceDamage(Region::INVALID_REGION);
		android::IGraphicBufferProducer::QueueBufferOutput qbo;
		status_t result = mComponent->queueToOutputSurface(block, qbi, &qbo);
		if (result != OK) {
		@@ -1961,8 +1993,8 @@ status_t CCodecBufferChannel::discardBuffer(const sp<MediaCodecBuffer> &buffer)
		}
		}
		if (released) {
		feedInputBufferIfAvailable();
		sendOutputBuffers();
		feedInputBufferIfAvailable();
		} else {
		ALOGD("[%s] MediaCodec discarded an unknown buffer", mName);
		}