/*

* 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 <mmcccodecinformationfactory.h>

#include <mmcccodecinformation.h>

#include "mccfilesink.h"

#include "mmccinterfacedef.h"

#include "mmcccodecinformation.h"

#include "mccfilesinklogs.h"

#include "mccinternalevents.h"

#include "mccinternaldef.h"

#include "mccresources.h"

// CONSTANTS

const TInt KMccMaxNumTimestamps = 5;

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

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

// CMccFileSink::NewSinkL

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

//

MDataSink* CMccFileSink::NewSinkL( TUid /*aImplementationUid*/, 

                                   const TDesC8& /*aInitData*/ )

    {

    __FILESINK_CONTROLL( "CMccFileSink::NewSinkL" )

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

    return static_cast<MDataSink*>( self );

    }

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

// CMccFileSink::ConstructSinkL

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

//

void CMccFileSink::ConstructSinkL( const TDesC8& aInitData )

    {

    __FILESINK_CONTROLL( "CMccFileSink::ConstructSinkL" )

	iFileComposer = CCamC3GPDataSink::NewL( this );

    iFileComposer->SetSizeLimit( iMaxFileSize );

    TPckgBuf<TFileName> initData;

    initData.Copy( aInitData );

    iFileName = initData();

    }

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

// CMccFileSink::CMccFileSink

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

//

CMccFileSink::CMccFileSink() : 

    {

    iVideoCodec.iFourCC = TFourCC( KMccFourCCIdH263 );

    // FJKI-7J58CB no use case for audio in file, hence removing the audio track capability 

    //             per request from customer

    // iAudioFourCC = TFourCC( KMccFourCCIdAMRNB );

    iAudioFourCC = TFourCC( KMMFFourCCCodeNULL );

    iFileName = KNullDesC;

    iMaxFileSize = 0; 

    iT1 = 0;

    iT2 = 0;

    iPausedDuration = 0;

    iPreviousTimestamp = 0;

    iAddToTimestamp = 0;

    iSizeLimitReached = EFalse;

    iNotifySizeLimitReached = EFalse;

    SetActiveUserIndex( 0 );

    }

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

// CMccFileSink::~CMccFileSink

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

//

CMccFileSink::~CMccFileSink()

    {

    __FILESINK_CONTROLL( "CMccFileSink::~CMccFileSink" )

    // Cleanup and other ending operations...

    if ( iCurrentState == ERecording || iCurrentState == EPaused )

        {

        TRAP_IGNORE( CMccFileSink::SinkStopL() );

        }	

	delete iFileComposer;

	iTimestamps.Close();

	iUsers.ResetAndDestroy();

    }

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

// CMccFileSink::SetCurrentUser

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

//

void CMccFileSink::SetCurrentUser( MAsyncEventHandler* aEventHandler )

    {

    iAsyncEventHandler = aEventHandler;

    }

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

// CMccFileSink::SinkPrimeL

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

//

void CMccFileSink::SinkPrimeL()

	{

	__FILESINK_CONTROLL( "CMccFileSink::SinkPrimeL" )

    DoSinkPrimeL();	

	}

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

// CMccFileSink::SinkPlayL()

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

//

void CMccFileSink::SinkPlayL()

    {

    __FILESINK_CONTROLL( "CMccFileSink::SinkPlayL" )  

    DoSinkPlayL();

    }

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

// CMccFileSink::SinkPauseL()

// 

// Pauses streaming by cancelling timers

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

//

void CMccFileSink::SinkPauseL()

    {

    __FILESINK_CONTROLL( "CMccFileSink::SinkPauseL" )

    DoSinkPauseL();

	}

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

// CMccFileSink::SinkStopL()

// 

// Stops streaming

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

//

void CMccFileSink::SinkStopL()

    {

    __FILESINK_CONTROLL( "CMccFileSink::SinkStopL" )

    DoSinkStopL();		

    }

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

// CMccFileSink::SinkDataTypeCode

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

//

TFourCC CMccFileSink::SinkDataTypeCode( TMediaId aMediaId )

	{

    __FILESINK_CONTROLL( "CMccFileSink::SinkDataTypeCode" )

    if ( KUidMediaTypeVideo == aMediaId.iMediaType )

        {

        return iVideoCodec.iFourCC;

        }

    else if ( KUidMediaTypeAudio == aMediaId.iMediaType  )

        {

        return iAudioFourCC;

        }

    else

        {

        return TFourCC( KMMFFourCCCodeNULL );

        }

	}

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

// CMccFileSink::SetSinkDataTypeCode

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

//

TInt CMccFileSink::SetSinkDataTypeCode( TFourCC aCodec, 

                            TMediaId aMediaId )

	{

    __FILESINK_CONTROLL( "CMccFileSink::SetSinkDataTypeCode" )

    TInt retVal = KErrNone;

    if ( KUidMediaTypeVideo == aMediaId.iMediaType &&

    	aCodec == iVideoCodec.iFourCC )

        {

        retVal = KErrNone;

        }

    else if ( KUidMediaTypeAudio == aMediaId.iMediaType &&

    	aCodec == iAudioFourCC )

        {

        retVal = KErrNone;

        }

    else

        {

        retVal = KErrNotSupported;

        }

	return retVal;

	}	

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

