Merge "Modify StateTransitions test" into oc-mr1-dev (51b64c30) · Commits · e / os / android_hardware_interfaces

media/omx/1.0/vts/functional/common/media_hidl_test_common.cpp

+65 −64

Original line number	Original line	Diff line number	Diff line
	@@ -187,82 +187,83 @@ Return<android::hardware::media::omx::V1_0::Status> setAudioPortFormat(
	}		}

	// allocate buffers needed on a component port		// allocate buffers needed on a component port
	void allocatePortBuffers(sp<IOmxNode> omxNode,		void allocateBuffer(sp<IOmxNode> omxNode, BufferInfo* buffer, OMX_U32 portIndex,
	android::Vector<BufferInfo>* buffArray,		OMX_U32 nBufferSize, PortMode portMode) {
	OMX_U32 portIndex, PortMode portMode) {
	android::hardware::media::omx::V1_0::Status status;		android::hardware::media::omx::V1_0::Status status;
	OMX_PARAM_PORTDEFINITIONTYPE portDef;

	buffArray->clear();

	status = getPortParam(omxNode, OMX_IndexParamPortDefinition, portIndex,
	&portDef);
	ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);

	if (portMode == PortMode::PRESET_SECURE_BUFFER) {		if (portMode == PortMode::PRESET_SECURE_BUFFER) {
	for (size_t i = 0; i < portDef.nBufferCountActual; i++) {		buffer->owner = client;
	BufferInfo buffer;		buffer->omxBuffer.type = CodecBuffer::Type::NATIVE_HANDLE;
	buffer.owner = client;
	buffer.omxBuffer.type = CodecBuffer::Type::NATIVE_HANDLE;
	omxNode->allocateSecureBuffer(		omxNode->allocateSecureBuffer(
	portIndex, portDef.nBufferSize,		portIndex, nBufferSize,
	[&status, &buffer](		[&status, &buffer](
	android::hardware::media::omx::V1_0::Status _s, uint32_t id,		android::hardware::media::omx::V1_0::Status _s, uint32_t id,
	::android::hardware::hidl_handle const& nativeHandle) {		::android::hardware::hidl_handle const& nativeHandle) {
	status = _s;		status = _s;
	buffer.id = id;		buffer->id = id;
	buffer.omxBuffer.nativeHandle = nativeHandle;		buffer->omxBuffer.nativeHandle = nativeHandle;
	});		});
	buffArray->push(buffer);		ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
	ASSERT_EQ(status,
	::android::hardware::media::omx::V1_0::Status::OK);
	}
	} else if (portMode == PortMode::PRESET_BYTE_BUFFER \|\|		} else if (portMode == PortMode::PRESET_BYTE_BUFFER \|\|
	portMode == PortMode::DYNAMIC_ANW_BUFFER) {		portMode == PortMode::DYNAMIC_ANW_BUFFER) {
	sp<IAllocator> allocator = IAllocator::getService("ashmem");		sp<IAllocator> allocator = IAllocator::getService("ashmem");
	EXPECT_NE(allocator.get(), nullptr);		EXPECT_NE(allocator.get(), nullptr);

	for (size_t i = 0; i < portDef.nBufferCountActual; i++) {		buffer->owner = client;
	BufferInfo buffer;		buffer->omxBuffer.type = CodecBuffer::Type::SHARED_MEM;
	buffer.owner = client;		buffer->omxBuffer.attr.preset.rangeOffset = 0;
	buffer.omxBuffer.type = CodecBuffer::Type::SHARED_MEM;		buffer->omxBuffer.attr.preset.rangeLength = 0;
	buffer.omxBuffer.attr.preset.rangeOffset = 0;
	buffer.omxBuffer.attr.preset.rangeLength = 0;
	bool success = false;		bool success = false;
	if (portMode != PortMode::PRESET_BYTE_BUFFER) {		if (portMode != PortMode::PRESET_BYTE_BUFFER) {
	portDef.nBufferSize = sizeof(android::VideoNativeMetadata);		nBufferSize = sizeof(android::VideoNativeMetadata);
	}		}
	allocator->allocate(		allocator->allocate(
	portDef.nBufferSize,		nBufferSize,
	[&success, &buffer](		[&success, &buffer](bool _s,
	bool _s, ::android::hardware::hidl_memory const& mem) {		::android::hardware::hidl_memory const& mem) {
	success = _s;		success = _s;
	buffer.omxBuffer.sharedMemory = mem;		buffer->omxBuffer.sharedMemory = mem;
	});		});
	ASSERT_EQ(success, true);		ASSERT_EQ(success, true);
	ASSERT_EQ(buffer.omxBuffer.sharedMemory.size(),		ASSERT_EQ(buffer->omxBuffer.sharedMemory.size(), nBufferSize);
	portDef.nBufferSize);		buffer->mMemory = mapMemory(buffer->omxBuffer.sharedMemory);
	buffer.mMemory = mapMemory(buffer.omxBuffer.sharedMemory);		ASSERT_NE(buffer->mMemory, nullptr);
	ASSERT_NE(buffer.mMemory, nullptr);
	if (portMode == PortMode::DYNAMIC_ANW_BUFFER) {		if (portMode == PortMode::DYNAMIC_ANW_BUFFER) {
	android::VideoNativeMetadata* metaData =		android::VideoNativeMetadata* metaData =
	static_cast<android::VideoNativeMetadata*>(		static_cast<android::VideoNativeMetadata*>(
	static_cast<void*>(buffer.mMemory->getPointer()));		static_cast<void*>(buffer->mMemory->getPointer()));
	metaData->nFenceFd = -1;		metaData->nFenceFd = -1;
	buffer.slot = -1;		buffer->slot = -1;
	}		}
	omxNode->useBuffer(		omxNode->useBuffer(
	portIndex, buffer.omxBuffer,		portIndex, buffer->omxBuffer,
	[&status, &buffer](		[&status, &buffer](android::hardware::media::omx::V1_0::Status _s,
	android::hardware::media::omx::V1_0::Status _s,
	uint32_t id) {		uint32_t id) {
	status = _s;		status = _s;
	buffer.id = id;		buffer->id = id;
	});		});
	buffArray->push(buffer);		ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
	ASSERT_EQ(status,		}
	::android::hardware::media::omx::V1_0::Status::OK);
	}		}

			// allocate buffers needed on a component port
			void allocatePortBuffers(sp<IOmxNode> omxNode,
			android::Vector<BufferInfo>* buffArray,
			OMX_U32 portIndex, PortMode portMode) {
			android::hardware::media::omx::V1_0::Status status;
			OMX_PARAM_PORTDEFINITIONTYPE portDef;

			buffArray->clear();

			status = getPortParam(omxNode, OMX_IndexParamPortDefinition, portIndex,
			&portDef);
			ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);

			for (size_t i = 0; i < portDef.nBufferCountActual; i++) {
			BufferInfo buffer;
			allocateBuffer(omxNode, &buffer, portIndex, portDef.nBufferSize,
			portMode);
			buffArray->push(buffer);
	}		}
	}		}

