// 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 <e32debug.h>

#include <c3gplibrary.h>

#if defined (COMPOSE_DEBUG)

#define DEBUG_PRINT RDebug::Print

#else

#define DEBUG_PRINT

#endif

const TInt KMinWriteBufferMaxCount = 6;

_LIT(K3GPComposePanicName, "C3GPCompose");

// This is video base class containing common video properties.

T3GPVideoPropertiesBase::T3GPVideoPropertiesBase(T3GPVideoType aType,

		TUint aTimescale, const TSize& aSize) :

		iType(aType), iTimescale(aTimescale), iSize(aSize)

	{

	}

/**

This structure stores the common and MPEG-4 video specific properties of video data.

@param	aTimescale				Timescale of the video data.  This is the number of time units that 

 								pass in one second.

@param	aSize					Video width and height in pixels.

@param	aMaxBitRate 			Maximum video bit rate.

@param	aAvgBitRate				Average video bit rate.

@param	aDecoderSpecificInfo	MPEG-4 video DecoderSpecificInfo data stored in an ESDS atom.

*/

EXPORT_C T3GPVideoPropertiesMpeg4Video::T3GPVideoPropertiesMpeg4Video(TUint aTimescale,

		const TSize& aSize, TUint aMaxBitRate, TUint aAvgBitRate, const TDesC8& aDecoderSpecificInfo) :

		T3GPVideoPropertiesBase(E3GPMpeg4Video, aTimescale, aSize),

		iMaxBitRate(aMaxBitRate),

		iAvgBitRate(aAvgBitRate),

		iDecoderSpecificInfo(aDecoderSpecificInfo)

	{

	}

/**

This structure stores the common and H.263 specific properties of video data.

@param	aTimescale	Timescale of the video data.  This is the number of time units that 

					pass in one second.

@param	aSize		Video width and height in pixels.

@param	aVideoLevel	Indicates the H263 video level.

@param	aProfile	Indicates the H263 profile.

*/

EXPORT_C T3GPVideoPropertiesH263::T3GPVideoPropertiesH263(TUint aTimescale, const TSize& aSize,

		TInt aVideoLevel, TProfile aProfile) :

T3GPVideoPropertiesBase((aProfile == EProfile0) ? E3GPH263Profile0 : E3GPH263Profile3,

		aTimescale, aSize), iVideoLevel(aVideoLevel)

	{

	}

/**

This structure stores the common and AVC specific properties of video data.

@param	aTimescale				Timescale of the video data.  This is the number of time units that 

								pass in one second.

@param	aSize					Video width and height in pixels.

@param	aDecoderSpecificInfo	AVCDecoderConfigurationRecord data that will be stored in the avcC atom.

*/

EXPORT_C T3GPVideoPropertiesAvc::T3GPVideoPropertiesAvc(TUint aTimescale, const TSize& aSize,

		const TDesC8& aDecoderSpecificInfo) :

T3GPVideoPropertiesBase(E3GPAvcProfileBaseline, aTimescale, aSize),

iDecoderSpecificInfo(aDecoderSpecificInfo)

	{

	/*

		NOTE: Although Baseline profile is being set here, it's just used to indicate

		the fact that we have AVC data. The underlying 3GP lib does not differentiate

		between profiles when composing a file. It simply writes the contents of

		iDecoderSpecificInfo (which contains the profile amongst other things)

		verbatim into the "avcC" box.

	*/

	}

// This is audio base class containing common audio properties.

T3GPAudioPropertiesBase::T3GPAudioPropertiesBase(T3GPAudioType aType,

		TUint aTimescale, TInt aFramesPerSample) :

		iType(aType), iTimescale(aTimescale), iFramesPerSample(aFramesPerSample)

	{

	__ASSERT_ALWAYS((aTimescale > 0) && (aTimescale <= KMaxTUint16), User::Panic(K3GPComposePanicName, KErrOverflow));		

	}

/**

This structure stores the common and MPEG-4 audio-specific properties of audio data.

@param	aTimescale			Timescale of the audio data.  This is the number of time units that pass in one 

 							second. It must be smaller than 65536.

@param	aDecoderSpecificInfo MPEG-4 audio DecoderSpecificInfo data stored in an ESDS atom.

*/

