/*
* Copyright (c) 2004-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 <pv_plugin_interfaces.h>
#include "mvtprotocolhandler.h"
#include "cdatasourceproxy.h"

#ifdef _DEBUG
#    define __IF_DEBUG(t) {RDebug::t;}
#else
#    define __IF_DEBUG(t)
#endif

// -----------------------------------------------------------------------------
// CPVCameraSourceNodeProxy::CPVCameraSourceNodeProxy
// Constructor.
// -----------------------------------------------------------------------------
//
CPVCameraSourceNodeProxy::CPVCameraSourceNodeProxy() : MVTVideoSink(KNullUid) 
    { 
    }

// -----------------------------------------------------------------------------
// CPVCameraSourceNodeProxy::SetConsumer
// Set consumer object.
// -----------------------------------------------------------------------------
//
void CPVCameraSourceNodeProxy::SetConsumer(MPVDataSinkBase* aConsumer)
    {
    __IF_DEBUG(Print(_L("VTProto: CPVCameraSourceNodeProxy::SetConsumer<")));
    iConsumer = aConsumer;    
    __IF_DEBUG(Print(_L("VTProto: CPVCameraSourceNodeProxy::SetConsumer>")));
    }

// -----------------------------------------------------------------------------
// CPVCameraSourceNodeProxy::BufferFilledL
// Method called by a data source to pass back an filled buffer to the sink.
// -----------------------------------------------------------------------------
//
void CPVCameraSourceNodeProxy::BufferFilledL(CMMFBuffer* aBuffer)
    {
    __IF_DEBUG(Print(_L("VTProto: CPVCameraSourceNodeProxy::BufferFilledL<")));
    iConsumer->BufferFilledL(aBuffer);
    __IF_DEBUG(Print(_L("VTProto: CPVCameraSourceNodeProxy::BufferFilledL>")));
    }

// -----------------------------------------------------------------------------
// CPVCameraSourceNodeProxy::SendEventToClient
// Send event to client.
// -----------------------------------------------------------------------------
//
TInt CPVCameraSourceNodeProxy::SendEventToClient(const TMMFEvent &aEvent)
    {
    __IF_DEBUG(Print(_L("VTProto: CPVCameraSourceNodeProxy::SendEventToClient<")));	
    MAsyncEventHandler* eventHandler = dynamic_cast<MAsyncEventHandler*>(iConsumer);
    TInt result = eventHandler->SendEventToClient(aEvent);
    __IF_DEBUG(Print(_L("VTProto: CPVCameraSourceNodeProxy::SendEventToClient>")));
    return result;
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::CVideoSourceProxy
// Constructor.
// -----------------------------------------------------------------------------
//
CVideoSourceProxy::CVideoSourceProxy(MVTVideoSource* aDataSource) : MPVDataSource(KNullUid), iVideoSource(aDataSource) 
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::CVideoSourceProxy<")));
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::CVideoSourceProxy iVideoSource %d>"), iVideoSource));	
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::ConstructL
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::ConstructL() 
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::ConstructL<")));
    iCameraSourceNodeProxy = new (ELeave) CPVCameraSourceNodeProxy();
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::ConstructL>")));	
    }
    
// -----------------------------------------------------------------------------
// CVideoSourceProxy::NewL
// -----------------------------------------------------------------------------
//
CVideoSourceProxy* CVideoSourceProxy::NewL(MVTVideoSource* aDataSource) 
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::NewL<")));
    CVideoSourceProxy* self = new (ELeave)CVideoSourceProxy(aDataSource);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::NewL>")));  
    return self;
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::QueryInterface
// This API is to allow for extensibility of the plugin interface.
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::QueryInterface( const TPVUuid& aUuid, TPVInterfacePtr& aInterfacePtr )
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::QueryInterface<")));	
    if ( aUuid == KPVUidVideoInputInterface )
            {
            MPVVideoInput* interfaceP = (MPVVideoInput*) this;
            aInterfacePtr = (TPVInterfacePtr) interfaceP;
            }
        else
            {
            aInterfacePtr = NULL;
            }
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::QueryInterface aInterfacePtr %d<"), aInterfacePtr));        
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::GetMultimediaTypesL
// This API returns multimedias type supported by the data source/sink.
// -----------------------------------------------------------------------------
//
const RArray<TPVMIMEType *>& CVideoSourceProxy::GetMultimediaTypesL() const
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::GetMultimediaTypesL iVideoSource %d"), iVideoSource));	
    const RArray<TPVMIMEType *>& multimediaType = iVideoSource->GetMultimediaTypesL();
    return multimediaType;
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::QueryUUID
// This API is to allow for extensibility of the plugin interface.
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::QueryUUID( const TPVMIMEType& aMimeType, RArray<TPVUuid>& aUuids, bool aExactUuidsOnly)
    {
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::SetTimebaseL
// This API is used to provide a timebase for plugins that deal with synchronized media data.
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::SetTimebaseL(MPVSymbianTimebaseInterface* aTimebase)
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SetTimebaseL<")));
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SetTimebaseL>")));
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::FillBufferL
// Method called by a MDataSink to request the data source to fill aBuffer with data.
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::FillBufferL(CMMFBuffer* aBuffer, MPVDataSinkBase* aConsumer, TMediaId aMediaId )
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::FillBufferL<")));
    iCameraSourceNodeProxy->SetConsumer(aConsumer);
    iVideoSource->FillBufferL(aBuffer, iCameraSourceNodeProxy, aMediaId);
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::FillBufferL>")));
    }    

// -----------------------------------------------------------------------------
// CVideoSourceProxy::CreateSourceBufferL
// Returns a buffer created by the data source.
// -----------------------------------------------------------------------------
//
CMMFBuffer* CVideoSourceProxy::CreateSourceBufferL(TMediaId aMediaId, TBool &aReference )
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::CreateSourceBufferL")));
    return iVideoSource->CreateSourceBufferL(aMediaId, aReference);
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::CreateSourceBufferL
// Returns a buffer created by the data source.
// -----------------------------------------------------------------------------
//
CMMFBuffer* CVideoSourceProxy::CreateSourceBufferL(TMediaId aMediaId, CMMFBuffer &aSinkBuffer, TBool &aReference)
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::CreateSourceBufferL")));	
    return iVideoSource->CreateSourceBufferL(aMediaId, aSinkBuffer, aReference);
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::SourceThreadLogon
// Method to 'logon' the data source to the same thread that source will be supplying data in.
// -----------------------------------------------------------------------------
//
TInt CVideoSourceProxy::SourceThreadLogon( MAsyncEventHandler& aEventHandler )
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SourceThreadLogon")));	
    return iVideoSource->SourceThreadLogon(aEventHandler);
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::SourceThreadLogoff
// Method to 'logoff' the data source from the same thread that source supplies data in.
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::SourceThreadLogoff()
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SourceThreadLogoff<")));		
    iVideoSource->SourceThreadLogoff();
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SourceThreadLogoff>")));
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::SourcePrimeL
// Method to 'prime' the data source.
// -----------------------------------------------------------------------------
//
TInt CVideoSourceProxy::SourcePrimeL()
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SourcePrimeL<")));			
    return iVideoSource->SourcePrimeL();
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::SourcePlayL
// Method to 'play' the data source.
// -----------------------------------------------------------------------------
//
TInt CVideoSourceProxy::SourcePlayL()
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SourcePlayL")));	
    return iVideoSource->SourcePlayL();
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::SourcePauseL
// Method to 'pause' the data source.
// -----------------------------------------------------------------------------
//
TInt CVideoSourceProxy::SourcePauseL()
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SourcePauseL")));
    return iVideoSource->SourcePauseL();
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::SourceStopL
// Method to 'stop' the data source.
// -----------------------------------------------------------------------------
//
TInt CVideoSourceProxy::SourceStopL()
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SourceStopL")));	
    return iVideoSource->SourceStopL();
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::BufferEmptiedL
// Method called by a data sink to pass back an emptied buffer to the source.
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::BufferEmptiedL(CMMFBuffer* aBuffer)
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::BufferEmptiedL")));		
    iVideoSource->BufferEmptiedL(aBuffer);
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::CanCreateSourceBuffer
// Method to indicate whether the data source can create a buffer.
// -----------------------------------------------------------------------------
//
TBool CVideoSourceProxy::CanCreateSourceBuffer()
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::CanCreateSourceBuffer")));		
    return iVideoSource->CanCreateSourceBuffer();
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::SetFormatL
// Set the video frame format.  This must be from the list of supported formats.
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::SetFormatL(const TDesC8& aFormat)
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SetFormatL")));		
    iVideoSource->SetFormatL(aFormat);
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::SetFrameRateL
// Set the video frame rate.  This must be within the range of supported frame rates.
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::SetFrameRateL(TReal32 aFrameRate)
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SetFrameRateL")));		
    iVideoSource->SetFrameRateL(aFrameRate);
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::SetVideoFrameSizeL
// Set the video frame size.
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::SetVideoFrameSizeL(const TSize& aSize)
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SetVideoFrameSizeL <")));		
    iVideoSource->SetVideoFrameSizeL(aSize);
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::SetVideoFrameSizeL >")));	
    }

// -----------------------------------------------------------------------------
// CVideoSourceProxy::GetVideoFrameSizeL
// Get the video frame size.
// -----------------------------------------------------------------------------
//
void CVideoSourceProxy::GetVideoFrameSizeL(TSize& aSize) const
    {
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::GetVideoFrameSizeL<")));		
    iVideoSource->GetVideoFrameSizeL(aSize);
    __IF_DEBUG(Print(_L("VTProto: CVideoSourceProxy::GetVideoFrameSizeL>")));
    }
//  End of File