/*
 * Halftone.h
 * Copyright 1999-2000 Y.Takagi. All Rights Reserved.
 */

#ifndef __HALFTONE_H
#define __HALFTONE_H

#include <GraphicsDefs.h>

// definition for B_RGB32 (=B_RGB32_LITTLE) and B_RGBA32
typedef struct {
        uchar blue;
        uchar green;
        uchar red;
        uchar alpha; // unused in B_RGB32
} ColorRGB32Little;

// definition for B_RGB32_BIG and B_RGBA32_BIG
typedef struct {
        uchar alpha; // unused in B_RGB32_BIG
        uchar red;
        uchar green;
        uchar blue;
} ColorRGB32Big;

typedef union {
        ColorRGB32Little little;
        ColorRGB32Big    big;
} ColorRGB32;

class Halftone;

typedef void (Halftone::*PFN_dither)(uchar* destination, const uchar* source,
        int x, int y, int width);

typedef uint (*PFN_gray)(ColorRGB32 c);

class Halftone {
public:
        enum DitherType {
                kType1,
                kType2,
                kType3,
                kTypeFloydSteinberg,
        };

        enum GrayFunction {
                kMixToGray,
                kRedChannel,
                kGreenChannel,
                kBlueChannel
        };

        enum Planes {
                kPlaneMonochrome1, // 1 bit depth (0 white, 1 black)
                kPlaneRGB1,        // 3 planes, 1 bit depth (0 black, 7 white)
        };

        enum BlackValue {
                kHighValueMeansBlack,
                kLowValueMeansBlack,
        };

                                        Halftone(color_space colorSpace, double gamma = 1.4,
                                                double min = 0.0,
                                                DitherType dither_type = kTypeFloydSteinberg);
                                        ~Halftone();

                        void    SetPlanes(Planes planes);
                        void    SetBlackValue(BlackValue blackValue);

                        void    Dither(uchar *destination, const uchar *source, int x,
                                                int y, int width);

                        int             GetPixelDepth() const;

                        const uchar*    GetPattern() const;
                        void                    SetPattern(const uchar *pattern);

protected:
                        Halftone(const Halftone &);

                        Halftone&       operator=(const Halftone &);

                        // PFN_gray: return value of 0 means low density (or black) and
                        // value of 255 means high density (or white)
                        PFN_gray        GetGrayFunction() const;
                        void            SetGrayFunction(PFN_gray gray);
                        void            SetGrayFunction(GrayFunction grayFunction);

                        void            CreateGammaTable(double gamma, double min);
                        void            InitElements(int x, int y, uchar* elements);
                        uint            GetDensity(ColorRGB32 c) const;
                        uchar           ConvertUsingBlackValue(uchar byte) const;
                        void            DitherRGB32(uchar* destination, const uchar* source,
                                                        int x, int y, int width);

                        void            InitFloydSteinberg();
                        void            DeleteErrorTables();
                        void            UninitFloydSteinberg();
                        void            SetupErrorBuffer(int x, int y, int width);
                        void            DitherFloydSteinberg(uchar* destination,
                                                        const uchar* source, int x, int y, int width);

private:
        enum {
                kGammaTableSize = 256,
                kMaxNumberOfPlanes = 3
        };

        PFN_dither              fDither;
        PFN_gray                fGray;
        int                             fPixelDepth;
        Planes                  fPlanes;
        BlackValue              fBlackValue;
        const uchar*    fPattern;
        uint                    fGammaTable[kGammaTableSize];
        int                             fNumberOfPlanes;
        int                             fCurrentPlane;
        // fields used for floyd-steinberg dithering
        int                             fX;
        int                             fY;
        int                             fWidth;
        int*                    fErrorTables[kMaxNumberOfPlanes];
};


inline int
Halftone::GetPixelDepth() const
{
        return fPixelDepth;
}


inline const uchar*
Halftone::GetPattern() const
{
        return fPattern;
}


inline void
Halftone::SetPattern(const uchar* pattern)
{
        fPattern = pattern;
}


inline PFN_gray
Halftone::GetGrayFunction() const
{
        return fGray;
}


inline void
Halftone::SetGrayFunction(PFN_gray gray)
{
        fGray = gray;
}


inline uint
Halftone::GetDensity(ColorRGB32 c) const
{
        return fGammaTable[fGray(c)];
}


inline uchar
Halftone::ConvertUsingBlackValue(uchar byte) const
{
        // bits with value = '1' in byte mean black
        if (fBlackValue == kHighValueMeansBlack)
                return byte;

        return ~byte;
}


#endif  /* __HALFTONE_H */