/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

*

*/

// INCLUDE FILES

#include    "movieprocessorimpl.h"

#include    "mp4parser.h"

#include    "vedvideosettings.h"

#include    "vedaudiosettings.h"

#include    "vedvolreader.h"

#include    "vedavcedit.h"

// ASSERTIONS

#define MPASSERT(x) __ASSERT_DEBUG(x, User::Panic(_L("CMovieProcessorImpl"), EInternalAssertionFailure))

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x;

#else

#define PRINT(x)

#endif

// LOCAL CONSTANTS AND MACROS

#ifdef _DEBUG

const TInt KErrorCode = CParser::EParserFailure;

#else

const TInt KErrorCode = KErrGeneral;

#endif

//const TUint KNumFramesInOneRun = 10;

const TUint KVOLHeaderBufferSize = 256;

const TUint KAVCDCRBufferSize = 1024;

const TUint KMinBitrate = 128;

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

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

// might leave.

//

CMP4Parser::CMP4Parser()

{       

	iMP4Handle = 0;

	iVideoType = 0;

	iAudioType = 0; 

	iBytesRead = 0;

	iFirstRead = ETrue;		// added for Mp4

	iFirstFrameInfo = ETrue;  // added for Mp4

	iOutputNumberOfFrames = 0; 

    iStreamSource = ESourceNone;

	iFrameNumber=0;

	iFirstTimeClipParsing=ETrue;

    iStartFrameIndex=0;		

}

// Two-phased constructor.

CMP4Parser* CMP4Parser::NewL(CMovieProcessorImpl* aProcessor, const TDesC &aFileName)

{

	CMP4Parser *self = new (ELeave) CMP4Parser;

	CleanupStack::PushL(self);    

	if ( aFileName.Length() > 0 )   

		self->iStreamSource = ESourceFile;

	else

		self->iStreamSource = ESourceUser;

	self->ConstructL(aProcessor,aFileName);

	CleanupStack::Pop();  // self

	return self;

}

CMP4Parser* CMP4Parser::NewL(CMovieProcessorImpl* aProcessor, RFile* aFileHandle)

{

	CMP4Parser *self = new (ELeave) CMP4Parser;

	CleanupStack::PushL(self);    

	self->iStreamSource = ESourceFile;	

	self->ConstructL(aProcessor,aFileHandle);

	CleanupStack::Pop();  // self

	return self;

}

// Symbian OS default constructor can leave.

void CMP4Parser::ConstructL(CMovieProcessorImpl* aProcessor, const TDesC &aFileName)

{

	MP4Err error;

	iProcessor = aProcessor; 

	// open MP4 library

    if ( iStreamSource == ESourceFile )

        {        

        TBuf<258> temp(aFileName);

        temp.ZeroTerminate();			

        MP4FileName name = reinterpret_cast<MP4FileName>( const_cast<TUint16*>(temp.Ptr()) );

        error = MP4ParseOpen(&iMP4Handle, name);

        if ( error == MP4_OK )

            {

            // set buffer sizes; only parser buffer size is effective for this instance

            error = MP4SetCustomFileBufferSizes(iMP4Handle, K3gpMp4ComposerWriteBufferSize, K3gpMp4ComposerNrOfWriteBuffers, K3gpMp4ParserReadBufferSize );

            }

        }

    else

        {

        // buffer

        error = MP4ParseOpen(&iMP4Handle, 0);        

        }        

    if (error == MP4_OUT_OF_MEMORY)

        {

        User::Leave(KErrNoMemory);

        }

    else if ( error != MP4_OK )

        {

        User::Leave(KErrorCode);

		}

}

void CMP4Parser::ConstructL(CMovieProcessorImpl* aProcessor, RFile* aFileHandle)

{

	MP4Err error;

	iProcessor = aProcessor;

	// open MP4 library

    error = MP4ParseOpenFileHandle(&iMP4Handle, aFileHandle);

    if ( error == MP4_OK )

        {

        // set buffer sizes; only parser buffer size is effective for this instance

        error = MP4SetCustomFileBufferSizes(iMP4Handle, K3gpMp4ComposerWriteBufferSize, K3gpMp4ComposerNrOfWriteBuffers, K3gpMp4ParserReadBufferSize );

        }

    if (error == MP4_OUT_OF_MEMORY)

        {

        User::Leave(KErrNoMemory);

        }

    else if ( error != MP4_OK )

        {

        User::Leave(KErrorCode);

		}

}

// Destructor

CMP4Parser::~CMP4Parser()

