C2 VTS: Cleanup code around query() calls am: f1c7514ab7 am: ca0d4c8f87 (ccb0da14) · Commits · e / devices / smdk4412 / android_frameworks_av

media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioDecTest.cpp

+18 −20

Original line number	Original line	Diff line number	Diff line
	@@ -100,8 +100,10 @@ class Codec2AudioDecHidlTestBase : public ::testing::Test {
	ASSERT_NE(mLinearPool, nullptr);		ASSERT_NE(mLinearPool, nullptr);

	std::vector<std::unique_ptr<C2Param>> queried;		std::vector<std::unique_ptr<C2Param>> queried;
	mComponent->query({}, {C2PortMediaTypeSetting::input::PARAM_TYPE}, C2_DONT_BLOCK, &queried);		c2_status_t c2err = mComponent->query({}, {C2PortMediaTypeSetting::input::PARAM_TYPE},
	ASSERT_GT(queried.size(), 0);		C2_DONT_BLOCK, &queried);
			ASSERT_EQ(c2err, C2_OK) << "Query media type failed";
			ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";

	mMime = ((C2PortMediaTypeSetting::input*)queried[0].get())->m.value;		mMime = ((C2PortMediaTypeSetting::input*)queried[0].get())->m.value;

	@@ -277,15 +279,11 @@ void getInputChannelInfo(const std::shared_ptr<android::Codec2Client::Component>
	};		};
	std::vector<std::unique_ptr<C2Param>> inParams;		std::vector<std::unique_ptr<C2Param>> inParams;
	c2_status_t status = component->query({}, indices, C2_DONT_BLOCK, &inParams);		c2_status_t status = component->query({}, indices, C2_DONT_BLOCK, &inParams);
	if (status != C2_OK && inParams.size() == 0) {		ASSERT_EQ(status, C2_OK) << "Query sample rate and channel count info failed";
	ALOGE("Query media type failed => %d", status);		ASSERT_EQ(inParams.size(), indices.size()) << "Size of the vector returned is invalid";
	ASSERT_TRUE(false);
	} else {		bitStreamInfo[0] = C2StreamSampleRateInfo::output::From(inParams[0].get())->value;
	size_t offset = sizeof(C2Param);		bitStreamInfo[1] = C2StreamChannelCountInfo::output::From(inParams[1].get())->value;
	for (size_t i = 0; i < inParams.size(); ++i) {
	C2Param* param = inParams[i].get();
	bitStreamInfo[i] = (int32_t)((uint8_t*)param + offset);
	}
	if (mime.find("3gpp") != std::string::npos) {		if (mime.find("3gpp") != std::string::npos) {
	ASSERT_EQ(bitStreamInfo[0], 8000);		ASSERT_EQ(bitStreamInfo[0], 8000);
	ASSERT_EQ(bitStreamInfo[1], 1);		ASSERT_EQ(bitStreamInfo[1], 1);
	@@ -294,7 +292,7 @@ void getInputChannelInfo(const std::shared_ptr<android::Codec2Client::Component>
	ASSERT_EQ(bitStreamInfo[1], 1);		ASSERT_EQ(bitStreamInfo[1], 1);
	} else if (mime.find("gsm") != std::string::npos) {		} else if (mime.find("gsm") != std::string::npos) {
	ASSERT_EQ(bitStreamInfo[0], 8000);		ASSERT_EQ(bitStreamInfo[0], 8000);
	}		ASSERT_EQ(bitStreamInfo[1], 1);
	}		}
	}		}

media/codec2/hidl/1.0/vts/functional/audio/VtsHalMediaC2V1_0TargetAudioEncTest.cpp

+42 −63