// CMccFileSink::BufferEmptiedL

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

//

void CMccFileSink::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )

	{

    __FILESINK_MEDIA( "CMccFileSink::BufferEmptiedL" )

    User::Leave( KErrNotSupported );

	}

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

// CMccFileSink::CanCreateSinkBuffer

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

//

TBool CMccFileSink::CanCreateSinkBuffer()

	{

    __FILESINK_CONTROLL( "CMccFileSink::CanCreateSinkBuffer, EFalse" )

	return EFalse;

	}	

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

// CMccFileSink::CreateSinkBufferL

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

//

CMMFBuffer* CMccFileSink::CreateSinkBufferL( 

	TMediaId /*aMediaId*/, 

    TBool& /*aReference*/ )

	{

	__FILESINK_CONTROLL( "CMccFileSink::CreateSinkBufferL, return NULL" )

    CMMFBuffer* buffer = NULL;

	User::Leave( KErrNotSupported );	

	return buffer;	

	}

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

// CMccFileSink::SinkThreadLogon

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

//

TInt CMccFileSink::SinkThreadLogon( MAsyncEventHandler& aEventHandler )

	{

    __FILESINK_CONTROLL( "CMccFileSink::SinkThreadLogon" )

    TInt err( KErrNone );

    TMccFileSinkUser* userEntry = 

        MccUserArray<TMccFileSinkUser>::FindUserEntryForCurrent( iUsers, &aEventHandler );

    if ( !userEntry )

        {

        TRAP( err, AddUserL( &aEventHandler ) );

        }

    __FILESINK_CONTROLL_INT1( 

        "CMccFileSink::SinkThreadLogon, exit with err:", err )

    return err;

	}

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

// CMccFileSink::SinkThreadLogoff

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

//

void CMccFileSink::SinkThreadLogoff()

	{

	__FILESINK_CONTROLL( "CMccFileSink::SinkThreadLogoff" )

    // If multiple different codecs are using the filesink and active user

    // is removed, reset active user information so that new active user

    // can be seleceted once someone else tries to use the sink

    if ( IsActiveUser( iAsyncEventHandler ) )

        {

        SetActiveUserIndex( KErrNotFound );

        }

    MccUserArray<TMccFileSinkUser>::RemoveCurrentUser( iUsers, iAsyncEventHandler );

    if ( iUsers.Count() > 0 )

        {

        SetCurrentUser( iUsers[ 0 ]->iEventHandler );

        }

    else

        {

        SetCurrentUser( NULL );

        }

	}

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

// CMccFileSink::EmptyBufferL

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

//

void CMccFileSink::EmptyBufferL( CMMFBuffer* aBuffer,

                  MDataSource* aProvider,

                  TMediaId aMediaId )

	{

	__FILESINK_MEDIA( "CMccFileSink::EmptyBufferL" )

	__ASSERT_ALWAYS( aBuffer && aProvider, User::Leave( KErrArgument ) );

    if ( iCurrentState != ERecording )

        {

        __FILESINK_MEDIA( "CMccFileSink::EmptyBufferL, IGNORED" )

        // Do not let the datapath to halt

        aProvider->BufferEmptiedL( aBuffer );

        return;

        }

    if ( iNotifySizeLimitReached )

        {

        __FILESINK_MEDIA( 

            "CMccFileSink::EmptyBufferL, IGNORED (notify size limit reached)" )

        MfcoSizeLimitReachedL();

        // Do not let the datapath to halt

        aProvider->BufferEmptiedL( aBuffer );

        return;

        }

	CMMFDataBuffer* buffer = static_cast<CMMFDataBuffer*>(aBuffer);

	CCMRMediaBuffer* outBuffer = NULL; 

	TTimeIntervalMicroSeconds timeToPlay = TimeToPlayL( buffer->TimeToPlay() );

   	__FILESINK_MEDIA_INT1( "CMccFileSink::EmptyBufferL, timeToPlay = ", 

	                       timeToPlay.Int64() )

	TBool dropBuffer( EFalse );                      

	if ( aMediaId.iMediaType == KUidMediaTypeAudio )

		{

    	__FILESINK_MEDIA( "CMccFileSink::EmptyBufferL, audio" )

    	outBuffer = new ( ELeave ) CCMRMediaBuffer(

        	buffer->Data(), CCMRMediaBuffer::EAudioAMRNB, buffer->BufferSize(),

            ETrue,  timeToPlay ); 

        CleanupStack::PushL( outBuffer );  

		}

	else if ( aMediaId.iMediaType == KUidMediaTypeVideo )

		{

    	__FILESINK_MEDIA( "CMccFileSink::EmptyBufferL, video" )    

        TFourCC providerDataType = UpdateActiveUserL( aMediaId, *aProvider );

        CCMRMediaBuffer::TBufferType bufType = 

            ResolveBufferType( *buffer, providerDataType );	

        dropBuffer = CheckWritingPermission( *buffer, bufType );

    	outBuffer = new ( ELeave ) CCMRMediaBuffer(

        	buffer->Data(), bufType, buffer->BufferSize(),

            ETrue,  timeToPlay );    

        CleanupStack::PushL( outBuffer );   

		}

	else

		{

    	__FILESINK_MEDIA( "CMccFileSink::EmptyBufferL, unknown media" ) 

		User::Leave( KErrNotSupported );	

		}

    if ( !dropBuffer )

        {

    	iFileComposer->WriteBufferL( outBuffer );

        }

	CleanupStack::PopAndDestroy( outBuffer );

	outBuffer= NULL;

	aProvider->BufferEmptiedL( aBuffer );

	}	

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