{

    if (iMP4Handle)

        MP4ParseClose(iMP4Handle);

    iMP4Handle = 0;

}

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

// CMP4Parser::WriteDataBlockL

// Write a block of data to parser

// (other items were commented in a header).

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

//

TInt CMP4Parser::WriteDataBlock(const TDes8& aBlock)

{               

	MPASSERT(iStreamSource != ESourceFile);    

	MP4Err error = MP4ParseWriteData(iMP4Handle, (mp4_u8*)(aBlock.Ptr()), mp4_u32(aBlock.Length()) );

	if ( error == MP4_OUT_OF_MEMORY )

		return KErrNoMemory;

	else if ( error == MP4_ERROR )

		return KErrorCode;

    else

        return KErrNone;

}

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

// CMP4Parser::GetNextFrameInformation

// Get type (streaming-case), length and availability of next frame to be fetched

// using MP4 library API functions

// (other items were commented in a header).

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

//

TInt CMP4Parser::GetNextFrameInformation(TFrameType& aType, TUint& aLength, TBool& aIsAvailable)

{   

	// If aType == EFrameTypeNone, the type of next frame is retrieved 

	// (valid only in streaming case)

	// Otherwise, only the length of next specified type of frame is retrieved

	MPASSERT(iStreamSource != ESourceNone);            

	mp4_u32 type = MP4_TYPE_NONE;

	MP4Err error;

	aIsAvailable = 0;    

	if ( iNextFrameType == EFrameTypeNone )

		// if the mp4 library is reading a file, a frame has always been read when 

		// we come here

		// otherwise it might be that a complete frame was not available yet

		// and we come here to ask again        

	{

		if ( aType == EFrameTypeNone ) 

		{

			MPASSERT(iStreamSource == ESourceUser);

			// get next frame type

			error = MP4ParseNextFrameType(iMP4Handle, &type);

			if ( error == MP4_NOT_AVAILABLE )

				return KErrNone;                

			else if ( error == MP4_NO_FRAME )                

				return EParserEndOfStream; // no video or audio frames left, stream ended

			else if ( error == MP4_INVALID_INPUT_STREAM )

				return KErrCorrupt;

			else if ( error != MP4_OK )

				return KErrorCode;

            else

            {

                MPASSERT(error == MP4_OK);

            }

			switch ( type ) 

			{

			case MP4_TYPE_H263_PROFILE_0:

		    case MP4_TYPE_MPEG4_VIDEO:

				MPASSERT( type == iVideoType );

				iNextFrameType = EFrameTypeVideo;         

				break;

			case MP4_TYPE_AMR_NB:

				MPASSERT( type == iAudioType );

				iNextFrameType = EFrameTypeAudio;                    

				break;        

			default:

				return KErrNotSupported;

			}

		}

		else 

		{

			// library reads the file            

			//MPASSERT(iStreamSource == ESourceFile);

			type = ( aType == EFrameTypeVideo ) ? iVideoType : iAudioType;

			iNextFrameType = aType;

		}

		// get length for the frame

		mp4_u32 length = 0, mp4Specific = 0;

		MPASSERT( type != MP4_TYPE_NONE );

		if ( (iFirstFrameInfo) &&

		     ((iVideoType == MP4_TYPE_MPEG4_VIDEO) || (iVideoType == MP4_TYPE_AVC_PROFILE_BASELINE)) ) 		   

		{

			error = MP4ParseReadVideoDecoderSpecificInfo( iMP4Handle, 0, 0, &mp4Specific );

			iFirstFrameInfo = EFalse;

		}

		error = MP4ParseNextFrameSize(iMP4Handle, type, &length);

		MPASSERT( error != MP4_NOT_AVAILABLE );

		if ( length == 0 || error == MP4_NO_REQUESTED_FRAME )

		{            

			// file-reading case: all frames of this type have been read

			//   and the caller should try with the other type

			MPASSERT( length == 0 );

			iNextFrameType = EFrameTypeNone;

			aLength = 0;            

			return KErrNone;            

		}

		else if ( error == MP4_INVALID_INPUT_STREAM )

			return KErrCorrupt;

		else if ( error != MP4_OK )

			return KErrorCode;

       else if ( length > iMaxVideoFrameLength )

            {

            PRINT((_L("CMP4Parser::GetNextFrameInformation() too large video frame size %d, return KErrCorrupt"),length));

			return KErrCorrupt;

            }

        else

            iNextFrameLength = TUint(length + mp4Specific);

	}

	MPASSERT(iNextFrameType != EFrameTypeNone);

	MPASSERT(iNextFrameLength != 0);

	// check if frame is available

	if ( iStreamSource == ESourceUser )

	{

		error = MP4ParseIsFrameAvailable(iMP4Handle, type);

		if ( error != MP4_OK && error != MP4_NOT_AVAILABLE )

			return KErrorCode;

		aIsAvailable = ( error == MP4_NOT_AVAILABLE ) ? EFalse : ETrue;

	}

	else 

		aIsAvailable = ETrue;

	aType = iNextFrameType;

	aLength = iNextFrameLength;	

	return KErrNone;

}   

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

