/*

* 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 "mccfileaudio.h"

#include "mccfilevideo.h"

#include "mccinternalevents.h"

#include "mmccinterfacedef.h"

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

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

// CMccFileSourceImpl::NewL

// Static constructor.

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

//

CMccFileSourceImpl* CMccFileSourceImpl::NewL( 

    TUint32 aEndpointId, 

    MMccResources* aMccResources )

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::NewL" )

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

    CleanupStack::PushL(self);

    self->ConstructL( aMccResources );

    CleanupStack::Pop(self);

    return self;

    }

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

// CMccFileSourceImpl::ConstructL

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

//

void CMccFileSourceImpl::ConstructL( MMccResources* aMccResources )

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::ConstructL" )

    iFileAudio = CMccFileAudio::NewL( *this );

    iFileVideo = CMccFileVideo::NewL( *this, aMccResources, iEndpointId );

    }

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

// Destructor.

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

//

CMccFileSourceImpl::CMccFileSourceImpl( TUint32 aEndpointId )

	: iCurrentState( EConstructed ),

	  iIsAudio ( EFalse ),

	  iIsVideo ( EFalse ),

	  iEndpointId( aEndpointId ),

	  iDelayAfterStop( 0 ),

	  iEofTimer( 0 )

    {

    }

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

// CMccFileSourceImpl::~CMccFileSourceImpl.

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

//

CMccFileSourceImpl::~CMccFileSourceImpl()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::~CMccFileSourceImpl" )

    StopEofTimer();

    if ( iMP4Handle )

	    {

        MP4ParseClose( iMP4Handle );

	    iMP4Handle = NULL;

	    }

    delete iFileAudio;

	delete iFileVideo;  

	iAsyncEventHandler = NULL;

    }

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

// 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, TBool aFileChangeMode )

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::OpenFileL" )

    TCurrentState oldState = iCurrentState;

    // Close old file (if exists)

    CloseFileL( aFileChangeMode );

    aFileName.ZeroTerminate();

    TRAPD( err, OpenFileForStreamingL( aFileName ) );

    if ( err )

        {

        if ( aFileChangeMode )

            {

            // Have to stop timers etc, since old file was closed

            // and the new file is unusable

            DoCleanupL( EFalse );

            }

        User::Leave( err );

        }

	this->SetFileName( aFileName );

	if ( oldState == EPlaying )

	    {

	    // Continue playing with new file

	    iCurrentState = EPrimed;

	    SourcePlayL( ETrue, aFileChangeMode );

	    }

	else

	    {

	    // Keep old state

	    iCurrentState = oldState;

	    }

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::OpenFile, exit" )

    }

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

// CMccFileSourceImpl::CloseFileL()

//

// Closes the 3gp file

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

//

void CMccFileSourceImpl::CloseFileL( TBool aFileChangeMode )

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::CloseFileL" )

    if ( iCurrentState == EPlaying )

        {

        SourceStopL( ETrue, aFileChangeMode );

        }

    if ( iMP4Handle ) 

	    {

	    if ( MP4ParseClose( iMP4Handle ) != MP4_OK )

	        {

	        User::Leave( KErrGeneral );

	        }

    	iMP4Handle = NULL;

    	iFileAudio->SetFileHandle( iMP4Handle );

	    iFileVideo->SetFileHandle( iMP4Handle );		

	    }

    iCurrentState = EConstructed;

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::CloseFileL, file closed" )

    }

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

// CMccFileSourceImpl::FileNameL()

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

//   

TFileName& CMccFileSourceImpl::FileNameL()

    {

    return iFileName;

    }

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

// CMccFileSourceImpl::SetPositionL(TTimeIntervalMicroSeconds aPosition)

// 

// Sets a new streaming position

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

//

void CMccFileSourceImpl::SetPositionL( TTimeIntervalMicroSeconds aPosition )

    {

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

                                aPosition.Int64() )

 	if ( iCurrentState == EStopped ) 

    	{

    	return;

    	}

    TUint32 position = MicroToMilliSeconds( aPosition );

    if ( VideoInUse() ) 

	    {

	    iFileVideo->SetPositionL( position );

	    // Position might not end up to what was requested as it is set to

	    // nearest IFrame.  With audio there's no such limitation and

	    // therefore it is good to use actual video position for audio.

	    position = iFileVideo->Position();

	    __FILESOURCE_CONTROLL_INT1( "Pos modified to nearest IFrame (ms):", 

                                    position )

	    }

	if ( AudioInUse() )

		{

		iFileAudio->SetPositionL( position );	

		}

	}

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

// CMccFileSourceImpl::VideoTypeL()

// 

// Returns current video type

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

//

CCMRMediaBuffer::TBufferType CMccFileSourceImpl::VideoTypeL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::VideoTypeL" )

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

    return iFileVideo->Type();

    }

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

// CMccFileSourceImpl::AudioTypeL()

// 

// Returns current audio type

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

//

CCMRMediaBuffer::TBufferType CMccFileSourceImpl::AudioTypeL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::AudioTypeL" )

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

    return iFileAudio->Type();

    }

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

// CMccFileSourceImpl::VideoFrameRateL()

// 

// Returns current video frame rate

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

//

TReal CMccFileSourceImpl::VideoFrameRateL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::VideoFrameRateL" )

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

    return iFileVideo->VideoFrameRateL();    

    }

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

// CMccFileSourceImpl::AudioBitRateL()

// 

// Returns current audio bit rate

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

//

TUint32 CMccFileSourceImpl::AudioBitRateL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::AudioBitRateL" )

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

    TUint32 audioBitRate = iFileAudio->AudioBitRate();

    __FILESOURCE_CONTROLL_INT1( "CMccFileSourceImpl::AudioBitRateL", audioBitRate )

    return audioBitRate;

    }

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

// CMccFileSourceImpl::DurationL()

// 

// Returns duration of current media clip

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

//

TTimeIntervalMicroSeconds CMccFileSourceImpl::DurationL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::DurationL" )

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

    // Audio and video might have different duration, take longer one

    //

    TTimeIntervalMicroSeconds duration = 0;

    if ( AudioInUse() )

	    {

	    duration = MilliToMicroSeconds( iFileAudio->Duration() );

	    }

	if ( VideoInUse() )

		{

		TTimeIntervalMicroSeconds videoDuration = 

		    MilliToMicroSeconds( iFileVideo->Duration() );

		duration = videoDuration > duration ? videoDuration : duration;

		}

    __FILESOURCE_CONTROLL_INT1("CMccFileSourceImpl::DurationL in micro=", 

    	duration.Int64())

    return duration;

    }

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

// CMccFileSourceImpl::VideoFrameSizeL()

// 

// Returns current video frame size

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

//

TSize CMccFileSourceImpl::VideoFrameSizeL()

    {        

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::VideoFrameSizeL" )

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

    TSize size = iFileVideo->VideoFrameSize();

    __FILESOURCE_CONTROLL_INT1( "CMccFileSourceImpl::VideoFrameSizeL iWidth", 

                                size.iWidth )

	__FILESOURCE_CONTROLL_INT1("CMccFileSourceImpl::VideoFrameSizeL iHeight",

								size.iHeight )   

    return size;

    }

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

// CMccFileSourceImpl::VideoBitRateL()

// 

// Returns current video bitrate

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

//

TUint32 CMccFileSourceImpl::VideoBitRateL()

    {    

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::VideoBitRateL" )

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

    TUint32 audioBitRate = iFileAudio->AudioBitRate();

    // Average bitrate is for the whole stream, 

    // subtract audio average to get video average

    TUint32 averageBitRate = iFileVideo->StreamAverageBitRate() - audioBitRate;

    __FILESOURCE_CONTROLL_INT1( "CMccFileSourceImpl::VideoBitRateL, videoBitRate", 

                               averageBitRate )

    return averageBitRate;

    }

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

// CMccFileSourceImpl::PositionL()

// 

// Returns current streaming position. If other stream is already at end

// (zero pos) other ones position is used. Otherwise always less progressed

// streams position is returned.

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

//

TTimeIntervalMicroSeconds CMccFileSourceImpl::PositionL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::PositionL" )

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

    TTimeIntervalMicroSeconds audioPosition = 0;

    TTimeIntervalMicroSeconds videoPosition = 0;

    if ( AudioInUse() )

	    {

	    audioPosition = MilliToMicroSeconds( iFileAudio->Position() );

	    }

	if ( VideoInUse() )

		{

		videoPosition = MilliToMicroSeconds( iFileVideo->Position() );

		}

    __FILESOURCE_CONTROLL_INT2( "CMccFileSourceImpl::PositionL in micro, audio:", 

                                audioPosition.Int64(), 

                                " video:", videoPosition.Int64() )

    if ( videoPosition.Int64() == 0 || audioPosition.Int64() == 0 )

        {

        return Max( videoPosition, audioPosition );

        }

    return Min( videoPosition, audioPosition );

    }

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

// CMccFileSourceImpl::AudioFourCCL()

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

//    

TFourCC CMccFileSourceImpl::AudioFourCCL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::AudioFourCCL" )

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

    return iFileAudio->GetFourCC();

    }

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

// CMccFileSourceImpl::VideoFourCCL()

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

//	    

TFourCC CMccFileSourceImpl::VideoFourCCL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::VideoFourCCL" )

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

    return iFileVideo->GetFourCC();

    }

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

// CMccFileSourceImpl::GetConfigKeyL()

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

//

void CMccFileSourceImpl::GetConfigKeyL( TDes8& aConfigKey )

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::GetConfigKeyL" )

    __ASSERT_ALWAYS( iMP4Handle && VideoInUse(), User::Leave( KErrNotReady ) );

    HBufC8* configKey = iFileVideo->GetConfigKeyL();

    CleanupStack::PushL( configKey );

    __ASSERT_ALWAYS( configKey, User::Leave( KErrNotFound ) );

    __ASSERT_ALWAYS( configKey->Length() <= aConfigKey.MaxLength(), 

                     User::Leave( KErrOverflow ) );

    aConfigKey.Copy( *configKey );

    CleanupStack::PopAndDestroy( configKey );

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::GetConfigKeyL, exit" )

    }

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

// CMccFileSourceImpl::PlayL()

// 

// Starts streaming from 3gp file

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

//

void CMccFileSourceImpl::SourcePlayL( TBool aIgnoreEvents, TBool aFileChangeMode )

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::SourcePlayL" )

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

    if ( iCurrentState == EPlaying )

        {

        return;

        }

    // Start decision for both needs to be done before starting either one

    TBool videoStartNeeded = StartNeededL( *iFileVideo );

    TBool audioStartNeeded = StartNeededL( *iFileAudio );

	if ( videoStartNeeded && !aFileChangeMode  )

    	{

    	iFileVideo->StartTimerL();

    	}

	if ( audioStartNeeded && !aFileChangeMode )

	    {

    	iFileAudio->StartTimerL();	  

	    }

	if ( !aIgnoreEvents )

	    {   

    	if ( iCurrentState == EPaused )

    	    {

    	    SendStreamEventToClient( KMccEventCategoryStream, KMccStreamResumed );

    	    }

    	else

    	    {

    	    SendStreamEventToClient( KMccEventCategoryStream, KMccStreamStarted );

    	    }

	    }

    iCurrentState = EPlaying;

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::SourcePlayL, exit" )

    }

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

// CMccFileSourceImpl::SourcePauseL()

// 

// Pauses streaming by cancelling timers

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

//

void CMccFileSourceImpl::SourcePauseL()

    {

    __FILESOURCE_CONTROLL( "CMccFileSourceImpl::SourcePauseL" )

    if ( iCurrentState != EPlaying && iCurrentState != EWaitingPause ) 

    	{

    	return;

    	}

 	if ( VideoInUse() )

    	{

    	iFileVideo->StopTimer();