media/omx/1.0/vts/functional/common/media_hidl_test_common.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -296,6 +296,9 @@ Return<android::hardware::media::omx::V1_0::Status> setVideoPortFormat(
	Return<android::hardware::media::omx::V1_0::Status> setAudioPortFormat(		Return<android::hardware::media::omx::V1_0::Status> setAudioPortFormat(
	sp<IOmxNode> omxNode, OMX_U32 portIndex, OMX_AUDIO_CODINGTYPE eEncoding);		sp<IOmxNode> omxNode, OMX_U32 portIndex, OMX_AUDIO_CODINGTYPE eEncoding);

			void allocateBuffer(sp<IOmxNode> omxNode, BufferInfo* buffer, OMX_U32 portIndex,
			OMX_U32 nBufferSize, PortMode portMode);

	void allocatePortBuffers(sp<IOmxNode> omxNode,		void allocatePortBuffers(sp<IOmxNode> omxNode,
	android::Vector<BufferInfo>* buffArray,		android::Vector<BufferInfo>* buffArray,
	OMX_U32 portIndex,		OMX_U32 portIndex,

media/omx/1.0/vts/functional/component/VtsHalMediaOmxV1_0TargetComponentTest.cpp

+73 −40

Original line number	Original line	Diff line number	Diff line
	@@ -467,9 +467,6 @@ TEST_F(ComponentHidlTest, DISABLED_PopulatePort) {
	portBase = params.nStartPortNumber;		portBase = params.nStartPortNumber;
	}		}

	sp<IAllocator> allocator = IAllocator::getService("ashmem");
	EXPECT_NE(allocator.get(), nullptr);

	OMX_PARAM_PORTDEFINITIONTYPE portDef;		OMX_PARAM_PORTDEFINITIONTYPE portDef;
	status =		status =
	getPortParam(omxNode, OMX_IndexParamPortDefinition, portBase, &portDef);		getPortParam(omxNode, OMX_IndexParamPortDefinition, portBase, &portDef);
	@@ -482,30 +479,9 @@ TEST_F(ComponentHidlTest, DISABLED_PopulatePort) {

	for (size_t i = 0; i < portDef.nBufferCountActual; i++) {		for (size_t i = 0; i < portDef.nBufferCountActual; i++) {
	BufferInfo buffer;		BufferInfo buffer;
	buffer.owner = client;		allocateBuffer(omxNode, &buffer, portBase, nBufferSize,
	buffer.omxBuffer.type = CodecBuffer::Type::SHARED_MEM;		PortMode::PRESET_BYTE_BUFFER);
	buffer.omxBuffer.attr.preset.rangeOffset = 0;
	buffer.omxBuffer.attr.preset.rangeLength = 0;
	bool success = false;
	allocator->allocate(
	nBufferSize,
	[&success, &buffer](bool _s,
	::android::hardware::hidl_memory const& mem) {
	success = _s;
	buffer.omxBuffer.sharedMemory = mem;
	});
	ASSERT_EQ(success, true);
	ASSERT_EQ(buffer.omxBuffer.sharedMemory.size(), nBufferSize);

	omxNode->useBuffer(
	portBase, buffer.omxBuffer,
	[&status, &buffer](android::hardware::media::omx::V1_0::Status _s,
	uint32_t id) {
	status = _s;
	buffer.id = id;
	});
	pBuffer.push(buffer);		pBuffer.push(buffer);
	ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
	}		}

	status =		status =
	@@ -586,8 +562,8 @@ TEST_F(ComponentHidlTest, StateTransitions) {
	if (disableTest) return;		if (disableTest) return;
	android::hardware::media::omx::V1_0::Status status;		android::hardware::media::omx::V1_0::Status status;
	uint32_t kPortIndexInput = 0, kPortIndexOutput = 1;		uint32_t kPortIndexInput = 0, kPortIndexOutput = 1;
			OMX_U32 portBase = 0;
	Message msg;		Message msg;

	status = setRole(omxNode, gEnv->getRole().c_str());		status = setRole(omxNode, gEnv->getRole().c_str());
	ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);		ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
	OMX_PORT_PARAM_TYPE params;		OMX_PORT_PARAM_TYPE params;
	@@ -598,11 +574,12 @@ TEST_F(ComponentHidlTest, StateTransitions) {
	}		}
	if (status == ::android::hardware::media::omx::V1_0::Status::OK) {		if (status == ::android::hardware::media::omx::V1_0::Status::OK) {
	ASSERT_EQ(params.nPorts, 2U);		ASSERT_EQ(params.nPorts, 2U);
	kPortIndexInput = params.nStartPortNumber;		portBase = params.nStartPortNumber;
	kPortIndexOutput = kPortIndexInput + 1;
	}		}
			kPortIndexInput = portBase;
			kPortIndexOutput = portBase + 1;

	android::Vector<BufferInfo> iBuffer, oBuffer;		android::Vector<BufferInfo> pBuffer[2];

	// set port mode		// set port mode
	PortMode portMode[2];		PortMode portMode[2];
	@@ -613,28 +590,84 @@ TEST_F(ComponentHidlTest, StateTransitions) {
	EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);		EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);

	// set state to idle		// set state to idle
	changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,		status = omxNode->sendCommand(toRawCommandType(OMX_CommandStateSet),
	kPortIndexInput, kPortIndexOutput, portMode);		OMX_StateIdle);
			ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);

			for (size_t j = portBase; j < portBase + 2; j++) {
			pBuffer[j - portBase].clear();

			OMX_PARAM_PORTDEFINITIONTYPE def;
			status = getPortParam(omxNode, OMX_IndexParamPortDefinition, j, &def);
			ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);

			for (size_t i = 0; i < def.nBufferCountActual; i++) {
			// Dont switch states until the ports are populated
			status = observer->dequeueMessage(&msg, DEFAULT_TIMEOUT,
			&pBuffer[0], &pBuffer[1]);
			ASSERT_EQ(status,
			android::hardware::media::omx::V1_0::Status::TIMED_OUT);

			BufferInfo buffer;
			allocateBuffer(omxNode, &buffer, j, def.nBufferSize,
			portMode[j - portBase]);
			pBuffer[j - portBase].push(buffer);
			}
			}

			// As the ports are populated, check if the state transition is complete
			status = observer->dequeueMessage(&msg, DEFAULT_TIMEOUT, &pBuffer[0],
			&pBuffer[1]);
			ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
			ASSERT_EQ(msg.type, Message::Type::EVENT);
			ASSERT_EQ(msg.data.eventData.event, OMX_EventCmdComplete);
			ASSERT_EQ(msg.data.eventData.data1, OMX_CommandStateSet);
			ASSERT_EQ(msg.data.eventData.data2, OMX_StateIdle);

	// set state to executing		// set state to executing
	changeStateIdletoExecute(omxNode, observer);		changeStateIdletoExecute(omxNode, observer);
	// dispatch buffers		// dispatch buffers
	for (size_t i = 0; i < oBuffer.size(); i++) {		for (size_t i = 0; i < pBuffer[1].size(); i++) {
	dispatchOutputBuffer(omxNode, &oBuffer, i, portMode[1]);		dispatchOutputBuffer(omxNode, &pBuffer[1], i, portMode[1]);
	}		}
	// set state to idle		// set state to idle
	changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);		changeStateExecutetoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1]);
	// // set state to executing		// // set state to executing
	// changeStateIdletoExecute(omxNode, observer);		// changeStateIdletoExecute(omxNode, observer);
	// // TODO: Sending empty input buffers is slightly tricky.		// // TODO: Sending empty input buffers is slightly tricky.
	// // dispatch buffers		// // dispatch buffers
	// for (size_t i = 0; i < iBuffer.size(); i++) {		// for (size_t i = 0; i < pBuffer[0].size(); i++) {
	// dispatchInputBuffer(omxNode, &iBuffer, i, 0, 0, 0, portMode[0]);		// dispatchInputBuffer(omxNode, &pBuffer[0], i, 0, 0, 0,
			// portMode[0]);
	// }		// }
	// // set state to idle		// // set state to idle
	// changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);		// changeStateExecutetoIdle(omxNode, observer, &pBuffer[0], &pBuffer[1]);

	// set state to loaded		// set state to loaded
	changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,		status = omxNode->sendCommand(toRawCommandType(OMX_CommandStateSet),
	kPortIndexInput, kPortIndexOutput);		OMX_StateLoaded);
			ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);

			for (size_t j = portBase; j < portBase + 2; j++) {
			for (size_t i = 0; i < pBuffer[j].size(); ++i) {
			// Dont switch states until the ports are populated
			status = observer->dequeueMessage(&msg, DEFAULT_TIMEOUT,
			&pBuffer[0], &pBuffer[1]);
			ASSERT_EQ(status,
			android::hardware::media::omx::V1_0::Status::TIMED_OUT);

			status = omxNode->freeBuffer(j, pBuffer[j][i].id);
			ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
			}
			}

			status = observer->dequeueMessage(&msg, DEFAULT_TIMEOUT, &pBuffer[0],
			&pBuffer[1]);
			ASSERT_EQ(status, android::hardware::media::omx::V1_0::Status::OK);
			ASSERT_EQ(msg.type, Message::Type::EVENT);
			ASSERT_EQ(msg.data.eventData.event, OMX_EventCmdComplete);
			ASSERT_EQ(msg.data.eventData.data1, OMX_CommandStateSet);
			ASSERT_EQ(msg.data.eventData.data2, OMX_StateLoaded);
	}		}

	// state transitions test - monkeying		// state transitions test - monkeying