// 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:

//

#include <c3gplibrary.h>

/**

Creates an instance of a 3GP Parser for reading 3GP/3G2/MP4 data using default buffer size.

The default value for read buffer size is 8k. 

@return A pointer to the newly created 3gp parse object. 

@leave	KErrNoMemory	Out of memory.

*/

EXPORT_C C3GPParse* C3GPParse::NewL()

	{

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

	return self;

	}

/**

Creates an instance of a 3GP Parser for reading 3GP/3G2/MP4 data, and sets the 

internal file read buffer size.  

@param	aReadBufferSize	Size of file read buffer.

@return A pointer to the newly created 3gp parse object. 

@leave	KErrNoMemory	Out of memory.

@leave	KErrGeneral		General error.

@panic	C3GPParse	KErrArgument	if size of file read buffer is not greater than 0.

*/

EXPORT_C C3GPParse* C3GPParse::NewL(TInt aReadBufferSize)

	{

	__ASSERT_ALWAYS((aReadBufferSize > 0), Panic(KErrArgument));

	C3GPParse* self = new (ELeave) C3GPParse(aReadBufferSize);

	return self;

	}

// First phase constructor

C3GPParse::C3GPParse(TInt aReadBufferSize) : 

		iReadBufferSize(aReadBufferSize),

		iDuplicateFileHandleCreated(EFalse),

		iVideoType(E3GPNoVideo),

		iAudioType(E3GPNoAudio)

	{

	}

/**

This function initialises the 3GP Parser for reading 3GP/3G2/MP4 data from a buffer and expects data 

to be inserted through subsequent calls to C3GPParse::InsertData.  

@see C3GPParse::InsertData

@return	KErrNone 		if successful. Otherwise, returns one of the system wide error codes.

		KErrGeneral		if an error has no specific categorisation;

		KErrNoMemory	if an attempt to allocate memory has failed;

		KErrInUse		if the parser is currently engaged; C3GPParse::Complete must be called to 

						finish the parsing activities before the parser can be re-initialised again.

*/	

EXPORT_C TInt C3GPParse::Open()

	{

	if (iHandler)

		{

		return KErrInUse;

		}

	return SymbianOSError(MP4ParseOpen(&iHandler, NULL));

	}

/**

This function initialises the 3GP Parser for reading 3GP/3G2/MP4 data from a file.

@param	aFilename	A full path name of the file containing the data. 

@return	KErrNone 		if successful.  Otherwise, returns one of the system wide error codes.

		KErrGeneral		if an error has no specific categorisation;

		KErrNoMemory	if an attempt to allocate memory has failed;

		KErrAccessDenied	if opening file has failed;

		KErrUnderflow	if the file name length is not greater than 0;

		KErrInUse		if the parser is currently engaged;  C3GPParse::Complete must be called to 

						finish the parsing activities before the parser can be re-initialised again.

*/	

EXPORT_C TInt C3GPParse::Open(const TDesC& aFilename)

	{

	if (iHandler)

		{

		return KErrInUse;

		}

	if (aFilename.Length() <= 0)

		{

		return KErrUnderflow;

		}

	// Create a zero terminated version of the file name

	RBuf fileName;	

	TInt err = fileName.Create(aFilename.Length() + 1);

	if (err == KErrNone)

		{

		fileName.Copy(aFilename);

		mp4_u16* mp4FileName = const_cast<mp4_u16*>(fileName.PtrZ());

		MP4Err mp4Err = MP4ParseOpen(&iHandler, reinterpret_cast<MP4FileName>(mp4FileName));

		if (mp4Err == MP4_OK)

			{

			// Set composing related values to 0.

			mp4Err = MP4SetCustomFileBufferSizes(iHandler, 0, 0, iReadBufferSize);

			if (mp4Err != MP4_OK)

				{

				// Ignore the error

				Complete();

				}

			}

		err = SymbianOSError(mp4Err);

		}

	fileName.Close();

	return err;

	}

/**

This function initialises the 3GP Parser for reading 3GP/3G2/MP4 data from a file.

@param  aFile   File handle of the file containing the data.  It is expected to be a valid file handle, 

                opened and will be closed outside of the library.

@return KErrNone        if successful.  Otherwise, returns one of the system wide error codes.

        KErrNoMemory    if an attempt to allocate memory has failed;

        KErrInUse       if the parser is currently engaged;  C3GPParse::Complete must be called to 

                        finish the parsing activities before the parser can be re-initialised again.

*/

