// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @internalComponent

*/

#include <e32base.h>

#include <e32cmn.h>

#include <mmf/server/mmfbuffer.h>

#include <mmf/server/mmfdatabuffer.h>

#include <openmax/il/khronos/v1_x/OMX_Component.h>

#include <openmax/il/khronos/v1_x/OMX_Types.h>

#include <openmax/il/loader/omxilcomponentif.h>

#include <openmax/il/extensions/omxilsymbianaudiopcmextensions.h>

#include "log.h"

#include "omxilpcmrenderer.hrh"

#include <openmax/il/common/omxilspecversion.h>

#include "tsu_omxil_pcmrenderer_step.h"

_LIT8(KSymbianOmxILPcmRendererRole, "audio_renderer.pcm");

_LIT8(KTestOmxILWrongRendererRole, "audio_renderer.wrong");

_LIT(KPcmRendererTestFile, "c:\\omxil\\testfiles\\pcm16stereo8khz.raw");

_LIT(KPcmRendererTestFile2, "c:\\omxil\\testfiles\\pcm16stereo44khz.raw");

OMX_ERRORTYPE ComponentInit(OMX_HANDLETYPE /*aComponent*/)

	{

	return OMX_ErrorNone;

	}

//

// RAsyncTestStepOmxILPcmRenderer0020

//

RAsyncTestStepOmxILPcmRenderer0020::RAsyncTestStepOmxILPcmRenderer0020(const TDesC& aTestName, TInt aComponentUid)

	:

	RAsyncTestStepOmxILComponentBase(aTestName, aComponentUid),

	ipKickoff01(NULL),

	ipKickoff02(NULL),

	ipKickoff03(NULL),

	ipKickoff04(NULL),

	ipKickoff05(NULL),

	ipKickoff06(NULL)

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0020::RAsyncTestStepOmxILPcmRenderer0020"));

	}

void

RAsyncTestStepOmxILPcmRenderer0020::KickoffTestL()

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0020::KickoffTestL"));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : Test20  "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 1.- Init Component "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 2.- Obtain the component's state (GetState) "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 3.- Obtain the component's version (GetComponentVersion) "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 4.- Provide callbacks to component (SetCallbacks) "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 5.- Obtain the port def params for Port #0 (GetParameter) "));

	// This will install one callback

	RAsyncTestStepOmxILComponentBase::KickoffTestL();

	// This is the only step in this test...

	TCallBack callback01 (RAsyncTestStepOmxILPcmRenderer0020Step01, this);

	delete ipKickoff01;

	ipKickoff01 = NULL;

	ipKickoff01 =

		new (ELeave) CAsyncCallBack (callback01, CActive::EPriorityLow);

	ipKickoff01->Call();

	// The successful termination...

	TCallBack callbackStop (RAsyncTestStepOmxILComponentBase::StopTestCallBack, this);

	delete ipKickoffStop;

	ipKickoffStop = NULL;

	ipKickoffStop =

		new (ELeave) CAsyncCallBack (callbackStop, CActive::EPriorityLow);

	ipKickoffStop->Call();

	}

void

RAsyncTestStepOmxILPcmRenderer0020::CloseTest()

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0020::CloseTest"));

	delete ipKickoff01; // no need to Cancel

	ipKickoff01 = NULL;

	delete ipKickoff02; // no need to Cancel

	ipKickoff02 = NULL;

	delete ipKickoff03; // no need to Cancel

	ipKickoff03 = NULL;

	delete ipKickoff04; // no need to Cancel

	ipKickoff04 = NULL;

	delete ipKickoff05; // no need to Cancel

	ipKickoff05 = NULL;

	delete ipKickoff06; // no need to Cancel

	ipKickoff06 = NULL;

	delete ipKickoffStop; // no need to Cancel

	ipKickoffStop = 0;

	RAsyncTestStepOmxILComponentBase::CloseTest();

	}

void

