/*

* Copyright (c) 2002-2006 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:  3GP file composer

*

*/

// INCLUDE FILES

#include <f32file.h>

#include <mmf/server/mmffile.h>

#include <sysutildomaincrkeys.h>	// for critical disk level CentralRepository keys

#include <3gplibrary/mp4lib.h>

#include "CamC3GPDataSink.h"

#include "CamC3GPDataSinkImp.h"

#include "CCMRMediaSink.h"

#include "CCMRSupportedCodecs.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <sys/unistd.h>

// MACROS

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamC3GPDataSinkImpTraces.h"

#endif

// CONSTANTS

const TUint   KVideoAverageBitRate   = 48000;     // Default average bitrate for video

const TUint   KVideoMaxBitRate       = 64000;     // Default maximum bitrate for video

const TUint   KVideoXResolution      = 176;       // Default width of video

const TUint   KVideoYResolution      = 144;       // Default height of video

const TUint   KVideoBufferSize       = 8192;      // Maximum video frame size

const TUint   KAudioMaxFrameSize     = 32;        // Maximum AMR audio frame size

const TUint   KAudioBufferNumber     = 10;        // Number of audio frames to be buffered

const TUint   KVideoTimeScale        = 30000;     // Video timescale in the output file; use 30000 since it corresponds roughly to ~30 fps.

                                                  // 29970 would be exact for H.263, but it may not be exactly camera's baseframerate. And it may be harder for some players than 30000

                                                  // The most important is now that this value is in the same scale as used in MediaRecorder for Camera API framerate.

                                                  // If that is 15, then this should be 30000. But some other, e.g. 14.985 fps is used there, then it is better to change this one too.

const TUint   KAudioTimeScale        = 8000;      // Audio timescale in the output file, safer to use the same value as sampling rate although makes the times more difficult to understand

const TUint   KAudioFrameDuration    = 8*20;      // AMR frame is 20 ms, but timescale is 8000 => duration is 160 / 8000 s

const TUint8  KAMRAudioFramesPerSample  = 10;     // Number of AMR audio frames per sample in the output file

const TUint8  KAACAudioFramesPerSample  = 1;      // Number of AAC audio frames per sample in the output file

const TUint   KAACDefaultSampleRate  = 16000;     // Default samplerate for AAC that is used as audio track timescale in case we get no audiobuffers, but audio codec is selected.

const TUint16 KAudioModeSet          = 0x81ff;    // AMR modeset: all modes possible

const TUint   KDiskSafetyLimit       = 400000;    // Amount of free disk space to leave unused

const TReal   KMetaDataCoeff         = 1.03;      // Coefficient to estimate metadata amount

const TInt    KFreeDiskSpaceCounter  = 10;        // Interval when to find out real free disk space

const TUint   KFTYPSize              = 24;        // Size of FTYP box in bytes in 3GP files

const TUint   KCamCMaxClipDurationInSecs = 5400;  // Maximun video clip duration in seconds

const TInt    KLimitForLargeFileBuffers = 100000; // Bitrate limit to toggle to larger output file buffers in composer.

const TInt    KDelayUseBitrates      = 3000000;   // Delay used in GetRemainingTime until function uses real file sizes instead of avarage bitrates.

const TInt    KCamC3GPDeleteFileQueueGranularity  = 10; // Optimal value is the number of temporary files

const TUint32 KCamC3GPMaximumFileSize = 4294967295UL; // max size for RFile

_LIT(KTmpFileName, "\\system\\Temp\\CamcorderTMP");               // Temporary output file name

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

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

// CCamC3GPDataSink::NewL

//

// Sink constructor.

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

//

EXPORT_C CCamC3GPDataSink* CCamC3GPDataSink::NewL(M3GPDataSinkObserver *aObserver)

    {

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

	CleanupStack::PushL(self);

	self->ConstructL(aObserver);

	CleanupStack::Pop();

	return self;

    }

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

// CCamC3GPDataSinkImp::~CCamC3GPDataSinkImp

//

// Sink destructor.

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

//

