Snap for 7579269 from 1e703acbf4cf7a1f8f98ed9b38e28cb49d43b4f5 to sc-v2-release (0a38ded9) · Commits · e / os / android_frameworks_av

media/codec2/hidl/1.0/vts/functional/video/Android.bp

+2 −0

Original line number	Diff line number	Diff line
		@@ -36,6 +36,8 @@ cc_test {
		"libgui",
		"libutils",
		"libcrypto",
		"libdatasource",
		"libui",
		],
		data: [":media_c2_v1_video_decode_res"],
		test_config: "VtsHalMediaC2V1_0TargetVideoDecTest.xml",

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

+56 −9

Original line number	Diff line number	Diff line
		@@ -33,11 +33,18 @@
		#include <gui/IConsumerListener.h>
		#include <gui/IProducerListener.h>
		#include <system/window.h>
		#include <gui/GLConsumer.h>
		#include <gui/Surface.h>
		#include <gui/SurfaceComposerClient.h>

		#include "media_c2_hidl_test_common.h"
		#include "media_c2_video_hidl_test_common.h"

		using DecodeTestParameters = std::tuple<std::string, std::string, uint32_t, bool>;
		constexpr size_t kSmoothnessFactor = 4;
		constexpr size_t kRenderingDepth = 3;
		enum surfaceMode_t { NO_SURFACE, NULL_SURFACE, SURFACE };

		using DecodeTestParameters = std::tuple<std::string, std::string, uint32_t, bool, surfaceMode_t>;
		static std::vector<DecodeTestParameters> gDecodeTestParameters;

		using CsdFlushTestParameters = std::tuple<std::string, std::string, bool>;
		@@ -392,6 +399,36 @@ bool Codec2VideoDecHidlTestBase::getFileNames(size_t streamIndex) {
		return false;
		}

		void setOutputSurface(const std::shared_ptr<android::Codec2Client::Component>& component,
		surfaceMode_t surfMode) {
		using namespace android;
		sp<IGraphicBufferProducer> producer = nullptr;
		static std::atomic_uint32_t surfaceGeneration{0};
		uint32_t generation =
		(getpid() << 10) \|
		((surfaceGeneration.fetch_add(1, std::memory_order_relaxed) + 1) & ((1 << 10) - 1));
		int32_t maxDequeueBuffers = kSmoothnessFactor + kRenderingDepth;
		if (surfMode == SURFACE) {
		sp<IGraphicBufferConsumer> consumer = nullptr;
		BufferQueue::createBufferQueue(&producer, &consumer);
		ASSERT_NE(producer, nullptr) << "createBufferQueue returned invalid producer";
		ASSERT_NE(consumer, nullptr) << "createBufferQueue returned invalid consumer";

		sp<GLConsumer> texture =
		new GLConsumer(consumer, 0 /* tex */, GLConsumer::TEXTURE_EXTERNAL,
		true /* useFenceSync /, false / isControlledByApp */);

		sp<ANativeWindow> gSurface = new Surface(producer);
		ASSERT_NE(gSurface, nullptr) << "getSurface failed";

		producer->setGenerationNumber(generation);
		}

		c2_status_t err = component->setOutputSurface(C2BlockPool::BASIC_GRAPHIC, producer, generation,
		maxDequeueBuffers);
		ASSERT_EQ(err, C2_OK) << "setOutputSurface failed";
		}

		void decodeNFrames(const std::shared_ptr<android::Codec2Client::Component>& component,
		std::mutex& queueLock, std::condition_variable& queueCondition,
		std::list<std::unique_ptr<C2Work>>& workQueue,
		@@ -550,6 +587,7 @@ TEST_P(Codec2VideoDecDecodeTest, DecodeTest) {
		if (mDisableTest) GTEST_SKIP() << "Test is disabled";

		bool signalEOS = std::get<3>(GetParam());
		surfaceMode_t surfMode = std::get<4>(GetParam());
		mTimestampDevTest = true;

		android::Vector<FrameInfo> Info;
		@@ -594,6 +632,10 @@ TEST_P(Codec2VideoDecDecodeTest, DecodeTest) {
		refChksum.close();
		}

		if (surfMode != NO_SURFACE) {
		ASSERT_NO_FATAL_FAILURE(setOutputSurface(mComponent, surfMode));
		}

		ASSERT_NO_FATAL_FAILURE(decodeNFrames(mComponent, mQueueLock, mQueueCondition, mWorkQueue,
		mFlushedIndices, mLinearPool, eleStream, &Info, 0,
		(int)Info.size(), signalEOS));
		@@ -1061,18 +1103,23 @@ int main(int argc, char** argv) {
		parseArgs(argc, argv);
		gTestParameters = getTestParameters(C2Component::DOMAIN_VIDEO, C2Component::KIND_DECODER);
		for (auto params : gTestParameters) {
		// mOutputBufferQueue->configure() crashes when surface is NULL
		std::initializer_list<surfaceMode_t> surfaceMode = {
		surfaceMode_t::NO_SURFACE, surfaceMode_t::NULL_SURFACE, surfaceMode_t::SURFACE};
		for (surfaceMode_t mode : surfaceMode) {
		gDecodeTestParameters.push_back(
		std::make_tuple(std::get<0>(params), std::get<1>(params), 0, false));
		std::make_tuple(std::get<0>(params), std::get<1>(params), 0, false, mode));
		gDecodeTestParameters.push_back(
		std::make_tuple(std::get<0>(params), std::get<1>(params), 0, true));
		std::make_tuple(std::get<0>(params), std::get<1>(params), 0, true, mode));
		}
		gDecodeTestParameters.push_back(
		std::make_tuple(std::get<0>(params), std::get<1>(params), 1, false));
		std::make_tuple(std::get<0>(params), std::get<1>(params), 1, false, NO_SURFACE));
		gDecodeTestParameters.push_back(
		std::make_tuple(std::get<0>(params), std::get<1>(params), 1, true));
		std::make_tuple(std::get<0>(params), std::get<1>(params), 1, true, NO_SURFACE));
		gDecodeTestParameters.push_back(
		std::make_tuple(std::get<0>(params), std::get<1>(params), 2, false));
		std::make_tuple(std::get<0>(params), std::get<1>(params), 2, false, NO_SURFACE));
		gDecodeTestParameters.push_back(
		std::make_tuple(std::get<0>(params), std::get<1>(params), 2, true));
		std::make_tuple(std::get<0>(params), std::get<1>(params), 2, true, NO_SURFACE));

		gCsdFlushTestParameters.push_back(
		std::make_tuple(std::get<0>(params), std::get<1>(params), true));

