/*

* Copyright (c) 2008 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:  Video Source subsystem.

*

*/

// INCLUDE FILES

#include <imageconversion.h>

#include <cvtimageconverter.h>

#include <RPhCltServer.h>

#include <CPhCltImageHandler.h>

#include <bautils.h>

#include "cmultiframeprovider.h"

#include "cmultiframeloopao.h"

#include "cmultiframedataao.h"

#include "CVSStillImageDataProvider.h"

#include "cvtimagebitmap.h"

static const TInt KQcifWidth = 176;

static const TInt KQcifHeight = 144;

// Default bitmap size is VGA

static const TInt KDefaultBitmapSizeWidth = 640;

static const TInt KDefaultBitmapSizeHeight = 480;

// MACROS

#ifdef _DEBUG

#    define __IF_DEBUG(t) {RDebug::t;}

#else

#    define __IF_DEBUG(t)

#endif

// ============================ TScalingMediator ===============================

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

// TScalingMediator::TScalingMediator( )

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

//

TScalingMediator::TScalingMediator()

    {

    }

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

// TScalingMediator::ScalingFinished( )

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

//

void TScalingMediator::ScalingFinished( TInt aError )

		{

		__IF_DEBUG(Print(_L("TScalingMediator::ScalingFinished() >>")));

    iWait->Signal( aError );

   	__IF_DEBUG(Print(_L("TScalingMediator::ScalingFinished() error %d <<"), aError));

		}

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

// TScalingMediator::ScalingFinished( )

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

//

void TScalingMediator::SetWaiter( CVSActiveWait< CMultiframeProvider >* aWait )

			{

			iWait = aWait;

			}

// ============================ CMultiframeProvider ===============================

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

// CMultiframeProvider::NewL( )

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

//

CMultiframeProvider* CMultiframeProvider::NewL( MMultiframeprovider* aObserver, TDisplayMode aDisplayMode )

    {

    __IF_DEBUG(Print(_L("VideoSource: [%d] CMultiframeProvider::NewL() >>"), RThread().Id().operator TUint()));

    CMultiframeProvider* self =

    new (ELeave) CMultiframeProvider( aObserver, aDisplayMode );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    __IF_DEBUG(Print(_L("VideoSource: [%d] CMultiframeProvider::NewL() <<"), RThread().Id().operator TUint()));

    return self;

    }

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

// CMultiframeProvider::CMultiframeProvider(

//  MVSDataProviderObserver* aObserver )

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

//

CMultiframeProvider::CMultiframeProvider(

    MMultiframeprovider* aObserver , TDisplayMode aDisplayMode ): iDisplayMode( aDisplayMode ), iObserver( aObserver ), iBlank( EFalse ), iGSImage( EFalse )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::CMultiframeProvider() >>"), RThread().Id().operator TUint()));

    //Set target VF size QCIF as default

    iTargetSize.SetSize( KQcifWidth , KQcifHeight );

    iVFSize.SetSize( KQcifWidth , KQcifHeight );

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::CMultiframeProvider() <<"), RThread().Id().operator TUint()));

    }

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

// CMultiframeProvider::~CMultiframeProvider()

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

//

CMultiframeProvider::~CMultiframeProvider()

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::~CMultiframeProvider() >>"), RThread().Id().operator TUint()));

    iFs.Close();

    iFreezeCS.Close();

    delete iImageDecoder; iImageDecoder = 0;

    delete iVtImageScalerInit;

    delete iVtImageScalerScale;

    delete iActiveWaitInit;

    delete iActiveWaitScale;

    delete iActiveWaitInitScale;

    delete iConverted;

    delete iMask;

    delete iTempBM;

    delete iDataTimer;

    delete iLoopAo;

    if ( iScaled != iBuffer1 && iScaled != iBuffer2 )

        {

    	  delete iScaled;

        }

    delete iGSBitmap;

    if ( !iBlank || !iGSImage )

    	  {

    	  delete iBuffer1;

		    delete iBuffer2;

    	  }

    delete iFirstVfBuf;

    delete iSecondVfBuf;

    iFreeQueue.Close();

    iDefaultImageFile.Close();

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::~CMultiframeProvider() <<"), RThread().Id().operator TUint()));

    }

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

// CMultiframeProvider::ConstructL()

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

//

