/*

* Copyright (c) 2004 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 Transforms subsystem.

*

*/

#ifndef CVTIMAGESCALER_H

#define CVTIMAGESCALER_H

// INCLUDE FILES

#include <e32base.h>

// FORWARD DECLARATIONS

class CVtImageScalerImpl;

class CVtImage;

class CFbsBitmap;

// CLASS DECLARATIONS

/**

*  Image scaler observer interface.

*

*  @lib videosource.lib

*/

class MVtImageScalerObserver

    {

    public:

        /**

        * Callback method that is called by CVtImageScaler when scaling has

        * finished.

        * @param "aError" KErrNone if the scaling was done successfully, one

        * of the system wide error codes otherwise.

        * @return Pointer to newly created instance.

        */

        virtual void ScalingFinished( TInt aError ) = 0;

    };

/**

*  Image scaler.

*

*  @lib videosource.lib

*/

class CVtImageScaler : public CActive

    {

    public:

        /**

        * An enumeration within the CVtImageScaler namespace.

        * It provides a set of panic codes that may happen during

        * scaling process.

        */

        enum TPanics

            {

            /**

            * RotateL() is called while previous rotation process

            * has not yet been finished.

            */

            EBusy = 1

            };

        /**

        * An enumeration within the CVtImageScaler namespace.

        * It provides a set of supported scaling quality settings.

        */

        enum TQuality

            {

            /**

            * Nearest neigbour algorithm. Fast but poor image quality

            * when scale factor exceeds 2x.

            */

            ENearest,

            /**

            * Weighted average algorithm. Slower than Nearest Neighbour

            * but also better image quality when scaling at factor 2x or

            * higher.

            */

            EWeightedAverage,

            /**

            * Bilinear scaling algorithm. Slower than Weighted Average

            * but also better image quality.

            */

            EBilinear

            };

    public:

        /**

        * Creates new instance of CVtImageScaler.

        * @param "aObserver" Reference to instance observer.

        * @param "aQuality" Scaling quality. If this is omitted, then default

        * value of EWeightedAverage is used.

        * @param "aPriority" Active object priority.

        * @exception In error situation leaves with one of the system wide

        * error codes.

        * @return Pointer to newly created instance.

        */

        IMPORT_C static CVtImageScaler* NewL(

            MVtImageScalerObserver& aObserver,

            TQuality aQuality = EWeightedAverage,

            TPriority aPriority = EPriorityStandard );

        /**

        * C++ destructor.

        */

        IMPORT_C ~CVtImageScaler();

        /**

        * Sets scaling quality.

        * @param "aQuality" Scaling quality.

        * @exception In error situation leaves with one of the system wide

        * error codes.

        */

        IMPORT_C void SetQualityL( TQuality aQuality );

        /**

        * Scales image to new size.

        * @param "aSource" Source image that will be scaled.

        * @param "aTarget" Target image that will hold the scaled image. New

        * image's dimensions

        * will be taken from the size of target image.

        * @exception In error situation leaves with one of the system wide

        * error codes.

        */

        IMPORT_C void ScaleL( const CVtImage& aSource, CVtImage& aTarget );

        /**

        * Scales image to new size. Possible error during initialization is

        * returned via MVtImageScalerObserver.

        * @param "aSource" Source image that will be scaled.

        * @param "aTarget" Target image that will hold the scaled image. New

        * image's dimensions will be taken from the size of target image.

        */

        IMPORT_C void Scale( const CVtImage& aSource, CVtImage& aTarget );

        /**

        * Scales image to new size. This scale method is synchronous and

        * aTarget will contain scaled image of aSource on return. This method

        * may leave if aSource and/or aTarget are not suitable for scaling.

        * MVtImageScalerObserver::ScalingFinished is not called when this

        * method is used.

        * @param "aSource" Source image that will be scaled.

        * @param "aTarget" Target image that will hold the scaled image. New

        * image's dimensions will be taken from the size of target image.

        */

        IMPORT_C void ScaleNowL( const CVtImage& aSource, CVtImage& aTarget );

    private: // internal

        /**

        * C++ default constructor.

        */

        CVtImageScaler();

        /**

        * C++ constructor.

        * @param "aObserver" Reference to observer.

        * @param "aPriority" Active object priority.

        * @exception In error situation leaves with one of the system wide

        * error codes.

        */

        CVtImageScaler( MVtImageScalerObserver& aObserver, TPriority aPriority );

        /**

        * Second phase constructor.

        * @param "aQuality" Quality of the scaling.

        * @exception In error situation leaves with one of the system wide

        * error codes.

        */

        void ConstructL( TQuality aQuality );

        /**

        * Sets iStatus to KRequestPending and calls CActive::SetActive().

        */

        void Activate();

        /**

        * Signals this instance AO with given error code.

        * @param "aError" Signalling error code.

        */

        void Signal( TInt aError );

    private: // from CActive

        /**

        * This is defined in CActive. Check CActive for description.

        */

        void RunL();

        /**

        * This is defined in CActive. Check CActive for description.

        */

        void DoCancel();

        /**

        * Scale method called by the CAsyncCallBack.

        */

        static TInt StaticScale( TAny* aPtr );

        /**

        * Scale method called by the StaticScale.

        */

        void DoScale();

    private:

        // Scaling observer

        MVtImageScalerObserver& iObserver;

        // Active quality implementation

        CVtImageScalerImpl* iScalerImpl; // owned

        // Bitmap that will be used for locking global bitmap heap

        CFbsBitmap* iHeapLock; // owned

        // Asynccallback instance

        CAsyncCallBack* iAsyncCallBack; // owned

        // This is set to ETrue in DoCancel() method, and when CAsyncCallBack

        // gets executed, iCancelled is checked whether scaling should be done

        // or not.

        TBool iCancelled;

    };

#endif // CVTIMAGESCALER_H

// End of File