Snap for 8642511 from 866b66391ddb6d61f73b1b258868aa7407e5d466 to tm-release (73cf68cf) · Commits · e / os / android_frameworks_av

media/codec2/sfplugin/CCodecBuffers.cpp

+8 −3

Original line number	Original line	Diff line number	Diff line
	@@ -208,7 +208,7 @@ void OutputBuffers::setSkipCutBuffer(int32_t skip, int32_t cut) {

	bool OutputBuffers::convert(		bool OutputBuffers::convert(
	const std::shared_ptr<C2Buffer> &src, sp<Codec2Buffer> *dst) {		const std::shared_ptr<C2Buffer> &src, sp<Codec2Buffer> *dst) {
	if (!src \|\| src->data().type() != C2BufferData::LINEAR) {		if (src && src->data().type() != C2BufferData::LINEAR) {
	return false;		return false;
	}		}
	int32_t configEncoding = kAudioEncodingPcm16bit;		int32_t configEncoding = kAudioEncodingPcm16bit;
	@@ -237,7 +237,12 @@ bool OutputBuffers::convert(
	if (!mDataConverter) {		if (!mDataConverter) {
	return false;		return false;
	}		}
	sp<MediaCodecBuffer> srcBuffer = ConstLinearBlockBuffer::Allocate(mFormat, src);		sp<MediaCodecBuffer> srcBuffer;
			if (src) {
			srcBuffer = ConstLinearBlockBuffer::Allocate(mFormat, src);
			} else {
			srcBuffer = new MediaCodecBuffer(mFormat, new ABuffer(0));
			}
	if (!srcBuffer) {		if (!srcBuffer) {
	return false;		return false;
	}		}
	@@ -1259,8 +1264,8 @@ status_t FlexOutputBuffers::registerBuffer(
	if (newBuffer == nullptr) {		if (newBuffer == nullptr) {
	return NO_MEMORY;		return NO_MEMORY;
	}		}
	}
	newBuffer->setFormat(mFormat);		newBuffer->setFormat(mFormat);
			}
	*index = mImpl.assignSlot(newBuffer);		*index = mImpl.assignSlot(newBuffer);
	handleImageData(newBuffer);		handleImageData(newBuffer);
	*clientBuffer = newBuffer;		*clientBuffer = newBuffer;

media/codec2/sfplugin/CCodecConfig.cpp

+17 −1

Original line number	Original line	Diff line number	Diff line
	@@ -969,7 +969,23 @@ void CCodecConfig::initializeStandardParams() {
	.limitTo(D::ENCODER & D::VIDEO & D::READ));		.limitTo(D::ENCODER & D::VIDEO & D::READ));

	add(ConfigMapper(KEY_PICTURE_TYPE, C2_PARAMKEY_PICTURE_TYPE, "value")		add(ConfigMapper(KEY_PICTURE_TYPE, C2_PARAMKEY_PICTURE_TYPE, "value")
	.limitTo(D::ENCODER & D::VIDEO & D::READ));		.limitTo(D::ENCODER & D::VIDEO & D::READ)
			.withMappers([](C2Value v) -> C2Value {
			int32_t sdk;
			C2Config::picture_type_t c2;
			if (v.get(&sdk) && C2Mapper::map(sdk, &c2)) {
			return C2Value(c2);
			}
			return C2Value();
			}, [](C2Value v) -> C2Value {
			C2Config::picture_type_t c2;
			int32_t sdk = PICTURE_TYPE_UNKNOWN;
			using C2ValueType=typename _c2_reduce_enum_to_underlying_type<decltype(c2)>::type;
			if (v.get((C2ValueType*)&c2) && C2Mapper::map(c2, &sdk)) {
			return sdk;
			}
			return C2Value();
			}));

	/* still to do		/* still to do
	not yet used by MediaCodec, but defined as MediaFormat		not yet used by MediaCodec, but defined as MediaFormat

media/codec2/sfplugin/Codec2Buffer.cpp

+13 −8

Original line number	Original line	Diff line number	Diff line
	@@ -1178,9 +1178,6 @@ c2_status_t SetHdrMetadataToGralloc4Handle(
	}		}
	if (dynamicInfo && *dynamicInfo && dynamicInfo->flexCount() > 0) {		if (dynamicInfo && *dynamicInfo && dynamicInfo->flexCount() > 0) {
	ALOGV("Setting dynamic HDR info as gralloc4 metadata");		ALOGV("Setting dynamic HDR info as gralloc4 metadata");
	hidl_vec<uint8_t> vec;
	vec.resize(dynamicInfo->flexCount());
	memcpy(vec.data(), dynamicInfo->m.data, dynamicInfo->flexCount());
	std::optional<IMapper4::MetadataType> metadataType;		std::optional<IMapper4::MetadataType> metadataType;
	switch (dynamicInfo->m.type_) {		switch (dynamicInfo->m.type_) {
	case C2Config::HDR_DYNAMIC_METADATA_TYPE_SMPTE_2094_10:		case C2Config::HDR_DYNAMIC_METADATA_TYPE_SMPTE_2094_10:
	@@ -1190,13 +1187,21 @@ c2_status_t SetHdrMetadataToGralloc4Handle(
	metadataType = MetadataType_Smpte2094_40;		metadataType = MetadataType_Smpte2094_40;
	break;		break;
	}		}

	if (metadataType) {		if (metadataType) {
			std::vector<uint8_t> smpte2094_40;
			smpte2094_40.resize(dynamicInfo->flexCount());
			memcpy(smpte2094_40.data(), dynamicInfo->m.data, dynamicInfo->flexCount());

			hidl_vec<uint8_t> vec;
			if (gralloc4::encodeSmpte2094_40({ smpte2094_40 }, &vec) == OK) {
	Return<Error4> ret = mapper->set(buffer.get(), *metadataType, vec);		Return<Error4> ret = mapper->set(buffer.get(), *metadataType, vec);
	if (!ret.isOk()) {		if (!ret.isOk()) {
	err = C2_REFUSED;		err = C2_REFUSED;
	} else if (ret != Error4::NONE) {		} else if (ret != Error4::NONE) {
	err = C2_CORRUPTED;		err = C2_CORRUPTED;
	}		}
			}
	} else {		} else {
	err = C2_BAD_VALUE;		err = C2_BAD_VALUE;
	}		}

media/codec2/sfplugin/tests/CCodecBuffers_test.cpp

+53 −0

Original line number	Original line	Diff line number	Diff line
	@@ -861,4 +861,57 @@ INSTANTIATE_TEST_SUITE_P(
	+ std::to_string(std::get<3>(info.param));		+ std::to_string(std::get<3>(info.param));
	});		});

			TEST(LinearOutputBuffersTest, PcmConvertFormat) {
			// Prepare LinearOutputBuffers
			std::shared_ptr<LinearOutputBuffers> buffers =
			std::make_shared<LinearOutputBuffers>("test");
			sp<AMessage> format{new AMessage};
			format->setInt32(KEY_CHANNEL_COUNT, 1);
			format->setInt32(KEY_SAMPLE_RATE, 8000);
			format->setInt32(KEY_PCM_ENCODING, kAudioEncodingPcmFloat);
			format->setInt32("android._config-pcm-encoding", kAudioEncodingPcm16bit);
			format->setInt32("android._codec-pcm-encoding", kAudioEncodingPcmFloat);
			buffers->setFormat(format);

			// Prepare a linear C2Buffer
			std::shared_ptr<C2BlockPool> pool;
			ASSERT_EQ(OK, GetCodec2BlockPool(C2BlockPool::BASIC_LINEAR, nullptr, &pool));

			std::shared_ptr<C2LinearBlock> block;
			ASSERT_EQ(OK, pool->fetchLinearBlock(
			1024, C2MemoryUsage{C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE}, &block));
			std::shared_ptr<C2Buffer> c2Buffer =
			C2Buffer::CreateLinearBuffer(block->share(0, 1024, C2Fence()));

			// Test regular buffer convert
			size_t index;
			sp<MediaCodecBuffer> clientBuffer;
			ASSERT_EQ(OK, buffers->registerBuffer(c2Buffer, &index, &clientBuffer));
			int32_t pcmEncoding = 0;
			ASSERT_TRUE(clientBuffer->format()->findInt32(KEY_PCM_ENCODING, &pcmEncoding));
			EXPECT_EQ(kAudioEncodingPcm16bit, pcmEncoding);
			ASSERT_TRUE(buffers->releaseBuffer(clientBuffer, &c2Buffer));

			// Test null buffer convert
			ASSERT_EQ(OK, buffers->registerBuffer(nullptr, &index, &clientBuffer));
			ASSERT_TRUE(clientBuffer->format()->findInt32(KEY_PCM_ENCODING, &pcmEncoding));
			EXPECT_EQ(kAudioEncodingPcm16bit, pcmEncoding);
			ASSERT_TRUE(buffers->releaseBuffer(clientBuffer, &c2Buffer));

			// Do the same test in the array mode
			std::shared_ptr<OutputBuffersArray> array = buffers->toArrayMode(8);

			// Test regular buffer convert
			ASSERT_EQ(OK, buffers->registerBuffer(c2Buffer, &index, &clientBuffer));
			ASSERT_TRUE(clientBuffer->format()->findInt32(KEY_PCM_ENCODING, &pcmEncoding));
			EXPECT_EQ(kAudioEncodingPcm16bit, pcmEncoding);
			ASSERT_TRUE(buffers->releaseBuffer(clientBuffer, &c2Buffer));

			// Test null buffer convert
			ASSERT_EQ(OK, buffers->registerBuffer(nullptr, &index, &clientBuffer));
			ASSERT_TRUE(clientBuffer->format()->findInt32(KEY_PCM_ENCODING, &pcmEncoding));
			EXPECT_EQ(kAudioEncodingPcm16bit, pcmEncoding);
			ASSERT_TRUE(buffers->releaseBuffer(clientBuffer, &c2Buffer));
			}

	} // namespace android		} // namespace android

media/codec2/sfplugin/utils/Codec2Mapper.cpp

+17 −0

Original line number	Original line	Diff line number	Diff line
	@@ -460,6 +460,13 @@ ALookup<uint32_t, int32_t> sPixelFormats = {
	{ HAL_PIXEL_FORMAT_RGBA_FP16, COLOR_Format64bitABGRFloat },		{ HAL_PIXEL_FORMAT_RGBA_FP16, COLOR_Format64bitABGRFloat },
	};		};

			ALookup<C2Config::picture_type_t, int32_t> sPictureType = {
			{ C2Config::picture_type_t::SYNC_FRAME, PICTURE_TYPE_I },
			{ C2Config::picture_type_t::I_FRAME, PICTURE_TYPE_I },
			{ C2Config::picture_type_t::P_FRAME, PICTURE_TYPE_P },
			{ C2Config::picture_type_t::B_FRAME, PICTURE_TYPE_B },
			};

	/**		/**
	* A helper that passes through vendor extension profile and level values.		* A helper that passes through vendor extension profile and level values.
	*/		*/
	@@ -1075,3 +1082,13 @@ bool C2Mapper::mapPixelFormatCodecToFramework(
	}		}
	return true;		return true;
	}		}

			// static
			bool C2Mapper::map(C2Config::picture_type_t from, int32_t *to) {
			return sPictureType.map(from, to);
			}

			// static
			bool C2Mapper::map(int32_t from, C2Config::picture_type_t *to) {
			return sPictureType.map(from, to);
			}