/*
* Copyright (c) 2002-2004 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:    Uplink (record) datapath
*
*/




// INCLUDE FILES
#include <mmf/common/mmfcontroller.h>
#include "mcculdatapath.h"
#include "mccsubcontrollerlogs.h"


// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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


// -----------------------------------------------------------------------------
// CMccUlDataPath::CMccUlDataPath
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
CMccUlDataPath::CMccUlDataPath( 
	MAsyncEventHandler* aEventHandler,   
  	MMccResources* aMccResources,
	TMediaId aMediaId  ) : 
        CMccDataPathBase( aEventHandler, aMccResources, aMediaId )
    {
    }

// -----------------------------------------------------------------------------
// CMccUlDataPath::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
void CMccUlDataPath::ConstructL()
    {
	__SUBCONTROLLER( "CMccUlDataPath::ConstructL" )
 //   __ASSERT_ALWAYS( iEventHandler, User::Leave( KErrArgument ) );
	__SUBCONTROLLER( "CMccUlDataPath::ConstructL, exit" )
    }

// -----------------------------------------------------------------------------
// CMccUlDataPath::NewL
// Static constructor.
// -----------------------------------------------------------------------------
CMccUlDataPath* CMccUlDataPath::NewL( MAsyncEventHandler* aEventHandler, 
                                	  MMccResources* aMccResources,
                                	  TMediaId aMediaId )
    {
  //  __ASSERT_ALWAYS ( aEventHandler, User::Leave(KErrArgument) );
    CMccUlDataPath* self = new ( ELeave ) CMccUlDataPath( 
    	aEventHandler, aMccResources, aMediaId );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

// -----------------------------------------------------------------------------
// CMccUlDataPath::~CMccUlDataPath
// Destructor
// ----------------------------------------------------------------------------- 
CMccUlDataPath::~CMccUlDataPath()
    {
	__SUBCONTROLLER( "CMccUlDataPath::~CMccUlDataPath" )
    }

// -----------------------------------------------------------------------------
// CMccUlDataPath::PrimeL
// Primes the datapath
// -----------------------------------------------------------------------------
void CMccUlDataPath::PrimeL( TUint32 /*aEndpointId*/ )
    {
	__SUBCONTROLLER( "CMccUlDataPath::PrimeL" )
  /*  if ( iDataPathCreated && ( EStopped == State() ) )
        {
        __SUBCONTROLLER( "CMccUlDataPath::PrimeL, priming" )

        TBool bufferReference;
        iSinkBuffer = iDataSink->CreateSinkBufferL( iMediaId, bufferReference);
        __ASSERT_ALWAYS ( iSinkBuffer, User::Leave(KErrGeneral) );
        __ASSERT_ALWAYS ( bufferReference, User::Leave(KErrGeneral) );

        // Prime the source
        iDataSource->SourcePrimeL();
        // Prime the sink
        iDataSink->SinkPrimeL();
        
        // And we're primed...
        SetStateL( EPrimed );
        
        // Other allocations...
        CreateCompleteCallBackL();
        }
    else if( EPrimed == State() )
        {
        __SUBCONTROLLER( "CMccUlDataPath::PrimeL, already primed" )
        }
    else
        {
        __SUBCONTROLLER( "CMccUlDataPath::PrimeL, KErrNotReady" )
        User::Leave( KErrNotReady );
        }
        */
	__SUBCONTROLLER( "CMccUlDataPath::PrimeL, exit" )
    }

// -----------------------------------------------------------------------------
// CMccDlDataPath::PauseL
// Pauses the uplink streaming
// -----------------------------------------------------------------------------
void CMccUlDataPath::PauseL( TUint32 /*ndpointId*/ )
    {
	__SUBCONTROLLER( "CMccUlDataPath::PauseL" )
 /*   if( ERecording == State() && ( iDataPathCreated ) )
        {
        __SUBCONTROLLER( "CMccUlDataPath::PauseL, already pausing" )
        iDataSource->SourceStopL(); 
        iDataSink->SinkPauseL();     
          
        SetStateL( EPaused );
        iSinkBuffer = NULL;
        Cancel();
        }
    else if( EPrimed == State() )
        {
        __SUBCONTROLLER( "CMccUlDataPath::PauseL, already paused" )
        }
    else
        {
        __SUBCONTROLLER( "CMccUlDataPath::PauseL, KErrNotReady" )
        User::Leave( KErrNotReady );
        }
        */
	__SUBCONTROLLER( "CMccUlDataPath::PauseL, exit" )
    }

// -----------------------------------------------------------------------------
// CMccUlDataPath::PlayL
// Starts the uplink playing
// -----------------------------------------------------------------------------
void CMccUlDataPath::PlayL( TUint32 /*aEndpointId*/ )
    {
	__SUBCONTROLLER( "CMccUlDataPath::PlayL" )
  /*  if ( iDataPathCreated && ( EPrimed == State() ) )
        {
        __SUBCONTROLLER( "CMccUlDataPath::PlayL, playing" )
        SetStateL( ERecording );

        iDataPathCompletedErrorCode = KErrNone;       
        iDataSource->SourcePlayL();
        iDataSink->SinkPlayL();

        iSinkBuffer->SetStatus( EAvailable );          
        ChangeDataPathTransferState( ENeedSourceData );
        }
    else if( ERecording == State() )
        {
        __SUBCONTROLLER( "CMccUlDataPath::PlayL, already playing" )
        }
    else
        {
        __SUBCONTROLLER( "CMccUlDataPath::PlayL, KErrNotReady" )
        User::Leave( KErrNotReady );
        }
        */
	__SUBCONTROLLER( "CMccUlDataPath::PlayL, exit" )
    }

// -----------------------------------------------------------------------------
// CMccUlDataPath::BufferEmptiedL
// Buffer has been emptied callback
// -----------------------------------------------------------------------------
void CMccUlDataPath::BufferEmptiedL( CMMFBuffer* aBuffer )
    {
	__ASSERT_ALWAYS ( aBuffer, User::Leave(KErrArgument) );
	/*
    // This is the buffer emptied by payload format encoder
    // If it returns NULL buffer then something serious has happened
    // The NULL buffer is cheked in the IsBufferSupportedL() function
    IsBufferSupportedL( aBuffer );

    //Has the datapath stopped running, if so were not interested in any callbacks.
    if( ERecording == State() )
        {
        if ( iSinkBuffer != aBuffer ) //buffer has been updated
            {
            iSinkBuffer = aBuffer;
            }     

        iSinkBuffer->SetStatus( EAvailable );
                ChangeDataPathTransferState( ENeedSourceData );
        }
    else
        {
        User::Leave( KErrNotReady );
        }
        */
    };

// -----------------------------------------------------------------------------
// CMccUlDataPath::BufferFilledL
// Databuffer filled callback
// -----------------------------------------------------------------------------
void CMccUlDataPath::BufferFilledL( CMMFBuffer* /*aBuffer*/ )
    {
    /*
    //Has the datapath stopped running, if so were not interested in any callbacks.
    if( ERecording == State() )
        {
        if ( !aBuffer )
            {
            ChangeDataPathTransferState( EEndOfData );
            }
        else //sink buffer is with datapath, see if there is anything to send to sink
            {
	        IsBufferSupportedL( aBuffer );
	        aBuffer->SetStatus( EFull );

		    if( iSinkBuffer != aBuffer )
	        	{
				CopyBuffer( iSinkBuffer, aBuffer );
	        	}	
		    
		    if ( !aBuffer->BufferSize() || aBuffer->LastBuffer() )
		    	{
		        //ignore zero length buffer request for next buffer from AudioInput
		        iSinkBuffer->SetStatus( EAvailable );

		        ChangeDataPathTransferState( ENeedSourceData );
		    	}
		    else 
			    { 			    
          	    ChangeDataPathTransferState( ESendDataToSink );		
			    }
            }
        }
    else if( EPaused == State() )
        {
        }
    else
        {
        User::Leave( KErrNotReady );
        }
        */
    }

// -----------------------------------------------------------------------------
// CMccUlDataPath::FillSourceBufferL
// Fill the source buffer
// -----------------------------------------------------------------------------
void CMccUlDataPath::FillSourceBufferL()
    {
    /*
    iSinkBuffer->SetStatus( EBeingFilled );
    iSinkBuffer->SetLastBuffer( EFalse );

    // wait for BufferFilled callback from source. Do this here as some sources cause
    // re-entrancy into data path via BufferFilledL
    ChangeDataPathTransferState( EWaitSource );
    
	iDataSource->FillBufferL( iSinkBuffer, this, iMediaId );
	*/
    }

// -----------------------------------------------------------------------------
// CMccUlDataPath::EmptySinkBufferL
// Empty the sink buffer
// -----------------------------------------------------------------------------
void CMccUlDataPath::EmptySinkBufferL()
    {
    /*
    ChangeDataPathTransferState( EWaitSink );  

    iSinkBuffer->SetStatus( EFull );
    TRAPD( error, iDataSink->EmptyBufferL( iSinkBuffer, this, iMediaId ) );

    if ( KErrEof == error || KErrOverflow == error || KErrUnderflow == error )
        {
        iDataPathCompletedErrorCode = error;
        ChangeDataPathTransferState( EEndOfData );
        }
    else
	    {
	   	User::LeaveIfError( error );
	    }
	    */
    }

// -----------------------------------------------------------------------------
// CMccUlDataPath::DoEndOfData
// Worker function for data ending
// -----------------------------------------------------------------------------
void CMccUlDataPath::DoEndOfDataL()
    {
    /*
    if ( KErrNone == iDataPathCompletedErrorCode )
        {
        iDataPathCompletedErrorCode = KErrCompletion;
        }

    SignalDataPathCompleteL( iDataPathCompletedErrorCode );

    SetStateL( EStopped );
    */
    };

// -----------------------------------------------------------------------------
// CMccUlDataPath::Stop
// Stop the datapath
// -----------------------------------------------------------------------------
void CMccUlDataPath::StopL( TUint32 /*ndpointId*/ )
    {   
	__SUBCONTROLLER( "CMccUlDataPath::StopL" )
  /*  if ( ( iDataPathCreated )  && ( EStopped != State() ) )
        {
		__SUBCONTROLLER( "CMccUlDataPath::StopL, stopping" )
        iDataSource->SourceStopL();
        iDataSink->SinkStopL();
        iDataPathCompletedErrorCode = KErrNone;    
        iSinkBuffer = NULL;
        SetStateL( EStopped );                         
        Cancel();
        }
    else if( EStopped == State() )
        {
		__SUBCONTROLLER( "CMccUlDataPath::StopL, already stopped" )
        }
    else
        {
		__SUBCONTROLLER( "CMccUlDataPath::StopL, KErrNotReady" )
        User::Leave( KErrNotReady );
        }
        */
	__SUBCONTROLLER( "CMccUlDataPath::StopL, exit" )
    }


// -----------------------------------------------------------------------------
// CMccUlDataPath::NegotiateL
// Negotiate the source and sink
// -----------------------------------------------------------------------------
void CMccUlDataPath::NegotiateL( MDataSink& /*aDataSink*/ )
    {
	__SUBCONTROLLER( "CMccUlDataPath::NegotiateL" )
   /* iDataSink = &aDataSink;
    iDataSource->NegotiateSourceL( *iDataSink );
	DoNegotiateL();    
	*/
	__SUBCONTROLLER( "CMccUlDataPath::NegotiateL, exit" )
    }
    

// -----------------------------------------------------------------------------
// CMccUlDataPath::ResumeL
// Resumes pause audio streaming
// -----------------------------------------------------------------------------
void CMccUlDataPath::ResumeL( TUint32 /*aEndpointId*/ )
    {
    
	__SUBCONTROLLER( "CMccUlDataPath::ResumeL" )
	/*
    if ( iDataPathCreated && ( EPaused == State() ) )
        {
		__SUBCONTROLLER( "CMccUlDataPath::ResumeL, playing" )
        iDataSource->SourcePrimeL();        
        SetStateL( ERecording );
        iDataPathCompletedErrorCode = KErrNone;
        TBool bufferReference;
        iSinkBuffer = iDataSink->CreateSinkBufferL( iMediaId, bufferReference);
        __ASSERT_ALWAYS ( iSinkBuffer, User::Leave(KErrGeneral) );
        __ASSERT_ALWAYS ( bufferReference, User::Leave(KErrGeneral) );
        
        iDataSource->SourcePlayL();
        iDataSink->SinkPlayL();

        iSinkBuffer->SetStatus( EAvailable );
        ChangeDataPathTransferState( ENeedSourceData );
        }
    else if( ERecording == State() )
        {
		__SUBCONTROLLER( "CMccUlDataPath::ResumeL, already playing" )
        }
    else
        {
		__SUBCONTROLLER( "CMccUlDataPath::ResumeL, KErrNotReady" )
        User::Leave( KErrNotReady );
        }
        */
	__SUBCONTROLLER( "CMccUlDataPath::ResumeL, exit" )
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File