/*

* 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 conversion library for VideoTelephony.

*

*/

#ifndef CVTIMAGECONVERTER_H

#define CVTIMAGECONVERTER_H

// INCLUDE FILES

#include <e32base.h>

#include <gdi.h>

// CLASS FORWARDS

class CFbsBitmap;

class CVTYUVFbsBitmapConverter;

class CVSFbsBitmapIYUVConverter;

// DATA TYPES

typedef TRgb ( *TVSColorReadFunc ) ( TAny*& );

// CLASS DECLARATIONS

/**

*  Base class for all YUV to CFbsBitmap converters.

*

*  @lib VTImageConverter.lib

*/

class CVTYUVFbsBitmapConverter : public CBase

    {

    public:  // Constructors and destructor

        /**

        * C++ destructor.

        */

        IMPORT_C ~CVTYUVFbsBitmapConverter();

    public: // New functions

        /**

        * Starts image conversion from YUV to CFbsBitmap.

        * @exception Can leave with one of the system wide error codes.

        */

        IMPORT_C virtual void ProcessL();

        /**

        * Sets size of the source YUV image in pixels. This must be implemented

        * in derived classes.

        * @param "aSize" Size of source YUV image in pixels.

        * @exception Can leave with one of the system wide error codes.

        */

        virtual void SetSourceSizeL( const TSize& aSize ) = 0;

        /**

        * Sets source YUV image data. This method must be implemented in derived

        * classes.

        * @param "aSourceData" 8-bit descriptor containing the YUV data. As

        * data is referenced and not copied, given reference must be still

        * valid when ProcessL() is called.

        * @exception Can leave with one of the system wide error codes.

        */

        virtual void SetSourceL( const TDesC8& aSourceData ) = 0;

        /**

        * Sets size of the source YUV image in pixels and image data.

        * This method must be implemented in derived classes.

        * @param "aSize" Size of source YUV image in pixels.

        * @param "aSourceData" 8-bit descriptor containing the YUV data.

        * As data is referenced and not copied, given reference must be still

        * valid when ProcessL() is called.

        * @exception Can leave with one of the system wide error codes.

        */

        virtual void SetSourceL(

            const TSize& aSize,

            const TDesC8& aSourceData ) = 0;

        /**

        * Sets destination bitmap into which conversion will be made.

        * @param "aDestinationBitmap" Reference to destination bitmap.

        * @exception Can leave with one of the system wide error codes.

        */

        IMPORT_C virtual void SetDestinationL(

            const CFbsBitmap& aDestinationBitmap );

        /**

        * Sets destination bitmap into which conversion will be made.

        * Bitmap is given as handle to existing bitmap.

        * @param "aHandle" Handle to existing bitmap.

        * @exception Can leave with one of the system wide error codes.

        */

        IMPORT_C virtual void SetDestinationL( TInt aHandle );

    public: // Functions from base classes

    protected:  // New functions

        /**

        * Updates iY, iU and iV member variables. Must be implemented in

        * derived classes.

        * @param "aSourceData" 8-bit descriptor to source YUV data.

        */

        virtual void SetYUVPtrs( const TDesC8& aSourceData ) = 0;

        /**

        * Second phase constructor.

        * @param "aBitmapHandle" Handle to destination bitmap.

        * @exception Can leave with one of the system wide error codes.

        */

        virtual void ConstructL( TInt aBitmapHandle );

        /**

        * Second phase constructor that will be called when destination is

        * changed.

        * @param "aBitmapHandle" Handle to destination bitmap.

        * @exception Can leave with one of the system wide error codes.

        */

        virtual void ReConstructL( TInt aBitmapHandle );

        /**

        * Updates internal variables.

        * @exception Can leave with one of the system wide error codes.

        */

        virtual void SizeUpdateL();

        /**

        * C++ constructor.

        * @param "aSourceSize" Source size in pixels.

        */

        CVTYUVFbsBitmapConverter( const TSize& aSourceSize );

        /**

        * Returns source size in pixels.

        * @return Source size in pixels, as constant reference.

        */

        inline const TSize& SourceSize() const;

        /**

        * Returns source size in pixels.

        * @return Source size in pixels, as reference.

        */

        inline TSize& SourceSize();

        /**

        * Returns destination size in pixels.

        * @return Destination size in pixels, as constant reference.

        */

        inline const TSize& DestinationSize() const;

        /**

        * Returns destination size in pixels.

        * @return Destination size in pixels, as reference.

        */

        inline TSize& DestinationSize();

        /**

        * Main process loop for Color4K mode. This must be implemented in

        * derived classes.

        * @param "aWriteFunction" Pointer to function that writes one pixel to

        * destination.

        */

        virtual void DoProcess4K() = 0;

        /**

        * Main process loop for Color64K mode. This must be implemented in

        * derived classes.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        virtual void DoProcess64K() = 0;

        /**

        * Main process loop for Color16M mode. This must be implemented in

        * derived classes.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        virtual void DoProcess16M() = 0;

        /**

        * Main process loop for Color16MU mode. This must be implemented in

        * derived classes.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        virtual void DoProcess16MU16MA() = 0;

    protected:  // Functions from base classes

    private:    // New functions

        /**

        * C++ default constructor.

        */

        CVTYUVFbsBitmapConverter();

    private:    // Functions from base classes

    public: // Data

    protected:  // Data

        // Table of coefficients for EColor4K

        static const TUint8 COFF_TBL_4K[ 80 ];

        // Table of coefficients for EColor64K

        static const TUint8 COFF_TBL_64K[ 220 ];

        // Table of coefficients for EColor16M

        static const TUint8 COFF_TBL_16M[ 528 ];

        // Source size in pixels.

        TSize iSourceSize;

        // Target size in pixels.

        TSize iDestinationSize;

        // Pointer to destination bitmap.

        CFbsBitmap* iDestination; // owned, duplicate

        // Pointer descriptor that points to Y data of the YUV image.

        const TUint8* iY;

        // Pointer descriptor that points to Cr (U) data of the YUV image.

        const TUint8* iU;

        // Pointer descriptor that points to Cb (V) data of the YUV image.

        const TUint8* iV;

        // Horizontal skip real value. After every pixel this valus is added

        // to X index in conversion loop.

        TReal32 iVSkipReal;

        // Vertical skip real value. After every pixel this valus is added

        // to Y index in conversion loop.

        TReal32 iHSkipReal;

    private:    // Data

    };

