#ifndef __RIIMAGE_H

#define __RIIMAGE_H

/*------------------------------------------------------------------------

 *

 * OpenVG 1.1 Reference Implementation

 * -----------------------------------

 *

 * Copyright (c) 2007 The Khronos Group Inc.

 * Portions copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and /or associated documentation files

 * (the "Materials "), to deal in the Materials without restriction,

 * including without limitation the rights to use, copy, modify, merge,

 * publish, distribute, sublicense, and/or sell copies of the Materials,

 * and to permit persons to whom the Materials are furnished to do so,

 * subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Materials.

 *

 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

 * THE USE OR OTHER DEALINGS IN THE MATERIALS.

 *

 *//**

 * \file

 * \brief	Color and Image classes.

 * \note

 *//*-------------------------------------------------------------------*/

#ifndef _OPENVG_H

#include "VG/openvg.h"

#endif

#ifndef __RIMATH_H

#include "riMath.h"

#endif

#ifndef __RIARRAY_H

#include "riArray.h"

#endif

#include "sfAlphaRcp.h"

#include "sfGammaLUT.h"

#include "riUtils.h"

//==============================================================================================

namespace OpenVGRI

{

class VGContext;

class DynamicBlitter;

/*-------------------------------------------------------------------*//*!

* \brief	A class representing rectangles.

* \param

* \return

* \note

*//*-------------------------------------------------------------------*/

class Rectangle

{

public:

    Rectangle() : x(0), y(0), width(0), height(0) {}

    Rectangle(int rx, int ry, int rw, int rh) : x(rx), y(ry), width(rw), height(rh) {}

    void		intersect(const Rectangle& r)

    {

        if(width >= 0 && r.width >= 0 && height >= 0 && r.height >= 0)

        {

            int x1 = RI_INT_MIN(RI_INT_ADDSATURATE(x, width), RI_INT_ADDSATURATE(r.x, r.width));

            x = RI_INT_MAX(x, r.x);

            width = RI_INT_MAX(x1 - x, 0);

            int y1 = RI_INT_MIN(RI_INT_ADDSATURATE(y, height), RI_INT_ADDSATURATE(r.y, r.height));

            y = RI_INT_MAX(y, r.y);

            height = RI_INT_MAX(y1 - y, 0);

        }

        else

        {

            x = 0;

            y = 0;

            width = 0;

            height = 0;

        }

    }

    bool isEmpty() const { return width == 0 || height == 0; }

    int			x;

    int			y;

    int			width;

    int			height;

};

/*-------------------------------------------------------------------*//*!

* \brief	A class representing color for processing and converting it

*			to and from various surface formats.

* \param

* \return

* \note

*//*-------------------------------------------------------------------*/

class Color

{

public:

    enum FormatSize

    {

        SIZE_1      = 0,

        SIZE_4      = 1,

        SIZE_8      = 2,

        SIZE_16     = 3,

        SIZE_24     = 4,

        SIZE_32     = 5

    };

    enum Shape

    {

        SHAPE_RGBA            = 0,

        SHAPE_RGBX            = 1,

        SHAPE_RGB             = 2,

        SHAPE_LA              = 3,

        SHAPE_L               = 4,

        SHAPE_A               = 5,

        SHAPE_ARGB            = 6,

        SHAPE_XRGB            = 7,

        SHAPE_AL              = 8,

        SHAPE_BGRA            = 9,

        SHAPE_BGRX            = 10,

        SHAPE_BGR             = 11,

        SHAPE_ABGR            = 12,

        SHAPE_XBGR            = 13

    };

    enum InternalFormat

    {

        lRGBA			= 0,

        sRGBA			= 1,

        lRGBA_PRE		= 2,

        sRGBA_PRE		= 3,

        lLA				= 4,

        sLA				= 5,

        lLA_PRE			= 6,

        sLA_PRE			= 7

    };

    enum FormatBits

    {

        NONLINEAR		= (1<<0),

        PREMULTIPLIED	= (1<<1),

        LUMINANCE		= (1<<2)

    };

    struct SmallDescriptor

    {

        RIuint32        toUint32()

        {

            RIuint32 ret = 0;

            ret = (RIuint32)size;

            ret |= (RIuint32)shape << 3;

            ret |= (RIuint32)internalFormat << (3 + 4);

            return ret;

        }

        FormatSize      size;

        Shape           shape;