Original line number	Original line	Diff line number	Diff line
	@@ -73,9 +73,10 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test {
	ASSERT_NE(mLinearPool, nullptr);		ASSERT_NE(mLinearPool, nullptr);

	std::vector<std::unique_ptr<C2Param>> queried;		std::vector<std::unique_ptr<C2Param>> queried;
	mComponent->query({}, {C2PortMediaTypeSetting::output::PARAM_TYPE}, C2_DONT_BLOCK,		c2_status_t c2err = mComponent->query({}, {C2PortMediaTypeSetting::output::PARAM_TYPE},
	&queried);		C2_DONT_BLOCK, &queried);
	ASSERT_GT(queried.size(), 0);		ASSERT_EQ(c2err, C2_OK) << "Query media type failed";
			ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";

	mMime = ((C2PortMediaTypeSetting::output*)queried[0].get())->m.value;		mMime = ((C2PortMediaTypeSetting::output*)queried[0].get())->m.value;
	mEos = false;		mEos = false;
	@@ -84,16 +85,10 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test {
	mEncoderFrameSize = 0;		mEncoderFrameSize = 0;
	mWorkResult = C2_OK;		mWorkResult = C2_OK;
	mOutputSize = 0u;		mOutputSize = 0u;
	getInputMaxBufSize();		ASSERT_NO_FATAL_FAILURE(getInputMaxBufSize());
			ASSERT_NO_FATAL_FAILURE(getChannelCount(&mNumChannels));
	c2_status_t status = getChannelCount(&mNumChannels);		ASSERT_NO_FATAL_FAILURE(getSampleRate(&mSampleRate));
	ASSERT_EQ(status, C2_OK) << "Unable to get supported channel count";		ASSERT_NO_FATAL_FAILURE(getSamplesPerFrame(mNumChannels, &mSamplesPerFrame));

	status = getSampleRate(&mSampleRate);
	ASSERT_EQ(status, C2_OK) << "Unable to get supported sample rate";

	status = getSamplesPerFrame(mNumChannels, &mSamplesPerFrame);
	ASSERT_EQ(status, C2_OK) << "Unable to get supported number of samples per frame";

	getFile(mNumChannels, mSampleRate);		getFile(mNumChannels, mSampleRate);
	}		}
	@@ -109,9 +104,9 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test {
	// Get the test parameters from GetParam call.		// Get the test parameters from GetParam call.
	virtual void getParams() {}		virtual void getParams() {}

	c2_status_t getChannelCount(int32_t* nChannels);		void getChannelCount(int32_t* nChannels);
	c2_status_t getSampleRate(int32_t* nSampleRate);		void getSampleRate(int32_t* nSampleRate);
	c2_status_t getSamplesPerFrame(int32_t nChannels, int32_t* samplesPerFrame);		void getSamplesPerFrame(int32_t nChannels, int32_t* samplesPerFrame);

	void getFile(int32_t channelCount, int32_t sampleRate);		void getFile(int32_t channelCount, int32_t sampleRate);

	@@ -175,21 +170,13 @@ class Codec2AudioEncHidlTestBase : public ::testing::Test {

	// In encoder components, fetch the size of input buffer allocated		// In encoder components, fetch the size of input buffer allocated
	void getInputMaxBufSize() {		void getInputMaxBufSize() {
	int32_t bitStreamInfo[1] = {0};
	std::vector<std::unique_ptr<C2Param>> inParams;		std::vector<std::unique_ptr<C2Param>> inParams;
	c2_status_t status = mComponent->query({}, {C2StreamMaxBufferSizeInfo::input::PARAM_TYPE},		c2_status_t status = mComponent->query({}, {C2StreamMaxBufferSizeInfo::input::PARAM_TYPE},
	C2_DONT_BLOCK, &inParams);		C2_DONT_BLOCK, &inParams);
	if (status != C2_OK && inParams.size() == 0) {		ASSERT_EQ(status, C2_OK) << "Query max buffer size info failed";
	ALOGE("Query MaxBufferSizeInfo failed => %d", status);		ASSERT_EQ(inParams.size(), 1) << "Size of the vector returned is invalid";
	ASSERT_TRUE(false);
	} else {		mInputMaxBufSize = C2StreamMaxBufferSizeInfo::input::From(inParams[0].get())->value;
	size_t offset = sizeof(C2Param);
	for (size_t i = 0; i < inParams.size(); ++i) {
	C2Param* param = inParams[i].get();
	bitStreamInfo[i] = (int32_t)((uint8_t*)param + offset);
	}
	}
	mInputMaxBufSize = bitStreamInfo[0];
	}		}
	};		};

	@@ -245,17 +232,15 @@ bool setupConfigParam(const std::shared_ptr<android::Codec2Client::Component>& c
	return false;		return false;
	}		}

	c2_status_t Codec2AudioEncHidlTestBase::getChannelCount(int32_t* nChannels) {		void Codec2AudioEncHidlTestBase::getChannelCount(int32_t* nChannels) {
	std::unique_ptr<C2StreamChannelCountInfo::input> channelCount =		std::unique_ptr<C2StreamChannelCountInfo::input> channelCount =
	std::make_unique<C2StreamChannelCountInfo::input>();		std::make_unique<C2StreamChannelCountInfo::input>();
	std::vector<C2FieldSupportedValuesQuery> validValueInfos = {		std::vector<C2FieldSupportedValuesQuery> validValueInfos = {
	C2FieldSupportedValuesQuery::Current(		C2FieldSupportedValuesQuery::Current(
	C2ParamField(channelCount.get(), &C2StreamChannelCountInfo::value))};		C2ParamField(channelCount.get(), &C2StreamChannelCountInfo::value))};
	c2_status_t c2err = mComponent->querySupportedValues(validValueInfos, C2_DONT_BLOCK);		c2_status_t c2err = mComponent->querySupportedValues(validValueInfos, C2_DONT_BLOCK);
	if (c2err != C2_OK \|\| validValueInfos.size() != 1u) {		ASSERT_EQ(c2err, C2_OK) << "Query channel count info failed";
	ALOGE("querySupportedValues_vb failed for channelCount");		ASSERT_EQ(validValueInfos.size(), 1) << "Size of the vector returned is invalid";
	return c2err;
	}

	// setting default value of channelCount		// setting default value of channelCount
	*nChannels = 1;		*nChannels = 1;
	@@ -282,48 +267,45 @@ c2_status_t Codec2AudioEncHidlTestBase::getChannelCount(int32_t* nChannels) {
	break;		break;
	}		}
	default:		default:
			ASSERT_TRUE(false) << "Unsupported type: " << c2FSV.type;
	break;		break;
	}		}
	return C2_OK;		return;
	}		}
	c2_status_t Codec2AudioEncHidlTestBase::getSampleRate(int32_t* nSampleRate) {		void Codec2AudioEncHidlTestBase::getSampleRate(int32_t* nSampleRate) {
	// Use the default sample rate for mComponents		// Use the default sample rate for mComponents
	std::vector<std::unique_ptr<C2Param>> queried;		std::vector<std::unique_ptr<C2Param>> queried;
	c2_status_t c2err = mComponent->query({}, {C2StreamSampleRateInfo::input::PARAM_TYPE},		c2_status_t c2err = mComponent->query({}, {C2StreamSampleRateInfo::input::PARAM_TYPE},
	C2_DONT_BLOCK, &queried);		C2_DONT_BLOCK, &queried);
	if (c2err != C2_OK \|\| queried.size() == 0) return c2err;		ASSERT_EQ(c2err, C2_OK) << "Query sample rate info failed";
			ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";
	size_t offset = sizeof(C2Param);
	C2Param* param = queried[0].get();
	nSampleRate = (int32_t)((uint8_t)param + offset);

	return C2_OK;		*nSampleRate = C2StreamSampleRateInfo::input::From(queried[0].get())->value;
			return;
	}		}

	c2_status_t Codec2AudioEncHidlTestBase::getSamplesPerFrame(int32_t nChannels,		void Codec2AudioEncHidlTestBase::getSamplesPerFrame(int32_t nChannels, int32_t* samplesPerFrame) {
	int32_t* samplesPerFrame) {
	std::vector<std::unique_ptr<C2Param>> queried;		std::vector<std::unique_ptr<C2Param>> queried;
	c2_status_t c2err = mComponent->query({}, {C2StreamAudioFrameSizeInfo::input::PARAM_TYPE},		c2_status_t c2err = mComponent->query({}, {C2StreamAudioFrameSizeInfo::input::PARAM_TYPE},
	C2_DONT_BLOCK, &queried);		C2_DONT_BLOCK, &queried);
	size_t offset = sizeof(C2Param);
	if (c2err == C2_OK && queried.size()) {		if (c2err == C2_OK && queried.size() == 1) {
	C2Param* param = queried[0].get();		mEncoderFrameSize = C2StreamAudioFrameSizeInfo::input::From(queried[0].get())->value;
	mEncoderFrameSize = (uint32_t)((uint8_t*)param + offset);
	if (mEncoderFrameSize) {		if (mEncoderFrameSize) {
	*samplesPerFrame = mEncoderFrameSize;		*samplesPerFrame = mEncoderFrameSize;
	return C2_OK;		return;
	}		}
	}		}

	c2err = mComponent->query({}, {C2StreamMaxBufferSizeInfo::input::PARAM_TYPE}, C2_DONT_BLOCK,		c2err = mComponent->query({}, {C2StreamMaxBufferSizeInfo::input::PARAM_TYPE}, C2_DONT_BLOCK,
	&queried);		&queried);
	if (c2err != C2_OK \|\| queried.size() == 0) return c2err;		ASSERT_EQ(c2err, C2_OK) << "Query max buffer size info failed";
			ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";

	C2Param* param = queried[0].get();		uint32_t maxInputSize = C2StreamMaxBufferSizeInfo::input::From(queried[0].get())->value;
	uint32_t maxInputSize = (uint32_t)((uint8_t*)param + offset);
	samplesPerFrame = std::min((maxInputSize / (nChannels 2)), kMaxSamplesPerFrame);		samplesPerFrame = std::min((maxInputSize / (nChannels 2)), kMaxSamplesPerFrame);

	return C2_OK;		return;
	}		}

	// LookUpTable of clips and metadata for component testing		// LookUpTable of clips and metadata for component testing
	@@ -619,12 +601,11 @@ TEST_P(Codec2AudioEncHidlTest, MultiChannelCountTest) {
	std::vector<std::unique_ptr<C2Param>> inParams;		std::vector<std::unique_ptr<C2Param>> inParams;
	c2_status_t c2_status = mComponent->query({}, {C2StreamChannelCountInfo::input::PARAM_TYPE},		c2_status_t c2_status = mComponent->query({}, {C2StreamChannelCountInfo::input::PARAM_TYPE},
	C2_DONT_BLOCK, &inParams);		C2_DONT_BLOCK, &inParams);
	ASSERT_TRUE(!c2_status && inParams.size())		ASSERT_EQ(c2_status, C2_OK) << "Query channel count info failed";
	<< "Query configured channelCount failed => %d" << c2_status;		ASSERT_EQ(inParams.size(), 1) << "Size of the vector returned is invalid";

			int32_t channelCount = C2StreamChannelCountInfo::input::From(inParams[0].get())->value;

	size_t offset = sizeof(C2Param);
	C2Param* param = inParams[0].get();
	int32_t channelCount = (int32_t)((uint8_t*)param + offset);
	if (channelCount != nChannels) {		if (channelCount != nChannels) {
	std::cout << "[ WARN ] Test Skipped for ChannelCount " << nChannels << "\n";		std::cout << "[ WARN ] Test Skipped for ChannelCount " << nChannels << "\n";
	continue;		continue;
	@@ -708,13 +689,11 @@ TEST_P(Codec2AudioEncHidlTest, MultiSampleRateTest) {
	std::vector<std::unique_ptr<C2Param>> inParams;		std::vector<std::unique_ptr<C2Param>> inParams;
	c2_status_t c2_status = mComponent->query({}, {C2StreamSampleRateInfo::input::PARAM_TYPE},		c2_status_t c2_status = mComponent->query({}, {C2StreamSampleRateInfo::input::PARAM_TYPE},
	C2_DONT_BLOCK, &inParams);		C2_DONT_BLOCK, &inParams);
			ASSERT_EQ(c2_status, C2_OK) << "Query sample rate info failed";
			ASSERT_EQ(inParams.size(), 1) << "Size of the vector returned is invalid";

	ASSERT_TRUE(!c2_status && inParams.size())		int32_t configuredSampleRate =
	<< "Query configured SampleRate failed => %d" << c2_status;		C2StreamSampleRateInfo::input::From(inParams[0].get())->value;
	size_t offset = sizeof(C2Param);
	C2Param* param = inParams[0].get();
	int32_t configuredSampleRate = (int32_t)((uint8_t*)param + offset);

	if (configuredSampleRate != nSampleRate) {		if (configuredSampleRate != nSampleRate) {
	std::cout << "[ WARN ] Test Skipped for SampleRate " << nSampleRate << "\n";		std::cout << "[ WARN ] Test Skipped for SampleRate " << nSampleRate << "\n";
	continue;		continue;

media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoDecTest.cpp

+4 −2

Original line number	Original line	Diff line number	Diff line
	@@ -123,8 +123,10 @@ class Codec2VideoDecHidlTestBase : public ::testing::Test {
	ASSERT_NE(mLinearPool, nullptr);		ASSERT_NE(mLinearPool, nullptr);

	std::vector<std::unique_ptr<C2Param>> queried;		std::vector<std::unique_ptr<C2Param>> queried;
	mComponent->query({}, {C2PortMediaTypeSetting::input::PARAM_TYPE}, C2_DONT_BLOCK, &queried);		c2_status_t c2err = mComponent->query({}, {C2PortMediaTypeSetting::input::PARAM_TYPE},
	ASSERT_GT(queried.size(), 0);		C2_DONT_BLOCK, &queried);
			ASSERT_EQ(c2err, C2_OK) << "Query media type failed";
			ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";

	mMime = ((C2PortMediaTypeSetting::input*)queried[0].get())->m.value;		mMime = ((C2PortMediaTypeSetting::input*)queried[0].get())->m.value;
	mEos = false;		mEos = false;

media/codec2/hidl/1.0/vts/functional/video/VtsHalMediaC2V1_0TargetVideoEncTest.cpp

+15 −6

Original line number	Original line	Diff line number	Diff line
	@@ -74,9 +74,10 @@ class Codec2VideoEncHidlTestBase : public ::testing::Test {
	ASSERT_NE(mGraphicPool, nullptr);		ASSERT_NE(mGraphicPool, nullptr);

	std::vector<std::unique_ptr<C2Param>> queried;		std::vector<std::unique_ptr<C2Param>> queried;
	mComponent->query({}, {C2PortMediaTypeSetting::output::PARAM_TYPE}, C2_DONT_BLOCK,		c2_status_t c2err = mComponent->query({}, {C2PortMediaTypeSetting::output::PARAM_TYPE},
	&queried);		C2_DONT_BLOCK, &queried);
	ASSERT_GT(queried.size(), 0);		ASSERT_EQ(c2err, C2_OK) << "Query media type failed";
			ASSERT_EQ(queried.size(), 1) << "Size of the vector returned is invalid";

	mMime = ((C2PortMediaTypeSetting::output*)queried[0].get())->m.value;		mMime = ((C2PortMediaTypeSetting::output*)queried[0].get())->m.value;
	std::cout << "mime : " << mMime << "\n";		std::cout << "mime : " << mMime << "\n";
	@@ -531,9 +532,17 @@ TEST_P(Codec2VideoEncEncodeTest, EncodeTest) {
	<< " resetting num BFrames to 0\n";		<< " resetting num BFrames to 0\n";
	mConfigBPictures = false;		mConfigBPictures = false;
	} else {		} else {
	size_t offset = sizeof(C2Param);		int32_t numBFrames = 0;
	C2Param* param = inParams[0].get();		C2StreamGopTuning::output* gop = C2StreamGopTuning::output::From(inParams[0].get());
	int32_t numBFrames = (int32_t)((uint8_t*)param + offset);		if (gop && gop->flexCount() >= 1) {
			for (size_t i = 0; i < gop->flexCount(); ++i) {
			const C2GopLayerStruct& layer = gop->m.values[i];
			if (layer.type_ == C2Config::picture_type_t(P_FRAME \| B_FRAME)) {
			numBFrames = layer.count;
			break;
			}
			}
			}

	if (!numBFrames) {		if (!numBFrames) {
	std::cout << "[ WARN ] Bframe not supported for " << mComponentName		std::cout << "[ WARN ] Bframe not supported for " << mComponentName