// CMP4Parser::ReadFrames

// Read the next frame(s) from file / stream

// (other items were commented in a header).

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

//

TInt CMP4Parser::ReadFrames(TDes8& aDstBuffer, TFrameType aType, TUint32& aNumRead, 

														TUint32& aTimeStamp)

{

	MP4Err error;

	mp4_u32 returnedSize = 0;    

	mp4_bool keyFrame = 0;

	MPASSERT( iNextFrameType != EFrameTypeNone && aType == iNextFrameType ); 

	MPASSERT( iNextFrameLength != 0 );

#ifdef _DEBUG

	mp4_u32 type = MP4_TYPE_NONE; // buffer support

	type = ( aType == EFrameTypeVideo ) ? iVideoType : iAudioType; // buffer support

	if (iStreamSource == ESourceUser)

		MPASSERT( MP4ParseIsFrameAvailable(iMP4Handle, type) == MP4_OK );

#endif

	if (aType == EFrameTypeVideo) 

	{	

		TUint32 iTimeStampInTicks=0;

		mp4_u32 mp4Specific = 0;

		if ( (iFirstRead) &&

		     ((iVideoType == MP4_TYPE_MPEG4_VIDEO) || (iVideoType == MP4_TYPE_AVC_PROFILE_BASELINE)) ) 		   

		{

			error = MP4ParseReadVideoDecoderSpecificInfo( iMP4Handle, (mp4_u8*)(aDstBuffer.Ptr() + aDstBuffer.Length()), 

				mp4_u32( aDstBuffer.MaxLength() ), &mp4Specific );

			iFirstRead = EFalse;

		}

		error = MP4ParseReadVideoFrame(iMP4Handle, (mp4_u8*)(aDstBuffer.Ptr() + aDstBuffer.Length()+ mp4Specific), 

			mp4_u32( aDstBuffer.MaxLength() ), &returnedSize, (mp4_u32*)&aTimeStamp,

			&keyFrame, &iTimeStampInTicks);					    

		returnedSize += mp4Specific;

		iFrameNumber++;

		aNumRead = 1;

	}

	else 

	{       

		error = MP4ParseReadAudioFrames(iMP4Handle, (mp4_u8*)(aDstBuffer.Ptr()), 

			mp4_u32(aDstBuffer.MaxLength()), &returnedSize, (mp4_u32*)&aTimeStamp, 

			(mp4_u32*)&aNumRead, NULL);               

		//PRINT((_L("audio TS:%d, "), aTimeStamp));

	}

	MPASSERT(error != MP4_BUFFER_TOO_SMALL);    

	aDstBuffer.SetLength(aDstBuffer.Length() + TInt(returnedSize));

	iBytesRead += returnedSize;

	iNextFrameType = EFrameTypeNone;

	iNextFrameLength = 0;

	//PRINT((_L("error=%d, numReturned=%d, returnedSize=%d, bufferSize=%d\n"), 

	//	error, aNumRead, returnedSize, aDstBuffer.MaxLength()));

	if (error == MP4_NOT_AVAILABLE)

		return EParserNotEnoughData;    

	else if ( error == MP4_INVALID_INPUT_STREAM )

		return KErrCorrupt;

	else if ( error != MP4_OK )

		return KErrorCode;

    else

        return KErrNone;

}

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

// CMP4Parser::Reset

// Resets the parser to its initial state

// (other items were commented in a header).

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

//

TInt CMP4Parser::Reset()

{

	MP4Err error;

	if ( iStreamSource == ESourceFile )

	{

		mp4_u32 audioPos, videoPos;

		// seek to very beginning

		error = MP4ParseSeek(iMP4Handle, 0, &audioPos, &videoPos, EFalse);

		if ( error != MP4_OK )

			return KErrorCode;

		MPASSERT( videoPos == 0 && (iAudioType == 0 || audioPos == 0) );		

	}

	else 

	{

		// close & open library to make sure old data is flushed

		error = MP4ParseClose(iMP4Handle);

		if ( error != MP4_OK )

			return KErrorCode;

		error = MP4ParseOpen(&iMP4Handle, 0);

		if ( error != MP4_OK )

			return KErrorCode;                    

	}

	iBytesRead = 0;

	iNextFrameType = EFrameTypeNone;

	iNextFrameLength = 0;

	return KErrNone;

}

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

