/*
* 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 "mccmultiplexer.h"
#include "mccsinkitem.h"
#include "mccinternaldef.h"
#include "mccinternalevents.h"
#include "mccmultiplexerlogs.h"
#include "mccinternalevents.h"
#include "mccrtpdatasource.h"

// MACROS

// LOCAL FUNCTION PROTOTYPES

// LOCAL CONSTANTS

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

// -----------------------------------------------------------------------------
// CMccMultiplexer::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CMccMultiplexer* CMccMultiplexer::NewL( MDataSource* aSource )
    {
	CMccMultiplexer* self = new ( ELeave ) CMccMultiplexer;
	CleanupStack::PushL( self );
    self->ConstructL( aSource );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::~CMccMultiplexer
// -----------------------------------------------------------------------------
//
EXPORT_C CMccMultiplexer::~CMccMultiplexer()
    {
    }
  
// -----------------------------------------------------------------------------
// CMccMultiplexer::MultiplexerSourceThreadLogon
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMccMultiplexer::MultiplexerSourceThreadLogon( 
    MAsyncEventHandler& aEventHandler, 
    MDataSink& /*aSink*/, 
    TBool /*aSinkIsDecoder*/, 
    TUid /*aMediaType*/,
    TBool /*aPassAllBuffersSink*/ )
    {
    return iSource->SourceThreadLogon( aEventHandler );
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SourceThreadLogoff
// -----------------------------------------------------------------------------
//       
EXPORT_C TInt CMccMultiplexer::MultiplexerSourceThreadLogoff( MDataSink* /*aSink*/ )
    {
    iSource->SourceThreadLogoff();
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SetCurrentUserL
// -----------------------------------------------------------------------------
//    
EXPORT_C void CMccMultiplexer::SetCurrentUserL( MDataSink& /*aSink*/ )
    {
    }
    
// -----------------------------------------------------------------------------
// CMccMultiplexer::RegClientForPayloadsL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMccMultiplexer::RegClientForPayloadsL( MDataSink& /*aConsumer*/, 
        const RArray<TUint>& aPayloadTypes )
    {
    __MULTIPLEXER( "CMccMultiplexer::RegClientForPayloadsL" )
    __ASSERT_ALWAYS( iSource, User::Leave( KErrNotReady ) );
    __ASSERT_ALWAYS( KMccRtpSourceUid == iSource->DataSourceType(),
        User::Leave( KErrNotSupported ) );
    
    //FindSinkItemL( &aConsumer )->RegisterPayloadTypesL( aPayloadTypes );
    static_cast<CMccRtpDataSource*>( iSource )
        ->RegisterPayloadTypesL( aPayloadTypes );
    }
    
// -----------------------------------------------------------------------------
// CMccMultiplexer::Streams
// -----------------------------------------------------------------------------
//
TUint CMccMultiplexer::Streams( TUid /*aMediaType*/ ) const
    {
    return 1;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::FrameTimeInterval
// -----------------------------------------------------------------------------
//
TTimeIntervalMicroSeconds CMccMultiplexer::FrameTimeInterval( 
    TMediaId /*aMediaId*/ ) const
    {
    return TTimeIntervalMicroSeconds( 0 );
    }  

// -----------------------------------------------------------------------------
// CMccMultiplexer::DataSourceType
// -----------------------------------------------------------------------------
//
TUid CMccMultiplexer::DataSourceType() const
    {
    return KMccMultiplexerUid;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::FillBufferL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::FillBufferL( 
    CMMFBuffer* /*aBuffer*/, 
    MDataSink* /*aConsumer*/, 
    TMediaId /*aMediaId*/ )
    {
    }  
        
// -----------------------------------------------------------------------------
// CMccMultiplexer::SourceDataTypeCode
// -----------------------------------------------------------------------------
//
TFourCC CMccMultiplexer::SourceDataTypeCode( 
	TMediaId /*aMediaId*/ )
    {
    return TFourCC();
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SetSourceDataTypeCode
// -----------------------------------------------------------------------------
//
TInt CMccMultiplexer::SetSourceDataTypeCode( 
    TFourCC /*aSourceFourCC*/, 
    TMediaId /*aMediaId*/ )
    {
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SourceThreadLogon
// -----------------------------------------------------------------------------
//
TInt CMccMultiplexer::SourceThreadLogon( 
    MAsyncEventHandler& /*aEventHandler*/ )
    {
    return KErrNotSupported;
    }
    
// -----------------------------------------------------------------------------
// CMccMultiplexer::NegotiateSourceL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::NegotiateSourceL( MDataSink& aDataSink )
    {
    if ( KUidMmfAudioInput == iSource->DataSourceType() )
        {
        // Audio input need settings from real sink.
        // This is just quick workaround, better way would be to route
        // those requests through multiplexer to the sink
        
        __MULTIPLEXER( "CMccMultiplexer::NegotiateSourceL, negotiate (use sink)" )
        
        iSource->NegotiateSourceL( aDataSink );
        }
    else
        {
        __MULTIPLEXER( "CMccMultiplexer::NegotiateSourceL, negotiate (normal)" )
        
        iSource->NegotiateSourceL( *this );
        }
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SourceThreadLogoff
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::SourceThreadLogoff()
    {
    // NOP
    }
    
// -----------------------------------------------------------------------------
// CMccMultiplexer::SourcePrimeL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::SourcePrimeL()
    {
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SourcePlayL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::SourcePlayL()
    {
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SourcePauseL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::SourcePauseL()
    {
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SourceStopL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::SourceStopL()
    {
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::DataBufferFilledL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::DataBufferFilledL( 
    CMMFBuffer* /*aBuffer*/, 
    const TRtpRecvHeader& /*aRtpHeader*/ )
    {
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::ConfigurePayloadFormatL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::ConfigurePayloadFormatL( const TDesC8& /*aConfigParams*/ )
    {
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::BufferFilledL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::BufferFilledL( CMMFBuffer* /*aBuffer*/ )
	{
	}
	
// -----------------------------------------------------------------------------
// CMccMultiplexer::Duration
// -----------------------------------------------------------------------------
//
TTimeIntervalMicroSeconds CMccMultiplexer::Duration( 
	TMediaId /*aMediaType*/ ) const
    {
    return TTimeIntervalMicroSeconds( 0 );
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::CanCreateSourceBuffer
// -----------------------------------------------------------------------------
//    
TBool CMccMultiplexer::CanCreateSourceBuffer()
    {
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::CreateSourceBufferL
// -----------------------------------------------------------------------------
//
CMMFBuffer* CMccMultiplexer::CreateSourceBufferL( 
    TMediaId /*aMediaId*/, 
    TBool& /*aReference*/ )
    {
    User::Leave( KErrNotSupported );
    return 0;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SuggestSourceBufferSize
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::SuggestSourceBufferSize( TUint aSuggestedBufferSize )
    {
    __MULTIPLEXER_INT1( "CMccMultiplexer::SuggestSourceBufferSize, SIZE: ",
         aSuggestedBufferSize )
    
//    iSuggestedBufSize = aSuggestedBufferSize;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SendEventToClient
// -----------------------------------------------------------------------------
//
TInt CMccMultiplexer::SendEventToClient( const TMMFEvent& /*aEvent*/ )
    {
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CMccMultiplexer::CMccMultiplexer
// -----------------------------------------------------------------------------
//
CMccMultiplexer::CMccMultiplexer()
    {
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::ConstructL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::ConstructL( MDataSource* aSource )
    {
    __ASSERT_ALWAYS( aSource, User::Leave( KErrArgument ) );
    
    iSource = aSource;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::FindSinkItemL
// -----------------------------------------------------------------------------
//
CMccSinkItem* CMccMultiplexer::FindSinkItemL( MDataSink* aSink )
    {
    TInt index = FindSinkItemIndex( aSink );
    __ASSERT_ALWAYS( index != KErrNotFound, User::Leave( KErrNotFound ) );
    
    return iSinkItems[ index ];
    }
    
// -----------------------------------------------------------------------------
// CMccMultiplexer::FindSinkItemIndex
// -----------------------------------------------------------------------------
//
TInt CMccMultiplexer::FindSinkItemIndex( MDataSink* /*aSink*/ )
    {
    /*for ( TInt i = 0; i < iSinkItems.Count(); i++ )
        {
        if ( iSinkItems[ i ]->Match( aSink ) )
            {
            return i;
            }
        }*/
    return KErrNotFound;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::IsPrimarySink
// -----------------------------------------------------------------------------
//    
TBool CMccMultiplexer::IsPrimarySink( MDataSink* /*aSink*/ )
    {
    return ETrue;
    }
    
// -----------------------------------------------------------------------------
// CMccMultiplexer::DoBufferFilledL
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::DoBufferFilledL( 
    CMMFBuffer* /*aBuffer*/, 
    const TRtpRecvHeader* /*aRtpHeader*/ )
    {
    }   

// -----------------------------------------------------------------------------
// CMccMultiplexer::AddSinkL
// -----------------------------------------------------------------------------
//  
void CMccMultiplexer::AddSinkL( 
    MDataSink* /*aSink*/, 
    TBool /*aSinkIsDecoder*/,
    TUid /*aMediaType*/,
    TBool /*aPassAllBuffersSink*/ )
    {
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SetMultiplexerState
// -----------------------------------------------------------------------------
//    
TBool CMccMultiplexer::SetMultiplexerState( TMccMultiplexerState /*aState*/ )
    {
    return EFalse;
    }
    
// -----------------------------------------------------------------------------
// CMccMultiplexer::SendStreamEventToClient
// -----------------------------------------------------------------------------
//     
void CMccMultiplexer::SendStreamEventToClient( TMccEventType& /*aEventType*/ )
    {
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::UpdateSinkModes
// -----------------------------------------------------------------------------
//
void CMccMultiplexer::UpdateSinkModes()
    {
    }
    
// -----------------------------------------------------------------------------
// CMccMultiplexer::PassAllRequestsToSource
// -----------------------------------------------------------------------------
//   
TBool CMccMultiplexer::PassAllRequestsToSource( CMccSinkItem& /*aItem*/ ) const
    {
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::IsSupportedMediaType
// -----------------------------------------------------------------------------
//    
TBool CMccMultiplexer::IsSupportedMediaType( TUid aMediaType ) const
    {
    return ( aMediaType == KUidMediaTypeVideo || 
             aMediaType == KUidMediaTypeAudio );
    }

// -----------------------------------------------------------------------------
// CMccMultiplexer::SendEventToAllClients
// -----------------------------------------------------------------------------
// 
void CMccMultiplexer::SendEventToAllClients( const TMMFEvent& /*aEvent*/ )
    {
    /*for ( TInt i = 0; i < iSinkItems.Count(); i++ )
        {
        iSinkItems[ i ]->SendEventToClient( aEvent );
        }*/
    }

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

// -----------------------------------------------------------------------------
// E32Dll.
// DLL Entry point
// Returns: KErrNone
// -----------------------------------------------------------------------------
//
#ifndef EKA2
EXPORT_C TInt E32Dll( TDllReason )
    {
    return KErrNone;
    }
#endif


//  End of File