        InternalFormat  internalFormat;

    };

    class Descriptor

    {

    public:

        Descriptor() {};

        RI_INLINE Descriptor(int dredBits, int dredShift, int dgreenBits, int dgreenShift, int dblueBits, int dblueShift, int dalphaBits, int dalphaShift, int dluminanceBits, int dluminanceShift, InternalFormat dinternalFormat, int dbpp, Shape shape);

        RI_INLINE bool      isNonlinear() const                                 { return (internalFormat & NONLINEAR) ? true : false; }

        RI_INLINE void      setNonlinear(bool nonlinear);

        RI_INLINE bool      isPremultiplied() const                             { return (internalFormat & PREMULTIPLIED) ? true : false; }

        RI_INLINE bool      isLuminance() const                                 { return (internalFormat & LUMINANCE) ? true : false; }

        RI_INLINE bool      isAlphaOnly() const                                 { return (alphaBits && (redBits+greenBits+blueBits+luminanceBits) == 0) ? true : false; }

        RI_INLINE bool      isBW() const { return isLuminance() && (luminanceBits == 1); }

        RI_INLINE bool      hasAlpha() const { return alphaBits > 0; }

        RI_INLINE bool      operator==(const Descriptor& rhs) const;

        RI_INLINE bool      isShiftConversionToLower(const Descriptor& rhs) const;

        RI_INLINE bool      isShiftConversion(const Descriptor& rhs) const;

        RI_INLINE bool      isZeroConversion(const Descriptor& rhs) const;

        RI_INLINE bool      maybeUnsafe() const { return internalFormat & PREMULTIPLIED ? true : false; };

        static RI_INLINE RIuint32  crossConvertToLower(RIuint32 c, const Descriptor& src, const Descriptor& dst);

        void                toSmallDescriptor(SmallDescriptor& smallDesc) const;

        RI_INLINE RIuint32  toIndex() const;

        static Descriptor   getDummyDescriptor();

        Shape               getShape() const;

        int				redBits;

        int				redShift;

        int				greenBits;

        int				greenShift;

        int				blueBits;

        int				blueShift;

        int				alphaBits;

        int				alphaShift;

        int				luminanceBits;

        int				luminanceShift;

        Shape           shape;

        VGImageFormat   vgFormat; // \note Storage only

        InternalFormat	internalFormat;

        int				bitsPerPixel;

        // Derived info:

        int             bytesPerPixel;

        int             maskBits;

        int             maskShift;

    };

    RI_INLINE Color() : r(0.0f), g(0.0f), b(0.0f), a(0.0f), m_format(sRGBA_PRE)													{}

    RI_INLINE Color(RIfloat cl, RIfloat ca, InternalFormat cs) : r(cl), g(cl), b(cl), a(ca), m_format(cs)							{ RI_ASSERT(cs == lLA || cs == sLA || cs == lLA_PRE || cs == sLA_PRE); }

    RI_INLINE Color(RIfloat cr, RIfloat cg, RIfloat cb, RIfloat ca, InternalFormat cs) : r(cr), g(cg), b(cb), a(ca), m_format(cs)	{ RI_ASSERT(cs == lRGBA || cs == sRGBA || cs == lRGBA_PRE || cs == sRGBA_PRE || cs == lLA || cs == sLA || cs == lLA_PRE || cs == sLA_PRE); }

    RI_INLINE Color(const Color& c) : r(c.r), g(c.g), b(c.b), a(c.a), m_format(c.m_format)									{}

    RI_INLINE Color& operator=(const Color&c)										{ r = c.r; g = c.g; b = c.b; a = c.a; m_format = c.m_format; return *this; }

    RI_INLINE void operator*=(RIfloat f)											{ r *= f; g *= f; b *= f; a*= f; }

    RI_INLINE void operator+=(const Color& c1)										{ RI_ASSERT(m_format == c1.getInternalFormat()); r += c1.r; g += c1.g; b += c1.b; a += c1.a; }

    RI_INLINE void operator-=(const Color& c1)										{ RI_ASSERT(m_format == c1.getInternalFormat()); r -= c1.r; g -= c1.g; b -= c1.b; a -= c1.a; }

    void						set(RIfloat cl, RIfloat ca, InternalFormat cs)							{ RI_ASSERT(cs == lLA || cs == sLA || cs == lLA_PRE || cs == sLA_PRE); r = cl; g = cl; b = cl; a = ca; m_format = cs; }