RAsyncTestStepOmxILPcmRenderer0020::DoEventHandlerL(OMX_HANDLETYPE /*aComponent*/,

											  OMX_EVENTTYPE /*aEvent*/,

											  TUint /*aData1*/,

											  TUint /*aData2*/,

											  TAny* /*aExtra*/)

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0020::DoEventHandlerL"));

	// We don't expect here any callback

	return StopTest(KErrGeneral, EFail);

	}

TInt

RAsyncTestStepOmxILPcmRenderer0020::RAsyncTestStepOmxILPcmRenderer0020Step01(TAny* aPtr)

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0020::RAsyncTestStepOmxILPcmRenderer0020Step01"));

    RAsyncTestStepOmxILPcmRenderer0020* self =

		static_cast<RAsyncTestStepOmxILPcmRenderer0020*> (aPtr);

	self->DoRAsyncTestStepOmxILPcmRenderer0020Step01();

	return KErrNone;

	}

void

RAsyncTestStepOmxILPcmRenderer0020::DoRAsyncTestStepOmxILPcmRenderer0020Step01()

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0020::DoRAsyncTestStepOmxILPcmRenderer0020Step01"));

	//

	// Obtain the component's state

	//

	OMX_STATETYPE compState;

	if (OMX_ErrorNone != ipCompHandle->GetState(ipCompHandle,

												&compState))

		{

		return StopTest(KErrGeneral, EFail);

		}

	PrintOmxState(compState);

	if (OMX_StateLoaded != compState)

		{

		return StopTest(KErrGeneral, EFail);

		}

	char componentNameArray[OMX_MAX_STRINGNAME_SIZE];

	OMX_VERSIONTYPE componentVersion;

	OMX_VERSIONTYPE specVersion;

	OMX_UUIDTYPE componentUUID;

	//

	// Obtain the component's version

	//

	if (OMX_ErrorNone != ipCompHandle->GetComponentVersion(

			ipCompHandle,

			componentNameArray,

			&componentVersion,

			&specVersion,

			&componentUUID))

		{

		return StopTest(KErrGeneral, EFail);

		}

	TBuf8<128> componentNameBuf8;

	componentNameBuf8 = const_cast<const TUint8*>(reinterpret_cast<TUint8*>(componentNameArray));

	TBuf<128> componentNameBuf16;

	INFO_PRINTF2(_L("Component Name length: %d"), componentNameBuf8.Length());

	componentNameBuf16.Copy(componentNameBuf8);

	componentNameBuf16.PtrZ();

	// INFO_PRINTF2(_L("Component Name: %s"), dst.Ptr());

	INFO_PRINTF2(_L("Component Name: %S"), &componentNameBuf16);

	INFO_PRINTF2(_L("Component Version Major: %d"), componentVersion.s.nVersionMajor);

	INFO_PRINTF2(_L("Component Version Minor: %d"), componentVersion.s.nVersionMinor);

	INFO_PRINTF2(_L("Component Version Revision: %d"), componentVersion.s.nRevision);

	INFO_PRINTF2(_L("Component Version Step: %d"), componentVersion.s.nStep);

	INFO_PRINTF2(_L("OMX Version Major: %d"), specVersion.s.nVersionMajor);

	INFO_PRINTF2(_L("OMX Version Minor: %d"), specVersion.s.nVersionMinor);

	INFO_PRINTF2(_L("OMX Version Revision: %d"), specVersion.s.nRevision);

	INFO_PRINTF2(_L("OMX Version Step: %d"), specVersion.s.nStep);

	INFO_PRINTF2(_L("Component UUID: %X"), componentUUID);

	//

	// Provide callbacks to component

	//

	OMX_CALLBACKTYPE* omxCallbacks = *ipCallbackHandler;

	if (OMX_ErrorNone != ipCompHandle->SetCallbacks(

			ipCompHandle,

			omxCallbacks,

			ipCallbackHandler))

		{

		return StopTest(KErrGeneral, EFail);

		}

	INFO_PRINTF2(_L("Component Callbacks set successfully: %X"), ipCallbackHandler);

	//

	// Obtain the port def params for Port #0

	//

	OMX_PARAM_PORTDEFINITIONTYPE portParamsInputPort;

	portParamsInputPort.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);

	portParamsInputPort.nVersion = TOmxILSpecVersion();

	portParamsInputPort.nPortIndex = 0;

	if (OMX_ErrorNone != ipCompHandle->GetParameter(

			ipCompHandle,

			OMX_IndexParamPortDefinition,

			&portParamsInputPort))

		{

		return StopTest(KErrGeneral, EFail);

		}

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE nPortIndex: %d"), portParamsInputPort.nPortIndex);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE eDir: %d"), portParamsInputPort.eDir);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE nBufferCountActual: %d"), portParamsInputPort.nBufferCountActual);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE nBufferCountMin: %d"), portParamsInputPort.nBufferCountMin);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE nBufferSize: %d"), portParamsInputPort.nBufferSize);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE bEnabled: %d"), portParamsInputPort.bEnabled == OMX_FALSE ? 0 : 1);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE bPopulated: %d"), portParamsInputPort.bPopulated == OMX_FALSE ? 0 : 1);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE eDomain: %d"), portParamsInputPort.eDomain);

	TBuf8<128> cMIMEType8Input;

	cMIMEType8Input = const_cast<const TUint8*>(reinterpret_cast<TUint8*>(portParamsInputPort.format.audio.cMIMEType));

	TBuf<128> cMIMEType16Input;

	cMIMEType16Input.Copy(cMIMEType8Input);

	cMIMEType16Input.PtrZ();

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE format.cMIMEType: %S"), &cMIMEType16Input);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE format.pNativeRender: %X"), portParamsInputPort.format.audio.pNativeRender);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE format.bFlagErrorConcealment: %d"),

				 portParamsInputPort.format.audio.bFlagErrorConcealment == OMX_FALSE ? 0 : 1);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE format.eEncoding: %d"), portParamsInputPort.format.audio.eEncoding);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE bBuffersContiguous: %d"),

				 portParamsInputPort.bBuffersContiguous == OMX_FALSE ? 0 : 1);

	INFO_PRINTF2(_L("PORTDEFINITIONTYPE nBufferAlignment: %d"), portParamsInputPort.nBufferAlignment);

	}