void CMultiframeProvider::ConstructL()

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::ConstructL() >>"), RThread().Id().operator TUint()));

    User::LeaveIfError( iFs.Connect() );

    User::LeaveIfError( iFreezeCS.CreateLocal() );

    // Create waiters and mediators for scaling purposes

    iActiveWaitInit = new (ELeave) CVSActiveWait< CMultiframeProvider >( this );

    iActiveWaitScale = new (ELeave) CVSActiveWait< CMultiframeProvider >( this );

    iActiveWaitInitScale = new (ELeave) CVSActiveWait< CMultiframeProvider >( this );

    iInitMediator.SetWaiter( iActiveWaitInitScale );

    iScalingMediator.SetWaiter( iActiveWaitScale );

    iVtImageScalerInit = CVtImageScaler::NewL( iInitMediator, CVtImageScaler::EBilinear );

    iVtImageScalerScale = CVtImageScaler::NewL( iScalingMediator, CVtImageScaler::EBilinear );

		iDataTimer = new (ELeave) CMultiframeDataAO( this );

		iDataTimer->SetObserver( iObserver );

    iLoopAo = new (ELeave) CMultiframeloopAO( this );

    iFirstVfBuf = CVtImageBitmap::NewL( TSize( KQcifWidth >> 2, KQcifHeight >> 2 ), iDisplayMode );

    iSecondVfBuf = CVtImageBitmap::NewL( TSize( KQcifWidth >> 2, KQcifHeight >> 2 ), iDisplayMode );

    iSecondVFBuffer = EFalse;

    iFirstVFBuffer = ETrue;

    iIsVfStopped = EFalse;

    iWaitForConverting = EFalse;

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::ConstructL() <<"), RThread().Id().operator TUint()));

    }

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

// CMultiframeProvider::IniatializeGSL()

//

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

//

void CMultiframeProvider::IniatializeGSL( const TGeneralSettingsImageType aType )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::IniatializeGSL() >>"), RThread().Id().operator TUint()));

	  if ( aType == EGSStillImage )

        {

        // Open connection to phone server

        RPhCltServer phoneClient;

        User::LeaveIfError( phoneClient.Connect() );

        CleanupClosePushL( phoneClient );

    	  CPhCltImageHandler* stillH = CPhCltImageHandler::NewL();

        CleanupStack::PushL( stillH );

    	  // Load images

    	  CPhCltImageParams* imageParams;

        imageParams = stillH->CPhCltBaseImageParamsL( EPhCltTypeVTStill );

        CleanupStack::PushL( imageParams );

        User::LeaveIfError( stillH->LoadImages( imageParams ) );

        // Duplicate to image

    	  if( imageParams->Count() > 0 )

           {

           __IF_DEBUG(Print(_L("iImageCount > 0")));

           iGSBitmap = CVtImageBitmap::NewL( imageParams->GetImageL( 0 ) );

           }

        else

           {

           __IF_DEBUG(Print(_L("iImageCount <= 0 -> User::Leave( KErrNotFound )")));

           User::Leave( KErrNotFound );

           }

        // Cleanup

    	  CleanupStack::PopAndDestroy( 3 ); // phoneClient, stillH, imageParams

    	  iScaled = CVtImageBitmap::NewL( TSize( KQcifWidth, KQcifHeight ), iDisplayMode );

        // If bitmap has different display mode than screen, then new bitmap

        // is created and image is converted to screen's display mode

        if ( iGSBitmap->Bitmap().DisplayMode() != iDisplayMode || 

                iGSBitmap->Bitmap().ExtendedBitmapType() != KNullUid )

            {

            CVtImageBitmap* temp = CVtImageBitmap::NewL(

                iGSBitmap->Bitmap().SizeInPixels(), iDisplayMode );

            CleanupStack::PushL( temp );

            // Color conversion is done by blitting it to other bitmap

            CFbsBitmapDevice* fbd = CFbsBitmapDevice::NewL( &temp->Bitmap() );

            CleanupStack::PushL( fbd );

            CFbsBitGc* fgc = NULL;

            User::LeaveIfError( fbd->CreateContext( fgc ) );

            CleanupStack::PushL( fgc );

            fgc->BitBlt( TPoint(), &iGSBitmap->Bitmap() );

            CleanupStack::PopAndDestroy( 2 ); // fbd, fgc

            CleanupStack::Pop(); // temp

            delete iGSBitmap; iGSBitmap = NULL;

            iGSBitmap = temp;

            }

        iGSImage = ETrue;

        iCount = 1;     

		    iActiveWaitInit->InitializeWaiter( &ConversionFinished );

        iActiveWaitInit->Signal( KErrNone );

        }

    else

        { // default still image prepared by using file handle

        InitializeL( NULL );

        }

    iInitialization = ETrue;

    iDelay = 0;    

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::IniatializeGSL() <<"), RThread().Id().operator TUint()));

	}

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