// CMccFileSink::BufferFilledL

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

//

void CMccFileSink::BufferFilledL( CMMFBuffer* /*aBuffer*/ )

	{

	__FILESINK_MEDIA( "CMccFileSink::BufferFilledL" )

	}	                  

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

// CMccFileSink::MfcoDiskFullL

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

//

void CMccFileSink::MfcoDiskFullL()

	{

	__FILESINK_MEDIA( "CMccFileSink::MfcoDiskFullL" )

	// After size limit has been reached, there is no way to really continue

	// recording to the same file, writebuffer returns without error but

	// has no effect. Pause the sink anyway but fail if resume is tried.

	// Creating new filewriter would be only way to recover from this but

	// that would overwrite old recording.

	iSizeLimitReached = ETrue;

	SendStreamEventToClient( KMccResourceNotAvailable, KErrNoMemory, ETrue );

    TRAP_IGNORE( AutomaticPauseL() );

    iNotifySizeLimitReached = EFalse;

	}	                  

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

// CMccFileSink::MfcoSizeLimitReachedL

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

//

void CMccFileSink::MfcoSizeLimitReachedL()

	{

	__FILESINK_MEDIA( "CMccFileSink::MfcoSizeLimitReachedL" )

	iSizeLimitReached = ETrue;

	SendStreamEventToClient( KMccResourceNotAvailable, KErrNone, ETrue );

    TRAP_IGNORE( AutomaticPauseL() );

    iNotifySizeLimitReached = EFalse;

	}	                  

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

// CMccFileSink::SetVideoCodecL

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

//

void CMccFileSink::SetVideoCodecL( const TMccCodecInfo& aVideoCodec )

    {

   	__FILESINK_CONTROLL_STR8( 

	    "CMccFileSink::SetVideoCodecL, sdpname:", aVideoCodec.iSdpName )

    TMccFileSinkUser* user = 

        MccUserArray<TMccFileSinkUser>::FindUserEntryForCurrent( iUsers, iAsyncEventHandler );

    if ( user )

        {

        user->iCodecInfo = aVideoCodec;

        }

    }

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

// CMccFileSink::SetAudioCodecL

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

//

void CMccFileSink::SetAudioCodecL( const TMccCodecInfo& /*aAudioCodec*/ )

    {

    __FILESINK_MEDIA( "CMccFileSink::SetAudioCodecL" )

    }

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

// CMccFileSink::RecordTimeAvailableL

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

//

void CMccFileSink::RecordTimeAvailableL( TTimeIntervalMicroSeconds& aTime )

	{ 

	__FILESINK_CONTROLL( "CMccFileSink::RecordTimeAvailableL" )

	aTime = iFileComposer->GetRemainingTimeL();

	}

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

// CMccFileSink::SetFileNameL

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

//

void CMccFileSink::SetFileNameL( const TFileName aFileName )

	{

	__FILESINK_CONTROLL( "CMccFileSink::SetFileNameL" )

	iFileName = aFileName;

	}

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

// CMccFileSink::SendStreamEventToClient

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

//	

void CMccFileSink::SendStreamEventToClient( 

    TMccEventType aEventType, 

    TInt aError,

    TBool aToAllClients )

	{

	__FILESINK_CONTROLL_INT2( 

	    "CMccFileSink::SendStreamEventToClient, type", aEventType, 

	    " to all:", aToAllClients )

    TMccEvent event( 0, 

                     0, 

                     0, 

                     MCC_ENDPOINT_ID( static_cast<MDataSink*>( this ) ), 

                     KMccEventCategoryStream, 

                     aEventType, 

                     aError, 

                     KNullDesC8 );

    if ( aToAllClients )

        {

        for ( TInt i = 0; i < iUsers.Count(); i++ )

            {

            FinalizeSendEvent( iUsers[ i ]->iEventHandler, event );

            }

        }

    else

        {

        FinalizeSendEvent( iAsyncEventHandler, event );

        }

	}

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

// CMccFileSink::TimeToPlayL

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

//	   	

TTimeIntervalMicroSeconds CMccFileSink::TimeToPlayL( 

    TTimeIntervalMicroSeconds aCurrentTimestamp )

    { 

    CalculateAverageTimestampDifferenceL( aCurrentTimestamp );

    TTimeIntervalMicroSeconds timeToPlay( 0 );