//

// RAsyncTestStepOmxILPcmRenderer0021

//

RAsyncTestStepOmxILPcmRenderer0021::RAsyncTestStepOmxILPcmRenderer0021(const TDesC& aTestName, TInt aComponentUid)

	:

	RAsyncTestStepOmxILComponentBase(aTestName, aComponentUid),

	ipKickoff01(NULL),

	ipKickoff02(NULL),

	ipKickoff03(NULL),

	ipKickoff04(NULL),

	ipKickoff05(NULL),

	ipKickoff06(NULL)

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0021::RAsyncTestStepOmxILPcmRenderer0021"));

	}

void

RAsyncTestStepOmxILPcmRenderer0021::KickoffTestL()

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0021::KickoffTestL"));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : Test21  "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 1.- Init Component "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 2.- Provide callbacks to component (SetCallbacks) "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 3.- Obtain the component's state (GetState) "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 4.- Obtain component's role #1 with null string (ComponentRoleEnum fails with OMX_ErrorBadParameter) "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 5.- Obtain component's role #1 (ComponentRoleEnum returns audio_renderer.pcm) "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 6.- Obtain component's role #2 (ComponentRoleEnum fails with OMX_ErrorNoMore) "));

	// This will install one callback

	RAsyncTestStepOmxILComponentBase::KickoffTestL();

	// This is the only step in this test...

	TCallBack callback01 (RAsyncTestStepOmxILPcmRenderer0021Step01, this);

	delete ipKickoff01;

	ipKickoff01 = NULL;

	ipKickoff01 =

		new (ELeave) CAsyncCallBack (callback01, CActive::EPriorityLow);

	ipKickoff01->Call();

	// The successful termination...

	TCallBack callbackStop (RAsyncTestStepOmxILComponentBase::StopTestCallBack, this);

	delete ipKickoffStop;

	ipKickoffStop = NULL;

	ipKickoffStop =

		new (ELeave) CAsyncCallBack (callbackStop, CActive::EPriorityLow);

	ipKickoffStop->Call();

	}