// CMultiframeProvider::IniatializeBlank()

//

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

//

void CMultiframeProvider::IniatializeBlankL()

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::IniatializeBlank() >>"), RThread().Id().operator TUint()));

    iBlank = ETrue;

    iInitialization = ETrue;

    iDelay = 0;

    iCount = 1;

    CFbsBitmap* tempBitmap = 0;

    CreateBlankBitmapL(

        tempBitmap,

        TSize( KQcifWidth, KQcifHeight ),

        iDisplayMode,

#ifdef _DEBUG

        KRgbYellow

#else

        KRgbBlack

#endif

        );

    CleanupStack::PushL( tempBitmap );

    iScaled = CVtImageBitmap::NewL( tempBitmap->Handle() );

    CleanupStack::PopAndDestroy(); // tempBitmap

    tempBitmap = 0;

    iActiveWaitInit->InitializeWaiter( &BMSScalingFinished );

    iActiveWaitInit->Signal( KErrNone );

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::IniatializeBlank() <<"), RThread().Id().operator TUint()));

    }

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

// CVSStillImageDataProvider::CreateBlankBitmapL(

//  CFbsBitmap*& aBitmap, const TSize& aSize, const TDisplayMode& aMode,

//  const TRgb& aColor )

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

//

void CMultiframeProvider::CreateBlankBitmapL(

    CFbsBitmap*& aBitmap,

    const TSize& aSize,

    const TDisplayMode& aMode,

    const TRgb& aColor )

    {

    __IF_DEBUG(Print(_L("VideoSource[%d]: CMultiframeProvider::CreateBlankBitmapL() >>"), RThread().Id().operator TUint()));

    if( aBitmap )

       {

       delete aBitmap;

       aBitmap = 0;

       }

    aBitmap = new (ELeave) CFbsBitmap();

    User::LeaveIfError( aBitmap->Create( aSize, aMode ) );

    CFbsBitmapDevice* fbd = CFbsBitmapDevice::NewL( aBitmap );

    CleanupStack::PushL( fbd );

    CFbsBitGc* fgc = 0;

    User::LeaveIfError( fbd->CreateContext( fgc ) );

    CleanupStack::PushL( fgc );

    fgc->SetPenColor( aColor );

    fgc->SetBrushColor( aColor );

    fgc->SetBrushStyle( CGraphicsContext::ESolidBrush );

    fgc->DrawRect( TRect( aSize ) );

    CleanupStack::PopAndDestroy( 2 ); // fbd, fgc

    __IF_DEBUG(Print(_L("VideoSource[%d]: CMultiframeProvider::CreateBlankBitmapL() <<"), RThread().Id().operator TUint()));

    }

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

// CMultiframeProvider::Iniatialize()

//

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

//