/**

*  Base class for YUV 4:2:0 planar image to CFbsBitmap converters.

*

*  @lib VTImageConverter.lib

*/

class CVTYUVPlanarFbsBitmapConverter : public CVTYUVFbsBitmapConverter

    {

    public: // New functions

    public: // Functions from base classes

        /**

        * Sets size of the source YUV image in pixels.

        * @param "aSize" Size of source YUV image in pixels.

        * @exception Can leave with one of the system wide error codes.

        */

        IMPORT_C void SetSourceSizeL( const TSize& aSize );

        /**

        * Sets source YUV image data.

        * @param "aSourceData" 8-bit descriptor containing the YUV data. As

        * data is referenced and

        * not copied, given reference must be still valid when ProcessL() is

        * called.

        * @exception Can leave with one of the system wide error codes.

        */

        IMPORT_C void SetSourceL( const TDesC8& aSourceData );

        /**

        * Sets size of the source YUV image in pixels and image data. This

        * method must be

        * implemented in derived classes.

        * @param "aSize" Size of source YUV image in pixels.

        * @param "aSourceData" 8-bit descriptor containing the YUV data. As

        * data is referenced and

        * not copied, given reference must be still valid when ProcessL() is

        * called.

        * @exception Can leave with one of the system wide error codes.

        */

        IMPORT_C void SetSourceL(

            const TSize& aSize,

            const TDesC8& aSourceData );

    protected:  // Constructors and destructor

        /**

        * C++ constructor.

        * @param "aSourceSize" Source size in pixels.

        */

        CVTYUVPlanarFbsBitmapConverter( const TSize& aSourceSize );

    protected:  // New functions

    protected:  // Functions from base classes

        /**

        * Main process loop for Color4K mode.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        void DoProcess4K();

        /**

        * Main process loop for Color4K mode when scaling is not required.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        void DoProcess4KNoScale();

        /**

        * Main process loop for Color64K mode.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        void DoProcess64K();

        /**

        * Main process loop for Color64K mode when scaling is not required.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        void DoProcess64KNoScale();

        /**

        * Main process loop for Color16M mode.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        void DoProcess16M();

        /**

        * Main process loop for Color16M mode when scaling is not required.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        void DoProcess16MNoScale();

        /**

        * Main process loop for Color16MU and Color16MA modes.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        void DoProcess16MU16MA();

        /**

        * Main process loop for Color16MU and Color16MA modes when scaling is

        * not required.

        * @param "aWriteFunction" Pointer to function that writes one pixel

        * to destination.

        */

        void DoProcess16MU16MANoScale();

    private:    // New functions

        /**

        * C++ default constructor.

        */

        CVTYUVPlanarFbsBitmapConverter();

    private:    // Functions from base classes

    };

