/*

* 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 <mmf/devvideo/devvideobase.h>

#include <mmcccodecinformationfactory.h>

#include <mmcccodecinformation.h>

#include "mccvideosourceimpl.h"

#include "mccinternalcodecs.h"

#include "mmcccodecinformation.h"

#include "mmcccodech263.h"

#include "mmcccodecavc.h"

#include "mccvideosourcewrapper.h"

#include "mccvideosourcesinklogs.h"

#include "mccinternalevents.h"

#include "mmccinterfacedef.h"

#include "mccrateadaptationdef.h"

#include "mccdef.h"

#include "mccinternaldef.h"

#include "mccvideosourcekeyretriever.h"

#include "mccresources.h"

_LIT8(KVideoCodecFourCC, "video/%S; %S");

const TInt KMccMaxVideoQueueSize = 10;

const TUint KMccBitrateTooLowLimit = 20000;

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

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::NewL

// -----------------------------------------------------------------------------

//

CMccVideoSourceImpl* CMccVideoSourceImpl::NewL( 

    TUint32 aEndpointId, MMccResources* aMccResources, TBool aConfigKeyRetrieval )

    {

    CMccVideoSourceImpl* self = new ( ELeave ) CMccVideoSourceImpl( 

            aEndpointId, aMccResources, aConfigKeyRetrieval );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::ConstructL

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::ConstructL()

    {

	iMediaRecorder = CMccVideoSourceWrapper::NewL(*this, *this);

    iVideoCodec.iFourCC = TFourCC();

    iAudioFourCC = TFourCC();

    iFrameRate = KMccDefaultVideoFrameRate;

    }

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::CMccVideoSourceImpl

// -----------------------------------------------------------------------------

//

CMccVideoSourceImpl::CMccVideoSourceImpl( 

    TUint32 aEndpointId, MMccResources* aMccResources, TBool aConfigKeyRetrieval ) : 

    iAudioEnabled( EFalse ),

    iEndpointId( aEndpointId ),

    iMccResources( aMccResources ),

    iConfigKeyRetrieval( aConfigKeyRetrieval )

	{

    }

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::~CMccVideoSourceImpl 

// -----------------------------------------------------------------------------

//

CMccVideoSourceImpl::~CMccVideoSourceImpl()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::~CMccVideoSourceImpl" )

    StopCameraMonitoring();

    if ( iMediaRecorder )

        {

        TRAP_IGNORE( iMediaRecorder->StopL() )

        }

	delete iVideoCodecFourCC;

	delete iMediaRecorder;

	iAsyncEventHandler = NULL;

	iVideoQueue.ResetAndDestroy();

	delete iConfigKey;	

	delete iConfigKeyData;

	__V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::~CMccVideoSourceImpl, exit" )

    }

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SetResources

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::SetResources( MMccResources* aResources )

	{

	__V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SetResources" )		

	iMccResources = aResources;

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SetCameraHandler

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::SetCameraHandler( MMccCameraHandler& aCameraHandler )

	{

	__V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SetCameraHandler" )		

	iCameraHandler = &aCameraHandler;

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SourcePrimeL

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::SourcePrimeL( TBool aMultipleCodecs )

	{

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePrimeL" )

    __ASSERT_ALWAYS( iMediaRecorder, User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS( iCameraHandler, User::Leave( KErrNotReady ) );

    iMultipleCodecs = aMultipleCodecs;

    if ( !iCameraHandler->IsCameraReady() )

        {

        __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePrimeL, camera not ready" )

        HandleCameraReservationL();

        }

    else if ( iMediaRecorder->State() == CCMRMediaRecorder::EStateNone )

        {       

        if ( !FullPrepareAllowed() )

            {

            __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePrimeL, prepare partially" )

            // Cannot prepare recorder yet fully, fake preparing and do it

            // later automatically once recording is started

            SendStreamEventToClient( KMccStreamPrepared, KErrNone, KMccAutomaticEvent );

            }

        else

            {

            __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePrimeL, prepare fully" )

            TUid encoderUid( KNullUid );

            __ASSERT_ALWAYS( iVideoCodecFourCC, User::Leave( KErrNotReady ) );

            __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePrimeL, opening source" )		

        	iMediaRecorder->OpenL( iAudioSource, iCameraHandler->Handle(), 

            }

        }

    else

        {

        __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePrimeL, not priming" )

        }

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePrimeL, exit" )

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SourcePlayL()

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::SourcePlayL()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePlayL" )

    TMccEventType event = KMccEventNone;

    TUint32 eventNumData = 0;

    iMultipleCodecs = EFalse;

    if ( iMediaRecorder->State() == CCMRMediaRecorder::EStateNone )

        {

        __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePlayL, \

not prepared, prepare in autoplay mode" )

        SetAutoPlayMode( ETrue );

        SourcePrimeL();

        }

    else if ( iMediaRecorder->State() == CCMRMediaRecorder::EStateReadyToRecord )

        {        

	    iMediaRecorder->PlayL();

	    if ( AutoPlayMode() )

	        {

	        event = KMccStreamResumed;

	        eventNumData = KMccAutomaticEvent;

	        SetAutoPlayMode( EFalse );

	        }

	    else

	        {

	        event = KMccStreamStarted;

	        }

        }

    else

        {

        __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePlayL, \

already playing or stopping" )

        }

    if ( event != KMccEventNone && !AutoPlayMode() )

        {

        SendStreamEventToClient( event, KErrNone, eventNumData );

        }

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePlayL, exit" )

    }

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SourcePauseL()

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::SourcePauseL()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePauseL")

    iVideoConsumer = NULL;

	iVideoConsumerBuffer = NULL;

	SetAutoPlayMode( EFalse );

	StopCameraMonitoring();

    // Always stop the recorder, this will free camera resources

    iMediaRecorder->StopL();

    iVideoQueue.ResetAndDestroy();

    SendStreamEventToClient( KMccStreamPaused );

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourcePauseL, exit")

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SourceStopL()

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::SourceStopL()

    {

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourceStopL" )

    __V_SOURCESINK_MEDIA_INT1("CMccVideoSourceImpl::SourceStopL, thread", \

        RThread().Id().operator TUint());

	iVideoConsumer = NULL;

	iVideoConsumerBuffer = NULL;

	iMultipleCodecs = EFalse;

	iMediaRecorder->StopL();

    iVideoQueue.ResetAndDestroy();

    SendStreamEventToClient( KMccStreamStopped );

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourceStopL, exit" )

    }

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SourceDataTypeCode()

// -----------------------------------------------------------------------------

//

TFourCC CMccVideoSourceImpl::SourceDataTypeCode( TMediaId aMediaId )

	{

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourceDataTypeCode" )

    if ( KUidMediaTypeVideo == aMediaId.iMediaType )

        {

        return iVideoCodec.iFourCC;

        }

    else if ( KUidMediaTypeAudio == aMediaId.iMediaType  )

        {

        return iAudioFourCC;

        }

    else

        {

        return TFourCC( KMMFFourCCCodeNULL );

        }

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SetSourceDataTypeCode()

// -----------------------------------------------------------------------------

//

TInt CMccVideoSourceImpl::SetSourceDataTypeCode( 

    TFourCC aCodec, 

    TMediaId aMediaId )

	{

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SetSourceDataTypeCode" )

    if ( KUidMediaTypeVideo == aMediaId.iMediaType &&

    	aCodec == iVideoCodec.iFourCC )

        {

        return KErrNone;

        }

    else if ( KUidMediaTypeAudio == aMediaId.iMediaType &&

    	aCodec == iAudioFourCC )

        {

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

	}	

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::BufferEmptiedL()

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )

	{

    __V_SOURCESINK_MEDIA( "CMccVideoSourceImpl::BufferEmptiedL" )

    __ASSERT_ALWAYS( EFalse, User::Leave( KErrNotSupported ) );

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::CanCreateSourceBuffer()

// -----------------------------------------------------------------------------

//

TBool CMccVideoSourceImpl::CanCreateSourceBuffer()

	{

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::CanCreateSourceBuffer, ETrue" )

	return EFalse;

	}	

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::CreateSourceBufferL()

// -----------------------------------------------------------------------------

//

CMMFBuffer* CMccVideoSourceImpl::CreateSourceBufferL( 

    TMediaId /*aMediaId*/, 

    TBool& /*aReference*/ )

	{

	__V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::CreateSourceBufferL" )

    CMMFBuffer* buffer = NULL;

    __ASSERT_ALWAYS( EFalse, User::Leave( KErrNotSupported ) );

	return buffer;	

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SourceThreadLogon()

// -----------------------------------------------------------------------------

//

TInt CMccVideoSourceImpl::SourceThreadLogon( MAsyncEventHandler& aEventHandler )

	{

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourceThreadLogon" )	

	iAsyncEventHandler = static_cast<MAsyncEventHandler*>( &aEventHandler );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SourceThreadLogoff()

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::SourceThreadLogoff()

	{

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::SourceThreadLogoff" )

    iAsyncEventHandler = NULL;

    iVideoQueue.ResetAndDestroy();

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::FillBufferL()

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::FillBufferL( 

    CMMFBuffer* aBuffer,

    MDataSink* aConsumer,

    TMediaId aMediaId )

	{

	__V_SOURCESINK_MEDIA( "CMccVideoSourceImpl::FillBufferL" )

    // Sink might want to indicate pause/stop by passing NULL buffer

    if ( aBuffer )

        {

        __ASSERT_ALWAYS ( aConsumer, User::Leave( KErrArgument ) );

        }

    if ( aMediaId.iMediaType == KUidMediaTypeVideo )

		{

    	__V_SOURCESINK_MEDIA( "CMccVideoSourceImpl::FillBufferL, video" )

	    iVideoConsumer = aConsumer;

		iVideoConsumerBuffer = aBuffer;	

	    WriteFirstBufferL();

		}

	else

		{

    	__V_SOURCESINK_MEDIA_INT1( "CMccVideoSourceImpl::FillBufferL, \

unknown media, type=", aMediaId.iMediaType.iUid ) 

		User::Leave( KErrNotSupported );	

		}

	}	

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::NegotiateSourceL()

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::NegotiateSourceL( MDataSink& /*aDataSink*/ )

	{

    __V_SOURCESINK_CONTROLL( "CMccVideoSourceImpl::NegotiateSourceL" )

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::WriteBufferL()

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::WriteBufferL( CCMRMediaBuffer* aBuffer )

	{

	__V_SOURCESINK_MEDIA( "CMccVideoSourceImpl::WriteBufferL" )

    __ASSERT_ALWAYS( aBuffer, User::Leave( KErrArgument ) );

    if ( QueueBufferL( *aBuffer ) )

        {

        WriteFirstBufferL();

        }

    __V_SOURCESINK_MEDIA( "CMccVideoSourceImpl::WriteBufferL, exit" )

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SetVideoFrameSize()

// -----------------------------------------------------------------------------

//

TInt CMccVideoSourceImpl::SetVideoFrameSize( TSize aSize )

	{

    __V_SOURCESINK_CONTROLL_INT2( 

        "CMccVideoSourceImpl::SetVideoFrameSize (from mediarecorder), width", 

        aSize.iWidth,

        " heigth", 

        aSize.iHeight )

    iVideoCodec.iVideoHeight = aSize.iHeight;

    iVideoCodec.iVideoWidth = aSize.iWidth;

    return KErrNone;				

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SetAverageVideoBitRate()

// -----------------------------------------------------------------------------

//

TInt CMccVideoSourceImpl::SetAverageVideoBitRate( TInt aBitRate )

	{

    __V_SOURCESINK_CONTROLL_INT1( 

        "CMccVideoSourceImpl::SetAverageVideoBitRate (from mediarecorder)", 

        aBitRate )				

    iVideoCodec.iAverageBitrate = (TUint)aBitRate;

    return KErrNone;				

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SetMaxVideoBitRate()

// -----------------------------------------------------------------------------

//

TInt CMccVideoSourceImpl::SetMaxVideoBitRate( TInt aBitRate )

	{

    __V_SOURCESINK_CONTROLL_INT1( 

        "CMccVideoSourceImpl::SetMaxVideoBitRate (from mediarecorder)", 

        aBitRate )

    // Do not reset max bitrate as mediarecorder will call back with the same

    // value which was given in SetVideoBitrate phase (i.e. value is meaningless)

    aBitRate = aBitRate; 

    return KErrNone;				

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::SetAverageAudioBitRate()

// -----------------------------------------------------------------------------

//

TInt CMccVideoSourceImpl::SetAverageAudioBitRate( TInt aBitRate )

	{

    __V_SOURCESINK_CONTROLL_INT1( 

        "CMccVideoSourceImpl::SetAverageAudioBitRate (from mediarecorder)", 

        aBitRate )

    iAverageAudioBitRate = aBitRate;

    return KErrNone;				

	}

// -----------------------------------------------------------------------------

// CMccVideoSourceImpl::MmroPrepareComplete()

// -----------------------------------------------------------------------------

//

void CMccVideoSourceImpl::MmroPrepareComplete( TInt aError )    

	{

    __V_SOURCESINK_CONTROLL_INT1( "CMccVideoSourceImpl::MmroPrepareComplete=", aError )

	if ( !aError )

    	{	

    	aError = SetVideoBitrate( iVideoCodec.iBitrate );  

        if ( !aError )

            {

            TRAP( aError, iMediaRecorder->SetVideoFrameRateL( iVideoCodec.iFramerate ) );

            if ( !aError )

                {

                TRateControlOptions options;

                TRAP( aError, iMediaRecorder->GetVideoRateControlOptionsL( options ) );

                if ( !aError )

                    {

                    __V_SOURCESINK_CONTROLL_INT1( 

                        "Ratecontrol options:: control:", options.iControl )

                    __V_SOURCESINK_CONTROLL_INT1(