void CMultiframeProvider::InitializeL( const TFileName* aFileName )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::InitializeL() >>"), RThread().Id().operator TUint()));

		// Create bitmaps used for conversion and scaling  

		iBuffer1 = CVtImageBitmap::NewL( TSize( KQcifWidth, KQcifHeight ), iDisplayMode );

		iBuffer2 = CVtImageBitmap::NewL( TSize( KQcifWidth, KQcifHeight ), iDisplayMode );

    User::LeaveIfError( iFreeQueue.Append( iBuffer1 ) );

		User::LeaveIfError( iFreeQueue.Append( iBuffer2 ) );

		iLoopAo->SetFreeBitmaps( 2 );

		// Create ICL decoder in its own thread for current file  

		TInt decodingoptions( 

		CImageDecoder::TOptions( CImageDecoder::EOptionAlwaysThread | CImageDecoder::EAllowGeneratedMask ) );	

    if ( aFileName )

    		{

    		__IF_DEBUG(Print(_L(" file name exist, creating CImageDecoder")));

    		iImageDecoder = CImageDecoder::FileNewL( iFs, *aFileName, (CImageDecoder::TOptions )decodingoptions /*CImageDecoder::EOptionNone*/ );

    	  }

    else

        {

        __IF_DEBUG(Print(_L(" default vt image file => use phone server")));

        // default VT image file handle obtained from phone server

        RPhCltServer phoneClient;

        User::LeaveIfError( phoneClient.Connect() );

        __IF_DEBUG(Print(_L("  connected to phone server")));

        CleanupClosePushL( phoneClient );

        CPhCltImageHandler* handler = CPhCltImageHandler::NewL();

        CleanupStack::PushL( handler );                          

        __IF_DEBUG(Print(_L(" created image handler")));

        User::LeaveIfError( handler->OpenDefaultVtImage( iDefaultImageFile ) );

        decodingoptions &= ~CImageDecoder::EOptionAlwaysThread;

        __IF_DEBUG(Print(_L(" creating image decoder")));

        iImageDecoder = CImageDecoder::FileNewL( iDefaultImageFile, ContentAccess::EPlay, (CImageDecoder::TOptions )decodingoptions );

        __IF_DEBUG(Print(_L(" created image decoder")));

        CleanupStack::PopAndDestroy( 2 ); // handler, phoneClient

        }

    // Use ICL to calculate frame count 

		iCount = iImageDecoder->FrameCount();

		__IF_DEBUG(Print(_L(" frame count=%d"),iCount));

		//If advanced flags are on show only first frame!

		for ( TInt index = 0; index < iCount; ++index )

    		 {

    		 TFrameInfo frameInfo( iImageDecoder->FrameInfo( index ) );

    		 __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::InitializeL() frameInfo.iFlags %b >>"), RThread().Id().operator TUint(), frameInfo.iFlags));

    		 if ( frameInfo.iFlags & TFrameInfo::ELeaveInPlace )

    		     {

    			   iDelay = 0;

    		     iCount = 1;	

    			   }

    		 }        	

		//Set num of frames to viewer AO

		iLoopAo->SetFrameCount( iCount );

		//For default loopping frame sequence is disabled

		iAnimation = EFalse;

		iInitialization = ETrue;

		//Start ICL image conversion (decoding) and local scaling 

		ConvertAndScaleL( KFirstFrameIndx );	

    __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::InitializeL() <<"), RThread().Id().operator TUint()));

    }

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

// CMultiframeProvider::SetVFScalingTargetSize()

//

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

//

void CMultiframeProvider::SetVFScalingTargetSize( TSize aSize )

	  {

	  __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::SetVFScalingTargetSize() >>"), RThread().Id().operator TUint()));

  	iTargetSize = aSize;

	  __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::SetVFScalingTargetSize() W %d H %d <<"), RThread().Id().operator TUint(), aSize.iWidth , aSize.iHeight ));

  	}

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

// CMultiframeProvider::ConvertAndScaleL()

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

//

