/*

* 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 "comxil3gpmuxeraudioinputport.h"

#include "comxil3gpmuxervideoinputport.h"

#include "c3gpmuxer.h"

#include "log.h"

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

_LIT(K3GPMuxerPanic, "C3GPMuxer");

const TUint KAudioTimeScale = 44100;

static const TUint KThreadStackSize = 8192;	// 8KB

const TInt KMaxBufferSize = 62400 * 2;

const TInt KMicroSecondsPerSecond = 1000000;

C3GPMuxer* C3GPMuxer::NewL(MOmxILCallbackNotificationIf& aCallbacks)

	{

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

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

C3GPMuxer::C3GPMuxer(MOmxILCallbackNotificationIf& aCallbacks): 

 CActive(EPriorityStandard), 

 iCallbacks(aCallbacks)

	{

	}

void C3GPMuxer::ConstructL()

	{

	User::LeaveIfError(iVideoQueue.CreateLocal(KMaxVideoBuffers));	

	iPartialFrame.CreateL(KMaxBufferSize);	

	User::LeaveIfError(iAudioQueue.CreateLocal(KMaxAudioBuffers));

	User::LeaveIfError(iRemoveQueue.CreateLocal(Max(KMaxVideoBuffers, KMaxAudioBuffers)));

	User::LeaveIfError(iQueMutex.CreateLocal());

	iComposer = C3GPCompose::NewL();

	}

void C3GPMuxer::StartL(TBool aAudioPortEnabled, TBool aVideoPortEnabled)

	{

	DEBUG_PRINTF(_L8("C3GPMuxer::StartL"));

	iPaused = EFalse;

	if (!iThreadRunning)

		{

		iAudioPortEnabled = aAudioPortEnabled;

		iVideoPortEnabled = aVideoPortEnabled;

		TBuf<40> threadName;

		threadName.Format(_L("C3GPMuxerThread@%08X"), this);

		User::LeaveIfError(iThread.Create(threadName, ThreadEntryPoint, KThreadStackSize, NULL, this));

		// start the thread and wait for it to start the active scheduler

		TRequestStatus status;

		iThread.Rendezvous(status);

		iThread.Resume();

		User::WaitForRequest(status);

		User::LeaveIfError(status.Int());

		}

	else

	    {

	    // self complete

        iQueMutex.Wait();

        if (!iRequestOutstanding)

            {

            TRequestStatus* statusPtr = &iStatus;

            iThread.RequestComplete(statusPtr, KErrNone);        

            }

        iQueMutex.Signal();

	    }

	}

TInt C3GPMuxer::ThreadEntryPoint(TAny* aPtr)

	{

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(!cleanup)

		{

		return KErrNoMemory;

		}

	// Call this objects clock initialisation routine

	TRAPD(err, static_cast<C3GPMuxer*>(aPtr)->RunThreadL());

	delete cleanup;

	return err;

	}

void C3GPMuxer::RunThreadL()

	{

	DEBUG_PRINTF(_L8("C3GPMuxer::RunThreadL"));

	CActiveScheduler* sched = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(sched);

	CActiveScheduler::Install(sched);

	CActiveScheduler::Add(this);

	if (iAudioPortEnabled)

		{

		iAudioQueue.NotifyDataAvailable(iStatus);

		SetActive();												

        iRequestOutstanding = ETrue;

		}

	else if (iVideoPortEnabled)

		{

		iVideoQueue.NotifyDataAvailable(iStatus);

		SetActive();									

        iRequestOutstanding = ETrue;

		}

	iEndWaitAO = CEndWaitAO::NewL();

	iThreadRunning = ETrue;

	iThread.Rendezvous(KErrNone);

	CActiveScheduler::Start();

	HandleError(iComposer->Complete());

	iComposerOpened = EFalse;

	CleanupStack::PopAndDestroy(sched);

	}

C3GPMuxer::~C3GPMuxer()

	{

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

	if(iThreadRunning)

		{		

		iThreadRunning = EFalse;

		TRequestStatus logonStatus;

		iThread.Logon(logonStatus);

		iEndWaitAO->Call();

		User::WaitForRequest(logonStatus);

		delete iEndWaitAO;

		iEndWaitAO = NULL;

		}

	iVideoQueue.Close();

	iPartialFrame.Close();

	iAudioQueue.Close();

	iRemoveQueue.Close();

	delete iComposer;

	iThread.Close();

	iQueMutex.Close();

	}

void C3GPMuxer::ProcessThisBufferL(OMX_BUFFERHEADERTYPE* aBufferHeader, TUint32 aPortIndex)

	{

	DEBUG_PRINTF3(_L8("C3GPMuxer::ProcessThisBufferL : aBufferHeader[%X]; aPortIndex[%u]"), aBufferHeader, aPortIndex);

	__ASSERT_ALWAYS(aBufferHeader->nOffset + aBufferHeader->nFilledLen <= aBufferHeader->nAllocLen, User::Invariant());

	if (aPortIndex == COmxIL3GPMuxer::EPortIndexAudioInput && iAudioPortEnabled)

		{

		User::LeaveIfError(iAudioQueue.Send(aBufferHeader));		

		}

	else if (aPortIndex == COmxIL3GPMuxer::EPortIndexVideoInput && iVideoPortEnabled)

		{

		User::LeaveIfError(iVideoQueue.Send(aBufferHeader));		

		}

	// FIXME buffer arrived on disabled port?? if we don't consider this an error why bother checking?

	}

void C3GPMuxer::FlushBuffers(TUint32 aPortIndex)

	{

	DEBUG_PRINTF2(_L8("C3GPMuxer::FlushBuffers : aPortIndex[%u]"), aPortIndex);

	__ASSERT_DEBUG(aPortIndex == OMX_ALL || aPortIndex < COmxIL3GPMuxer::EPortIndexMax, User::Invariant());

	if (aPortIndex == OMX_ALL || aPortIndex < COmxIL3GPMuxer::EPortIndexMax)

		{

		iQueMutex.Wait();

		if (aPortIndex == OMX_ALL)

			{

			for (TInt portIndex = 0; portIndex < COmxIL3GPMuxer::EPortIndexMax; ++portIndex)

				{

				DoFlushBuffers(portIndex);

				}

			}

		else

			{

			DoFlushBuffers(aPortIndex);

			}

		iQueMutex.Signal();

		}

	}

void C3GPMuxer::DoFlushBuffers(TUint32 aPortIndex)

	{

	DEBUG_PRINTF2(_L8("C3GPMuxer::DoFlushBuffers : aPortIndex[%u]"), aPortIndex);

	OMX_BUFFERHEADERTYPE* buffer = NULL;

	switch(aPortIndex)

		{

		case COmxIL3GPMuxer::EPortIndexAudioInput:

			{

			if (iAudioBuffer)

				{

				ReturnBuffer(iAudioBuffer, aPortIndex);

				}

			while(iAudioQueue.Receive(buffer) != KErrUnderflow)

				{

				ReturnBuffer(buffer, aPortIndex); 

				}

			break;

			}

		case COmxIL3GPMuxer::EPortIndexVideoInput:

			{

			if (iCurrentVideoBuffer)

				{

				ReturnBuffer(iCurrentVideoBuffer, aPortIndex);

				iCurrentVideoBuffer = NULL;

				}

			if (iNextVideoBuffer)

				{

				ReturnBuffer(iNextVideoBuffer, aPortIndex);

				iNextVideoBuffer = NULL;

				}

			while(iVideoQueue.Receive(buffer) != KErrUnderflow)

				{

				ReturnBuffer(buffer, aPortIndex); 

				}

			break;			

			}

		default:

			{

			User::Panic(K3GPMuxerPanic, KErrArgument);

			break;

			}

		}

	}

TBool C3GPMuxer::RemoveBuffer(OMX_BUFFERHEADERTYPE* aBufferHeader)

	{

	DEBUG_PRINTF2(_L8("C3GPMuxer::RemoveBuffer : aBufferHeader[%X]"), aBufferHeader);

	iQueMutex.Wait();	

	TBool found = EFalse;

	// check the current audio/video buffers first

	if(aBufferHeader == iAudioBuffer)

		{

		iAudioBuffer = NULL;

		found = ETrue;

		}

	if(!found && aBufferHeader == iCurrentVideoBuffer)

		{

		iCurrentVideoBuffer = NULL;

		found = ETrue;

		}

	if(!found && aBufferHeader == iNextVideoBuffer)

		{

		iNextVideoBuffer = NULL;

		found = ETrue;

		}

	if (!found)

		{

		found = RemoveFromQueue(iAudioQueue, aBufferHeader);

		}

	if (!found)

		{

		found = RemoveFromQueue(iVideoQueue, aBufferHeader);

		}

	iQueMutex.Signal();

	return found;

	}

void C3GPMuxer::SetFilename(const HBufC* aFilename)

	{

	DEBUG_PRINTF(_L8("C3GPMuxer::SetFilename"));

 	iFilename = aFilename;

	}

void C3GPMuxer::SetAudioVideoProperties(OMX_U32& aFrameWidth, OMX_U32& aFrameHeight, 

									OMX_U32& aFramerate, OMX_U32& aBitRate, OMX_U32& /*aAudioFramerate*/)

	{

	DEBUG_PRINTF(_L8("C3GPMuxer::SetAudioVideoProperties"));

	iVideoSize.iWidth = static_cast<TInt>(aFrameWidth);

	iVideoSize.iHeight = static_cast<TInt>(aFrameHeight);

	iBitRate = aBitRate;

	CalculateVideoTimeScale(aFramerate);

	}