void

RAsyncTestStepOmxILPcmRenderer0021::CloseTest()

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0021::CloseTest"));

	delete ipKickoff01; // no need to Cancel

	ipKickoff01 = NULL;

	delete ipKickoff02; // no need to Cancel

	ipKickoff02 = NULL;

	delete ipKickoff03; // no need to Cancel

	ipKickoff03 = NULL;

	delete ipKickoff04; // no need to Cancel

	ipKickoff04 = NULL;

	delete ipKickoff05; // no need to Cancel

	ipKickoff05 = NULL;

	delete ipKickoff06; // no need to Cancel

	ipKickoff06 = NULL;

	delete ipKickoffStop; // no need to Cancel

	ipKickoffStop = 0;

	RAsyncTestStepOmxILComponentBase::CloseTest();

	}

void

RAsyncTestStepOmxILPcmRenderer0021::DoEventHandlerL(OMX_HANDLETYPE /*aComponent*/,

											  OMX_EVENTTYPE /*aEvent*/,

											  TUint /*aData1*/,

											  TUint /*aData2*/,

											  TAny* /*aExtra*/)

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0021::DoEventHandlerL"));

	// We don't expect here any callback

	return StopTest(KErrGeneral, EFail);

	}

TInt

RAsyncTestStepOmxILPcmRenderer0021::RAsyncTestStepOmxILPcmRenderer0021Step01(TAny* aPtr)

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0021::RAsyncTestStepOmxILPcmRenderer0021Step01"));

    RAsyncTestStepOmxILPcmRenderer0021* self =

		static_cast<RAsyncTestStepOmxILPcmRenderer0021*> (aPtr);

	self->DoRAsyncTestStepOmxILPcmRenderer0021Step01();

	return KErrNone;

	}

void

RAsyncTestStepOmxILPcmRenderer0021::DoRAsyncTestStepOmxILPcmRenderer0021Step01()

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0021::DoRAsyncTestStepOmxILPcmRenderer0021Step01"));

	//

	// Provide callbacks to component

	//

	OMX_CALLBACKTYPE* omxCallbacks = *ipCallbackHandler;

	if (OMX_ErrorNone != ipCompHandle->SetCallbacks(

			ipCompHandle,

			omxCallbacks,

			ipCallbackHandler))

		{

		return StopTest(KErrGeneral, EFail);

		}

	//

	// Obtain the component's state

	//

	OMX_STATETYPE compState;

	if (OMX_ErrorNone != ipCompHandle->GetState(ipCompHandle,

												&compState))

		{

		return StopTest(KErrGeneral, EFail);

		}

	PrintOmxState(compState);

	if (OMX_StateLoaded != compState)

		{

		return StopTest(KErrGeneral, EFail);

		}

	INFO_PRINTF2(_L("Component Callbacks set successfully: %X"), ipCallbackHandler);

	//

	// Try to obtain the component's first role with null string  (must fail with error OMX_ErrorBadParameter)

	//

	OMX_U8* pNullUint = 0;

	if (OMX_ErrorBadParameter != ipCompHandle->ComponentRoleEnum(

			ipCompHandle,

			pNullUint,

			0 // This is index # 0, the first of the component's roles

			))

		{

		return StopTest(KErrGeneral, EFail);

		}

	//

	// Obtain the component's first role (success)

	//

	char componentRoleArray[OMX_MAX_STRINGNAME_SIZE];

	if (OMX_ErrorNone != ipCompHandle->ComponentRoleEnum(

			ipCompHandle,

			reinterpret_cast<OMX_U8*>(componentRoleArray),

			0 // This is index # 0, the first of the component's roles

			))

		{

		return StopTest(KErrGeneral, EFail);

		}

	TBuf8<128> componentRoleBuf8;

	componentRoleBuf8 = const_cast<const TUint8*>(reinterpret_cast<TUint8*>(componentRoleArray));

	TBuf<128> componentRoleBuf16;

	INFO_PRINTF2(_L("Component's Role length: %d"), componentRoleBuf8.Length());

	componentRoleBuf16.Copy(componentRoleBuf8);

	componentRoleBuf16.PtrZ();

	INFO_PRINTF2(_L("Component's 1st Role [%S] "), &componentRoleBuf16);

	if (componentRoleBuf8.Compare(KSymbianOmxILPcmRendererRole()) != 0)

		{

		return StopTest(KErrGeneral, EFail);

		}

	//

	// Obtain the component's second role (must fail with error OMX_ErrorNoMore)

	//

	if (OMX_ErrorNoMore != ipCompHandle->ComponentRoleEnum(

			ipCompHandle,

			reinterpret_cast<OMX_U8*>(componentRoleArray),

			1 // This is index # 1, the second of the component's roles

			))

		{

		return StopTest(KErrGeneral, EFail);

		}

	}