CCamC3GPDataSinkImp::~CCamC3GPDataSinkImp(void)

    {

    OstTrace0( CAMERASRV_PERFORMANCE, CCAMC3GPDATASINKIMP_CCAMC3GPDATASINKIMP, "e_CCamC3GPDataSinkImp::~CCamC3GPDataSinkImp 1" );

    PRINT(_L("CCamC3GPDataSinkImp::~CCamC3GPDataSinkImp enter"));

    if ( iFileName != KNullDesC )

        {

        // we need to try to stop sink

        TInt error = KErrNone;

        TRAP(error, SinkStopL());

        iFileName = KNullDesC;

        }

    if (iMP4Handle)

        {

        MP4ComposeClose(iMP4Handle);

        iMP4Handle = NULL;

        }

    if (iFS)

        {

        iFS->Delete(iTmpFileName);

        iFS->Close();

        delete iFS;

        iFS = NULL;

        }

    delete [] iVideoBuffer;

    delete [] iAudioBuffer;

    iObserver = NULL;

    iMMFFile = NULL; // not owned

    iFile = NULL; // not owned

    // Delete the CIdle async file remover object

    delete iIdleDelete;

    iIdleDelete = 0;

    // Do async temp file deletion for rest of files

    if ( iDeleteFileQueue )

        {

        // Reset and destroy the file name pointers from queue (if any left).

        iDeleteFileQueue->ResetAndDestroy();

        }

    delete iDeleteFileQueue;

    iDeleteFileQueue = 0;

    PRINT(_L("CCamC3GPDataSinkImp::~CCamC3GPDataSinkImp exit"));

    OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAMC3GPDATASINKIMP_CCAMC3GPDATASINKIMP, "e_CCamC3GPDataSinkImp::~CCamC3GPDataSinkImp 0" );

    }

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

// CCamC3GPDataSinkImp::ConstructL

//

// Symbian 2nd phase constructor.

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

//

void CCamC3GPDataSinkImp::ConstructL(M3GPDataSinkObserver *aObserver)

	{

    OstTrace0( CAMERASRV_PERFORMANCE, CCAMC3GPDATASINKIMP_CONSTRUCTL, "e_CCamC3GPDataSinkImp::ConstructL 1" );

    PRINT(_L("CCamC3GPDataSinkImp::ConstructL enter"));

    iObserver = aObserver;

    iVideoBuffer = new (ELeave) TUint8[KVideoBufferSize];

    iVideoBufferSize = KVideoBufferSize;

    iAudioBuffer = new (ELeave) TUint8[KAudioMaxFrameSize * KAudioBufferNumber];

    iAudioBufferSize = KAudioMaxFrameSize * KAudioBufferNumber;

    iMP4Handle = NULL;

    iMMFFile = NULL;

    iFileName = KNullDesC;

    iBytesReceived = 0;

    iBytesOfMetadata = 0;

    iVideoXResolution = 0;

    iVideoYResolution = 0;

    iVideoAverageBitRate = -1;

    iVideoMaxBitRate = -1;

    iAudioAverageBitRate = -1;

    iBufferSize = 0;

    iFileCodecType = MP4_TYPE_NONE;

    iVideoTimestamp = 0;

    iVideoBufferTimestamp = -1;

    iFirstVideoFrameTimestamp = 0;

    iVideoRandomAccessPoint = EFalse;

    iVideoBufferRandomAccessPoint = EFalse;

    iVideoFrameDuration = 0;

    iVideoBufferFrameSize = 0;

    iVideoFrameNumber = 0;

    iVideoIntraFrameNumber = 0;

    iVideoDecSpecInfoSize = 0;

    iAudioDecSpecInfoSize = 0;

    iAudioBufferFrameSize = 0;

    iAudioFrameNumber = 0;

    iAudioFramesInBuffer = 0;

    iFreeDiskSpace = 0;

    iFreeDiskSpaceCounter = 0;

    iAvailableSpaceAtStart = 0;

    iAvarageEndTime = -1;

    iAudioAACFrameDuration = 0;

    iAudioAACSamplerate = 0;

    iAVCOutputLevel = 10;

    iCriticalDiskVal = 0;

    iSizeLimit = KCamC3GPMaximumFileSize; // max size for RFile

    iFileSizeLimitReached = EFalse;

    iDiskFull = EFalse;

    iFS = NULL;

    iDeleteFileQueue = new( ELeave ) RPointerArray<MP4FileName>( KCamC3GPDeleteFileQueueGranularity );

    // Idle priority Active object for async video temp file deletion

    iIdleDelete = CIdle::NewL( CActive::EPriorityIdle );

    PRINT(_L("CCamC3GPDataSinkImp::ConstructL exit"));

	OstTrace0( CAMERASRV_PERFORMANCE, DUP1_CCAMC3GPDATASINKIMP_CONSTRUCTL, "e_CCamC3GPDataSinkImp::ConstructL 0" );

	}

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