    void						set(RIfloat cr, RIfloat cg, RIfloat cb, RIfloat ca, InternalFormat cs)	{ RI_ASSERT(cs == lRGBA || cs == sRGBA || cs == lRGBA_PRE || cs == sRGBA_PRE); r = cr; g = cg; b = cb; a = ca; m_format = cs; }

    void						unpack(unsigned int inputData, const Descriptor& inputDesc);

    unsigned int				pack(const Descriptor& outputDesc) const;

    RI_INLINE InternalFormat	getInternalFormat() const							{ return m_format; }

    //clamps nonpremultiplied colors and alpha to [0,1] range, and premultiplied alpha to [0,1], colors to [0,a]

    void						clamp()												{ a = RI_CLAMP(a,0.0f,1.0f); RIfloat u = (m_format & PREMULTIPLIED) ? a : (RIfloat)1.0f; r = RI_CLAMP(r,0.0f,u); g = RI_CLAMP(g,0.0f,u); b = RI_CLAMP(b,0.0f,u); }

    void						convert(InternalFormat outputFormat);

    void						premultiply()										{ if(!(m_format & PREMULTIPLIED)) { r *= a; g *= a; b *= a; m_format = (InternalFormat)(m_format | PREMULTIPLIED); } }

    void						unpremultiply()										{ if(m_format & PREMULTIPLIED) { RIfloat ooa = (a != 0.0f) ? 1.0f/a : (RIfloat)0.0f; r *= ooa; g *= ooa; b *= ooa; m_format = (InternalFormat)(m_format & ~PREMULTIPLIED); } }

    void                        luminanceToRGB()                                    { if(m_format & LUMINANCE) { RI_ASSERT(r == g && g == b); m_format = (InternalFormat)(m_format & ~LUMINANCE); } }

    bool                        isNonlinear() const                                 { return (m_format & NONLINEAR) ? true : false; }

    bool                        isPremultiplied() const                             { return (m_format & PREMULTIPLIED) ? true : false; }

    bool                        isLuminance() const                                 { return (m_format & LUMINANCE) ? true : false; }

    RI_INLINE void              assertConsistency() const;

    // \note Why are these in the color class instead of descriptor?

    static VGImageFormat        descriptorToVGImageFormat(const Descriptor& desc);

    RI_INLINE static Descriptor formatToDescriptorConst(VGImageFormat format);

    static Descriptor			formatToDescriptor(VGImageFormat format);

    static bool					isValidDescriptor(const Descriptor& desc);

    RIfloat		r;

    RIfloat		g;

    RIfloat		b;

    RIfloat		a;

private:

    InternalFormat	m_format;

};

RI_INLINE Color::Descriptor::Descriptor(int dredBits, int dredShift, int dgreenBits, int dgreenShift, int dblueBits, int dblueShift, int dalphaBits, int dalphaShift, int dluminanceBits, int dluminanceShift, InternalFormat dinternalFormat, int dbpp, Shape shape) :

    redBits(dredBits),

    redShift(dredShift),

    greenBits(dgreenBits),

    greenShift(dgreenShift),

    blueBits(dblueBits),

    blueShift(dblueShift),

    alphaBits(dalphaBits),

    alphaShift(dalphaShift),

    luminanceBits(dluminanceBits),

    luminanceShift(dluminanceShift),

    shape(shape),

    internalFormat(dinternalFormat),

