/*

* Copyright (c) 2008 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 "comxil3gpmuxerprocessingfunction.h"

#include "c3gpmuxer.h"

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

#include "comxil3gpmuxerconfigmanager.h"

#include "comxil3gpmuxervideoinputport.h"

#include "comxil3gpmuxeraudioinputport.h"

#include "log.h"

#include "c3gpmuxerwriterthreadobserver.h"

COmxIL3GPMuxerProcessingFunction* COmxIL3GPMuxerProcessingFunction::NewL(MOmxILCallbackNotificationIf& aCallbacks)

	{

	DEBUG_PRINTF(_L8("COmxIL3GPMuxerProcessingFunction::NewL"));

	COmxIL3GPMuxerProcessingFunction* self = new (ELeave) COmxIL3GPMuxerProcessingFunction(aCallbacks);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

COmxIL3GPMuxerProcessingFunction::COmxIL3GPMuxerProcessingFunction(MOmxILCallbackNotificationIf& aCallbacks) :

 COmxILProcessingFunction(aCallbacks),

 iMuxer(NULL)

 	{

	}

void COmxIL3GPMuxerProcessingFunction::ConstructL()

	{

	}

COmxIL3GPMuxerProcessingFunction::~COmxIL3GPMuxerProcessingFunction()

	{

	DEBUG_PRINTF(_L8("COmxIL3GPMuxerProcessingFunction::~COmxIL3GPMuxerProcessingFunction"));

	delete iMuxer;	

	delete iWriterThreadObserver;

	}

void COmxIL3GPMuxerProcessingFunction::SetConfigManager(COmxIL3GPMuxerConfigManager& aConfigManager)

	{

	iConfigManager = &aConfigManager;

	}

OMX_ERRORTYPE COmxIL3GPMuxerProcessingFunction::StateTransitionIndication(TStateIndex aNewState)

	{

	DEBUG_PRINTF2(_L8("COmxIL3GPMuxerProcessingFunction::StateTransitionIndication : aNewState[%u]"), aNewState);

	OMX_ERRORTYPE omxError = OMX_ErrorNone;

	switch(aNewState)

		{

		case EStateExecuting:

			{

			TRAPD(error, iMuxer->StartL(iAudioPort->IsEnabled(), iVideoPort->IsEnabled()));

			if (error != KErrNone)

				{

				omxError = SymbianErrorToOmx(error);

				}

			//Creating Writer thread observer

			TRAP(error, iWriterThreadObserver = C3GPMuxerWriterThreadObserver::NewL(iMuxer));

			if (error != KErrNone)

	                {

	                omxError = SymbianErrorToOmx(error);

	                }

			iWriterThreadObserver->IssueRequest();

			break;

			}

		case ESubStateLoadedToIdle:

			{

			OMX_U32 frameWidth = 0;

			OMX_U32 frameHeight = 0;

			OMX_U32 framerate = 0;

			OMX_U32 bitRate = 0;

			OMX_U32 audioFramerate = 0;

			iVideoPort->GetVideoProperties(frameWidth, frameHeight, framerate, bitRate);

			audioFramerate = iAudioPort->GetAudioFrameRate();

			const HBufC* filename = iConfigManager->Filename();

			if(!filename)

				{

				// no file name has been set

				omxError = OMX_ErrorUnsupportedSetting;

				break;

				}

			delete iMuxer;

			iMuxer = NULL;

			TRAPD(error, iMuxer = C3GPMuxer::NewL(iCallbacks)); 

			if (error != KErrNone)

				{

				omxError = SymbianErrorToOmx(error);

				break;

				}

			iMuxer->SetFilename(filename);							

			iMuxer->SetAudioVideoProperties(frameWidth, frameHeight, framerate, bitRate, audioFramerate);

			break;

			}

		case EStateLoaded:

			{

			delete iMuxer;

			iMuxer = NULL;

			break;

			}

		case EStatePause:

			{

			iMuxer->Pause();

			break;

			}

		default:

			{

			break;

			}

		}

	return omxError;		

	}

OMX_ERRORTYPE COmxIL3GPMuxerProcessingFunction::BufferFlushingIndication(TUint32 aPortIndex, OMX_DIRTYPE aDirection)

	{

	DEBUG_PRINTF3(_L8("COmxIL3GPMuxerProcessingFunction::BufferFlushingIndication : aPortIndex[%u]; aDirection[%u]"), aPortIndex, aDirection);

	if (aDirection == OMX_DirInput)

		{

		iMuxer->FlushBuffers(aPortIndex);

		}

	else

		{

		return OMX_ErrorBadParameter;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIL3GPMuxerProcessingFunction::ParamIndication(OMX_INDEXTYPE /*aParamIndex*/, const TAny* /*apComponentParameterStructure*/)

	{

	DEBUG_PRINTF(_L8("COmxIL3GPMuxerProcessingFunction::ParamIndication"));

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIL3GPMuxerProcessingFunction::ConfigIndication(OMX_INDEXTYPE /*aConfigIndex*/, const TAny* /*apComponentConfigStructure*/)

	{

	DEBUG_PRINTF(_L8("COmxIL3GPMuxerProcessingFunction::ConfigIndication"));

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxIL3GPMuxerProcessingFunction::BufferIndication(OMX_BUFFERHEADERTYPE* apBufferHeader,

                                                                 OMX_DIRTYPE aDirection)

	{

	DEBUG_PRINTF2(_L8("COmxIL3GPMuxerProcessingFunction::BufferIndication : aBufferHeader[%X]"), apBufferHeader);

	// Check if the previous buffer processing invalidated the Muxer 

	if (iMuxer->IsMuxerInvalid())

		{	

		return OMX_ErrorInvalidState;

		}	

	TUint32 portIndex;

	if (aDirection == OMX_DirInput)

		{

		portIndex = apBufferHeader->nInputPortIndex;

		}

	else

		{

		return OMX_ErrorBadParameter;

		}

	TRAPD(err, iMuxer->ProcessThisBufferL(apBufferHeader, portIndex));

	return SymbianErrorToOmx(err);

	}

OMX_BOOL COmxIL3GPMuxerProcessingFunction::BufferRemovalIndication(OMX_BUFFERHEADERTYPE* apBufferHeader, OMX_DIRTYPE /*aDirection*/)

	{

	DEBUG_PRINTF2(_L8("COmxIL3GPMuxerProcessingFunction::BufferRemovalIndication : aBufferHeader[%X]"), apBufferHeader);

	if (iMuxer->RemoveBuffer(apBufferHeader))

		{

		return OMX_TRUE;

		}

	return OMX_FALSE;

	}

void COmxIL3GPMuxerProcessingFunction::SetVideoPort(COmxIL3GPMuxerVideoInputPort& aVideoPort)

	{

	iVideoPort = &aVideoPort;

	}

void COmxIL3GPMuxerProcessingFunction::SetAudioPort(COmxIL3GPMuxerAudioInputPort& aAudioPort)

	{

	iAudioPort = &aAudioPort;

	}

OMX_ERRORTYPE COmxIL3GPMuxerProcessingFunction::SymbianErrorToOmx(TInt aError)

	{

	switch(aError)

		{

	case KErrNone:

		return OMX_ErrorNone;

	case KErrNoMemory:

		return OMX_ErrorInsufficientResources;

	default:

		return OMX_ErrorUndefined;

		}

	}