/**

Calculate video timescale and frame duration.

The video timescale is the nearest whole number multiple of the frame rate.

Where the frame rate includes more than 2 decimal places, it is rounded down

to 2 decimal places. This means the calculation is not wholly accurate in those

circumstances, but hopefully it is close enough.

*/

void C3GPMuxer::CalculateVideoTimeScale(OMX_U32& aFramerate)

	{

	// Get rid of floating point and round to 2 decimal places

	TInt fps = ((static_cast<TReal>(aFramerate) / (1<<16)) * 100.0) + 0.5;

	iVideoTimeScale = 0;

	iDefaultVideoFrameDuration = 1;

	// Find nearest whole number multiple

	for (TInt i = 1; i <= 100; ++i)

		{

		if ((fps * i) % 100 == 0)

			{

			iVideoTimeScale = fps * i / 100;

			iDefaultVideoFrameDuration = i;

			break;

			}

		}

	}

void C3GPMuxer::RunL()

	{

	DEBUG_PRINTF(_L8("C3GPMuxer::RunL"));

	iQueMutex.Wait();

	iRequestOutstanding = EFalse;	

	if (!iPaused)

	    {

	    if (iAudioPortEnabled && iVideoPortEnabled)

	        {

	        RunAudioVideoL();

	        }

	    else if (iAudioPortEnabled)

	        {

	        RunAudioL();

	        }

	    else if (iVideoPortEnabled)

	        {

	        RunVideoL();

	        }

	    }

	else

	    {

	    iStatus = KRequestPending;	    

	    }

    SetActive();

	iQueMutex.Signal();

	}