media/codec2/hidl/client/output.cpp

+4 −1

Original line number	Diff line number	Diff line
		@@ -181,7 +181,7 @@ bool OutputBufferQueue::configure(const sp<IGraphicBufferProducer>& igbp,
		int maxDequeueBufferCount,
		std::shared_ptr<V1_2::SurfaceSyncObj> *syncObj) {
		uint64_t consumerUsage = 0;
		if (igbp->getConsumerUsage(&consumerUsage) != OK) {
		if (igbp && igbp->getConsumerUsage(&consumerUsage) != OK) {
		ALOGW("failed to get consumer usage");
		}

		@@ -254,6 +254,9 @@ bool OutputBufferQueue::configure(const sp<IGraphicBufferProducer>& igbp,
		mBqId = bqId;
		mOwner = std::make_shared<int>(0);
		mMaxDequeueBufferCount = maxDequeueBufferCount;
		if (igbp == nullptr) {
		return false;
		}
		for (int i = 0; i < BufferQueueDefs::NUM_BUFFER_SLOTS; ++i) {
		if (mBqId == 0 \|\| !mBuffers[i]) {
		continue;

media/libaudiohal/impl/ConversionHelperHidl.cpp

+9 −0

Original line number	Diff line number	Diff line
		@@ -104,6 +104,15 @@ ConversionHelperHidl::ConversionHelperHidl(const char* className)
		: mClassName(className) {
		}

		// static
		void ConversionHelperHidl::argsFromHal(
		const Vector<String16>& args, hidl_vec<hidl_string> *hidlArgs) {
		hidlArgs->resize(args.size());
		for (size_t i = 0; i < args.size(); ++i) {
		(*hidlArgs)[i] = String8(args[i]).c_str();
		}
		}

		// static
		status_t ConversionHelperHidl::analyzeResult(const Result& result) {
		switch (result) {

media/libaudiohal/impl/ConversionHelperHidl.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,8 @@
		#include <hidl/HidlSupport.h>
		#include <system/audio.h>
		#include <utils/String8.h>
		#include <utils/String16.h>
		#include <utils/Vector.h>

		using ::android::hardware::audio::CPP_VERSION::ParameterValue;
		using CoreResult = ::android::hardware::audio::CPP_VERSION::Result;
		@@ -37,6 +39,7 @@ class ConversionHelperHidl {
		static status_t keysFromHal(const String8& keys, hidl_vec<hidl_string> *hidlKeys);
		static status_t parametersFromHal(const String8& kvPairs, hidl_vec<ParameterValue> *hidlParams);
		static void parametersToHal(const hidl_vec<ParameterValue>& parameters, String8 *values);
		static void argsFromHal(const Vector<String16>& args, hidl_vec<hidl_string> *hidlArgs);

		ConversionHelperHidl(const char* className);