EXPORT_C TInt C3GPParse::Open(const RFile& aFile)

	{

	TInt err = KErrNone;

	if (!iDuplicateFileHandleCreated)

		{

		iDuplicateFileHandleCreated = ETrue;

		iFile.Close();

		err = iFile.Duplicate(aFile);

		if (err != KErrNone)

			{

			return err;

			}

		}

	return Open(iFile);

	}

/**

This function initialises the 3GP Parser for reading 3GP/3G2/MP4 data from a file.

@param	aFile	File handle of the file containing the data.  It is expected to be a valid file handle, 

				opened and will be closed outside of the library.

@return	KErrNone 		if successful.  Otherwise, returns one of the system wide error codes.

		KErrNoMemory	if an attempt to allocate memory has failed;

		KErrInUse		if the parser is currently engaged;  C3GPParse::Complete must be called to 

						finish the parsing activities before the parser can be re-initialised again.

*/

EXPORT_C TInt C3GPParse::Open(const RFile64& aFile)

	{

	if (iHandler)

		{

		return KErrInUse;

		}

	const RFile64* file = &aFile;

	MP4Err mp4Err = MP4ParseOpenFileHandle64(&iHandler, (const_cast<RFile64*>(file)));

	if (mp4Err == MP4_OK)

		{

		// Set composing related values to 0.

		mp4Err = MP4SetCustomFileBufferSizes(iHandler, 0, 0, iReadBufferSize);

		if (mp4Err != MP4_OK)

			{

			// Ignore the error

			Complete();

			}

		}

	return SymbianOSError(mp4Err);

	}

/**

This function initialises the 3GP Parser for reading 3GP/3G2/MP4 data from a CAF object.

@param	aData	A CData object pointing to a CAF object.  It is expected to be opened and will be 

				closed outside of the library.

@return	KErrNone 		if successful.  Otherwise, returns one of the system wide error codes.

		KErrNoMemory	if an attempt to allocate memory has failed;

		KErrInUse		if the parser is currently engaged;  C3GPParse::Complete must be called to 

						finish the parsing activities before the parser can be re-initialised again.

*/

EXPORT_C TInt C3GPParse::Open(const ContentAccess::CData& aData)

	{

	if (iHandler)

		{

		return KErrInUse;

		}

	MP4Err mp4Err = MP4ParseOpenCAF(&iHandler, const_cast<ContentAccess::CData*>(&aData));

	if (mp4Err  == MP4_OK)

		{

		// Set composing related values to 0.

		mp4Err = MP4SetCustomFileBufferSizes(iHandler, 0, 0, iReadBufferSize);

		if (mp4Err != MP4_OK)

			{

			// Ignore the error

			Complete();

			}

		}

	return SymbianOSError(mp4Err);

	}

/**

Destructor. Deletes all objects.

*/

EXPORT_C C3GPParse::~C3GPParse()

	{

	Complete(); // Ignore the error

	}

/**

This function completes the parsing operation.

If C3GPParse::Complete is called before the parse is initialised, it will be ignored and KErrNone is 

returned.

The parser can be reused again after this call, following another call to C3GPParse::Open to 

re-initialise the parser. 

@return	KErrNone 		if successful.  Otherwise, returns one of the system wide error codes.

		KErrGeneral		if an error has no specific categorisation;

*/

EXPORT_C TInt C3GPParse::Complete()

	{

	MP4Err mp4Err = MP4_OK;

	if (iHandler)

		{

		mp4Err = MP4ParseClose(iHandler);

		}

	if (iAsyncReadBuffer)

		{

		CancelReadFrame();

		}

	// Always reset the class member data even MP4ParseClose returns error

	Reset();

	return SymbianOSError(mp4Err);

	}

// Helper function to reset class member data.

void C3GPParse::Reset()

	{

	iVideoType = E3GPNoVideo;

	iAudioType = E3GPNoAudio;

	iAsyncReadBuffer = NULL;

	iCallback = NULL; // Parse doesn't own the callback. Set it to NULL.

	iAudioAvgBitRate = 0;

	iStreamAvgBitRate = 0;

	iVideoPropertiesSaved = EFalse;

	iAudioPropertiesSaved = EFalse;

	iStreamPropertiesSaved = EFalse;

	iVideoError = KErrNone;

	iAudioError = KErrNone;

	iStreamError = KErrNone;

	iHandler = NULL;

	iDuplicateFileHandleCreated = EFalse;

	iFile.Close();

	}