EXPORT_C T3GPAudioPropertiesMpeg4Audio::T3GPAudioPropertiesMpeg4Audio(TUint aTimescale,

		const TDesC8& aDecoderSpecificInfo) :

		T3GPAudioPropertiesBase(E3GPMpeg4Audio, aTimescale, 0), 

		iDecoderSpecificInfo(aDecoderSpecificInfo)

	{

	}

/**

This structure stores the common and AMR-specific properties of audio data. 

@param	aTimescale			Timescale of the audio data.  This is the number of time units that pass in one 

 							second. It must be smaller than 65536.

@param	aFramesPerSample	Frames per sample.  It must be smaller than 256.

 							MPEG-4 audio has a fixed value of 1.

@param	aModeSet			AMR mode set.

@param	aCodec				AMR Speech Codec.

*/

EXPORT_C T3GPAudioPropertiesAmr::T3GPAudioPropertiesAmr(TUint aTimescale, TInt aFramesPerSample,

		TInt aModeSet, TSpeechCodec aCodec) :

		T3GPAudioPropertiesBase((aCodec == EAmrNB) ? E3GPAmrNB : E3GPAmrWB, 

		aTimescale, aFramesPerSample), iModeSet(aModeSet)

	{	

	__ASSERT_ALWAYS((aFramesPerSample > 0) && (aFramesPerSample <= KMaxTUint8), 

					User::Panic(K3GPComposePanicName, KErrOverflow));	

	}

/**

This structure stores the common and QCELP-specific properties of MPEG4 audio data. The storage mode is 

automatically set to MPEG4 Audio Sample Description Box mode.

@param	aTimescale			Timescale of the audio data.  This is the number of time units that pass in one 

 							second. It must be smaller than 65536.

@param	aFramesPerSample	Frames per sample.  It must be smaller than 512.

 							MPEG-4 audio has a fixed value of 1.

@param	aDecoderSpecificInfo MPEG-4 audio decoder specific information data stored in an ESDS atom.

*/

EXPORT_C T3GPAudioPropertiesQcelp::T3GPAudioPropertiesQcelp(TUint aTimescale, TInt aFramesPerSample,

		const TDesC8& aDecoderSpecificInfo) :

		T3GPAudioPropertiesBase(E3GPQcelp13K, aTimescale, aFramesPerSample),

		iMode(E3GPMP4AudioDescriptionBox),

		iDecoderSpecificInfo(aDecoderSpecificInfo)

	{

	__ASSERT_ALWAYS((aFramesPerSample > 0) && (aFramesPerSample <= KMaxTUint8), 

					User::Panic(K3GPComposePanicName, KErrOverflow));		

	}

/**

This structure stores the common and QCELP-specific properties of audio data.  

@param	aTimescale			Timescale of the audio data.  This is the number of time units that pass in one 

 							second. It must be smaller than 65536.

@param	aFramesPerSample	Frames per sample.  It must be smaller than 512.

 							MPEG-4 audio has a fixed value of 1.

*/

EXPORT_C T3GPAudioPropertiesQcelp::T3GPAudioPropertiesQcelp(TUint aTimescale, TInt aFramesPerSample) :

		T3GPAudioPropertiesBase(E3GPQcelp13K, aTimescale, aFramesPerSample),

		iMode(E3GPQcelpSampleEntryBox),

		iDecoderSpecificInfo(KNullDesC8)

	{

	__ASSERT_ALWAYS((aFramesPerSample > 0) && (aFramesPerSample <= KMaxTUint8), 

					User::Panic(K3GPComposePanicName, KErrOverflow));		

	}

/** 

Create an instance of 3GP composer using default buffer count and size.

The default values for buffer count and size are as follow:

Write Buffer Size is 2048 

Write Buffer Max Count is 15

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

@leave	KErrGeneral		General error.

@leave	KErrNoMemory	Out of memory.

@panic	C3GPCompose	KErrAbort	if clients do not a CActiveScheduler installed already.

*/

EXPORT_C C3GPCompose* C3GPCompose::NewL()

	{

	// Leave if no scheduler exists

	__ASSERT_ALWAYS ((CActiveScheduler::Current() != NULL), Panic(KErrAbort));

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

	return self;

	}

