/*

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

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

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

#include "c3gpdemuxer.h"

#include "omxil3gpdemuxerpanic.h"

#include "comxil3gpdemuxertimeinputport.h"

#include "comxil3gpdemuxeraudiooutputport.h"

#include "comxil3gpdemuxervideooutputport.h"

C3GPDemuxer::CPort* C3GPDemuxer::CPort::NewL(TInt aBufferCount)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aBufferCount);

	CleanupStack::Pop(self);

	return self;

	}

C3GPDemuxer::CPort::CPort() :

	iEOS(EFalse)

	{

	}

void C3GPDemuxer::CPort::ConstructL(TInt aBufferCount)

	{

	iBuffers.ReserveL(aBufferCount);

	}

C3GPDemuxer::CPort::~CPort()

	{

	iBuffers.Reset();

	}

C3GPDemuxer* C3GPDemuxer::NewL(MOmxILCallbackNotificationIf& aCallbacks)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void C3GPDemuxer::ConstructL()

	{

	i3GPParser = C3GPParse::NewL();

	}

C3GPDemuxer::C3GPDemuxer(MOmxILCallbackNotificationIf& aCallbacks) :

	CActive(EPriorityStandard),

	iCallbacks(aCallbacks),

	iVideoType(E3GPNoVideo),

	iAudioType(E3GPNoAudio),

	iFirstVideoFrame(ETrue),

	iFirstAudioFrame(ETrue),

	iAsyncBuf(0, 0)

	{

	iOmxAudioFormat.iCoding = OMX_AUDIO_CodingMax;

	iOmxVideoFormat.iCoding = OMX_VIDEO_CodingMax;

	for (TInt port = 0; port < COmxIL3GPDemuxer::EPortIndexMax; ++port)

		{

		iPort[port] = NULL;

		}

	CActiveScheduler::Add(this);

	}

C3GPDemuxer::~C3GPDemuxer()

	{

	Cancel();

	DeleteBufferQueue();

	if (i3GPParser)

		{

		HandleIfError(i3GPParser->Complete());

		delete i3GPParser;

		}

	}

OMX_ERRORTYPE C3GPDemuxer::AcquireResources(const TDesC& aFilename)

	{

	DEBUG_PRINTF(_L8("C3GPDemuxer::AcquireResources"));

	TInt error = i3GPParser->Open(aFilename);

	if (error == KErrNone)

		{

		iParserOpened = ETrue;

		if (iStartTimePosition != 0)

			{

			SetPosition(iStartTimePosition, iStartKeyFrame);

			iSeekPosition = iStartTimePosition;

			iStartTimePosition = 0;

			}

		TRAP(error, CreateBufferQueueL());

		}

	return SymbianOSErrorToOmx(error);

	}

void C3GPDemuxer::ReleaseResources()

	{

	DeleteBufferQueue();

	if (i3GPParser)

		{

		HandleIfError(i3GPParser->Complete());

		iParserOpened = EFalse;

		}

	}

void C3GPDemuxer::Start()

	{

	if (iPaused && iState != EStateWaitingToStart)

		{

		if (iState != EStateFillingBuffer)

			{

			Cancel();

			// Self complete so that we start to process any buffer received while

			// we were in paused state

			CompleteSelf();

			}

		}

	else

		{

		Cancel();

		iState = EStateWaitingForBuffer;

		// Self complete so that we start to process any buffer received while

		// we were in idle state

		CompleteSelf();

		}

	iPaused = EFalse;

	}

OMX_ERRORTYPE C3GPDemuxer::Stop()

	{

	Cancel();

	if (iState == EStateFillingBuffer)

		{

	 	i3GPParser->CancelReadFrame();

		}

	iState = EStateWaitingToStart;

	StartWaitingForBuffer();

	iAudioHeadersSent = EFalse;

	iFirstAudioFrame = ETrue;

	iVideoHeadersSent = EFalse;

	iFirstVideoFrame = ETrue;

	iPaused = EFalse;

	TInt error = SetPosition(0, EFalse);

	return SymbianOSErrorToOmx(error);

	}

void C3GPDemuxer::Pause()

	{

	iPaused = ETrue;

	}

TBool C3GPDemuxer::Invalid() const

	{

	return iInvalid;

	}

void C3GPDemuxer::ProcessThisBufferL(OMX_BUFFERHEADERTYPE* aBufferHeader,

		TUint32 aPortIndex)

	{

	__ASSERT_DEBUG(iBufferQueueCreated, Panic(EProcessThisBufferLNoBufferQueue));

	aBufferHeader->nFilledLen = 0;

	aBufferHeader->nOffset = 0;

	aBufferHeader->nTimeStamp = 0;

	aBufferHeader->nFlags = 0;

	if (iBufferQueueCreated)

		{

		TBufferMessage buffer;

		buffer.iBufferHeader = aBufferHeader;

		buffer.iPortIndex = aPortIndex;

		User::LeaveIfError(iBufferQueue.Send(buffer));

		}

	else

		{

		User::Leave(KErrNotReady);

		}

	}

void C3GPDemuxer::FlushBuffers(TUint32 aPortIndex)

	{

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

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

		{

		Cancel();

		ReceiveQueuedBuffers();

		if (aPortIndex == OMX_ALL || iCurrentPort == aPortIndex)

			{

			if (iState == EStateFillingBuffer)

				{

				// We are about to flush a buffer that is being filled.

			 	// Cancel the read operation.

			 	i3GPParser->CancelReadFrame();

				}

		 	iState = EStateWaitingForBuffer;

			}

		if (aPortIndex == OMX_ALL)

			{

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

				{

				DoFlushBuffers(portIndex);

				}

			}

		else

			{

			DoFlushBuffers(aPortIndex);

			}

		// Unless we are waiting for a read to complete, we need to self

		// complete just in case the ReceiveQueuedBuffers() call above

		// received new buffers

		if (iState != EStateFillingBuffer)

			{

			CompleteSelf();

			}

		}

	}

void C3GPDemuxer::DoFlushBuffers(TUint32 aPortIndex)

	{

	if (iPort[aPortIndex])

		{

		OMX_DIRTYPE direction = OMX_DirOutput;

		if (aPortIndex == COmxIL3GPDemuxer::EPortIndexTimeInput)

			{

			direction = OMX_DirInput;

			}

		RQueuedBuffers& buffers = iPort[aPortIndex]->iBuffers;

		while (buffers.Count() > 0)

			{

			iCallbacks.BufferDoneNotification(buffers[0], aPortIndex, direction);

			buffers.Remove(0);

			}

		}

	}

TBool C3GPDemuxer::RemoveBuffer(OMX_BUFFERHEADERTYPE* aBufferHeader,

                                OMX_DIRTYPE aDirection)

	{

	TInt port = 0;

	if (aDirection == OMX_DirOutput)

		{

		port = aBufferHeader->nOutputPortIndex;

		}

	else if (aDirection == OMX_DirInput)

		{

		port = aBufferHeader->nInputPortIndex;

		}

	else

		{

		Panic(ERemoveBufferInvalidDirection);

		}

	__ASSERT_DEBUG(port >= 0 && port < COmxIL3GPDemuxer::EPortIndexMax, Panic(ERemoveBufferInvalidPort));

	TBool found = EFalse;

	if (port >= 0 && port < COmxIL3GPDemuxer::EPortIndexMax)

		{

		Cancel();

		ReceiveQueuedBuffers();

		if (iPort[port])

			{

			RQueuedBuffers& buffers = iPort[port]->iBuffers;

			for (TInt buf = 0; buf < buffers.Count(); ++buf)

				{

				if (buffers[buf] == aBufferHeader)

					{

					if (iCurrentPort == port && buf == 0)

						{				

						if (iState == EStateFillingBuffer)

							{

							// We are about to remove a buffer that is being filled.

			 				// Cancel the read operation.

			 				i3GPParser->CancelReadFrame();

							}

		 				iState = EStateWaitingForBuffer;

						}

					buffers[buf]->nFilledLen = 0;

					buffers.Remove(buf);

					found = ETrue;

					break;

					}

				}

			}

		// Unless we are waiting for a read to complete, we need to self

		// complete just in case the ReceiveQueuedBuffers() call above

		// received new buffers

		if (iState != EStateFillingBuffer)

			{

			CompleteSelf();

			}

		}

	return found;

	}

TBool C3GPDemuxer::GetVideoFormat(TSize& aFrameSize, TVideoFormat& aFormat) const

	{

	if (!iVideoPropertiesRead)

		{

		return EFalse;

		}

	aFrameSize.iWidth = iVideoWidth;

	aFrameSize.iHeight = iVideoHeight;

	aFormat = iOmxVideoFormat;

	return ETrue;

	}

TBool C3GPDemuxer::GetAudioFormat(TAudioFormat& aFormat) const

	{

	if (!iAudioPropertiesRead)

		{

		return EFalse;

		}

	aFormat = iOmxAudioFormat;

	return ETrue;

	}

OMX_ERRORTYPE C3GPDemuxer::GetVideoTimestamp(OMX_TICKS& aOmxticks)

	{

	TInt err = KErrNone;

	TUint timestampInMilliSec(0);

	if (iParserOpened)

		{

		// return last requested seek time

		timestampInMilliSec = iSeekPosition;

		}

	else

		{

		timestampInMilliSec = iStartTimePosition;

		}

	if (err == KErrNone)

		{

		aOmxticks = timestampInMilliSec * 1000;

		}

	return SymbianOSErrorToOmx(err);

	}

OMX_ERRORTYPE C3GPDemuxer::Seek(const OMX_TICKS& aOmxticks, OMX_TIME_SEEKMODETYPE aSeekModeType)

    {

	TInt err = KErrNone;

	//Set the firstFrame flags to true

	iFirstVideoFrame = ETrue;

	iFirstAudioFrame = ETrue;

	TUint timeInMilliSec = aOmxticks / 1000;

	TBool keyFrame(aSeekModeType == OMX_TIME_SeekModeFast);

	if (iParserOpened)

		{

		err = SetPosition(timeInMilliSec, keyFrame);

		if (err != KErrNone)

			{

			iSeekPosition = timeInMilliSec;

			}

		}

	else

		{

		iStartTimePosition = timeInMilliSec;

		iStartKeyFrame = keyFrame;

		}

	return SymbianOSErrorToOmx(err);

	}

OMX_ERRORTYPE C3GPDemuxer::DetectStreams()

	{

	iAudioPropertiesRead = EFalse;

	TUint s_audioLength;

	TInt s_audioFramesPerSample;

	TUint s_audioAvgBitRate;

	TUint s_audioTimeScale;

	TInt error = i3GPParser->GetAudioProperties(iAudioType, s_audioLength,

			s_audioFramesPerSample, s_audioAvgBitRate, s_audioTimeScale);

	if (error != KErrNotSupported)

		{

		if (error)

			{

			return SymbianOSErrorToOmx(error);

			}

		else

			{

			iOmxAudioFormat.iFramesPerSample = s_audioFramesPerSample;

			iOmxAudioFormat.iSampleRate = s_audioTimeScale;

			iOmxAudioFormat.iAverageBitrate = s_audioAvgBitRate;

			switch (iAudioType)

				{

				case E3GPQcelp13K:

					{

					iOmxAudioFormat.iCoding = OMX_AUDIO_CodingQCELP13;

					}

					break;

				case E3GPMpeg4Audio:

					{

					iOmxAudioFormat.iCoding = OMX_AUDIO_CodingAAC;

					}

					break;

				case E3GPAmrNB:

				case E3GPAmrWB:

					{

					iOmxAudioFormat.iCoding = OMX_AUDIO_CodingAMR;

					}

					break;

				default:

					{

					iOmxAudioFormat.iCoding = OMX_AUDIO_CodingMax;

					}

				}

			iAudioPropertiesRead = ETrue;

			}

		}

	iVideoPropertiesRead = EFalse;

	TSize vidSize(iVideoWidth, iVideoHeight);

	TUint s_vidLength = 0;

	TReal s_vidFrameRate = 0.0;

	TUint s_vidAvgBitRate = 0;

	TSize s_vidSize;

	TUint s_vidTimeScale = 0;

	error = i3GPParser->GetVideoProperties(iVideoType, s_vidLength,

			s_vidFrameRate, s_vidAvgBitRate, s_vidSize, s_vidTimeScale);

	if (error != KErrNotSupported)

		{

		if (error)

			{

			return SymbianOSErrorToOmx(error);

			}

		else

			{

			iVideoWidth = s_vidSize.iWidth;

			iVideoHeight = s_vidSize.iHeight;

			// translate library video type to OpenMAX IL coding and profile type

			switch (iVideoType)

				{

				case E3GPMpeg4Video:

					iOmxVideoFormat.iCoding = OMX_VIDEO_CodingMPEG4;

					break;

				case E3GPH263Profile0:

					iOmxVideoFormat.iCoding = OMX_VIDEO_CodingH263;

					iOmxVideoFormat.iProfile.h263

							= OMX_VIDEO_H263ProfileBaseline;

					break;

				case E3GPH263Profile3:

					iOmxVideoFormat.iCoding = OMX_VIDEO_CodingH263;

					iOmxVideoFormat.iProfile.h263 = OMX_VIDEO_H263ProfileISWV2;

					break;

				case E3GPAvcProfileBaseline:

					iOmxVideoFormat.iCoding = OMX_VIDEO_CodingAVC;

					iOmxVideoFormat.iProfile.avc = OMX_VIDEO_AVCProfileBaseline;

					break;

				default:

					// do not return an error here, the error is signalled after the transition to Executing

					iOmxVideoFormat.iCoding = OMX_VIDEO_CodingMax;

					break;

				}

			}

			iVideoPropertiesRead = ETrue;

		}

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE C3GPDemuxer::GetMetadataL(OMX_CONFIG_METADATAITEMTYPE* aMetadata)

	{

	// Metadata key size must be at least 4

	if (aMetadata->nKeySizeUsed < 4)

		{

		return OMX_ErrorBadParameter;

		}