void CMultiframeProvider::ConvertAndScaleL( TInt aFrameIndex )

	  {

	  // Variables related to Bitmap size

	  // calculation

	  __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::ConvertAndScale()  aFrameIndex %d>>"), RThread().Id().operator TUint(),aFrameIndex));

	  TSize convertedBitmapSize;

	  TFrameInfo frameInfo( iImageDecoder->FrameInfo( aFrameIndex ) );

	  if ( !iInitialization )

		    {

			  TInt delayindex;

			  delayindex = aFrameIndex - 1;

			  if ( delayindex <  KFirstFrameIndx )

					  {

						delayindex = ( iCount - 1 );

					  }

			  TFrameInfo delayframeInfo( iImageDecoder->FrameInfo( delayindex ) );

			  iDelay = delayframeInfo.iDelay;

		    }

	  else

		    {

		    iDelay = 1;

		    }

	  __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::ConvertAndScale()  iDelay %d>>"), RThread().Id().operator TUint(),iDelay.Int64() ));

#ifdef _DEBUG

    TUint threadId( RThread().Id() );

    switch ( frameInfo.iFrameDisplayMode )

        {

        case EColor4K:

            RDebug::Print( _L( "VideoSource [%d]: FrameDPmode = EColor4K" ),

            	threadId );

            break;

        case EColor64K:

            RDebug::Print( _L( "VideoSource [%d]: FrameDPmode = EColor64K" ),

            	threadId );

            break;

        case EColor16M:

          	  RDebug::Print( _L( "VideoSource [%d]: FrameDPmode = EColor16M" ),

            	threadId );

            break;

        case EColor16MU:

          	  RDebug::Print( _L( "VideoSource [%d]: FrameDPmode = EColor16MU" ),

            	threadId );

           	 break;

        default:

           	 RDebug::Print( _L( "VideoSource [%d]: FrameDPmode = %d" ),

            	threadId, frameInfo.iFrameDisplayMode );

           	 break;

        }

    RDebug::Print( _L( "VideoSource [%d]: CMultiframeProvider:: frameInfo.iFlags %d" ),

        threadId,frameInfo.iFlags );

#endif // _DEBUG

 	  // Use imagedecoder to calculate how many times source picture needs to be divided by 2

 	  // to fit in default (VGA) picture

	  TInt reductionfactor = iImageDecoder->ReductionFactor( frameInfo.iOverallSizeInPixels,

		    TSize( KDefaultBitmapSizeWidth, KDefaultBitmapSizeHeight ) );

 	  if ( iImageDecoder->ReducedSize( frameInfo.iOverallSizeInPixels, reductionfactor, convertedBitmapSize ) )

    	  {

    	  convertedBitmapSize = frameInfo.iOverallSizeInPixels;

    	  }

#ifdef _DEBUG

	   RDebug::Print( _L( "VideoSource [%d]: convertedBitmapSize Width = %d convertedBitmapSize Height = %d" ),

		    threadId, convertedBitmapSize.iWidth, convertedBitmapSize.iHeight );

#endif // _DEBUG

	  __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::ConvertAndScale() iConverted"), RThread().Id().operator TUint()));

	      iConverted = CVtImageBitmap::NewL( convertedBitmapSize, iDisplayMode );

	  __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::ConvertAndScale() iConverted"), RThread().Id().operator TUint()));

#ifdef _DEBUG

	  RDebug::Print( _L( "VideoSource [%d]: convBitmap Width = %d convBitmap Height = %d" ),

		    threadId, iConverted->Size().iWidth, iConverted->Size().iHeight );

#endif // _DEBUG

	  iStartTime.HomeTime();

	  if ( iFreeQueue.Count() < 2 )

       	{

       	__IF_DEBUG(Print(_L("VideoSource[%d]: CMultiframeProvider::ConvertAndScale() iFreeQueue.Count() < 2 "), RThread().Id().operator TUint()));

       	iOldBM = ETrue;

       	iOldBitmap = iScaled;

       	}

    iScaled	= iFreeQueue[ 0 ];

	  iFreeQueue.Remove( 0 );

	  iLoopAo->RemoveFreeBitmaps( 1 );

	  iActiveWaitInit->InitializeWaiter( &CMultiframeProvider::ConversionFinished );

	  // Check if masking is supported

	  if ( frameInfo.iFlags & TFrameInfo::ETransparencyPossible )

		    {

		    // Create mask for bitmap

		    iMask = new ( ELeave )CFbsBitmap();

		    User::LeaveIfError( iMask->Create( convertedBitmapSize, EGray256 ));

		    iTempBM = CVtImageBitmap::NewL( convertedBitmapSize, iDisplayMode );

		    iImageDecoder->Convert( iActiveWaitInit->RequestStatus(), iTempBM->Bitmap(), *iMask, aFrameIndex );

		    }

	  // No mask

	  else

		    {

		    iImageDecoder->Convert( iActiveWaitInit->RequestStatus(), iConverted->Bitmap(), aFrameIndex );

		    }

	  __IF_DEBUG(Print(_L("VideoSource [%d]: CMultiframeProvider::ConvertAndScale() <<"), RThread().Id().operator TUint()));

	}

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

// CMultiframeProvider::ConversionFinished( TInt aError )

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

//

void CMultiframeProvider::ConversionFinished( TInt aError )

    {

    __IF_DEBUG(Print(_L("VideoSource[%d]: CMultiframeProvider::ConversionFinished() >>"), RThread().Id().operator TUint()));

    if ( iCount == 1 || aError )

        {

        // delete decoder if not needed any more 

        // 1) single frame image, no further frames to convert

        // 2) error occured, decoder won't be used anyway

        __IF_DEBUG(Print(_L(" single frame image => destruct iImageDecoder, err %d"), aError ) );

        delete iImageDecoder;

        iImageDecoder = NULL;

        }

    // no harm done if other than this used, handle would already be 0

    iDefaultImageFile.Close(); 

    if ( aError == KErrNone )

        {

				iActiveWaitInitScale->InitializeWaiter( &BMSScalingFinished );

      	if ( iGSImage )

       			{

       			__IF_DEBUG(Print(_L("VideoSource[%d]: CMultiframeProvider::ConversionFinished() scale GS "), RThread().Id().operator TUint()));

       			iVtImageScalerInit->Scale( *iGSBitmap, *iScaled );

      			}

      	else

      			{

       			__IF_DEBUG(Print(_L("VideoSource[%d]: CMultiframeProvider::ConversionFinished() scale "), RThread().Id().operator TUint()));