/*

* 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:  Image scaler

*

*/

// INCLUDE FILES

#include    "CVtEngSettings.h"

#include    "VtEngUtils.h"

#include    "CVtEngImageScaler.h"

#include    <cvtimagebitmap.h>

#include    <fbs.h>

#include    <videotelephonyvariant.hrh>

#include    <cvtlogger.h>

// CONSTANTS

// The number of used bitmaps as scaling targets.

const TInt KVtEngTargetBitmapCount = 2;

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

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

// CVtEngImageScaler::NewL

// Two-phased constructor.

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

//

MVtEngImageScaler* CVtEngImageScaler::NewL(

    MVtEngScalerObserver& aObserver )

    {

    __VTPRINTENTER( "Scaler.NewL" )

    CVtEngImageScaler* scaler = new ( ELeave ) CVtEngImageScaler( aObserver );

    CleanupStack::PushL( scaler );

    scaler->ConstructL();

    CleanupStack::Pop( scaler );

    __VTPRINTEXIT( "Scaler.NewL" )

    return scaler;

    }

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

// CVtEngImageScaler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVtEngImageScaler::ConstructL()

    {

    iVtScaler = CVtImageScaler::NewL( *this );

    GetScalingMethodL();

    iVtScaler->SetQualityL( iScalingMethod );

    }

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

// CVtEngImageScaler::ScaleL

// Scaling method.

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

//

void CVtEngImageScaler::ScaleL(

            TInt aSourceIndex )

    {

    __VTPRINTENTER( "Scaler.ScaleL" )

    __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, "Scaler:ScaleL index=%d",

        aSourceIndex )

    __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, "Scaler:ScaleL target index=%d",

    iTargetBitmapInUse )

    if ( iVtScaler->IsActive() )

        {

        __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "Scaler:ScaleL NActive" )

        User::Leave( KErrInUse );

        }

    // If there is no bitmaps done, do leave.

    // The caller should call ConfigureL.

    if ( iSources.Count() <= 0  || iTargets.Count() <= 0 )

        {

        __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "Scaler:ScaleL: not conf" )

        User::Leave( KErrNotReady );

        }

    iVtScaler->ScaleL( *iSources[ aSourceIndex ] ,

         *iTargets[iTargetBitmapInUse] );

    __VTPRINTEXIT( "Scaler.ScaleL" )

    }

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

// CVtEngImageScaler::Configure

// Configure scaling.

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

//

TBool CVtEngImageScaler::ConfigureL(

    TDisplayMode aDisplayMode,

    TSize aSize,

    TInt aSourceHandle1,

    TInt aSourceHandle2 )

    {

    __VTPRINTENTER( "Scaler.ConfigureL" )

    __VTPRINT( DEBUG_MEDIA , "================== Scaler.Config ==================" )

    __VTPRINT2( DEBUG_MEDIA, "    aSize.iWidth:%d ", aSize.iWidth)

    __VTPRINT2( DEBUG_MEDIA, "    aSize.iHeight:%d ", aSize.iHeight )

    __VTPRINT2( DEBUG_MEDIA, "    aDisplayMode:%d", aDisplayMode )

    __VTPRINT( DEBUG_MEDIA , "================== Scaler.Config ==================" )

    TInt sourceHandle1( 0 );

    if ( iSources.Count() > 0 )

        {

        CVtImageBitmap* bmp = iSources[ EFirstBitmap ];

        if ( bmp )

            {

            sourceHandle1 = bmp->Bitmap().Handle();

            }

        }

    TInt sourceHandle2( 0 );

    if ( iSources.Count() > 1 )

        {

        CVtImageBitmap* bmp = iSources[ ESecondBitmap ];

        if ( bmp )

            {

            sourceHandle2 = bmp->Bitmap().Handle();

            }

        }

    // Do we have to cancel scaling first?

    TBool cancelled( iVtScaler->IsActive() );

    if ( aSourceHandle1 != sourceHandle1 || aSourceHandle2 != sourceHandle2

        || aSize != iSize || iMode != aDisplayMode )

        {

        if ( cancelled )

            {

            __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "Scaler:Config cancel" )

            Cancel();

            }

        }

    else

        {

        // Do we need the update => NO

        __VTPRINTEXITR( "Scaler.ConfigureL %d", EFalse )

        return EFalse;

        }

    // Store new mode and size.

    iMode = aDisplayMode;

    iSize = aSize;

    // The RVD source images have changed.

    if ( aSourceHandle1 != sourceHandle1 || aSourceHandle2 != sourceHandle2 )

        {

        __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,

            "Scaler:ConfigureL create bitmaps" )

        CVtImageBitmap* vtBitmap = CVtImageBitmap::NewL( aSourceHandle1 );

        CleanupStack::PushL( vtBitmap );

        CVtImageBitmap* vtBitmap2 = CVtImageBitmap::NewL( aSourceHandle2 );

        CleanupStack::PushL( vtBitmap2 );

	    __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "Scaler:ConfigureL source reset" )

        iSources.ResetAndDestroy();

        iSources.AppendL( vtBitmap );

        iSources.AppendL( vtBitmap2 );

	    CleanupStack::Pop( KVtEngTargetBitmapCount ); // vtBitMaps

        }

    __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "Scaler:ConfigureL create targets" )

    CVtImageBitmap* vtBitmapT =  CVtImageBitmap::NewL( aSize, aDisplayMode );

    CleanupStack::PushL( vtBitmapT );

    CVtImageBitmap* vtBitmapT2 = CVtImageBitmap::NewL( aSize, aDisplayMode );

    CleanupStack::PushL( vtBitmapT2 );

    __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "Scaler:ConfigureL target reset" )

    iTargets.ResetAndDestroy();

    iTargets.AppendL( vtBitmapT );

    iTargets.AppendL( vtBitmapT2 );

    CleanupStack::Pop( KVtEngTargetBitmapCount ); // vtBitMapTs

    __VTPRINTEXITR( "Scaler.ConfigureL %d", cancelled )

    return cancelled;

    }

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

