/*

* Copyright (c) 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:    

*

*/

// INCLUDE FILES

#include <ES_SOCK.H>

#include <e32std.h>

#include "MccFileSourceImpl.h"

#include "MmccCodecInformation.h"

#include "MccFileSourceLogs.h"

#include "MccTickVideoObserver.h"

#include "MccTickAudioObserver.h"

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

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

// CMccFileSourceImpl::NewL

// Static constructor.

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

//

CMccFileSourceImpl* CMccFileSourceImpl::NewL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::NewL" )

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CMccFileSourceImpl::ConstructL

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

//

void CMccFileSourceImpl::ConstructL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::ConstructL" )

    }

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

// Destructor.

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

//

CMccFileSourceImpl::CMccFileSourceImpl()

    {

    iObserver = 0;

    iVideoLength = 0;

    iFrameRate = 0;

    iVideoType = 0;

    iVideoWidth = 0;

    iVideoHeight = 0;

    iVideoTimeScale = 0;

    iAudioLength = 0;

    iAudioType = 0;

    iFramesPerSample = 0;

    iAudioTimeScale = 0;

    iAverageBitRate = 0;

    iStreamSize = 0;

    iStreamAverageBitRate = 0;

    iAudioPosition = 0;

    iVideoPosition = 0;

    iPosition = 0;

    iCurrentVideoType = CCMRMediaBuffer::EVideoH263;

    iCurrentAudioType = CCMRMediaBuffer::EAudioAMRNB;

    iBufferSize = 0;

    iAudioSize = 0;

    iReturnedFrames = 0;

    iNextFrameType = 0;

    iKeyFrame = 0;

    iVideoFrameSize = 0;

    iLastPosition = 0;

    iFrameSize.iWidth = 0;

    iFrameSize.iHeight = 0;

    iCurrentState = EConstructed;

    iMP4Handle = NULL;

    iIsAudioLeft = EFalse;

    iIsVideoLeft = EFalse;

    iIsAudio = EFalse;

    iIsVideo = EFalse;

	iRecursiveCalls = 0;

	iIsFirstVideoFrame = EFalse;

	iAudioConsumer = 0;

	iAudioConsumerBuffer = 0;

	iVideoConsumer = 0;

	iVideoConsumerBuffer = 0;    

    }

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

// CMccFileSourceImpl::~CMccFileSourceImpl.

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

//

CMccFileSourceImpl::~CMccFileSourceImpl()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::~CMccFileSourceImpl" )

  /*

    delete iPeriodicVideo;

    delete iPeriodicVideo;

   */

    if ( iMP4Handle )

	    {

	    MP4Err error = MP4ParseClose( iMP4Handle );

	    }

    iObserver = NULL;

    iVideoConsumer = NULL;

    iAudioConsumer = NULL;

    iAudioFrames.Reset();

    iAudioFrames.Close();

    }

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

// CMccFileSourceImpl::AddDataSink(MCMRMediaSink* aSink)

//

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

//

void CMccFileSourceImpl::AddDataSink( MCMRMediaSink* /*aSink*/ )

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::AddDataSink" )

    }

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

// CMccFileSourceImpl::OpenFileL(TFileName aFileName)

//

// Opens a 3gp file for streaming and reads media descriptions into

// member variables

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

//

void CMccFileSourceImpl::OpenFileL( TFileName aFileName )

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::OpenFileL" )

    __ASSERT_ALWAYS( iCurrentState == EConstructed, User::Leave( KErrNotReady ) );

    TFileName fullFileName;

    MP4Err error = MP4_OK;

    RFs fS;

    User::LeaveIfError( fS.Connect() );

	CleanupClosePushL( fS );

    TParse fp;	

    if ( fS.Parse( aFileName, fp ) != KErrNone )

        {

        RDebug::Print(_L("CMccFileSourceImpl::OpenFileL file name parse error!"));

	    User::Leave( KErrGeneral );

        }

    fullFileName = fp.FullName();

  	CleanupStack::PopAndDestroy( &fS ); 

  	error = MP4ParseOpen( &iMP4Handle, (wchar_t *) fullFileName.PtrZ() );

    if ( error != MP4_OK )

	    {

	    RDebug::Print(_L("CMccFileSourceImpl::OpenFileL parse open error!"));

        RDebug::Print(_L("CMccFileSourceImpl::OpenFileL parse open error=%d"), error);

	    FileOpenErrorL( error );	

	    }

 	ParseUpdateVideoDescriptions();

 	ParseUpdateAudioDescriptions();

    if ( ( !iIsAudio ) && ( !iIsVideo ) )

        {

        User::Leave( KErrNotSupported );

        }

    error = MP4ParseRequestStreamDescription( iMP4Handle,

        ( mp4_u32* ) &iStreamSize, ( mp4_u32* ) &iStreamAverageBitRate );

    __FILESOURCE_CONTROLL_INT1("CMccFileSourceImpl::OpenFileL, \

MP4ParseRequestStreamDescription error=",error)

	#ifdef TIMESTAMP

		iReplayTimeStamp = 0;

		iTimeDifference = 0;

		iPausedTime = 0;

	#endif

    iCurrentState = EReady;

    }

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