/** 

Create an instance of 3GP composer, and let the user set a count limit and size of 

internal buffer for composition.

The default values for buffer count and size are as follow:

 Write Buffer Size is 2048 

 Write Buffer Max Count is 15

An increase of the buffer count and size will lead to a decrease of file I/O activities, thereby, 

improves the performance of the 3GP Composer at the expense of higher memory usage.

@param	aMediaWriteBufferSize Size of media data file output buffer (in bytes).

@param	aWriteBufferMaxCount	Maximum number of buffers (both media and meta) allowed before file 

 								output changes to synchronous (by default file writing is asynchronous 

 								operation).  A minimum value of 6 is enforced.

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

@leave	KErrGeneral		General error.

@leave	KErrNoMemory	Out of memory.

@panic	C3GPCompose	KErrAbort	if clients do not a CActiveScheduler installed already.

@panic	C3GPCompose	KErrArgument	if Write Buffer Size is less or equal to 0 or Write Buffer Max Count is

									less than 6.

 */

EXPORT_C C3GPCompose* C3GPCompose::NewL(TInt aMediaWriteBufferSize, TInt aWriteBufferMaxCount)

	{

	__ASSERT_ALWAYS ((aMediaWriteBufferSize > 0 && aWriteBufferMaxCount >= KMinWriteBufferMaxCount), 

					Panic(KErrArgument));

	// Leave if no scheduler exists

	__ASSERT_ALWAYS ((CActiveScheduler::Current() != NULL), Panic(KErrAbort));

	C3GPCompose* self = new (ELeave) C3GPCompose(aMediaWriteBufferSize, aWriteBufferMaxCount);

	return self;

	}

// First phase constructor

C3GPCompose::C3GPCompose(TInt aMediaWriteBufferSize, TInt aWriteBufferMaxCount) :

		iMediaWriteBufferSize(aMediaWriteBufferSize), 

		iWriteBufferMaxCount(aWriteBufferMaxCount),

		iDuplicateFileHandleCreated(EFalse)

	{

	}

/** 

This function initialises the 3GP composer for writing 3GP/3G2/MP4 data into a file.

Any combination of one video and one audio type is acceptable.  

Note: Ownership of aVideo and aAudio remains with the caller.  Both aVideo and aAudio are ready for 

deletion after C3GPCompose::Open returns.

@param	aFileFormat	Specifies the file format in which the data will be created.  Refer to 

 					T3GPFileFormatType for supported file format types.

@param 	aVideo 		Specifies the video stream to be used for video data.  The input data given will 

 					be inserted into 3GP file headers and is ready to be disposed when 

 					C3GPCompose::Open returns. See Video Properties Classes.

 					If aVideo is NULL, audio-only file will be composed.

@param 	aAudio 		Specifies the audio stream to be used for audio data.  The input data given will 

 					be inserted into 3GP file headers and is ready to be disposed when 

 					C3GPCompose::Open returns. See Audio Properties Classes.

 					If aAudio is NULL, video-only file will be composed.

@param	aFilename  	A full path name of the file to save the data to.  An empty path is not allowed.

@param	aFlags		Optional flags for composing preferences.  Refer to T3GPComposeFlag for supported flags.

 					The combined use of flags is acceptable.  For example:

 					E3GPLongClip | E3GPMetaDataLast 

@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;

  		KErrArgument	if neither video nor audio stream is specified;  

  		KErrAccessDenied	if opening file has failed;

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

  		KErrInUse		if the composer is currently engaged; C3GPCompose::Complete must be called to 

  		 		 		finish the current composition before the composer can be re-initialised again.

*/

EXPORT_C TInt C3GPCompose::Open(T3GPFileFormatType aFileFormat,

		const T3GPVideoPropertiesBase* aVideo,

		const T3GPAudioPropertiesBase* aAudio,

		const TDesC& aFilename,

		TUint aFlags)

	{

	if (iHandler)

		{

		return KErrInUse;

		}

	if (aFilename.Length() <= 0)

		{

		return KErrUnderflow;

		}

	if (!aVideo && !aAudio)

		{

		// if neither video nor audio is supplied

		return KErrArgument;

		}

	// 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 = MP4ComposeOpen(&iHandler, reinterpret_cast<MP4FileName>(mp4FileName), Mp4Type(aVideo, aAudio));

		if (mp4Err == MP4_OK)

			{

			// Write audio and video properties to the 3GP file 

			err = SetComposeProperties(aVideo, aAudio, aFileFormat, aFlags);

			if (err != KErrNone)

				{

				Complete(); // Ingore the error

				}

			}

		else

			{

			err = SymbianOSError(mp4Err);

			}

		}

	fileName.Close();

	return err;

	}