void C3GPMuxer::RunAudioVideoL()

	{

	// When opening the composer, both audio and video properties must be passed in

	if(!iAudioBuffer)

		{

		// ignore error, if KErrUnderflow then we go back to waiting on iAudioQueue

		iAudioQueue.Receive(iAudioBuffer);

		}

	else

		{

		TInt err = KErrNone;

		if (!iCurrentVideoBuffer)

			{

			err = iVideoQueue.Receive(iCurrentVideoBuffer);					

			// if KErrUnderflow then we go back to waiting on iVideoQueue

			if (err == KErrNone)

				{

				// both audio and video buffers has been received

				if (!iComposerOpened)

					{

					OpenComposerL();

					iComposerOpened = ETrue;

					iVideoDuration = (iCurrentVideoBuffer->nTimeStamp * iVideoTimeScale) / KMicroSecondsPerSecond;

					ReturnBuffer(iAudioBuffer, COmxIL3GPMuxer::EPortIndexAudioInput);

					iAudioBuffer = NULL;

					// [SL] FIXME may also need to return iVideoBuffer in nFilledLen = 0

					// (VideoSpecificInfo was entire buffer)

					}

				// We need the timestamp of the next buffer to work out the frame duration of the current video buffer

				// so wait to receive the next video buffer

				}

			}

		else

			{

			if(!iNextVideoBuffer)

				{

				err = iVideoQueue.Receive(iNextVideoBuffer);

				}

			// if KErrUnderflow then we go back to waiting on iVideoQueue

			if(err == KErrNone)

				{

				// next video buffer received

				// audio/video frames are added into the composer in the order of timestap

				if (iAudioBuffer->nTimeStamp < iCurrentVideoBuffer->nTimeStamp)

					{

					WriteAudioBuffer();

					iAudioBuffer = NULL;					

					}

				else

					{

					WriteVideoBufferL();

					iCurrentVideoBuffer = iNextVideoBuffer;

					iNextVideoBuffer = NULL;									

					if (iCurrentVideoBuffer->nFlags & OMX_BUFFERFLAG_EOS)

						{

						// this is the last video buffer

						WriteVideoBufferL();

						iCurrentVideoBuffer = NULL;

						}			

					}

				}			

			}

		}

	if(!iAudioBuffer)

		{

		iAudioQueue.NotifyDataAvailable(iStatus);

		}

	else if(!iNextVideoBuffer)

		{

		iVideoQueue.NotifyDataAvailable(iStatus);

		}

	else

		{

		// already have both buffers available

		TRequestStatus* statusPtr = &iStatus;

		User::RequestComplete(statusPtr, KErrNone);

		}

	iRequestOutstanding = ETrue;

	}