//

// RAsyncTestStepOmxILPcmRenderer0022

//

RAsyncTestStepOmxILPcmRenderer0022::RAsyncTestStepOmxILPcmRenderer0022(const TDesC& aTestName, TInt aComponentUid)

	:

	RAsyncTestStepOmxILComponentBase(aTestName, aComponentUid),

	ipKickoff01(NULL),

	ipKickoff02(NULL),

	ipKickoff03(NULL),

	ipKickoff04(NULL),

	ipKickoff05(NULL),

	ipKickoff06(NULL)

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0022::RAsyncTestStepOmxILPcmRenderer0022"));

	}

void

RAsyncTestStepOmxILPcmRenderer0022::KickoffTestL()

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0022::KickoffTestL"));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : Test22  "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 1.- Init Component "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 2.- Provide callbacks to component (SetCallbacks) "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 3.- Obtain the component's state (GetState) "));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 4.- Get component's current role (GetParameter(OMX_IndexParamStandardComponentRole) )"));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 5.- Set unsupported audio_renderer.wrong role (SetParameter(OMX_IndexParamStandardComponentRole) )"));

	INFO_PRINTF1(_L("UNIT TEST OMX IL PCM RENDERER : 5a.- SetParameter returns OMX_ErrorBadParameter (audio_renderer.wrong role not supported)"));

	// This will install one callback

	RAsyncTestStepOmxILComponentBase::KickoffTestL();

	// This is the only step in this test...

	TCallBack callback01 (RAsyncTestStepOmxILPcmRenderer0022Step01, this);

	delete ipKickoff01;

	ipKickoff01 = NULL;

	ipKickoff01 =

		new (ELeave) CAsyncCallBack (callback01, CActive::EPriorityLow);

	ipKickoff01->Call();

	// The successful termination...

	TCallBack callbackStop (RAsyncTestStepOmxILComponentBase::StopTestCallBack, this);

	delete ipKickoffStop;

	ipKickoffStop = NULL;

	ipKickoffStop =

		new (ELeave) CAsyncCallBack (callbackStop, CActive::EPriorityLow);

	ipKickoffStop->Call();

	}

void

RAsyncTestStepOmxILPcmRenderer0022::CloseTest()

	{

    DEBUG_PRINTF(_L8("RAsyncTestStepOmxILPcmRenderer0022::CloseTest"));

	delete ipKickoff01; // no need to Cancel

	ipKickoff01 = NULL;

	delete ipKickoff02; // no need to Cancel

	ipKickoff02 = NULL;

	delete ipKickoff03; // no need to Cancel

	ipKickoff03 = NULL;

	delete ipKickoff04; // no need to Cancel

	ipKickoff04 = NULL;