/**

This function initialises the 3GP composer for writing 3GP/3G2/MP4 data into a file.

Any combination of one video and one audio type is acceptable.  

Note: E3GPMetaDataLast will be defaulted in aFlags if file handle is used for the initialisation 

of the 3GP composer.

Note: Ownership of aVideo and aAudio remains with the caller.  Both aVideo and aAudio are ready for 

deletion after C3GPCompose::Open returns.

@param  aFileFormat Specifies the file format in which the data will be created.  Refer to 

                    T3GPFileFormatType for supported file format types.

@param  aVideo      Specifies the video stream to be used for video data.  The input data given will 

                    be inserted into 3GP file headers and is ready to be disposed when 

                    C3GPCompose::Open returns. See Video Properties Classes.

                    If aVideo is NULL, audio-only file will be composed.

@param  aAudio      Specifies the audio stream to be used for audio data.  The input data given will 

                    be inserted into 3GP file headers and is ready to be disposed when 

                    C3GPCompose::Open returns. See Audio Properties Classes.

                    If aAudio is NULL, video-only file will be composed.

@param  aFile       File handle of the file to save the data to.  E3GPMetaDataLast needs to be set for 

                    aFlags when this is used.

@param  aFlags      Optional flags for composing preferences.  Refer to T3GPComposeFlag for supported flags.

                    The combined use of flags is acceptable.  For example:

                    E3GPLongClip | E3GPMetaDataLast 

@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;

        KErrArgument    if neither video nor audio stream is specified;         

        KErrAccessDenied    if opening file has failed;

        KErrInUse   if the composer is currently engaged; C3GPCompose::Complete must be called to 

                        finish the current composition before the composer can be re-initialised again.

*/

EXPORT_C TInt C3GPCompose::Open(T3GPFileFormatType aFileFormat,

		const T3GPVideoPropertiesBase* aVideo,

		const T3GPAudioPropertiesBase* aAudio,

		RFile& aFile,

		TUint aFlags)

	{

	TInt err = KErrNone;

	if (!iDuplicateFileHandleCreated)

		{

		iDuplicateFileHandleCreated = ETrue;

		iFile.Close();

		err = iFile.Duplicate(aFile);

		if (err != KErrNone)

			{

			return err;

			}

		}

	return Open(aFileFormat, aVideo, aAudio, iFile, aFlags);

	}

/**

This function initialises the 3GP composer for writing 3GP/3G2/MP4 data into a file.

Any combination of one video and one audio type is acceptable.  

Note: E3GPMetaDataLast will be defaulted in aFlags if file handle is used for the initialisation 

of the 3GP composer.

Note: Ownership of aVideo and aAudio remains with the caller.  Both aVideo and aAudio are ready for 

deletion after C3GPCompose::Open returns.

@param	aFileFormat Specifies the file format in which the data will be created.  Refer to 

 					T3GPFileFormatType for supported file format types.

@param 	aVideo 		Specifies the video stream to be used for video data.  The input data given will 

 					be inserted into 3GP file headers and is ready to be disposed when 

 					C3GPCompose::Open returns. See Video Properties Classes.

 					If aVideo is NULL, audio-only file will be composed.

@param 	aAudio 		Specifies the audio stream to be used for audio data.  The input data given will 

 					be inserted into 3GP file headers and is ready to be disposed when 

 					C3GPCompose::Open returns. See Audio Properties Classes.

 					If aAudio is NULL, video-only file will be composed.

@param	aFile  		File handle of the file to save the data to.  E3GPMetaDataLast needs to be set for 

 					aFlags when this is used.

@param	aFlags  	Optional flags for composing preferences.  Refer to T3GPComposeFlag for supported flags.

 					The combined use of flags is acceptable.  For example:

 					E3GPLongClip | E3GPMetaDataLast 

@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;

  		KErrArgument	if neither video nor audio stream is specified;    		

  		KErrAccessDenied	if opening file has failed;

  		KErrInUse	if the composer is currently engaged; C3GPCompose::Complete must be called to 

  		 		 		finish the current composition before the composer can be re-initialised again.

*/