    bitsPerPixel(dbpp)

{

    bytesPerPixel = bitsPerPixel / 8;

    if (alphaBits)

    {

        maskBits = alphaBits;

        maskShift = alphaShift;

    }

    else if (!this->isLuminance())

    {

        maskBits = redBits;

        maskShift = redShift;

    }

    else

    {

        maskBits = luminanceBits;

        maskShift = luminanceShift;

    }

    RI_ASSERT(getShape() == shape);

}

RI_INLINE void Color::Descriptor::setNonlinear(bool nonlinear)

{

    if (nonlinear)

        internalFormat = (InternalFormat)(((RIuint32)internalFormat)|NONLINEAR);

    else

        internalFormat = (InternalFormat)(((RIuint32)internalFormat)&(~NONLINEAR));

}

/**

 * \brief	Creates a pixel format descriptor out of VGImageFormat

 * \todo    The formats without alpha were non-premultiplied in the reference

 *          implementation, but wouldn't it make more sense to consider them

 *          premultiplied? This would make sense at least when blitting to

 *          windows, etc., where the output color should have the alpha

 *          multiplied "in".

 */

RI_INLINE Color::Descriptor Color::formatToDescriptorConst(VGImageFormat format)

{

    switch(format)

    {

    case VG_sRGBX_8888:

        return Color::Descriptor(8, 24, 8, 16, 8, 8, 0, 0, 0, 0, Color::sRGBA, 32, SHAPE_RGBX);

    case VG_sRGBA_8888:

        return Color::Descriptor(8, 24, 8, 16, 8, 8, 8, 0, 0, 0, Color::sRGBA, 32, SHAPE_RGBA);

    case VG_sRGBA_8888_PRE:

        return Color::Descriptor(8, 24, 8, 16, 8, 8, 8, 0, 0, 0, Color::sRGBA_PRE, 32, SHAPE_RGBA);

    case VG_sRGB_565:

        return Color::Descriptor(5, 11, 6, 5, 5, 0, 0, 0, 0, 0, Color::sRGBA, 16, SHAPE_RGB);

    case VG_sRGBA_5551:

        return Color::Descriptor(5, 11, 5, 6, 5, 1, 1, 0, 0, 0, Color::sRGBA, 16, SHAPE_RGBA);

    case VG_sRGBA_4444:

        return Color::Descriptor(4, 12, 4, 8, 4, 4, 4, 0, 0, 0, Color::sRGBA, 16, SHAPE_RGBA);

    case VG_sL_8:

        return Color::Descriptor(0, 0, 0, 0, 0, 0, 0, 0, 8, 0, Color::sLA, 8, SHAPE_L);

    case VG_lRGBX_8888:

        return Color::Descriptor(8, 24, 8, 16, 8, 8, 0, 0, 0, 0, Color::lRGBA, 32, SHAPE_RGBX);

    case VG_lRGBA_8888:

        return Color::Descriptor(8, 24, 8, 16, 8, 8, 8, 0, 0, 0, Color::lRGBA, 32, SHAPE_RGBA);

    case VG_lRGBA_8888_PRE:

        return Color::Descriptor(8, 24, 8, 16, 8, 8, 8, 0, 0, 0, Color::lRGBA_PRE, 32, SHAPE_RGBA);

    case VG_lL_8:

        return Color::Descriptor(0, 0, 0, 0, 0, 0, 0, 0, 8, 0, Color::lLA, 8, SHAPE_L);

    case VG_A_8:

        return Color::Descriptor(0, 0, 0, 0, 0, 0, 8, 0, 0, 0, Color::lRGBA, 8, SHAPE_A);

    case VG_BW_1:

        return Color::Descriptor(0, 0, 0, 0, 0, 0, 0, 0, 1, 0, Color::lLA, 1, SHAPE_L);

    case VG_A_1:

        return Color::Descriptor(0, 0, 0, 0, 0, 0, 1, 0, 0, 0, Color::lRGBA, 1, SHAPE_A);

    case VG_A_4:

        return Color::Descriptor(0, 0, 0, 0, 0, 0, 4, 0, 0, 0, Color::lRGBA, 4, SHAPE_A);

  /* {A,X}RGB channel ordering */

    case VG_sXRGB_8888:

        return Color::Descriptor(8, 16, 8, 8, 8, 0, 0, 0, 0, 0, Color::sRGBA, 32, SHAPE_XRGB);

    case VG_sARGB_8888:

        return Color::Descriptor(8, 16, 8, 8, 8, 0, 8, 24, 0, 0, Color::sRGBA, 32, SHAPE_ARGB);

    case VG_sARGB_8888_PRE:

        return Color::Descriptor(8, 16, 8, 8, 8, 0, 8, 24, 0, 0, Color::sRGBA_PRE, 32, SHAPE_ARGB);

    case VG_sARGB_1555:

        return Color::Descriptor(5, 10, 5, 5, 5, 0, 1, 15, 0, 0, Color::sRGBA, 16, SHAPE_ARGB);

    case VG_sARGB_4444:

        return Color::Descriptor(4, 8, 4, 4, 4, 0, 4, 12, 0, 0, Color::sRGBA, 16, SHAPE_ARGB);

    case VG_lXRGB_8888:

        return Color::Descriptor(8, 16, 8, 8, 8, 0, 0, 0, 0, 0, Color::lRGBA, 32, SHAPE_XRGB);

    case VG_lARGB_8888:

        return Color::Descriptor(8, 16, 8, 8, 8, 0, 8, 24, 0, 0, Color::lRGBA, 32, SHAPE_ARGB);

    case VG_lARGB_8888_PRE:

        return Color::Descriptor(8, 16, 8, 8, 8, 0, 8, 24, 0, 0, Color::lRGBA_PRE, 32, SHAPE_ARGB);

  /* BGR{A,X} channel ordering */

    case VG_sBGRX_8888:

        return Color::Descriptor(8, 8, 8, 16, 8, 24, 0, 0, 0, 0, Color::sRGBA, 32, SHAPE_BGRX);

    case VG_sBGRA_8888:

        return Color::Descriptor(8, 8, 8, 16, 8, 24, 8, 0, 0, 0, Color::sRGBA, 32, SHAPE_BGRA);

    case VG_sBGRA_8888_PRE:

        return Color::Descriptor(8, 8, 8, 16, 8, 24, 8, 0, 0, 0, Color::sRGBA_PRE, 32, SHAPE_BGRA);

    case VG_sBGR_565:

        return Color::Descriptor(5, 0, 6, 5, 5, 11, 0, 0, 0, 0, Color::sRGBA, 16, SHAPE_BGR);

    case VG_sBGRA_5551:

        return Color::Descriptor(5, 1, 5, 6, 5, 11, 1, 0, 0, 0, Color::sRGBA, 16, SHAPE_BGRA);

    case VG_sBGRA_4444:

        return Color::Descriptor(4, 4, 4, 8, 4, 12, 4, 0, 0, 0, Color::sRGBA, 16, SHAPE_BGRA);

    case VG_lBGRX_8888:

        return Color::Descriptor(8, 8, 8, 16, 8, 24, 0, 0, 0, 0, Color::lRGBA, 32, SHAPE_BGRX);

    case VG_lBGRA_8888:

        return Color::Descriptor(8, 8, 8, 16, 8, 24, 8, 0, 0, 0, Color::lRGBA, 32, SHAPE_BGRA);

    case VG_lBGRA_8888_PRE:

        return Color::Descriptor(8, 8, 8, 16, 8, 24, 8, 0, 0, 0, Color::lRGBA_PRE, 32, SHAPE_BGRA);

  /* {A,X}BGR channel ordering */

    case VG_sXBGR_8888:

        return Color::Descriptor(8, 0, 8, 8, 8, 16, 0, 0, 0, 0, Color::sRGBA, 32, SHAPE_XBGR);

    case VG_sABGR_8888:

        return Color::Descriptor(8, 0, 8, 8, 8, 16, 8, 24, 0, 0, Color::sRGBA, 32, SHAPE_ABGR);

    case VG_sABGR_8888_PRE:

        return Color::Descriptor(8, 0, 8, 8, 8, 16, 8, 24, 0, 0, Color::sRGBA_PRE, 32, SHAPE_ABGR);

    case VG_sABGR_1555:

        return Color::Descriptor(5, 0, 5, 5, 5, 10, 1, 15, 0, 0, Color::sRGBA, 16, SHAPE_ABGR);

    case VG_sABGR_4444:

        return Color::Descriptor(4, 0, 4, 4, 4, 8, 4, 12, 0, 0, Color::sRGBA, 16, SHAPE_ABGR);

    case VG_lXBGR_8888:

        return Color::Descriptor(8, 0, 8, 8, 8, 16, 0, 0, 0, 0, Color::lRGBA, 32, SHAPE_XBGR);

    case VG_lABGR_8888:

        return Color::Descriptor(8, 0, 8, 8, 8, 16, 8, 24, 0, 0, Color::lRGBA, 32, SHAPE_ABGR);

    default:

    //case VG_lABGR_8888_PRE:

        RI_ASSERT(format == VG_lABGR_8888_PRE);

        return Color::Descriptor(8, 0, 8, 8, 8, 16, 8, 24, 0, 0, Color::lRGBA_PRE, 32, SHAPE_ABGR);

    }

}

RI_INLINE bool 	Color::Descriptor::operator==(const Descriptor& rhs) const

{

    return memcmp(this, &rhs, sizeof(Descriptor)) ? false : true;

}

RI_INLINE bool Color::Descriptor::isZeroConversion(const Descriptor& rhs) const

{

    return (shape == rhs.shape) &&

        (internalFormat == rhs.internalFormat) &&

        (redBits == rhs.redBits) &&

        (greenBits == rhs.greenBits) &&

        (blueBits == rhs.blueBits) &&

        (alphaBits == rhs.alphaBits) &&

        (luminanceBits == rhs.luminanceBits);

}

RI_INLINE bool Color::Descriptor::isShiftConversion(const Descriptor& rhs) const

{

    // \note BW conversion is always forced to full at the moment.

    if (isBW() != rhs.isBW()) 

        return false;

    return (isPremultiplied() == rhs.isPremultiplied())

            && (isNonlinear() == rhs.isNonlinear())

            && (isLuminance() == rhs.isLuminance());

}

RI_INLINE bool Color::Descriptor::isShiftConversionToLower(const Descriptor& rhs) const

{

    // \note BW conversion is always forced to full at the moment.

    if (isBW() != rhs.isBW()) 

        return false;

    // \note Mask bits are not checked because they are derived information.

    return (isShiftConversion(rhs)

            && (rhs.redBits <= redBits)

            && (rhs.greenBits <= greenBits)

            && (rhs.blueBits <= blueBits)

            && (rhs.alphaBits <= alphaBits)

            && (rhs.luminanceBits <= luminanceBits));

}

/**

 * \brief   In-place conversion of packed color to lower bit-depth

 * \param   c   Input packed color

 * \param   src Source color descriptor

 * \param   dst Destination color descriptor

 */

RI_INLINE RIuint32  Color::Descriptor::crossConvertToLower(RIuint32 c, const Descriptor& src, const Descriptor& dst)

{

    RIuint32 r = 0;

    RI_ASSERT(dst.redBits <= src.redBits);

    RI_ASSERT(dst.greenBits <= src.greenBits);

    RI_ASSERT(dst.blueBits <= src.blueBits);

    RI_ASSERT(dst.alphaBits <= src.alphaBits);

    if (src.isLuminance())

    {

        RI_ASSERT(dst.isLuminance());

        r = ((c >> (src.luminanceShift + src.luminanceBits - dst.luminanceBits)) & ((1u<<dst.luminanceBits)-1)) << dst.luminanceShift;

    } else

    {

        r = ((c >> (src.redShift + src.redBits - dst.redBits)) & ((1u<<dst.redBits)-1)) << dst.redShift;

        r |= ((c >> (src.greenShift + src.greenBits - dst.greenBits)) & ((1u<<dst.greenBits)-1)) << dst.greenShift;

        r |= ((c >> (src.blueShift + src.blueBits - dst.blueBits)) & ((1u<<dst.blueBits)-1)) << dst.blueShift;

    }

    if (src.hasAlpha())

    {

        if (dst.hasAlpha())

            r |= ((c >> (src.alphaShift + src.alphaBits - dst.alphaBits)) & ((1u<<dst.alphaBits)-1)) << dst.alphaShift;

        else

        {

            // Make sure that the alpha is applied to the color if doing only a shift conversion.

            RI_ASSERT(src.isPremultiplied() == dst.isPremultiplied());

        }

    }

    return r;

}

RI_INLINE RIuint32 Color::Descriptor::toIndex() const

{

    SmallDescriptor smallDesc;

    toSmallDescriptor(smallDesc);

    return smallDesc.toUint32();

}

RI_INLINE Color operator*(const Color& c, RIfloat f)			{ return Color(c.r*f, c.g*f, c.b*f, c.a*f, c.getInternalFormat()); }

RI_INLINE Color operator*(RIfloat f, const Color& c)			{ return Color(c.r*f, c.g*f, c.b*f, c.a*f, c.getInternalFormat()); }

RI_INLINE Color operator+(const Color& c0, const Color& c1)		{ RI_ASSERT(c0.getInternalFormat() == c1.getInternalFormat()); return Color(c0.r+c1.r, c0.g+c1.g, c0.b+c1.b, c0.a+c1.a, c0.getInternalFormat()); }

RI_INLINE Color operator-(const Color& c0, const Color& c1)		{ RI_ASSERT(c0.getInternalFormat() == c1.getInternalFormat()); return Color(c0.r-c1.r, c0.g-c1.g, c0.b-c1.b, c0.a-c1.a, c0.getInternalFormat()); }

RI_INLINE void  Color::assertConsistency() const

{