/**

*  FourCC IYUV image to CFbsBitmap converter (see IYUV description below).

*

*  All Y samples are found first in memory as an array of unsigned char

*  (possibly with a larger stride for memory alignment), followed immediately

*  by all Cr (U) samples (with half the stride of the Y lines, and half the

*  number of lines), then followed immediately by all Cb (V) samples in a

*  similar fashion.

*

*  @lib VTImageConverter.lib

*/

class CVTIYUVFbsBitmapConverter : public CVTYUVPlanarFbsBitmapConverter

    {

    public: // Constructors and destructor

        /**

        * Static factory function to create instance of this class.

        * @param "aSourceSize" Size of source image in pixels.

        * @param "aDestination" Reference to destination bitmap.

        * @exception Can leave with one of the system wide error codes.

        * @return Pointer to newly created instance.

        */

        IMPORT_C static CVTIYUVFbsBitmapConverter* NewL(

            const TSize& aSourceSize,

            const CFbsBitmap& aDestination );

        /**

        * Static factory function to create instance of this class.

        * @param "aSourceSize" Size of source image in pixels.

        * @param "aBitmapHandle" Handle to destination bitmap.

        * @exception Can leave with one of the system wide error codes.

        * @return Pointer to newly created instance.

        */

        IMPORT_C static CVTIYUVFbsBitmapConverter* NewL(

            const TSize& aSourceSize,

            TInt aBitmapHandle );

    public: // New functions

    public: // Functions from base classes

    protected:  // New functions

    protected:  // Functions from base classes

    private:    // New functions

    private:    // Functions from base classes

        /**

        * Updates iY, iU and iV member variables.

        * @param "aSourceData" 8-bit descriptor to source YUV data.

        */

        void SetYUVPtrs( const TDesC8& aSourceData );

    private:    // Constructors and destructor

        /**

        * C++ destructor.

        * @param "aSourceSize" Source size in pixels.

        */

        CVTIYUVFbsBitmapConverter( const TSize& aSourceSize );

        /**

        * C++ default constructor.

        */

        CVTIYUVFbsBitmapConverter();

    };

/**

*  FourCC YV12 image to CFbsBitmap converter (see YV12 description below).

*

*  All Y samples are found first in memory as an array of unsigned char

*  (possibly with a larger stride for memory alignment), followed immediately

*  by all Cb (V) samples (with half the stride of the Y lines, and half the

*  number of lines), then followed immediately by all Cr (U) samples in a

*  similar fashion.

*

*  @lib VTImageConverter.lib

*/

class CVTYV12FbsBitmapConverter : public CVTYUVPlanarFbsBitmapConverter

    {

    public: // Constructors and destructor

        /**

        * Static factory function to create instance of this class.

        * @param "aSourceSize" Size of source image in pixels.

        * @param "aDestination" Reference to destination bitmap.

        * @exception Can leave with one of the system wide error codes.

        * @return Pointer to newly created instance.

        */

        IMPORT_C static CVTYV12FbsBitmapConverter* NewL(

            const TSize& aSourceSize,

            const CFbsBitmap& aDestination );

        /**

        * Static factory function to create instance of this class.

        * @param "aSourceSize" Size of source image in pixels.

        * @param "aBitmapHandle" Handle to destination bitmap.

        * @exception Can leave with one of the system wide error codes.

        * @return Pointer to newly created instance.

        */

        IMPORT_C static CVTYV12FbsBitmapConverter* NewL(

            const TSize& aSourceSize,

            TInt aBitmapHandle );

    public: // New functions

    public: // Functions from base classes

    protected:  // New functions

    protected:  // Functions from base classes

    private:    // New functions

    private:    // Functions from base classes

        /**

        * Updates iY, iU and iV member variables.

        * @param "aSourceData" 8-bit descriptor to source YUV data.

        */

        void SetYUVPtrs( const TDesC8& aSourceData );

    private: // Constructors and destructor

        /**

        * C++ destructor.

        * @param "aSourceSize" Source size in pixels.

        */

        CVTYV12FbsBitmapConverter( const TSize& aSourceSize );

        /**

        * C++ default constructor.

        */

        CVTYV12FbsBitmapConverter();

    };

/**

*  CFbsBitmap to FourCC IYUV image converter (see IYUV description below).

*

*  All Y samples are found first in memory as an array of unsigned char

*  (possibly with a larger stride for memory alignment), followed immediately

*  by all Cr (U) samples (with half the stride of the Y lines, and half the

*  number of lines), then followed immediately by all Cb (V) samples in a

*  similar fashion.

*

*  @lib VTImageConverter.lib

*/

class CVSFbsBitmapIYUVConverter : public CBase

    {