EXPORT_C TInt C3GPCompose::Open(T3GPFileFormatType aFileFormat,

		const T3GPVideoPropertiesBase* aVideo,

		const T3GPAudioPropertiesBase* aAudio,

		RFile64& aFile,

		TUint aFlags)

	{

	if (iHandler)

		{

		return KErrInUse;

		}

	if (!aVideo && !aAudio)

		{

		// if neither video nor audio is supplied

		return KErrArgument;

		}

	TInt driveNumber = EDriveA;

	TDriveInfo driveInfo;

	TInt err = aFile.Drive(driveNumber, driveInfo);

	if (err == KErrNone)

		{

		MP4Err mp4Err = MP4ComposeOpenFileHandle64(&iHandler, &aFile, static_cast<TDriveNumber>(driveNumber), Mp4Type(aVideo, aAudio));

		if (mp4Err == MP4_OK)

			{			

			// Write audio and video properties to the 3GP file 

			err = SetComposeProperties(aVideo, aAudio, aFileFormat, aFlags);

			if (err != KErrNone)

				{

				Complete(); // Ingore the error

				}

			}

		else

			{

			err = SymbianOSError(mp4Err);

			}

		}

	return err;

	}

/**

Destructor

Deletes all objects and releases all resource owned by this instance.

*/

EXPORT_C C3GPCompose::~C3GPCompose()

	{

	Complete(); // Ignore the error

	}

/**

This function completes the composing operation. It frees the memory allocated by the library instance 

and closes the output file.

It is necessary to call this function before the output file is guaranteed to be a valid output file 

even though the file may exist prior to the call.

The composer can be reused again after this call, following another call to C3GPCompose::Open to 

re-initialise the composer. 

If C3GPCompose::Complete is called before the composer is initialised, it will be ignored and KErrNone 

is returned.

Although during destruction of C3GPCompose, this function will be automatically called, and no error 

code will be returned.  Therefore, when destroying the Composer object that you have used to compose a 

file, you should ensure that data is committed to the file by invoking C3GPCompose::Complete before 

destroying the Composer object.

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

 		KErrGeneral		if an error has no specific categorisation;

 		KErrWrite		if metadata could not be written.

*/

EXPORT_C TInt C3GPCompose::Complete()

	{

	MP4Err mp4Err = MP4_OK;

	if (iHandler)

		{

		mp4Err = MP4ComposeClose(iHandler);

		}

	// Always reset the class member data even this function returns error

	Reset();

	return SymbianOSError(mp4Err);

	}

// Helper function to reset class member data.

void C3GPCompose::Reset()

	{

	iHasVideo = EFalse;

	iHasAudio = EFalse;

	iHandler = NULL;

	iFile.Close();

	}

/**

This function writes one video frame to the output file or buffer.

The frames must be inserted according to their causal sequence.  Because the library doesn't analyze 

the video bit stream, frames are inserted into the 3GP file in the same order as they are entered 

with this function.  Therefore, the frames will not be retrieved from the resulting 3GP file or 

buffer correctly if they are not in proper order.

A frame inserted with this function call will result in one 3GP sample and one 3GP chunk.

The current frame's dependency information which is using default values (E3GPDependencyUnknown & 

E3GPRedundancyUnknown) is inserted.

The data is available in the output file only after calling C3GPCompose::Complete. C3GPCompose::Complete 

should be called exactly once when all audio and video data has been inserted into the library.

@param	aBuffer		The descriptor containing the video frame data to be written.

@param	aDuration	Duration of video frame in timescale, see T3GPVideoPropertiesBase.

@param	aKeyFrame	ETrue to indicate whether this frame is a key frame.  EFalse otherwise.

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

 		KErrGeneral		if an error has no specific categorisation;

 		KErrNotSupported if the composer is setup for an audio-only file;

 		KErrUnderflow	if the supplied video frame buffer data is empty;

 		KErrNotReady	if the composer has not yet been initialised;  See C3GPCompose::Open.

*/

EXPORT_C TInt C3GPCompose::WriteVideoFrame(const TDesC8& aBuffer, TUint aDuration, TBool aKeyFrame)

	{

	if (!iHandler)

		{

		return KErrNotReady;

		}