// CCamC3GPDataSinkImp::OpenFileL

//

// Opens a 3GP file for writing.

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

//

void CCamC3GPDataSinkImp::OpenFileL(CMMFFile* aMMFFile, TFourCC aAudioCodecType, const TDesC8& aVideoCodecType, TCamCSinkFileFormat aFileFormat )

    {

    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL CMMFFile enter")));

    TFileName aFileName;

    iMMFFile = aMMFFile;

    aFileName = iMMFFile->FullName();

    OpenFileL(aFileName, aAudioCodecType, aVideoCodecType, aFileFormat);

    }

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

// CCamC3GPDataSinkImp::OpenFileL

//

// Opens a 3GP file for writing.

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

//

void CCamC3GPDataSinkImp::OpenFileL(TFileName aFileName, TFourCC aAudioCodecType, const TDesC8& aVideoCodecType, TCamCSinkFileFormat aFileFormat)

    {

    MP4Err    error;

    OstTrace0( CAMERASRV_PERFORMANCE, CCAMC3GPDATASINKIMP_OPENFILEL, "e_CCamC3GPDataSinkImp::OpenFileL 1" );

    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL TFileName enter")));

    if (iMP4Handle)

        {

        User::Leave(KErrGeneral);

        }

    iVideoBufferTimestamp = -1;     // reset duration information for new file

    iFirstVideoFrameTimestamp = 0;

    iAvailableSpaceAtStart = 0;

    iAvarageEndTime = -1;

    iVideoFrameNumber = 0;

    iVideoIntraFrameNumber = 0;

    iBytesReceived = 0;

    iAudioAACFrameDuration = 0;

    iAudioAACSamplerate = 0;

    iFileHandleExists = EFalse;

    iDiskFull = EFalse;

    iTmpFileName = KTmpFileName;

    iFileName = aFileName;

    TInt errorcode;

    OstTrace0( CAMERASRV_PERFORMANCE, DUP2_CCAMC3GPDATASINKIMP_OPENFILEL, "e_CCamC3GPDataSinkImp::OpenFileL_create_temp_files 1" );

    if (!iFS) // Don't allocate new file server, if there is one already

        {

        iFS = new (ELeave) RFs;

        errorcode = iFS->Connect();

        if ( errorcode != KErrNone)

            {

            delete(iFS);

            iFS = NULL;

            User::Leave( errorcode );

            }

        }

    TParse fp;

    User::LeaveIfError(iFS->Parse(iFileName, fp));

    TPtrC driveletter = fp.Drive();

    TChar drl = driveletter[0];

    User::LeaveIfError(iFS->CharToDrive(drl, iDriveNumber));

    // Get critical level for this drive type

    TDriveInfo driveInfo;

    iFS->Drive(driveInfo, iDriveNumber);

    iCriticalDiskVal = 0;

	if ( driveInfo.iType == EMediaRam ) // RAM drives have different critical levent than others

		{

		PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Asking disk critical level, memtype: EMediaRam")));

		CRepository* repository = CRepository::NewLC( KCRUidDiskLevel );

		User::LeaveIfError( repository->Get( KRamDiskCriticalLevel, iCriticalDiskVal ) );

		PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Got disk critical level: %d"),iCriticalDiskVal ));

		CleanupStack::PopAndDestroy( repository );

		}

	else // Some other media type

		{

		PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Asking disk critical level, memtype: other")));

		CRepository* repository = CRepository::NewLC( KCRUidDiskLevel );

		User::LeaveIfError( repository->Get( KDiskCriticalThreshold, iCriticalDiskVal ) );

		PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Got disk critical level: %d"),iCriticalDiskVal ));

		CleanupStack::PopAndDestroy( repository );

		}

    errorcode = iFS->MkDirAll(fp.DriveAndPath());

    if ( (errorcode != KErrAlreadyExists ) && ( errorcode != KErrNone ) )

        {

        PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Error creating output path: '%s', error: %d"), fp.DriveAndPath().Ptr(), errorcode ));

        User::Leave(errorcode);

        }

    errorcode = iFS->SetAtt( iFileName, KEntryAttNormal, KEntryAttReadOnly );

    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Deleting File: '%s'"), iFileName.Ptr()));

    errorcode = iFS->Delete(iFileName);

    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Deleting File Error: %d"), errorcode));

    if ( errorcode == KErrInUse && iMMFFile )

        {

        PRINT((_L("CCamC3GPDataSinkImp::OpenFileL using rfiles")));

        iMMFFile->SinkPrimeL();

        iFile = &(iMMFFile->FileL());

        iFileHandleExists = ETrue;

        }

    else if ( ( errorcode != KErrNone ) && ( errorcode != KErrNotFound ) && ( errorcode != KErrPathNotFound ) )

        {

        User::Leave(errorcode);

        }

    iTmpFileName.Insert(0, fp.Drive());

    errorcode = iFS->SetAtt( iTmpFileName, KEntryAttNormal, KEntryAttReadOnly );

    errorcode = iFS->Delete(iTmpFileName);

    if ( ( errorcode != KErrNone ) && ( errorcode != KErrNotFound ) && ( errorcode != KErrPathNotFound ) )

    	{

        if ( errorcode == KErrInUse )

        	{

        	// use actual output filename incase other instance still running with temporary file.

            PRINT((_L("CCamC3GPDataSinkImp::OpenFileL temporary output file in use (-14). Using actual output filename instead.")));

        	iTmpFileName = aFileName;

            errorcode = iFS->SetAtt( iTmpFileName, KEntryAttNormal, KEntryAttReadOnly );

            errorcode = iFS->Delete(iTmpFileName);

            if ( ( errorcode != KErrNone ) && ( errorcode != KErrNotFound ) && ( errorcode != KErrPathNotFound ) )

            	{

            	User::Leave(errorcode);

            	}

        	}

        else

        	{

        	User::Leave(errorcode);

        	}

        }

    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Temp files cleared")));

    OstTrace0( CAMERASRV_PERFORMANCE, DUP3_CCAMC3GPDATASINKIMP_OPENFILEL, "e_CCamC3GPDataSinkImp::OpenFileL_create_temp_files 0" );

    // Find used audio codec

    if ( ( aAudioCodecType == TFourCC(KCMRFourCCIdAMRNB) ) ) // AMR-NB

        {

        iFileCodecType |= MP4_TYPE_AMR_NB;

        PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Audio codec: AMR-NB")));

        }

    else if ( aAudioCodecType == TFourCC(KCMRFourCCIdMPEG4AAC) ) // AAC

        {

        iFileCodecType |= MP4_TYPE_MPEG4_AUDIO;

        PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Audio codec: AAC")));

        }

    else

        {

        PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Audio codec: none")));

        // if audio codec is null we don't generate audiotrack to composed file.

        }

    // Find used video codec

    mp4_u8 videoLevel = 10;

    if ( aVideoCodecType == KNullDesC8 ) // No video codec set.

        {

        // filecomposer will always create videotrack, whether we get video frames or not.

        iFileCodecType |= MP4_TYPE_H263_PROFILE_0;

        }

    else

        {

        TBuf8<256> matchstring;

        matchstring = KCMRMimeTypeH263;

        matchstring += _L8( "*" );

        if ( ( aVideoCodecType.MatchF( matchstring ) != KErrNotFound ) ) // H.263

            {

            matchstring = KCMRMimeTypeH263Profile3;

            matchstring += _L8( "*" );

            if ( aVideoCodecType.MatchF( matchstring ) != KErrNotFound )

                {

                iFileCodecType |= MP4_TYPE_H263_PROFILE_3;   // H.263 profile 3

                PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Video codec: H.263 profile 3")));

                }

            else

                {

                iFileCodecType |= MP4_TYPE_H263_PROFILE_0;   // H.263 profile 0

                PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Video codec: H.263 profile 0")));

                }

            // check if level is indicated too

            matchstring = _L8("*level=*");

            if (aVideoCodecType.MatchF( matchstring ) != KErrNotFound )

                {

                // yes, there is, check what it is

                if ( aVideoCodecType.MatchF( _L8("*level=10*") ) != KErrNotFound )

                    {

                    videoLevel = 10;

                    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Video codec: H.263 level 10")));

                    }

                else if ( aVideoCodecType.MatchF( _L8("*level=20*") ) != KErrNotFound )

                    {

                    videoLevel = 20;

                    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Video codec: H.263 level 20")));

                    }

                else if ( aVideoCodecType.MatchF( _L8("*level=30*") ) != KErrNotFound )

                    {

                    videoLevel = 30;

                    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Video codec: H.263 level 30")));

                    }

                else if ( aVideoCodecType.MatchF( _L8("*level=40*") ) != KErrNotFound )

                    {

                    videoLevel = 40;

                    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Video codec: H.263 level 40")));

                    }

                else if ( aVideoCodecType.MatchF( _L8("*level=45*") ) != KErrNotFound )

                    {

                    videoLevel = 45;

                    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Video codec: H.263 level 45")));

                    }

                else if ( aVideoCodecType.MatchF( _L8("*level=50*") ) != KErrNotFound )

                    {

                    videoLevel = 50;

                    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Video codec: H.263 level 50")));

                    }

                else

                    {

                    // assume 10

                    videoLevel = 10;

                    PRINT((_L("CCamC3GPDataSinkImp::OpenFileL Video codec: H.263 level 10")));

                    }

                }

            }

        else // MPEG-4

            {

            matchstring = KCMRMimeTypeMPEG4V;

            matchstring += _L8( "*" );

            if ( aVideoCodecType.MatchF(matchstring) != KErrNotFound )

                {

                iFileCodecType |= MP4_TYPE_MPEG4_VIDEO;     // MPEG-4

                }

            else // H.264 AVC

	            {

	            matchstring = KCMRMimeTypeH264AVC;

	            matchstring += _L8( "*" );

	            if ( aVideoCodecType.MatchF(matchstring) != KErrNotFound )

	                {

                    iAVCOutputLevel = 10;

		            // check if profile & level is indicated too

		            matchstring = _L8("*profile-level-id=*");

		            if (aVideoCodecType.MatchF( matchstring ) != KErrNotFound )

		                {

		                // yes, there is, check what it is

	                    // Determine if other AVC profile is used:

                        matchstring = _L8( "*profile-level-id=42*" ); // Main Profile 

                        if (aVideoCodecType.MatchF( matchstring ) != KErrNotFound)

                            {

                            iFileCodecType |= MP4_TYPE_AVC_PROFILE_BASELINE;     // H.264 AVC Baseline profile found 

                            }

	                    matchstring = _L8( "*profile-level-id=4D*" ); // Main Profile 

	                    if (aVideoCodecType.MatchF( matchstring ) != KErrNotFound)

	                        {

	                        iFileCodecType |= MP4_TYPE_AVC_PROFILE_MAIN;     // H.264 AVC Main profile found 

	                        }

	                    matchstring = _L8( "*profile-level-id=64*" ); // High Profile 

	                    if (aVideoCodecType.MatchF( matchstring ) != KErrNotFound)

	                        {

	                        iFileCodecType |= MP4_TYPE_AVC_PROFILE_HIGH;     // H.264 AVC Baseline profile found 

	                        }

	                    // Determine if other AVC level is used:

		                if ( aVideoCodecType.MatchF( _L8("*00A*") ) != KErrNotFound )

		                    {

		                    iAVCOutputLevel = 10; 	// Level 1

		                    }

		                else if ( (aVideoCodecType.MatchF( _L8("*profile-level-id=42900B*") ) != KErrNotFound) ||

                                  (aVideoCodecType.MatchF( _L8("*profile-level-id=4D500B*") ) != KErrNotFound) || 

                                  (aVideoCodecType.MatchF( _L8("*profile-level-id=644009*") ) != KErrNotFound) )

		                    {

		                    iAVCOutputLevel = 101; 	// Level 1b

		                    }

                        else if ( (aVideoCodecType.MatchF( _L8("*profile-level-id=42800B*") ) != KErrNotFound) ||

                                  (aVideoCodecType.MatchF( _L8("*profile-level-id=4D400B*") ) != KErrNotFound) || 

                                  (aVideoCodecType.MatchF( _L8("*profile-level-id=64400B*") ) != KErrNotFound) )

		                    {

		                    iAVCOutputLevel = 11;	// Level 1.1

		                    }

		                else if ( aVideoCodecType.MatchF( _L8("*00C*") ) != KErrNotFound )

		                    {

		                    iAVCOutputLevel = 12;	// Level 1.2

		                    }

		                else if ( aVideoCodecType.MatchF( _L8("*00D*") ) != KErrNotFound )

		                    {

		                    iAVCOutputLevel = 13;	// Level 1.3

		                    }

		                else if ( aVideoCodecType.MatchF( _L8("*014*") ) != KErrNotFound )

		                    {

		                    iAVCOutputLevel = 20;	// Level 2

		                    }

                        else if ( aVideoCodecType.MatchF( _L8("*015*") ) != KErrNotFound )

                            {

                            iAVCOutputLevel = 21;   // Level 2.1

                            }