/**

This function inserts MP4/3GP/3G2 data into the parser.

It is only necessary to call this function if no parameter has been supplied when 

C3GPParse::Open is called.  Several functions can return KErr3gpLibMoreDataRequired if the library 

does not have enough data to return the information that the caller requests. In this case, more data 

needs to be inserted to the library before calling those functions again.

This function makes a copy of the data inserted into the library so the caller can use the input buffer 

for other purposes. If the function returns KErrNoMemory, the buffer contents have not been copied into 

the library and the caller needs to reduce the buffer content before calling again.

If an empty string is supplied for the argument aBuffer, it indicates that there is be no more data 

to feed through this function.  Such a function call must be done to indicate that all 3GP/MP4/3G2 

data has been written to the library's internal memory.

@param	aBuffer	The descriptor containing the data to be inserted.

@return	KErrNone 		if successful.  Otherwise, returns one of the system wide error codes.

		KErrGeneral		if an error has no specific categorisation;

		KErrNoMemory	if parser cannot allocate enough memory for the data;

		KErrNotReady	if the parser has not yet been initialised; See C3GPParse::Open.

*/

EXPORT_C TInt C3GPParse::InsertData(const TDesC8& aBuffer)

	{

	if (!iHandler)

		{

		return KErrNotReady;

		}

	return SymbianOSError(MP4ParseWriteData(iHandler, const_cast<mp4_u8*>(aBuffer.Ptr()), aBuffer.Length()));

	}

/**

This function returns the parameters describing the video stream. 

If no file or CAF object is supplied during parser initialisation, this should be called after 

enough data has been inserted into the library buffers so that the 3GP headers containing the 

information can be read.

The aFrameRate parameter refers to the frame rate of the original video material.

@param	aType			The type of video stream.  Refer to T3GPVideoType for supported video type.

@param	aLength			Duration of video in milliseconds.

@param	aFrameRate		Average frame rate of video (in Hz).

@param	aAvgBitRate		Average bit rate of video.

@param	aSize			Width and height of video image measured in pixels.

@param	aTimeScale		Timescale of video track.  

@return	KErrNone 			if successful.  Otherwise, returns one of the system wide error codes.

		KErrGeneral			if an error has no specific categorisation;

		KErrNotSupported	if the input does not contain video;

		KErrCorrupt			if 3GP stream is invalid;

		KErrNotReady		if the parser has not yet been initialised; See C3GPParse::Open;

		KErr3gpLibMoreDataRequired	if more data is required before the requested information can be 

							retrieved;  See C3GPParse::InsertData.

*/

EXPORT_C TInt C3GPParse::GetVideoProperties(T3GPVideoType& aType, TUint& aLength, TReal& aFrameRate, 

		TUint& aAvgBitRate, TSize& aSize, TUint& aTimeScale) const

	{

	if (!iHandler)

		{

		return KErrNotReady;

		}

	TInt err = DoGetVideoProperties();

	if (err == KErrNone)

		{

		aLength = iVideoLength;

		aType = iVideoType;

		aFrameRate = iVideoFrameRate;

		aSize.iWidth = iVideoSize.iWidth;

		aSize.iHeight = iVideoSize.iHeight;

		aTimeScale = iVideoTimeScale;

		}

	else 

		{

		return err;

		}

	// Get average bit rate of the stream in bps

	err = DoGetStreamProperties();

	if (err != KErrNone)

		{

		return err;

		}

	// Video average bit rate is calculated from GetStreamDescription’s aAvgBitRate substructs Audio’s aAvgBitRate

	// GetAudioProperties has not been called

	err = DoGetAudioProperties();

	if (err == KErrNone)

		{

		aAvgBitRate = iStreamAvgBitRate - iAudioAvgBitRate;

		}

	else

		{

		// if the audio stream is not usable, ignore the error since the stream

		// in concern is video stream.  The audio stream error can be dealt with by

		// users when it asks for audio properties. 

		aAvgBitRate = iStreamAvgBitRate;

		}

	return KErrNone;

	}

/**

This function returns the parameters describing the audio stream. 

If no file or CAF object is supplied during parser initialisation, this should be called after 

enough data has been inserted into the library so that the 3GP headers containing the information 

can be read.

@param	aType		The type of audio stream.  Refer to T3GPFrameType for supported audio type values.

@param	aLength		Duration of audio in milliseconds.

@param	aFramesPerSample	Number of audio frames in each sample.

@param	aAvgBitRate	Average bit rate of audio.

@param	aTimeScale	Timescale of audio track. 

@return	KErrNone 		if successful.  Otherwise, returns one of the system wide error codes.

		KErrGeneral		if an error has no specific categorisation;

		KErrNotSupported	if input does not contain audio;

		KErrCorrupt		if 3GP stream is invalid;

		KErrNotReady	if the parser has not yet been initialised; See C3GPParse::Open;

		KErr3gpLibMoreDataRequired	if more data is required before the requested information can be 

						retrieved.  See C3GPParse::InsertData.

*/