// CMccFileSourceImpl::CloseFileL()

//

// Closes the 3gp file

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

//

void CMccFileSourceImpl::CloseFileL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::CloseFileL" )

    __ASSERT_ALWAYS( iCurrentState != EConstructed, User::Leave( KErrNotReady ) );

    if ( iCurrentState == EPlaying )

        {

        TRAP_IGNORE( SourceStopL() );

        }

    MP4Err error;

    error = MP4ParseClose( iMP4Handle );

    if ( error != MP4_OK )

        {

        User::Leave( KErrGeneral );

        }

    iCurrentState = EConstructed;

    iMP4Handle = NULL;

    }

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

// CMccFileSourceImpl::SetPositionL(TTimeIntervalMicroSeconds aPosition)

// 

// Sets a new streaming position

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

//

void CMccFileSourceImpl::SetPositionL( TTimeIntervalMicroSeconds aPosition )

    {

    __FILESOURCE_CONTROLL_INT1( "CMccFileSourceImpl::SetPositionL", Int64() )

    __ASSERT_ALWAYS( iCurrentState != EConstructed, User::Leave( KErrNotReady ) );

    if ( iCurrentState == EStopped ) 

    	{

    	return;

    	}

    MP4Err error;

    TInt64 tempPosition = aPosition.Int64();

    TUint tempPosition2 = tempPosition; 

    tempPosition2 = tempPosition2 / 1000; 

    iLastPosition = iVideoLength;

    TRAP_IGNORE( UpdatePositionL());

    if ( iLastPosition < iAudioLength )

        {

        iLastPosition = iAudioLength;

        }

    if ( tempPosition2 > iLastPosition )

        {

        User::Leave( KErrArgument );

        }

    error = MP4ParseSeek( iMP4Handle, ( mp4_u32 ) tempPosition2,

        ( mp4_u32* ) &iAudioPosition, ( mp4_u32* ) &iVideoPosition, MP4TRUE );

    if ( error != MP4_OK )

        {   

        User::Leave( KErrGeneral );

        }

    #ifdef TIMESTAMP

		if ( iIsAudioLeft == EFalse && iIsVideoLeft == EFalse)

			{

			iPosition = 0;

			}

        iTimeDifference = iTimeDifference + iPosition - iVideoPosition;

        iPosition = iVideoPosition;

    #endif

	}

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

// CMccFileSourceImpl::VideoTypeL()

// 

// Returns current video type

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

//

CCMRMediaBuffer::TBufferType CMccFileSourceImpl::VideoTypeL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::VideoTypeL" )

    __ASSERT_ALWAYS( iCurrentState != EConstructed, User::Leave( KErrNotReady ) );

    return iCurrentVideoType;

    }

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

// CMccFileSourceImpl::AudioTypeL()

// 

// Returns current audio type

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

//

CCMRMediaBuffer::TBufferType CMccFileSourceImpl::AudioTypeL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::AudioTypeL" )

    __ASSERT_ALWAYS( iCurrentState != EConstructed, User::Leave( KErrNotReady ) );

    return iCurrentAudioType;

    }

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

// CMccFileSourceImpl::VideoFrameRateL()

// 

// Returns current video frame rate

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

//

TReal32 CMccFileSourceImpl::VideoFrameRateL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::VideoFrameRateL" )

    __ASSERT_ALWAYS( iCurrentState != EConstructed, User::Leave( KErrNotReady ) );

    return TReal32 ( iFrameRate );

    }

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

// CMccFileSourceImpl::AudioBitRateL()

// 

// Returns current audio bit rate

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

//

TUint CMccFileSourceImpl::AudioBitRateL()

    {

    __FILESOURCE_CONTROLL_INT1( "CMccFileSourceImpl::AudioBitRateL", iAverageBitRate )

    __ASSERT_ALWAYS( iCurrentState != EConstructed, User::Leave( KErrNotReady ) );

    return iAverageBitRate;

    }

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

// CMccFileSourceImpl::DurationL()

// 

// Returns duration of current media clip

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

//

TTimeIntervalMicroSeconds CMccFileSourceImpl::DurationL()

    {

    __FILESOURCE_CONTROLL_INT1( "CMccFileSourceImpl::DurationL", 

                                iVideoLength * 1000 )

    __ASSERT_ALWAYS( iCurrentState != EConstructed, User::Leave( KErrNotReady ) );

    return TTimeIntervalMicroSeconds( iVideoLength * 1000 );

    }

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

// CMccFileSourceImpl::VideoFrameSizeL()

// 

// Returns current video frame size

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

//

TSize CMccFileSourceImpl::VideoFrameSizeL()

    {        

    __FILESOURCE_CONTROLL_INT1( "CMccFileSourceImpl::VideoFrameSizeL iWidth", 

                                iFrameSize.iWidth )

	__FILESOURCE_CONTROLL_INT1("CMccFileSourceImpl::VideoFrameSizeL iHeight",

								iFrameSize.iHeight )                            

    __ASSERT_ALWAYS( iCurrentState != EConstructed, User::Leave( KErrNotReady ) );

    return iFrameSize;

    }

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