// CVtEngImageScaler::ScalingFinished

// Callback telling that scaling is done.

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

//

void CVtEngImageScaler::ScalingFinished( TInt aError )

    {

    __VTPRINTENTER( "Scaler.ScalingFinished" )

    __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, "Scaler:ScaleFin ", aError )

    if ( aError == KErrNone )

        {

        CFbsBitmap& bitmap = iTargets [ iTargetBitmapInUse ]->Bitmap();

        __VTPRINT2( DEBUG_MEDIA, "Scaler.ScalingFin index", iTargetBitmapInUse )

        if ( iTargetBitmapInUse == EFirstBitmap )

            {

            iTargetBitmapInUse = ESecondBitmap;

            }

        else

            {

            iTargetBitmapInUse = EFirstBitmap;

            }

        // Notify client of done scaling

        iObserver.ScalingCompleted( &bitmap, aError );

        }

    else

        {

        iObserver.ScalingCompleted( NULL, aError );

        }

    __VTPRINTEXIT( "Scaler.ScalingFinished" )

    }

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

// CVtEngImageScaler::~CVtEngImageScaler

// Destructor.

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

//

CVtEngImageScaler::~CVtEngImageScaler()

    {

    __VTPRINTENTER( "Scaler.~" )

    __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "Scaler:Dtor" )

    iTargets.ResetAndDestroy();

    iTargets.Close();

    iSources.ResetAndDestroy();

    iSources.Close();

    delete iVtScaler;

    __VTPRINTEXIT( "Scaler.~" )

    }

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

// CVtEngImageScaler::CVtEngImageScaler

// C++ constructor.

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

//

CVtEngImageScaler::CVtEngImageScaler(

    MVtEngScalerObserver& aObserver ) :

    iObserver( aObserver ), iTargetBitmapInUse ( EFirstBitmap ),

    iScalingMethod( CVtImageScaler::EWeightedAverage )

    {

    }

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

// CVtEngImageScaler::Release

// Interface function implementation to delete the implementation.

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

//

void CVtEngImageScaler::Release()

    {

    // Delete myself

  __VTPRINTENTER( "Scaler.Release" )

    delete this;

    __VTPRINTEXIT( "Scaler.Release" )

    }

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

// VtEngScalerFactory::CreateScalerL

// Creates the image scaler.

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

//

MVtEngImageScaler* VtEngScalerFactory::CreateScalerL(

    MVtEngScalerObserver& aObserver )

    {

    __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,

        "VtEngScalerFactory::CreateScalerL" )

    return CVtEngImageScaler::NewL( aObserver );

    }

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

// CVtEngImageScaler::Cancel

// Cancels the conversion.

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

//

TInt CVtEngImageScaler::Cancel()

    {

    __VTPRINTENTER( "Scaler.Cancel" )

    iVtScaler->Cancel();

    __VTPRINTEXIT( "Scaler.Cancel" )

    return KErrNone;

    }

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

// CVtEngImageScaler::GetScalingMethodL

// Gets the used scaling method from local variation.

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

//

void CVtEngImageScaler::GetScalingMethodL()

    {

    __VTPRINTENTER( "Scaler.GetScalingMethodL" )

    // Check if the scaling method is non-default

    CVtEngSettings& settings = CVtEngUtility::Settings();

    if( settings.CheckBits(

        KVTLVFlagScalingMethodENearest ) )

        {

        iScalingMethod = CVtImageScaler::ENearest;

        }

    else if ( settings.CheckBits(

        KVTLVFlagScalingMethodEBilinear ) )

        {

        iScalingMethod = CVtImageScaler::EBilinear;

        }

    __VTPRINTEXITR( "Scaler.GetScalingMethodL %d", (TInt) iScalingMethod )

    }

//  End of File