--- a/egl/sfopenvg/riImage.h Fri Jul 16 18:54:03 2010 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,379 +0,0 @@
-#ifndef __RIIMAGE_H
-#define __RIIMAGE_H
-
-/*------------------------------------------------------------------------
- *
- * OpenVG 1.1 Reference Implementation
- * -----------------------------------
- *
- * Copyright (c) 2007 The Khronos Group Inc.
- *
- * 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 "openvg.h"
-#endif
-
-#ifndef __RIMATH_H
-#include "riMath.h"
-#endif
-
-#ifndef __RIARRAY_H
-#include "riArray.h"
-#endif
-
-//==============================================================================================
-
-namespace OpenVGRI
-{
-
-/*-------------------------------------------------------------------*//*!
-* \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;
- }
- }
-
- 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 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)
- };
- class Descriptor
- {
- public:
- bool isNonlinear() const { return (internalFormat & NONLINEAR) ? true : false; }
- bool isPremultiplied() const { return (internalFormat & PREMULTIPLIED) ? true : false; }
- bool isLuminance() const { return (internalFormat & LUMINANCE) ? true : false; }
- bool isAlphaOnly() const { return (alphaBits && (redBits+greenBits+blueBits+luminanceBits) == 0) ? true : false; }
-
- int redBits;
- int redShift;
- int greenBits;
- int greenShift;
- int blueBits;
- int blueShift;
- int alphaBits;
- int alphaShift;
- int luminanceBits;
- int luminanceShift;
- VGImageFormat format;
- InternalFormat internalFormat;
- int bitsPerPixel;
- };
-
- RI_INLINE Color() : r(0.0f), g(0.0f), b(0.0f), a(0.0f), m_format(lRGBA) {}
- 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;
-
- 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 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
-{
- RI_ASSERT(r >= 0.0f && r <= 1.0f);
- RI_ASSERT(g >= 0.0f && g <= 1.0f);
- RI_ASSERT(b >= 0.0f && b <= 1.0f);
- RI_ASSERT(a >= 0.0f && a <= 1.0f);
- RI_ASSERT(!isPremultiplied() || (r <= a && g <= a && b <= a)); //premultiplied colors must have color channels less than or equal to alpha
- RI_ASSERT((isLuminance() && r == g && r == b) || !isLuminance()); //if luminance, r=g=b
-}
-
-//==============================================================================================
-
-/*-------------------------------------------------------------------*//*!
-* \brief Storage and operations for VGImage.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-class Surface;
-class Image
-{
-public:
- Image(const Color::Descriptor& desc, int width, int height, VGbitfield allowedQuality); //throws bad_alloc
- //use data from a memory buffer. NOTE: data is not copied, so it is user's responsibility to make sure the data remains valid while the Image is in use.
- Image(const Color::Descriptor& desc, int width, int height, int stride, RIuint8* data); //throws bad_alloc
- //child image constructor
- Image(Image* parent, int x, int y, int width, int height); //throws bad_alloc
- ~Image();
-
- const Color::Descriptor& getDescriptor() const { return m_desc; }
- int getWidth() const { return m_width; }
- int getHeight() const { return m_height; }
- int getStride() const { return m_stride; }
- Image* getParent() const { return m_parent; }
- VGbitfield getAllowedQuality() const { return m_allowedQuality; }
- void addInUse() { m_inUse++; }
- void removeInUse() { RI_ASSERT(m_inUse > 0); m_inUse--; }
- int isInUse() const { return m_inUse; }
- RIuint8* getData() const { return m_data; }
- void addReference() { m_referenceCount++; }
- int removeReference() { m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }
- bool overlaps(const Image* src) const;
-
- void clear(const Color& clearColor, int x, int y, int w, int h);
- void blit(const Image& src, int sx, int sy, int dx, int dy, int w, int h, bool dither); //throws bad_alloc
- void blit(const Surface* src, int sx, int sy, int dx, int dy, int w, int h); //throws bad_alloc
-
- Color readPixel(int x, int y) const;
- void writePixel(int x, int y, const Color& c);
- void writeFilteredPixel(int x, int y, const Color& c, VGbitfield channelMask);
-
- RIfloat readMaskPixel(int x, int y) const; //can read any image format
- void writeMaskPixel(int x, int y, RIfloat m); //can write only to VG_A_x
-
- Color resample(RIfloat x, RIfloat y, const Matrix3x3& surfaceToImage, VGImageQuality quality, VGTilingMode tilingMode, const Color& tileFillColor); //throws bad_alloc
- void makeMipMaps(); //throws bad_alloc
-
- void colorMatrix(const Image& src, const RIfloat* matrix, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask);
- void convolve(const Image& src, int kernelWidth, int kernelHeight, int shiftX, int shiftY, const RIint16* kernel, RIfloat scale, RIfloat bias, VGTilingMode tilingMode, const Color& edgeFillColor, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask);
- void separableConvolve(const Image& src, int kernelWidth, int kernelHeight, int shiftX, int shiftY, const RIint16* kernelX, const RIint16* kernelY, RIfloat scale, RIfloat bias, VGTilingMode tilingMode, const Color& edgeFillColor, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask);
- void gaussianBlur(const Image& src, RIfloat stdDeviationX, RIfloat stdDeviationY, VGTilingMode tilingMode, const Color& edgeFillColor, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask);
- void lookup(const Image& src, const RIuint8 * redLUT, const RIuint8 * greenLUT, const RIuint8 * blueLUT, const RIuint8 * alphaLUT, bool outputLinear, bool outputPremultiplied, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask);
- void lookupSingle(const Image& src, const RIuint32 * lookupTable, VGImageChannel sourceChannel, bool outputLinear, bool outputPremultiplied, bool filterFormatLinear, bool filterFormatPremultiplied, VGbitfield channelMask);
-private:
- Image(const Image&); //!< Not allowed.
- void operator=(const Image&); //!< Not allowed.
-
- Color readTexel(int u, int v, int level, VGTilingMode tilingMode, const Color& tileFillColor) const;
-
- Color::Descriptor m_desc;
- int m_width;
- int m_height;
- VGbitfield m_allowedQuality;
- int m_inUse;
- int m_stride;
- RIuint8* m_data;
- int m_referenceCount;
- bool m_ownsData;
- Image* m_parent;
- int m_storageOffsetX;
- int m_storageOffsetY;
-
- bool m_mipmapsValid;
- Array<Image*> m_mipmaps;
-};
-
-/*-------------------------------------------------------------------*//*!
-* \brief Surface class abstracting multisampled rendering surface.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-class Surface
-{
-public:
- Surface(const Color::Descriptor& desc, int width, int height, int numSamples); //throws bad_alloc
- Surface(Image* image); //throws bad_alloc
- Surface(const Color::Descriptor& desc, int width, int height, int stride, RIuint8* data); //throws bad_alloc
- ~Surface();
-
- RI_INLINE const Color::Descriptor& getDescriptor() const { return m_image->getDescriptor(); }
- RI_INLINE int getWidth() const { return m_width; }
- RI_INLINE int getHeight() const { return m_height; }
- RI_INLINE int getNumSamples() const { return m_numSamples; }
- RI_INLINE void addReference() { m_referenceCount++; }
- RI_INLINE int removeReference() { m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }
- RI_INLINE int isInUse() const { return m_image->isInUse(); }
- RI_INLINE bool isInUse(Image* image) const { return image == m_image ? true : false; }
-
- void clear(const Color& clearColor, int x, int y, int w, int h);
- void clear(const Color& clearColor, int x, int y, int w, int h, const Array<Rectangle>& scissors);
- void blit(const Image& src, int sx, int sy, int dx, int dy, int w, int h); //throws bad_alloc
- void blit(const Image& src, int sx, int sy, int dx, int dy, int w, int h, const Array<Rectangle>& scissors); //throws bad_alloc
- void blit(const Surface* src, int sx, int sy, int dx, int dy, int w, int h); //throws bad_alloc
- void blit(const Surface* src, int sx, int sy, int dx, int dy, int w, int h, const Array<Rectangle>& scissors); //throws bad_alloc
- void mask(const Image* src, VGMaskOperation operation, int x, int y, int w, int h);
- void mask(const Surface* src, VGMaskOperation operation, int x, int y, int w, int h);
-
- RI_INLINE Color readSample(int x, int y, int sample) const { return m_image->readPixel(x*m_numSamples+sample, y); }
- RI_INLINE void writeSample(int x, int y, int sample, const Color& c) { m_image->writePixel(x*m_numSamples+sample, y, c); }
-
- RIfloat readMaskCoverage(int x, int y) const;
- void writeMaskCoverage(int x, int y, RIfloat m);
- unsigned int readMaskMSAA(int x, int y) const;
- void writeMaskMSAA(int x, int y, unsigned int m);
-
- Color FSAAResolve(int x, int y) const; //for fb=>img: vgGetPixels, vgReadPixels
-private:
- Surface(const Surface&); //!< Not allowed.
- void operator=(const Surface&); //!< Not allowed.
-
- struct ScissorEdge
- {
- ScissorEdge() : x(0), miny(0), maxy(0), direction(0) {}
- bool operator<(const ScissorEdge& e) const { return x < e.x; }
- int x;
- int miny;
- int maxy;
- int direction; //1 start, -1 end
- };
-
- int m_width;
- int m_height;
- int m_numSamples;
- int m_referenceCount;
- Image* m_image;
-};
-
-/*-------------------------------------------------------------------*//*!
-* \brief Drawable class for encapsulating color and mask buffers.
-* \param
-* \return
-* \note
-*//*-------------------------------------------------------------------*/
-
-class Drawable
-{
-public:
- Drawable(const Color::Descriptor& desc, int width, int height, int numSamples, int maskBits); //throws bad_alloc
- Drawable(Image* image, int maskBits); //throws bad_alloc
- Drawable(const Color::Descriptor& desc, int width, int height, int stride, RIuint8* data, int maskBits); //throws bad_alloc
- ~Drawable();
-
- RI_INLINE const Color::Descriptor& getDescriptor() const { return m_color->getDescriptor(); }
- RI_INLINE int getNumMaskBits() const { if(!m_mask) return 0; return m_mask->getDescriptor().alphaBits; }
- RI_INLINE int getWidth() const { return m_color->getWidth(); }
- RI_INLINE int getHeight() const { return m_color->getHeight(); }
- RI_INLINE int getNumSamples() const { return m_color->getNumSamples(); }
- RI_INLINE void addReference() { m_referenceCount++; }
- RI_INLINE int removeReference() { m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }
- RI_INLINE int isInUse() const { return m_color->isInUse() || (m_mask && m_mask->isInUse()); }
- RI_INLINE bool isInUse(Image* image) const { return m_color->isInUse(image) || (m_mask && m_mask->isInUse(image)); }
- RI_INLINE Surface* getColorBuffer() const { return m_color; }
- RI_INLINE Surface* getMaskBuffer() const { return m_mask; }
-
- void resize(int newWidth, int newHeight); //throws bad_alloc
-private:
- Drawable(const Drawable&); //!< Not allowed.
- void operator=(const Drawable&); //!< Not allowed.
-
- int m_referenceCount;
- Surface* m_color;
- Surface* m_mask;
-};
-
-//==============================================================================================
-
-} //namespace OpenVGRI
-
-//==============================================================================================
-
-#endif /* __RIIMAGE_H */