/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the

* Free Software Foundation, Inc., 59 Temple Place - Suite 330,

* Boston, MA 02111-1307, USA.

*

* Description:

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include "GStreamerTestClass.h"

#include "debug.h"

#include <stdlib.h>

#include <string.h>

_LIT8(defaultMedia,"audio/x-raw-int");

_LIT8(amrMedia,"audio/amr");

_LIT8(g711Media,"audio/x-alaw");

_LIT8(g729Media,"audio/g729");

_LIT8(iLbcMedia,"audio/ilbc");

_LIT8(mp3Media,"audio/mp3");

CGlibEventHandler* CGlibEventHandler::NewL()

{

    CGlibEventHandler* self = new(ELeave) CGlibEventHandler();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

CGlibEventHandler::~CGlibEventHandler()

{

    iTimer.Close();

}

void CGlibEventHandler::Start()

{

    iTimer.After(iStatus, TTimeIntervalMicroSeconds32(1000));

    SetActive();    

}

void CGlibEventHandler::Stop()

{

    Cancel();

}

void CGlibEventHandler::RunL()

{

    g_main_context_iteration(NULL, FALSE);

    iTimer.After(iStatus, TTimeIntervalMicroSeconds32(1000));

    SetActive();    

}

void CGlibEventHandler::DoCancel()

{

    iTimer.Cancel();    

}

CGlibEventHandler::CGlibEventHandler():CActive(EPriorityStandard)

{

    iTimer.CreateLocal();

    CActiveScheduler::Add(this);

}

void CGlibEventHandler::ConstructL()

{

}

// -----------------------------------------------------------------------------

// CGstObjects::CGstObjects

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CGstObjects::CGstObjects(void* aParent): iParent(aParent)

    {

    iPipeline = NULL;

    iLoop = NULL;

    iConverter = NULL;

    iResampler = NULL;

    iSink = NULL;        

    iSource = NULL;

    iWavparse = NULL;

    iDecoder = NULL;

    iFakesink = NULL;

    iFilesink = NULL;

    iEncoder = NULL;

    iFilter = NULL;

    iWavenc = NULL;

    iBus = NULL;

    iCaps = NULL;

    iG711EncoderIntfc = NULL;

    iG729EncoderIntfc = NULL;

    iIlbcEncoderIntfc = NULL;

    iSpeechEncoderIntfc = NULL;

    iErrconcealmentIntfc = NULL;

    iG711DecoderIntfc = NULL;

    iG729DecoderIntfc = NULL;

    iIlbcDecoderIntfc = NULL;  

    fp=NULL;

    iCGlibEventHandler = NULL;

    }

// -----------------------------------------------------------------------------

// CGstObjects::NewL

// Static constructor.

// -----------------------------------------------------------------------------

//

CGstObjects* CGstObjects::NewL(void* aParent)

    {

    CGstObjects* self = new (ELeave) CGstObjects(aParent);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// CGstObjects::ConstructL

// Symbian two-phase constructor

// -----------------------------------------------------------------------------

//

void CGstObjects::ConstructL()

    {

    iCGlibEventHandler = CGlibEventHandler::NewL();

    iCGlibEventHandler->Start();

    }

// -----------------------------------------------------------------------------

// CGstObjects::~CGstObjects

// Destructor deallocate memory.

// -----------------------------------------------------------------------------

//

CGstObjects::~CGstObjects()

    {

    }

gboolean

bus_call (GstBus     *bus,

          GstMessage *msg,

          gpointer    data)

{

  CGstObjects* objects = (CGstObjects*) data;

  switch (GST_MESSAGE_TYPE (msg)) {

    case GST_MESSAGE_EOS:

        gst_element_set_state (GST_ELEMENT (objects->iPipeline), GST_STATE_NULL);        

        //g_main_loop_quit(objects->iLoop);

        ((CGStreamerTestClass*)objects->iParent)->Signal(KErrNone);

      break;

    case GST_MESSAGE_ERROR: {

      gchar *debug;

      GError *err;

      gst_message_parse_error (msg, &err, &debug);

      g_free (debug);

      g_print ("Error: %s\n", err->message);

      g_error_free (err);

      break;

    }

    default:

      break;

  }

  return TRUE;

}

static void 

new_pad_cb (GstElement *wavparse, GstPad *new_pad, gpointer data)

 {

    CGstObjects* objects = (CGstObjects*) data; 

    gst_element_set_state ((_GstElement *)objects->iPipeline, GST_STATE_PAUSED);

    if(! gst_element_link_many (wavparse,objects->iConverter, objects->iResampler, objects->iSink, NULL))

        g_print ("link(wavparse,conv,remaple sink) failed!\n");  

    gst_element_set_state ((_GstElement *)objects->iPipeline, GST_STATE_PLAYING);

 }

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CGStreamerTestClass::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void CGStreamerTestClass::Delete() 

{

    FTRACE(FPrint(_L("CGStreamerTestClass::Delete")));

    iExpectedEvents.Close();

    iOcurredEvents.Close();

    iObjects->iCGlibEventHandler->Stop();

    //fclose(iObjects->fp);

    gst_object_unref(GST_OBJECT (iObjects->iPipeline));

    delete iObjects->iCGlibEventHandler;

    //g_main_loop_unref(iObjects->iLoop);

    delete iObjects;

    iObjects = NULL;

    iLog->Log(_L("Deleting test class..."));

	iLog->Log(_L(""));

	iLog->Log(_L(""));

}

// -----------------------------------------------------------------------------

// CGStreamerTestClass::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt CGStreamerTestClass::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

		ENTRY( "CreatePipeLine", CGStreamerTestClass::CreatePipeLine ),  	

		ENTRY( "CreateElement", CGStreamerTestClass::CreateElement ),  

		ENTRY( "InitGStreamer", CGStreamerTestClass::InitGStreamer ),

		ENTRY( "InitPipeLine", CGStreamerTestClass::InitPipeLine ),

		ENTRY( "SetElementProperties", CGStreamerTestClass::SetElementProperties ),

		ENTRY( "GetElementProperties", CGStreamerTestClass::GetElementProperties ),

		ENTRY( "AddElementToPipeline", CGStreamerTestClass::AddElementToPipeline ),

		ENTRY( "SetPipelineState", CGStreamerTestClass::SetPipelineState ),

		ENTRY( "LinkElementsInPipeline", CGStreamerTestClass::LinkElementsInPipeline ),

		ENTRY( "GetElementsCustomIntfc", CGStreamerTestClass::GetElementsCustomIntfc ),

		ENTRY( "CustomIntfcProp", CGStreamerTestClass::CustomIntfcProp ),

        ENTRY( "SetTimeout", CGStreamerTestClass::SetTimeout ),

        ENTRY( "SetAllowedPanic", CGStreamerTestClass::SetAllowedPanic ),

        ENTRY( "SetExpectedEvents", CGStreamerTestClass::SetExpectedEvents ),

        ENTRY( "SetMainLoopRun", CGStreamerTestClass::SetMainLoopRun ),

        ENTRY( "SetCapsInPipeLine", CGStreamerTestClass::SetCapsInPipeLine ),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

// -----------------------------------------------------------------------------

// CGStreamerTestClass::EventName

// Return descriptor with the notification description

// -----------------------------------------------------------------------------

TPtrC CGStreamerTestClass::EventName( TInt aKey )

{

	static TText* const badKeyword = (TText*)L"BadKeyword";

	static TText* const keywords[] =

	{

		(TText*)L"EEOSReceived",

	};

	if( (TUint)aKey >= (sizeof( keywords )/sizeof(TText*)) )

		{

		iLog->Log(_L("Keyword out of bounds"));

		TPtrC keyword( badKeyword );

		return keyword;

		}

	else

		{

		TPtrC keyword( keywords[aKey] );

		return keyword;

		}

}

// -----------------------------------------------------------------------------

// CGStreamerTestClass::AddExpectedEvent

// Add an event to the expected events' list

// -----------------------------------------------------------------------------

void CGStreamerTestClass::AddExpectedEvent(TGSTExpectedEvent event, TInt ms)

{

	FTRACE(FPrint(_L("CGStreamerTestClass::AddExpectedEvent")));

	iExpectedEvents.Append(event);

	TPtrC eventName = EventName(event);

	iLog->Log(_L("Adding expected event:(0x%02x)%S Total=%d"), event, &eventName, iExpectedEvents.Count() );

	if ( iTimeoutController && !iTimeoutController->IsActive() )

		{

		if (ms > 0)

			{

			iTimeoutController->Start( TTimeIntervalMicroSeconds(ms * 1000) );

			}

		else

			{

			iLog->Log(_L("Timeout with default value (1s)"));

			iTimeoutController->Start( TTimeIntervalMicroSeconds(1000000) );

			}

		}

}

// -----------------------------------------------------------------------------

// CGStreamerTestClass::RemoveExpectedEvent

// Remove the indicated event from the expected events' list

// -----------------------------------------------------------------------------

TBool CGStreamerTestClass::RemoveExpectedEvent(TGSTExpectedEvent aEvent)

{

	FTRACE(FPrint(_L("CGStreamerTestClass::RemoveExpectedEvent")));

	TBool match = EFalse;

	for (TUint i=0; i < iExpectedEvents.Count() ; i++)

		{

		if (iExpectedEvents[i] == aEvent)

			{

			iExpectedEvents.Remove(i);

			match = ETrue;

			break;

			}

		}

	return match;

}

// -----------------------------------------------------------------------------

// CGStreamerTestClass::RemoveAllExpectedEvents

// Remove the indicated event from the expected events' list

// -----------------------------------------------------------------------------

void CGStreamerTestClass::RemoveAllExpectedEvents()

{

	FTRACE(FPrint(_L("CGStreamerTestClass::RemoveAllExpectedEvents")));

	iLog->Log(_L("Removing all expected events"));

	iExpectedEvents.Reset();

	iOcurredEvents.Reset();

}

// -----------------------------------------------------------------------------

// CGStreamerTestClass::ProcessEvent

// -----------------------------------------------------------------------------

void CGStreamerTestClass::ProcessEvent(TGSTExpectedEvent aEvent, TInt aError)

{

	FTRACE(FPrint(_L("CGStreamerTestClass::ProcessExpectedEvent")));

	TPtrC nameEvent = EventName(aEvent);

	// Check for error

	if (aError == KErrNone)

		{

		// Remove the event

		if (RemoveExpectedEvent(aEvent))

			{

			iLog->Log(_L("Expected Event: (0x%02x)%S has ocurred Total=%d"), aEvent, &nameEvent,iExpectedEvents.Count());

			}

		else

			{

			iLog->Log(_L("Event: (0x%02x)%S has ocurred"), aEvent, &nameEvent);

			return;

			}

		// All expected events have ocurred

		if (iExpectedEvents.Count() == 0 )

			{

			Signal();

			iTimeoutController->Cancel();

			}

		}

	else

		{

		iLog->Log(_L("[Error] Event: (0x%02x)%S return with error code=%d"), aEvent, &nameEvent, aError);

		if (iExpectedEvents.Count() != 0 )

			{

			RemoveExpectedEvent(aEvent);

			}

		iTimeoutController->Cancel();

		Signal(KErrCallbackErrorCode);

		}

}

// -----------------------------------------------------------------------------

// CGStreamerTestClass::HandleTimeout

// Review if all the expected events have ocurred once the time is over

// -----------------------------------------------------------------------------

void CGStreamerTestClass::HandleTimeout(TInt aError)

{

	FTRACE(FPrint(_L("CGStreamerTestClass::HandleTimeout")));

	// All expected events have ocurred

	if (aError != KErrNone)

		{

		if (iExpectedEvents.Count() == 0 )

			{

			iLog->Log(_L("Timing out but events have ocurred"));

			Signal();

			}

		else

			{

			RemoveAllExpectedEvents();

			iLog->Log(_L("Timing out and events still pending"));

			Signal(KErrEventPending);

			}

		}

	else

		{

		iLog->Log(_L("Timing out return a error %d"), aError);

		Signal(aError);

		}

}

// -----------------------------------------------------------------------------

// CGStreamerTestClass::SetTimeout

// Create a timer and set a timeout

// When the timeout is reached the test case is marked as failed

// It's used rather than the "timeout" keyword in the configuration file

// because in this way the log continues

// -----------------------------------------------------------------------------

TInt CGStreamerTestClass::SetTimeout( CStifItemParser& aItem )

{

	FTRACE(FPrint(_L("CGStreamerTestClass::SetTimeout")));

	TInt timeout=0;

	TInt error = aItem.GetNextInt(timeout) ;

	if ( iTimeoutController )

		{

		if ( timeout > 0 )

			{

			iTimeoutController->Start( TTimeIntervalMicroSeconds(timeout*1000) );

			}

		else

			{

			iTimeoutController->Start( TTimeIntervalMicroSeconds(1000000) );

			}

		}

	else

		{

		iLog->Log(_L("Timeout Controller doesn't exist"));

		error = KErrTimeoutController;

		}

	return error;

}

// -----------------------------------------------------------------------------

// Uses the TestModuleBase API to allow a panic as exit reason for a test case

// -----------------------------------------------------------------------------

TInt CGStreamerTestClass::SetAllowedPanic( CStifItemParser& aItem )

{

	FTRACE(FPrint(_L("CGStreamerTestClass::SetAllowedPanic")));

	TInt error = KErrNone;

	TInt panicCode;

	TPtrC panicType;

	if (  ( KErrNone == aItem.GetNextString(panicType) ) &&

	( KErrNone == aItem.GetNextInt(panicCode) )  )

		{

		iLog->Log(_L("Allowing panic: %S %d"), &panicType, panicCode);

		iTestModuleIf.SetExitReason( CTestModuleIf::EPanic, panicCode );

		iNormalExitReason = EFalse;

		}

	else

		{

		iLog->Log(KMsgBadTestParameters);

		error = KErrBadTestParameter;

		}

	return error;

}

// -----------------------------------------------------------------------------

// CGStreamerTestClass::SetExpectedEvents()

// -----------------------------------------------------------------------------

TInt CGStreamerTestClass::SetExpectedEvents( CStifItemParser& aItem )

{

	FTRACE(FPrint(_L("CGStreamerTestClass::SetExpectedEvents")));

	TInt error = KErrNone;

	TInt event=0;

	while ( KErrNone == aItem.GetNextInt(event))

		{

		TInt timeout=0;

		aItem.GetNextInt(timeout);

		AddExpectedEvent(static_cast<TGSTExpectedEvent>(event), timeout); // Default timeout value