void C3GPMuxer::RunAudioL()

	{

	if(iAudioBuffer == NULL)

		{

		TInt err = iAudioQueue.Receive(iAudioBuffer);

		// KErrUnderflow if RemoveBuffer or FlushBuffers occurs between notify completion and RunL

		if(err != KErrNone && err != KErrUnderflow)

			{

			HandleError(err);

			return;

			}

		}

	if(iAudioBuffer != NULL)

		{

		if (!iComposerOpened)

			{

			OpenComposerL();

			iComposerOpened = ETrue;

			//return the buffer

			ReturnBuffer(iAudioBuffer, COmxIL3GPMuxer::EPortIndexAudioInput);

			}

		else

			{

			//write the non header audio buffer.

			WriteAudioBuffer();

			}

		iAudioBuffer = NULL;

		}

	iAudioQueue.NotifyDataAvailable(iStatus);

    iRequestOutstanding = ETrue;	

	}

void C3GPMuxer::RunVideoL()

	{

	if (!iCurrentVideoBuffer)

		{

		// FIXME KErrUnderflow if RemoveBuffer or FlushBuffers occurs between notify completion and RunL

		HandleError(iVideoQueue.Receive(iCurrentVideoBuffer));				

		if (!iComposerOpened)

			{

			OpenComposerL();

			iComposerOpened = ETrue;

			}

		iVideoDuration = (iCurrentVideoBuffer->nTimeStamp * iVideoTimeScale) / KMicroSecondsPerSecond;

		// We need the timestamp of the next buffer to work out the frame duration of the current buffer

		// so wait to receive the next buffer

		}

	else

		{

		// next buffer received

		// FIXME KErrUnderflow if RemoveBuffer or FlushBuffers occurs between notify completion and RunL

		HandleError(iVideoQueue.Receive(iNextVideoBuffer));

		WriteVideoBufferL();