/*
* 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 "mcedisplaysink.h"
#include "mcecomdisplaysink.h"
#include "mceevents.h"
#include "mcecomcodec.h"
#include "mcecommediastream.h"
#include "mcecomsession.h"
#include "mcecomavsink.h"

#ifdef MCE_COMMON_SERVER_SIDE

#include <mmccinterface.h>
#include "mcesdpsession.h"
#include "mcemediamanager.h"
#include "mcevideostream.h"
#include "mcecomvideocodec.h"

#endif//MCE_COMMON_SERVER_SIDE

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



// -----------------------------------------------------------------------------
// CMceComDisplaySink::NewL
// -----------------------------------------------------------------------------
//
CMceComDisplaySink* CMceComDisplaySink::NewL()
    {
    CMceComDisplaySink* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CMceComDisplaySink::NewLC
// -----------------------------------------------------------------------------
//
CMceComDisplaySink* CMceComDisplaySink::NewLC()
    {
    CMceComDisplaySink* self = new (ELeave) CMceComDisplaySink();
    CleanupStack::PushL( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CMceComDisplaySink::~CMceComDisplaySink
// -----------------------------------------------------------------------------
//
CMceComDisplaySink::~CMceComDisplaySink()
    {
    
    delete iSettings;
    if ( iEndpointProxy )
        {
        CMceComAvSink* endpointProxy = static_cast<CMceComAvSink*>( iEndpointProxy );
        endpointProxy->RemoveProxyClient( *this );
        if ( endpointProxy->ReferenceCount() == 0 )
            {
            delete endpointProxy;
            }
        iEndpointProxy = NULL;
        }
    
    }


// -----------------------------------------------------------------------------
// CMceComDisplaySink::CMceComDisplaySink
// -----------------------------------------------------------------------------
//
CMceComDisplaySink::CMceComDisplaySink()
  : CMceComMediaSink( KMceDisplaySink )
    {
    // Temporarily some default values
    // TRect (0,83,352,378);
    iDisplayIndex = 0;
    iDisplayRectTlX = 0;
    iDisplayRectTlY = 83;
    iDisplayRectBrX = 352;
    iDisplayRectBrY = 378;
    iPriority = 0;
    iIsViewFinder = EFalse;
    iRotation = CMceDisplaySink::ENone;
    iDisplaysAvailable = 0;
    iInitialInfoRetrieved = EFalse;
    
    }

// -----------------------------------------------------------------------------
// CMceComDisplaySink::CloneL
// -----------------------------------------------------------------------------
//
CMceComMediaSink* CMceComDisplaySink::CloneL()
    {
    CMceComDisplaySink* copy = new (ELeave) CMceComDisplaySink();
    Mem::Copy( copy, this, sizeof(CMceComDisplaySink) );
    copy->Zero();
    copy->iSettings = 0;
    return copy;
        
    }

// -----------------------------------------------------------------------------
// CMceComDisplaySink::UsesEndpointProxy()
// -----------------------------------------------------------------------------
//
TBool CMceComDisplaySink::UsesEndpointProxy() const
    {
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CMceComDisplaySink::CreateEndpointProxyL()
// -----------------------------------------------------------------------------
//
MMceComEndPointProxy* CMceComDisplaySink::CreateEndpointProxyL() const
    {
    return CMceComAvSink::NewL();
    }



// -----------------------------------------------------------------------------
// CMceComDisplaySink::InternalizeFlatL
// -----------------------------------------------------------------------------
//
void CMceComDisplaySink::InternalizeFlatL( RReadStream& aReadStream )
    {
    CMceComMediaSink::InternalizeFlatL( aReadStream );
    
    iDisplayIndex = aReadStream.ReadInt32L();
    iDisplayRectTlX = aReadStream.ReadInt32L();
    iDisplayRectTlY = aReadStream.ReadInt32L();
    iDisplayRectBrX = aReadStream.ReadInt32L();
    iDisplayRectBrY = aReadStream.ReadInt32L();
    iPriority = aReadStream.ReadUint32L();
    iIsViewFinder = aReadStream.ReadInt32L();
    iRotation = static_cast<CMceDisplaySink::TRotation> ( aReadStream.ReadInt32L() );
    
    iDisplaysAvailable = aReadStream.ReadInt32L();
    iInitialInfoRetrieved = static_cast<TBool>( aReadStream.ReadUint8L() );

    }



// -----------------------------------------------------------------------------
// CMceComDisplaySink::ExternalizeFlatL
// -----------------------------------------------------------------------------
//
void CMceComDisplaySink::ExternalizeFlatL( RWriteStream& aWriteStream )
    {
    CMceComMediaSink::ExternalizeFlatL( aWriteStream );
    
    aWriteStream.WriteInt32L( iDisplayIndex );
    aWriteStream.WriteInt32L( iDisplayRectTlX );
    aWriteStream.WriteInt32L( iDisplayRectTlY );
    aWriteStream.WriteInt32L( iDisplayRectBrX );
    aWriteStream.WriteInt32L( iDisplayRectBrY );
    aWriteStream.WriteUint32L( iPriority );
    aWriteStream.WriteInt32L( iIsViewFinder );
    aWriteStream.WriteInt32L( iRotation );
    aWriteStream.WriteInt32L( iDisplaysAvailable );
    aWriteStream.WriteUint8L( iInitialInfoRetrieved );
    
    }

  
    
// -----------------------------------------------------------------------------
// CMceComDisplaySink::EventReceivedL
// -----------------------------------------------------------------------------
//
TInt CMceComDisplaySink::EventReceivedL( TMceComEvent& aEvent )
    {
    TInt status = CMceComMediaSink::EventReceivedL( aEvent );
    if ( status != KMceEventNotConsumed )
        {
        return status;
        }
                
    if ( aEvent.Id().IsSinkId() )
        {
        status = aEvent.Handler().HandleL( *this, aEvent );
        }
    else
        {
        status = KMceEventNotConsumed;
        }
    
    return status;
    
    }
    
    
// -----------------------------------------------------------------------------
// CMceComDisplaySink::UpdateL
// -----------------------------------------------------------------------------
//
void CMceComDisplaySink::UpdateL( CMceComMediaSink& aUpdate )
    {
    CMceComMediaSink::UpdateL( aUpdate );
    CMceComDisplaySink& update = static_cast<CMceComDisplaySink&>( aUpdate );
    
    iDisplayIndex = update.iDisplayIndex;
    iDisplayRectTlX = update.iDisplayRectTlX;
    iDisplayRectTlY = update.iDisplayRectTlY;
    iDisplayRectBrX = update.iDisplayRectBrX;
    iDisplayRectBrY = update.iDisplayRectBrY;
    iPriority = update.iPriority;
    iIsViewFinder = update.iIsViewFinder;
    iDisplaysAvailable = update.iDisplaysAvailable;
    iInitialInfoRetrieved = update.iDisplaysAvailable;
    
    }
    

#ifdef MCE_COMMON_SERVER_SIDE

// -----------------------------------------------------------------------------
// CMceComDisplaySink::MccType
// -----------------------------------------------------------------------------
//
const TUid CMceComDisplaySink::MccType()
    {
    TUid id = KUidMccVideoSink;
    
    if ( EndpointProxy() )
        {
        CMceComAvSink* endpointProxy = static_cast<CMceComAvSink*>( EndpointProxy() );
        id = endpointProxy->MccType();
        }
    return id;
        
    }


// -----------------------------------------------------------------------------
// CMceComDisplaySink::EnableL
// -----------------------------------------------------------------------------
//
void CMceComDisplaySink::EnableL( const CMceComCodec& aCodec )
    {
    __ASSERT_ALWAYS( iIsViewFinder, User::Leave( KErrArgument ) );
    CMceMediaManager& manager = MediaStream()->Session()->SdpSession().Manager();
    
    // Update iSettings
    DoInitParamL( aCodec );
    
    manager.EnableViewFinderL( *this, *iSettings );		
    
    }

// -----------------------------------------------------------------------------
// CMceComMediaSource::DisableL
// -----------------------------------------------------------------------------
//
void CMceComDisplaySink::DisableL()
    {
    __ASSERT_ALWAYS( iIsViewFinder, User::Leave( KErrArgument ) );
    CMceMediaManager& manager = MediaStream()->Session()->SdpSession().Manager();
    
    manager.DisableViewFinderL( *this );
    
    }


// -----------------------------------------------------------------------------
// CMceComDisplaySink::InitParamL
// -----------------------------------------------------------------------------
//
const TDesC8& CMceComDisplaySink::InitParamL( const CMceComCodec& aCodec )
    {
    delete iSettings;
    iSettings = NULL;

    if ( EndpointProxy() )
        {
        CMceComAvSink* endpointProxy = static_cast<CMceComAvSink*>( EndpointProxy() );
        return endpointProxy->InitParamL( aCodec );
        }
    else
        {
        DoInitParamL( aCodec );
        }
       
    return *iSettings;
    
    }

// -----------------------------------------------------------------------------
// CMceComDisplaySink::PrepareL
// -----------------------------------------------------------------------------
//    
void CMceComDisplaySink::PrepareL()
    {
    if ( EndpointProxy() )
        {
        CMceComAvSink* endpointProxy = static_cast<CMceComAvSink*>( EndpointProxy() );
        endpointProxy->PrepareL();
        }
    }

// -----------------------------------------------------------------------------
// CMceComDisplaySink::DoInitParamL
// -----------------------------------------------------------------------------
//
const TDesC8& CMceComDisplaySink::DoInitParamL( const CMceComCodec& aCodec )
    {
    delete iSettings;
    iSettings = NULL;

    TMccVideoSinkSetting displaySetting;
    TRect displayRect = DisplayRect();
    
    CMceComDisplaySink::ToPointAndSize( displayRect, 
                                        displaySetting.iLocation, 
                                        displaySetting.iSize );
    displaySetting.iDeviceIndex = 0;
    TMMFPrioritySettings priority;
    priority.iPriority = aCodec.iPriority;
    priority.iPref = TMdaPriorityPreference(aCodec.iPriorityPreference);
    displaySetting.iPriority = priority;
    
    displaySetting.iVideoPayloadType = aCodec.iPayloadType;
    displaySetting.iIAPId = MediaStream()->Session()->iIapId;
    displaySetting.iWindowOrdinalPosition = 1;
    displaySetting.iWindowOrdinalPriority = iPriority;
    displaySetting.iRotation = EMccNone;
    
    if ( aCodec.Stream() && aCodec.Stream()->iType == KMceVideo )
        {
        displaySetting.iVideoFrameRate = 
            reinterpret_cast<const CMceComVideoCodec&>( aCodec ).iReceiveFrameRate;
        }
    else
        {
        displaySetting.iVideoFrameRate = 0;
        }

    TMccVideoSinkSettingBuf settings( displaySetting );
    
    iSettings = settings.AllocL();
    
    return *iSettings;

    }
    
// -----------------------------------------------------------------------------
// CMceComDisplaySink::DisplayRect
// -----------------------------------------------------------------------------
//
TRect CMceComDisplaySink::DisplayRect()
    {
    return TRect( iDisplayRectTlX,
                  iDisplayRectTlY,
                  iDisplayRectBrX,
                  iDisplayRectBrY );
    }

// -----------------------------------------------------------------------------
// CMceComDisplaySink::SetDisplayRect
// -----------------------------------------------------------------------------
//
void CMceComDisplaySink::SetDisplayRect( const TRect& aRect )
    {
    iDisplayRectTlX = aRect.iTl.iX;
    iDisplayRectTlY = aRect.iTl.iY;
    iDisplayRectBrX = aRect.iBr.iX;
    iDisplayRectBrY = aRect.iBr.iY;
    }

// -----------------------------------------------------------------------------
// CMceComDisplaySink::ToRect
// -----------------------------------------------------------------------------
//
void CMceComDisplaySink::ToRect( const TPoint& aPoint, const TSize& aSize, TRect& aRect )
    {
    aRect = TRect( aPoint, aSize );
    }


// -----------------------------------------------------------------------------
// CMceComDisplaySink::ToPointAndSize
// -----------------------------------------------------------------------------
//
void CMceComDisplaySink::ToPointAndSize( const TRect& aRect, TPoint& aPoint, TSize& aSize )
    {
    aPoint = TPoint( aRect.iTl.iX, aRect.iTl.iY );
    aSize = TSize( aRect.iBr.iX - aRect.iTl.iX,
                   aRect.iBr.iY - aRect.iTl.iY );
    
    }
    

// -----------------------------------------------------------------------------
// CMceComDisplaySink::SetViewFinder
// -----------------------------------------------------------------------------
//
void CMceComDisplaySink::SetViewFinder( TBool aIsViewFinder )
    {
    iIsViewFinder = aIsViewFinder;
    }

// -----------------------------------------------------------------------------
// CMceComDisplaySink::MccParameterName
// -----------------------------------------------------------------------------
//    
TUint32 CMceComDisplaySink::MccParameterName() const
    {
    return iIsViewFinder ? KMccCamLocalVideo : KMccDisplayLocalVideo;
    }

#endif//MCE_COMMON_SERVER_SIDE