// CMP4Parser::ParseHeaderL

// Get relevant stream parameters by calling mp4 library functions

// (other items were commented in a header).

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

//

TInt CMP4Parser::ParseHeaderL(CParser::TStreamParameters& aStreamParameters)

{

    PRINT((_L("CMP4Parser::ParseHeaderL() begin")));

	MP4Err error;

	mp4_double frameRate = 0;    

	TBool hasVideo = ETrue;

	// Reset channel info

	aStreamParameters.iHaveVideo = EFalse;

	aStreamParameters.iHaveAudio = EFalse;

	aStreamParameters.iNumDemuxChannels = 0;

	aStreamParameters.iFileFormat = EFileFormatUnrecognized;

	aStreamParameters.iVideoFormat = EVideoFormatNone;

	aStreamParameters.iAudioFormat = EAudioFormatNone;

	aStreamParameters.iVideoLength = 0;

	aStreamParameters.iAudioLength = 0;

	aStreamParameters.iStreamLength = 0;

	aStreamParameters.iAudioFramesInSample = 0;

	aStreamParameters.iVideoPicturePeriodNsec = 0;

	aStreamParameters.iCanSeek = EFalse;

	aStreamParameters.iFrameRate=0;

	aStreamParameters.iVideoTimeScale=0; 

	aStreamParameters.iAudioTimeScale=0; 

	iAudioType = 0;

	iVideoType = 0;

	iNumberOfFrames=0;

	// get video description

	error = MP4ParseRequestVideoDescription(iMP4Handle, (mp4_u32 *)&aStreamParameters.iVideoLength,

		&frameRate, &iVideoType, (mp4_u32 *)&aStreamParameters.iVideoWidth, 

		(mp4_u32 *)&aStreamParameters.iVideoHeight, (mp4_u32 *)&aStreamParameters.iVideoTimeScale);

	if ( error == MP4_NOT_AVAILABLE )

		User::Leave(KErrorCode);

	else if ( error == MP4_INVALID_INPUT_STREAM )

		User::Leave(KErrCorrupt);

	else if ( error == MP4_NO_VIDEO )  

	{

		hasVideo = EFalse;

		aStreamParameters.iVideoWidth = aStreamParameters.iVideoHeight = 0;

	}

	else if ( error != MP4_OK )

		User::Leave(KErrorCode);

    else

    {

        MPASSERT(error == MP4_OK);

    }

	// get audio description. ask also for averagebitrate to get error if the track is empty; the information is needed later on

    mp4_u32 averagebitrate = 0;

	error = MP4ParseRequestAudioDescription(iMP4Handle, (mp4_u32 *)&aStreamParameters.iAudioLength, 

		&iAudioType, (mp4_u8*)&aStreamParameters.iAudioFramesInSample, (mp4_u32 *)&aStreamParameters.iAudioTimeScale, &averagebitrate );

    if ( (error == MP4_ERROR) && ((iAudioType == MP4_TYPE_MPEG4_AUDIO) || (iAudioType == MP4_TYPE_AMR_NB) || (iAudioType == MP4_TYPE_AMR_WB)))

        {

        // a special case: there may be audio track but it is empty; if type was recognized, mark as no audio

        PRINT((_L("CMP4Parser::ParseHeaderL() problems with getting audio description, mark no audio since audio type was recognized")));

        iAudioType = MP4_NO_AUDIO;

        error = MP4_NO_AUDIO;

        }

	if(error == MP4_NOT_AVAILABLE)     

		User::Leave(EParserNotEnoughData);        

	else if ( error == MP4_INVALID_INPUT_STREAM )

		User::Leave(KErrCorrupt);

	else if ( error != MP4_NO_AUDIO && error != MP4_OK )

		User::Leave(KErrorCode);

    else

    {

        MPASSERT(error == MP4_OK || error == MP4_NO_AUDIO);

    }

    // store the sample size for sanity checking purposes

    iMaxAMRSampleSize = KVedMaxAMRFrameSize * aStreamParameters.iAudioFramesInSample;

	if (aStreamParameters.iVideoLength > 0)