/*

* 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