// CMccFileSourceImpl::VideoBitRateL()

// 

// Returns current video bitrate

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

//

TUint CMccFileSourceImpl::VideoBitRateL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::VideoBitRateL, videoBitRate" )

    __ASSERT_ALWAYS( iCurrentState != EConstructed, User::Leave( KErrNotReady ) );

    TUint videoBitRate = iStreamAverageBitRate - iAverageBitRate;

    __FILESOURCE_CONTROLL_INT1( "CMccFileSourceImpl::VideoBitRateL, videoBitRate", 

                                videoBitRate )

    return videoBitRate;

    }

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

// CMccFileSourceImpl::PositionL()

// 

// Returns current streaming position

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

//

TTimeIntervalMicroSeconds CMccFileSourceImpl::PositionL()

    {

    __FILESOURCE_CONTROLL_INT1( "CMccFileSourceImpl::PositionL", 

                                iPosition * 1000 )

    __ASSERT_ALWAYS( iCurrentState != EConstructed, User::Leave( KErrNotReady ) );

    return TTimeIntervalMicroSeconds( iPosition * 1000 ); 

    }

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

// CMccFileSourceImpl::UpdatePositionL()

// 

// Updates the position parameter

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

//

void CMccFileSourceImpl::UpdatePositionL()

	{

	__FILESOURCE_CONTROLL( "CMccFileSourceImpl::UpdatePosition" )

	MP4Err error;

    error=MP4ParseGetNextVideoTimestamp( iMP4Handle,

        ( mp4_u32* ) &iPosition, NULL );

    if ( error != MP4_OK )

        {

        User::Leave( KErrGeneral );

        }

    error = MP4ParseSeek( iMP4Handle, ( mp4_u32 ) iPosition,

        ( mp4_u32* ) &iAudioPosition, ( mp4_u32* ) &iVideoPosition, MP4FALSE );

     if ( error != MP4_OK )

        {

        User::Leave( KErrGeneral );

        }

	}

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

// CMccFileSourceImpl::ReadAudioFrameL()

// 

// Reads the next audio frame from 3gp file

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

//

void CMccFileSourceImpl::ReadAudioFrameL()

    {

	__FILESOURCE_CONTROLL( "CMccFileSourceImpl::ReadAudioFrameL" )

    TBool brokenFrame = EFalse;

  	if ( iAudioConsumer == NULL)

  		{

  		__FILESOURCE_CONTROLL( "CMccFileSourceImpl::ReadAudioFrameL, \

source not available" )

  		return;

  		}

  	else

  		{

  		__FILESOURCE_CONTROLL( "CMccFileSourceImpl::ReadAudioFrameL, \

writing buffer" )  		

  		}	

	if (!iAudioFrames.Count())

		{		

	    MP4Err error;

	    error = MP4ParseIsFrameAvailable( iMP4Handle, MP4_TYPE_AMR_NB );

	    if ( error != MP4_OK )

	        {

	  		__FILESOURCE_CONTROLL( "CMccFileSourceImpl::ReadAudioFrameL, \

no audio" ) 

			iIsAudioLeft = EFalse;

	        }

	    else 

	    	{

	  		__FILESOURCE_CONTROLL( "CMccFileSourceImpl::ReadAudioFrameL, \

	audio OK" )

	    	iIsAudioLeft = ETrue;

	    	}

	    if ( iIsAudioLeft == EFalse && iIsVideoLeft == EFalse )

	        {

	  		__FILESOURCE_CONTROLL( "CMccFileSourceImpl::ReadAudioFrameL, \

no video & audio available" ) 		

			#ifdef TIMESTAMP

				iReplayTimeStamp = iReplayTimeStamp + iPosition + 10;

			#endif

			SetPositionL(  TTimeIntervalMicroSeconds ( 0 ) );

			SourcePauseL();

	        if ( iObserver )

	            {

	            iObserver->EndOfFile( KErrNone );

	            }

	        return;

		    }

		// Timing correction code

		TTimeIntervalMicroSeconds elapsedTime;

	    TTime currentTime;

	    currentTime.HomeTime();

	    elapsedTime = currentTime.MicroSecondsFrom( iStartTime );

	    TInt64 tempTime = elapsedTime.Int64();

	    TInt timeNow = tempTime  / 1000;

		if ( ( timeNow + 500 ) < ( ( TInt ) iAudioPosition + iTimeDifference + iReplayTimeStamp + ( iPausedTime / 1000 ) ) )

			{

	  		__FILESOURCE_CONTROLL( "CMccFileSourceImpl::ReadAudioFrameL, \

Position check, returning" ) 

	  		__FILESOURCE_CONTROLL( "CMccFileSourceImpl::ReadAudioFrameL, IGNORING" ) 

	  		//return    				

			}

		MP4ParseNextFrameSize( iMP4Handle, MP4_TYPE_AMR_NB,

	        ( mp4_u32* ) &iBufferSize );