EXPORT_C TInt C3GPParse::GetAudioProperties(T3GPAudioType& aType, TUint& aLength, TInt& aFramesPerSample, 

		TUint& aAvgBitRate, TUint& aTimeScale) const

	{

	if (!iHandler)

		{

		return KErrNotReady;

		}

	TInt err = DoGetAudioProperties();

	if (err == KErrNone)

		{

		aLength = iAudioLength;

		aType = iAudioType;

		aFramesPerSample = iAudioFramesPerSample;

		aAvgBitRate = iAudioAvgBitRate;

		aTimeScale = iAudioTimeScale;

		iAudioPropertiesSaved = ETrue;

		}

	return err;

	}

/**

This function returns the parameters that describe the contents of the input file or buffer. 

If no file or CAF object is supplied during parser initialisation, this should be called after 

enough data has been inserted into the library so that the headers containing the information can 

be read.

@param	aSize		Length of the stream in bytes.

@param	aAvgBitRate	Average bit rate of the stream in bps.

@return	KErrNone 		if successful.  Otherwise, returns one of the system wide error codes.

		KErrGeneral		if an error has no specific categorisation;

		KErrCorrupt		if 3GP stream is invalid;

		KErrNotReady	if the parser has not yet been initialised; See C3GPParse::Open;

		KErr3gpLibMoreDataRequired	if more data is required before the requested information can be 

						retrieved.  See C3GPParse::InsertData.

 */

EXPORT_C TInt C3GPParse::GetContainerProperties(TUint& aSize, TUint& aAvgBitRate) const

	{

	if (!iHandler)

		{

		return KErrNotReady;

		}

	TInt err = DoGetStreamProperties();

	if (err == KErrNone)

		{

		aSize = iStreamSize;

		aAvgBitRate = iStreamAvgBitRate;

		}

	return err;

	}

/**

This function returns the number of bytes that the library instance has in its allocated buffers.

The function is only valid when the parser is initialized without any parameters. Zero is 

returned when in file mode, that is, the parser has been initialized with a valid filename, file handle 

or a CAF object.

@see C3GPParse::InsertData.

@param	aNum	Number of allocated bytes in the library.

@return	KErrNone 		if successful.  Otherwise, returns one of the system wide error codes.

		KErrGeneral		if an error has no specific categorisation;

		KErrNotSupported	if the parser has been initialised with a file name or file handle;

		KErrNotReady	if the parser has not yet been initialised; See C3GPParse::Open.

*/

EXPORT_C TInt C3GPParse::GetNumBufferedBytes(TInt& aNum) const

	{

	if (!iHandler)

		{

		return KErrNotReady;

		}

	mp4_u32 numBytes = 0;

	MP4Err mp4Err = MP4ParseGetBufferedBytes(iHandler, &numBytes);

	aNum = numBytes;

	return SymbianOSError(mp4Err);

	}

/**

This function returns the type of the next audio/video frame in the stream.

This function has no effect on the parser’s current position.

@param	aType	Type of the next frame.  Refer to the definition of T3GPFrameType for all possible values.

@return	KErrNone 		if successful.  Otherwise, returns one of the system wide error codes.

		KErrGeneral		if an error has no specific categorisation;

		KErrNotFound	if frame does not exist (the previous frame was the last one);

		KErrNotReady	if the parser has not yet been initialised; See C3GPParse::Open;

		KErrCorrupt		if 3GP stream is invalid;

		KErr3gpLibMoreDataRequired		if 3GP library needs more data before the requested 

						information can be returned.

*/

EXPORT_C TInt C3GPParse::GetFrameType(T3GPFrameType& aType) const

	{

	if (!iHandler)

		{

		return KErrNotReady;

		}

	mp4_u32 frameType = 0;

	MP4Err mp4Err = MP4ParseNextFrameType(iHandler, &frameType);

	if (mp4Err == MP4_OK)

		{

		if (

		        frameType == MP4_TYPE_MPEG4_VIDEO ||

		        frameType == MP4_TYPE_H263_PROFILE_0 || 

		        frameType == MP4_TYPE_H263_PROFILE_3 ||