add oversampler

oversampling/WDL/lice/lice.h

@@ -0,0 +1,639 @@
+#ifndef _LICE_H
+#define _LICE_H
+
+/*
+  Cockos WDL - LICE - Lightweight Image Compositing Engine
+
+  Copyright (C) 2007 and later, Cockos Incorporated
+  Portions Copyright (C) 2007 "schwa"
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+  
+*/
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include "../swell/swell-types.h" // use SWELL on other systems
+#endif
+
+
+// one of these can be defined in your project if you choose:
+//#define LICE_FAVOR_SPEED // optimizes some stuff that doesnt seem to benefit much (like LICE_DeltaBlit/LICE_RotatedBlit/LICE_TransformBlit)
+// (nothing) default probably good overall
+//#define LICE_FAVOR_SIZE // reduces code size of normal/scaled blit functions
+//#define LICE_FAVOR_SIZE_EXTREME // same as LICE_FAVOR_SIZE w/ smaller gains with bigger perf penalties (solid fills etc)
+
+#ifdef LICE_FAVOR_SPEED
+  #ifdef LICE_FAVOR_SIZE_EXTREME
+    #undef LICE_FAVOR_SIZE_EXTREME
+  #endif
+  #ifdef LICE_FAVOR_SIZE
+    #undef LICE_FAVOR_SIZE
+  #endif
+#endif
+#if defined(LICE_FAVOR_SIZE_EXTREME) && !defined(LICE_FAVOR_SIZE)
+#define LICE_FAVOR_SIZE
+#endif
+
+
+typedef unsigned int LICE_pixel;
+typedef unsigned char LICE_pixel_chan;
+
+#define LICE_RGBA(r,g,b,a) (((b)&0xff)|(((g)&0xff)<<8)|(((r)&0xff)<<16)|(((a)&0xff)<<24))
+#define LICE_GETB(v) ((v)&0xff)
+#define LICE_GETG(v) (((v)>>8)&0xff)
+#define LICE_GETR(v) (((v)>>16)&0xff)
+#define LICE_GETA(v) (((v)>>24)&0xff)
+
+#if defined(__APPLE__) && defined(__ppc__)
+#define LICE_PIXEL_A 0
+#define LICE_PIXEL_R 1
+#define LICE_PIXEL_G 2
+#define LICE_PIXEL_B 3
+#else
+#define LICE_PIXEL_B 0
+#define LICE_PIXEL_G 1
+#define LICE_PIXEL_R 2
+#define LICE_PIXEL_A 3
+#endif
+
+
+static inline LICE_pixel LICE_RGBA_FROMNATIVE(LICE_pixel col, int alpha=0)
+{
+  return LICE_RGBA(GetRValue(col),GetGValue(col),GetBValue(col),alpha);
+}
+
+// bitmap interface, and some built-in types (memory bitmap and system bitmap)
+
+class LICE_IBitmap
+{
+public:
+  virtual ~LICE_IBitmap() { }
+
+  virtual LICE_pixel *getBits()=0;
+  virtual int getWidth()=0;
+  virtual int getHeight()=0;
+  virtual int getRowSpan()=0; // includes any off-bitmap data
+  virtual bool isFlipped() { return false;  }
+  virtual bool resize(int w, int h)=0;
+
+  virtual HDC getDC() { return 0; } // only sysbitmaps have to implement this
+
+
+  virtual INT_PTR Extended(int id, void* data) { return 0; }  
+};
+
+#define LICE_EXT_SET_SCALING 0x2000 // data = int *, scaling is .8 fixed point. returns true if supported. affects LICE_*() draw operations
+#define LICE_EXT_GET_SCALING 0x2001 // data ignored, returns .8 fixed point, returns 0 if unscaled
+#define LICE_EXT_SET_ADVISORY_SCALING 0x2002 // data = int *, scaling is .8 fixed point. returns true if supported. does not affect draw operations
+#define LICE_EXT_GET_ADVISORY_SCALING 0x2003 // data ignored, returns .8 fixed point. returns 0 if unscaled
+#define LICE_EXT_GET_ANY_SCALING 0x2004 // data ignored, returns .8 fixed point, 0 if unscaled
+
+#define LICE_MEMBITMAP_ALIGNAMT 63
+
+class LICE_MemBitmap : public LICE_IBitmap
+{
+public:
+  LICE_MemBitmap(int w=0, int h=0, unsigned int linealign=4);
+  virtual ~LICE_MemBitmap();
+
+
+  // LICE_IBitmap interface
+  virtual LICE_pixel *getBits() 
+  { 
+    const UINT_PTR extra=LICE_MEMBITMAP_ALIGNAMT;
+    return (LICE_pixel *) (((UINT_PTR)m_fb + extra)&~extra);
+  }
+  virtual int getWidth() { return m_width; }
+  virtual int getHeight() { return m_height; }
+  virtual int getRowSpan() { return (m_width+m_linealign)&~m_linealign; }
+  virtual bool resize(int w, int h) { return __resize(w,h); } // returns TRUE if a resize occurred
+
+  // todo: LICE_EXT_SET_SCALING ?
+
+private:
+  bool __resize(int w, int h);
+  LICE_pixel *m_fb;
+  int m_width, m_height;
+  int m_allocsize;
+  unsigned int m_linealign;
+};
+
+class LICE_SysBitmap : public LICE_IBitmap
+{
+public:
+  LICE_SysBitmap(int w=0, int h=0);
+  virtual ~LICE_SysBitmap();
+  
+  // LICE_IBitmap interface
+  virtual LICE_pixel *getBits() { return m_bits; }
+  virtual int getWidth() { return m_width; }
+  virtual int getHeight() { return m_height; }
+  virtual int getRowSpan() { return m_allocw; }; 
+  virtual bool resize(int w, int h) { return __resize(w,h); } // returns TRUE if a resize occurred
+
+  virtual INT_PTR Extended(int id, void* data)
+  {
+    switch (id)
+    {
+      case LICE_EXT_SET_ADVISORY_SCALING: 
+        {
+          int sc = data && *(int*)data != 256 ? *(int *)data : 0; 
+          if (sc < 0) sc = 0;
+          m_adv_scaling = sc;
+        }
+      return 1;
+      case LICE_EXT_SET_SCALING: 
+        {
+          int sc = data && *(int*)data != 256 ? *(int *)data : 0; 
+          if (sc < 0) sc = 0;
+          if (m_draw_scaling != sc)
+          {
+            const int tmp=m_width;
+            m_draw_scaling = sc;
+            m_width=0;
+            resize(tmp,m_height);
+          }
+        }
+      return 1;
+      case LICE_EXT_GET_SCALING: 
+      return m_draw_scaling;
+      case LICE_EXT_GET_ADVISORY_SCALING: 
+      return m_adv_scaling;
+      case LICE_EXT_GET_ANY_SCALING:
+        if (m_draw_scaling > 0) 
+        {
+          if (m_adv_scaling > 0)
+            return (m_adv_scaling * m_draw_scaling) >> 8;
+          return m_draw_scaling;
+        }
+        return m_adv_scaling;
+    }
+    return 0;
+  }
+
+  // sysbitmap specific calls
+  virtual HDC getDC() { return m_dc; }
+
+
+private:
+  bool __resize(int w, int h);
+  int m_width, m_height;
+
+  HDC m_dc;
+  LICE_pixel *m_bits;
+  int m_allocw, m_alloch;
+#ifdef _WIN32
+  HBITMAP m_bitmap;
+  HGDIOBJ m_oldbitmap;
+#endif
+  int m_draw_scaling, m_adv_scaling;
+};
+
+class LICE_WrapperBitmap : public LICE_IBitmap 
+{
+  public:
+    LICE_WrapperBitmap(LICE_pixel *buf, int w, int h, int span, bool flipped)
+    {
+      m_buf=buf;
+      m_w=w;
+      m_h=h;
+      m_span=span;
+      m_flipped=flipped;
+    }
+    virtual ~LICE_WrapperBitmap() {}
+
+    virtual bool resize(int w, int h) { return false; }
+    virtual LICE_pixel *getBits() { return m_buf; }
+    virtual int getWidth() { return m_w; }
+    virtual int getHeight() { return m_h; }
+    virtual int getRowSpan() { return m_span; }
+
+    virtual HDC getDC() { return NULL; }
+    virtual bool isFlipped() { return m_flipped; }
+
+
+    LICE_pixel *m_buf;
+    int m_w,m_h,m_span;
+    bool m_flipped;
+};
+
+
+class LICE_SubBitmap : public LICE_IBitmap // note: you should only keep these around as long as they are needed, and don't resize the parent while this is allocated
+{
+  public:
+    LICE_SubBitmap(LICE_IBitmap *parent, int x, int y, int w, int h)
+    {
+      m_parent=parent;
+      if(x<0)x=0; 
+      if(y<0)y=0;
+      m_x=x;m_y=y;
+      __resize(w,h);
+    }
+    virtual ~LICE_SubBitmap() { }
+
+    virtual bool resize(int w, int h) { return __resize(w,h); }
+
+    bool __resize(int w, int h)
+    {
+      m_w=0;m_h=0;
+      if (m_parent && m_x >= 0 && m_y >= 0 && m_x < m_parent->getWidth() && m_y < m_parent->getHeight())
+      {
+        if (w > m_parent->getWidth()-m_x) w=m_parent->getWidth()-m_x;
+        if (h > m_parent->getHeight()-m_y) h=m_parent->getHeight()-m_y;
+
+        m_w=w; 
+        m_h=h;
+      }
+
+      return true;
+    }
+
+    virtual bool isFlipped() { return m_parent && m_parent->isFlipped();  }
+
+    virtual LICE_pixel *getBits() 
+    {
+      if (!m_parent) return 0;
+
+      int xc = m_x, yc = m_y, h = m_h;
+      const int scale = (int)m_parent->Extended(LICE_EXT_GET_SCALING,NULL);
+      if (scale > 0)
+      {
+        xc = (xc*scale)>>8;
+        yc = (yc*scale)>>8;
+        h = (h*scale)>>8;
+      }
+
+      LICE_pixel* parentptr=m_parent->getBits();
+      if (m_parent->isFlipped()) parentptr += (m_parent->getHeight() - (yc+h))*m_parent->getRowSpan()+xc;
+      else parentptr += yc*m_parent->getRowSpan()+xc;
+
+      return parentptr; 
+    }
+
+    enum { 
+        LICE_GET_SUBBITMAP_VERSION = 0x51b7000, 
+        LICE_SUBBITMAP_VERSION = 0x1000  // if we change any of this struct, then we *must* increment this version.
+    }; 
+
+    virtual INT_PTR Extended(int id, void* data)
+    {
+      if (id == LICE_GET_SUBBITMAP_VERSION) return LICE_SUBBITMAP_VERSION;
+
+      if (!m_parent) return 0;
+      return m_parent->Extended(id, data);
+    }
+      
+    virtual int getWidth() { return m_w; }
+    virtual int getHeight() { return m_h; }
+    virtual int getRowSpan() { return m_parent ? m_parent->getRowSpan() : 0; }
+
+    virtual HDC getDC() { return NULL; }
+
+    int m_w,m_h,m_x,m_y;
+    LICE_IBitmap *m_parent;
+};
+
+
+// flags that most blit functions can take
+
+#define LICE_BLIT_MODE_MASK 0xff
+#define LICE_BLIT_MODE_COPY 0
+#define LICE_BLIT_MODE_ADD 1
+#define LICE_BLIT_MODE_DODGE 2
+#define LICE_BLIT_MODE_MUL 3
+#define LICE_BLIT_MODE_OVERLAY 4
+#define LICE_BLIT_MODE_HSVADJ 5
+
+#define LICE_BLIT_MODE_CHANCOPY 0xf0 // in this mode, only available for LICE_Blit(), the low nibble is 2 bits of source channel (low 2), 2 bits of dest channel (high 2)
+
+#define LICE_BLIT_FILTER_MASK 0xff00
+#define LICE_BLIT_FILTER_NONE 0
+#define LICE_BLIT_FILTER_BILINEAR 0x100 // currently pretty slow! ack
+#define LICE_BLIT_IGNORE_SCALING 0x20000
+
+
+#define LICE_BLIT_USE_ALPHA 0x10000 // use source's alpha channel
+
+#ifndef lice_max
+#define lice_max(x,y) ((x)<(y)?(y):(x))
+#define lice_min(x,y) ((x)<(y)?(x):(y))
+#endif
+
+#ifdef _MSC_VER
+  #include <float.h>
+  #define lice_isfinite(x) _finite(x)
+#else
+  #define lice_isfinite(x) isfinite(x)
+#endif
+
+// Reaper exports most LICE functions, so the function declarations below
+// will collide with reaper_plugin.h
+#ifndef LICE_PROVIDED_BY_APP
+
+
+// bitmap loaders
+
+// dispatch to a linked loader implementation based on file extension 
+LICE_IBitmap* LICE_LoadImage(const char* filename, LICE_IBitmap* bmp=NULL, bool tryIgnoreExtension=false);
+char *LICE_GetImageExtensionList(bool wantAllSup=true, bool wantAllFiles=true); // returns doublenull terminated GetOpenFileName() style list -- free() when done.
+bool LICE_ImageIsSupported(const char *filename);  // must be a filename that ends in .jpg, etc. if you want to check the extension, pass .ext
+
+
+// pass a bmp if you wish to load it into that bitmap. note that if it fails bmp will not be deleted.
+LICE_IBitmap *LICE_LoadPNG(const char *filename, LICE_IBitmap *bmp=NULL); // returns a bitmap (bmp if nonzero) on success
+LICE_IBitmap *LICE_LoadPNGFromMemory(const void *data_in, int buflen, LICE_IBitmap *bmp=NULL);
+LICE_IBitmap *LICE_LoadPNGFromResource(HINSTANCE hInst, const char *resid, LICE_IBitmap *bmp=NULL); // returns a bitmap (bmp if nonzero) on success
+#ifndef _WIN32
+LICE_IBitmap *LICE_LoadPNGFromNamedResource(const char *name, LICE_IBitmap *bmp=NULL); // returns a bitmap (bmp if nonzero) on success
+#endif
+
+LICE_IBitmap *LICE_LoadBMP(const char *filename, LICE_IBitmap *bmp=NULL); // returns a bitmap (bmp if nonzero) on success
+LICE_IBitmap *LICE_LoadBMPFromResource(HINSTANCE hInst, const char *resid, LICE_IBitmap *bmp=NULL); // returns a bitmap (bmp if nonzero) on success
+
+LICE_IBitmap *LICE_LoadIcon(const char *filename, int reqiconsz=16, LICE_IBitmap *bmp=NULL); // returns a bitmap (bmp if nonzero) on success
+LICE_IBitmap *LICE_LoadIconFromResource(HINSTANCE hInst, const char *resid, int reqiconsz=16, LICE_IBitmap *bmp=NULL); // returns a bitmap (bmp if nonzero) on success
+
+LICE_IBitmap *LICE_LoadJPG(const char *filename, LICE_IBitmap *bmp=NULL);
+LICE_IBitmap *LICE_LoadJPGFromMemory(const void *data_in, int buflen, LICE_IBitmap *bmp = NULL);
+LICE_IBitmap* LICE_LoadJPGFromResource(HINSTANCE hInst, const char *resid, LICE_IBitmap* bmp = 0);
+
+LICE_IBitmap *LICE_LoadGIF(const char *filename, LICE_IBitmap *bmp=NULL, int *nframes=NULL); // if nframes set, will be set to number of images (stacked vertically), otherwise first frame used
+
+LICE_IBitmap *LICE_LoadPCX(const char *filename, LICE_IBitmap *bmp=NULL); // returns a bitmap (bmp if nonzero) on success
+
+// bitmap saving
+bool LICE_WritePNG(const char *filename, LICE_IBitmap *bmp, bool wantalpha=true);
+bool LICE_WriteJPG(const char *filename, LICE_IBitmap *bmp, int quality=95, bool force_baseline=true);
+bool LICE_WriteGIF(const char *filename, LICE_IBitmap *bmp, int transparent_alpha=0, bool dither=true); // if alpha<transparent_alpha then transparent. if transparent_alpha<0, then intra-frame checking is used
+
+// animated GIF API. use transparent_alpha=-1 to encode unchanged pixels as transparent
+void *LICE_WriteGIFBegin(const char *filename, LICE_IBitmap *firstframe, int transparent_alpha=0, int frame_delay=0, bool dither=true, int nreps=0); // nreps=0 for infinite
+void *LICE_WriteGIFBeginNoFrame(const char *filename, int w, int h, int transparent_alpha=0, bool dither=true, bool is_append=false);
+bool LICE_WriteGIFFrame(void *handle, LICE_IBitmap *frame, int xpos, int ypos, bool perImageColorMap=false, int frame_delay=0, int nreps=0); // nreps only used on the first frame, 0=infinite
+unsigned int LICE_WriteGIFGetSize(void *handle); // gets current output size
+bool LICE_WriteGIFEnd(void *handle);
+int LICE_SetGIFColorMapFromOctree(void *wr, void *octree, int numcolors); // can use after LICE_WriteGIFBeginNoFrame and before LICE_WriteGIFFrame
+
+// animated GIF reading
+void *LICE_GIF_LoadEx(const char *filename);
+void LICE_GIF_Close(void *handle);
+void LICE_GIF_Rewind(void *handle);
+unsigned int LICE_GIF_GetFilePos(void *handle); // gets current read position
+int LICE_GIF_UpdateFrame(void *handle, LICE_IBitmap *bm); // returns duration in msec (0 or more), or <0 if no more frames. bm will be modified/resized with new frame data
+
+
+
+// basic primitives
+void LICE_PutPixel(LICE_IBitmap *bm, int x, int y, LICE_pixel color, float alpha, int mode);
+LICE_pixel LICE_GetPixel(LICE_IBitmap *bm, int x, int y);
+
+// blit functions
+
+void LICE_Copy(LICE_IBitmap *dest, LICE_IBitmap *src); // resizes dest to fit
+
+
+//alpha parameter = const alpha (combined with source alpha if spcified)
+void LICE_Blit(LICE_IBitmap *dest, LICE_IBitmap *src, int dstx, int dsty, const RECT *srcrect, float alpha, int mode);
+void LICE_Blit(LICE_IBitmap *dest, LICE_IBitmap *src, int dstx, int dsty, int srcx, int srcy, int srcw, int srch, float alpha, int mode);
+
+void LICE_Blur(LICE_IBitmap *dest, LICE_IBitmap *src, int dstx, int dsty, int srcx, int srcy, int srcw, int srch);
+
+// dstw/dsty can be negative, srcw/srch can be as well (for flipping)
+void LICE_ScaledBlit(LICE_IBitmap *dest, LICE_IBitmap *src, int dstx, int dsty, int dstw, int dsth, 
+                     float srcx, float srcy, float srcw, float srch, float alpha, int mode);
+
+
+void LICE_HalveBlitAA(LICE_IBitmap *dest, LICE_IBitmap *src); // AA's src down to dest. uses the minimum size of both (use with LICE_SubBitmap to do sections)
+
+// if cliptosourcerect is false, then areas outside the source rect can get in (otherwise they are not drawn)
+void LICE_RotatedBlit(LICE_IBitmap *dest, LICE_IBitmap *src, 
+                      int dstx, int dsty, int dstw, int dsth, 
+                      float srcx, float srcy, float srcw, float srch, 
+                      float angle, 
+                      bool cliptosourcerect, float alpha, int mode,
+                      float rotxcent=0.0, float rotycent=0.0); // these coordinates are offset from the center of the image, in source pixel coordinates
+
+
+void LICE_TransformBlit(LICE_IBitmap *dest, LICE_IBitmap *src,  
+                    int dstx, int dsty, int dstw, int dsth,
+                    const float *srcpoints, int div_w, int div_h, // srcpoints coords should be div_w*div_h*2 long, and be in source image coordinates
+                    float alpha, int mode);
+void LICE_TransformBlit2(LICE_IBitmap *dest, LICE_IBitmap *src,  
+                    int dstx, int dsty, int dstw, int dsth,
+                    const double *srcpoints, int div_w, int div_h, // srcpoints coords should be div_w*div_h*2 long, and be in source image coordinates
+                    float alpha, int mode);
+
+void LICE_TransformBlit2Alpha(LICE_IBitmap *dest, LICE_IBitmap *src,  
+                    int dstx, int dsty, int dstw, int dsth,
+                    const double *srcpoints, int div_w, int div_h, // srcpoints coords should be div_w*div_h*3 long, and be in source image coordinates + alpha
+                    int mode);
+
+// if cliptosourcerect is false, then areas outside the source rect can get in (otherwise they are not drawn)
+void LICE_DeltaBlit(LICE_IBitmap *dest, LICE_IBitmap *src, 
+                    int dstx, int dsty, int dstw, int dsth,                     
+                    float srcx, float srcy, float srcw, float srch, 
+                    double dsdx, double dtdx, double dsdy, double dtdy,         
+                    double dsdxdy, double dtdxdy,
+                    bool cliptosourcerect, float alpha, int mode);
+
+void LICE_DeltaBlitAlpha(LICE_IBitmap *dest, LICE_IBitmap *src, 
+                    int dstx, int dsty, int dstw, int dsth,                     
+                    float srcx, float srcy, float srcw, float srch, 
+                    double dsdx, double dtdx, double dsdy, double dtdy,         
+                    double dsdxdy, double dtdxdy,
+                    bool cliptosourcerect, float alpha, int mode, double dadx, double dady, double dadxdy);
+
+
+// only LICE_BLIT_MODE_ADD or LICE_BLIT_MODE_COPY are used by this, for flags
+// ir-ia should be 0.0..1.0 (or outside that and they'll be clamped)
+// drdx should be X/dstw, drdy X/dsth etc
+void LICE_GradRect(LICE_IBitmap *dest, int dstx, int dsty, int dstw, int dsth, 
+                      float ir, float ig, float ib, float ia,
+                      float drdx, float dgdx, float dbdx, float dadx,
+                      float drdy, float dgdy, float dbdy, float dady,
+                      int mode);
+
+void LICE_FillRect(LICE_IBitmap *dest, int x, int y, int w, int h, LICE_pixel color, float alpha = 1.0f, int mode = 0);
+void LICE_ProcessRect(LICE_IBitmap *dest, int x, int y, int w, int h, void (*procFunc)(LICE_pixel *p, void *parm), void *parm);
+
+void LICE_Clear(LICE_IBitmap *dest, LICE_pixel color);
+void LICE_ClearRect(LICE_IBitmap *dest, int x, int y, int w, int h, LICE_pixel mask=0, LICE_pixel orbits=0);
+void LICE_MultiplyAddRect(LICE_IBitmap *dest, int x, int y, int w, int h, 
+                          float rsc, float gsc, float bsc, float asc, // 0-1, or -100 .. +100 if you really are insane
+                          float radd, float gadd, float badd, float aadd); // 0-255 is the normal range on these.. of course its clamped
+
+void LICE_SetAlphaFromColorMask(LICE_IBitmap *dest, LICE_pixel color);
+
+
+// non-flood fill. simply scans up/down and left/right
+void LICE_SimpleFill(LICE_IBitmap *dest, int x, int y, LICE_pixel newcolor,  
+                     LICE_pixel comparemask=LICE_RGBA(255,255,255,0), 
+                     LICE_pixel keepmask=LICE_RGBA(0,0,0,0));
+
+
+// texture generators
+void LICE_TexGen_Marble(LICE_IBitmap *dest, const RECT *rect, float rv, float gv, float bv, float intensity); //fills whole bitmap if rect == NULL
+
+//this function generates a Perlin noise
+//fills whole bitmap if rect == NULL
+//smooth needs to be a multiple of 2
+enum
+{
+  NOISE_MODE_NORMAL = 0,
+  NOISE_MODE_WOOD,
+};
+void LICE_TexGen_Noise(LICE_IBitmap *dest, const RECT *rect, float rv, float gv, float bv, float intensity, int mode=NOISE_MODE_NORMAL, int smooth=1); 
+
+//this function generates a Perlin noise in a circular fashion
+//fills whole bitmap if rect == NULL
+//size needs to be a multiple of 2
+void LICE_TexGen_CircNoise(LICE_IBitmap *dest, const RECT *rect, float rv, float gv, float bv, float nrings, float power, int size);
+
+
+// bitmapped text drawing:
+void LICE_DrawChar(LICE_IBitmap *bm, int x, int y, char c, 
+                   LICE_pixel color, float alpha, int mode);
+void LICE_DrawText(LICE_IBitmap *bm, int x, int y, const char *string, 
+                   LICE_pixel color, float alpha, int mode);
+void LICE_MeasureText(const char *string, int *w, int *h);
+
+// line drawing functions
+
+void LICE_Line(LICE_IBitmap *dest, int x1, int y1, int x2, int y2, LICE_pixel color, float alpha=1.0f, int mode=0, bool aa=true);
+void LICE_FLine(LICE_IBitmap* dest, float x1, float y1, float x2, float y2, LICE_pixel color, float alpha=1.0f, int mode=0, bool aa=true);
+void LICE_ThickFLine(LICE_IBitmap* dest, double x1, double y1, double x2, double y2, LICE_pixel color, float alpha, int mode, int wid); // always AA. wid is not affected by scaling (1 is always normal line, 2 is always 2 physical pixels, etc)
+
+void LICE_DashedLine(LICE_IBitmap* dest, int x1, int y1, int x2, int y2, int pxon, int pxoff, LICE_pixel color, float alpha=1.0f, int mode=0, bool aa=false); // straight lines only for now
+
+void LICE_FillTrapezoidF(LICE_IBitmap* dest, double fx1a, double fx1b, int y1, double fx2a, double fx2b, int y2, LICE_pixel color, float alpha, int mode);
+void LICE_FillTrapezoid(LICE_IBitmap* dest, int x1a, int x1b, int y1, int x2a, int x2b, int y2, LICE_pixel color, float alpha, int mode);
+void LICE_FillConvexPolygon(LICE_IBitmap* dest, const int* x, const int* y, int npoints, LICE_pixel color, float alpha, int mode);
+
+void LICE_FillTriangle(LICE_IBitmap *dest, int x1, int y1, int x2, int y2, int x3, int y3, LICE_pixel color, float alpha=1.0f, int mode=0);
+
+
+// Returns false if the line is entirely offscreen.
+bool LICE_ClipLine(int* pX1, int* pY1, int* pX2, int* pY2, int xLo, int yLo, int xHi, int yHi);
+bool LICE_ClipFLine(float* px1, float* py1, float* px2, float* py2, float xlo, float ylo, float xhi, float yhi);
+
+void LICE_Arc(LICE_IBitmap* dest, float cx, float cy, float r, float minAngle, float maxAngle, 
+              LICE_pixel color, float alpha=1.0f, int mode=0, bool aa=true);
+void LICE_Circle(LICE_IBitmap* dest, float cx, float cy, float r, LICE_pixel color, float alpha=1.0f, int mode=0, bool aa=true);
+void LICE_FillCircle(LICE_IBitmap* dest, float cx, float cy, float r, LICE_pixel color, float alpha=1.0f, int mode=0, bool aa=true);
+void LICE_RoundRect(LICE_IBitmap *drawbm, float xpos, float ypos, float w, float h, int cornerradius,
+                    LICE_pixel col, float alpha, int mode, bool aa);
+
+// useful for drawing shapes from a cache
+void LICE_DrawGlyph(LICE_IBitmap* dest, int x, int y, LICE_pixel color, const LICE_pixel_chan* alphas, int glyph_w, int glyph_h, float alpha=1.0f, int mode = 0);
+void LICE_DrawGlyphEx(LICE_IBitmap* dest, int x, int y, LICE_pixel color, const LICE_pixel_chan* alphas, int glyph_w, int glyph_span, int glyph_h, float alpha=1.0f, int mode = 0);
+
+void LICE_DrawMonoGlyph(LICE_IBitmap* dest, int x, int y, LICE_pixel color, const unsigned char* alphas, int glyph_w, int glyph_span, int glyph_h, float alpha=1.0f, int mode = 0);
+
+// quadratic bezier
+// tol means try to draw segments no longer than tol px
+void LICE_DrawQBezier(LICE_IBitmap* dest, double xstart, double ystart, double xctl, double yctl, double xend, double yend, 
+  LICE_pixel color, float alpha=1.0f, int mode=0, bool aa=true, double tol=0.0); 
+
+// cubic bezier
+// tol means try to draw segments no longer than tol px
+void LICE_DrawCBezier(LICE_IBitmap* dest, double xstart, double ystart, double xctl1, double yctl1,
+  double xctl2, double yctl2, double xend, double yend, LICE_pixel color, float alpha=1.0f, int mode=0, bool aa=true, double tol=0.0); 
+
+void LICE_DrawThickCBezier(LICE_IBitmap* dest, double xstart, double ystart, double xctl1, double yctl1,
+  double xctl2, double yctl2, double xend, double yend, LICE_pixel color, float alpha=1.0f, int mode=0, int wid=2, double tol=0.0);
+
+// vertical fill from y=yfill
+void LICE_FillCBezier(LICE_IBitmap* dest, double xstart, double ystart, double xctl1, double yctl1,
+  double xctl2, double yctl2, double xend, double yend, int yfill, LICE_pixel color, float alpha=1.0f, int mode=0, double tol=0.0);
+// horizontal fill from x=xfill
+void LICE_FillCBezierX(LICE_IBitmap* dest, double xstart, double ystart, double xctl1, double yctl1,
+  double xctl2, double yctl2, double xend, double yend, int xfill, LICE_pixel color, float alpha=1.0f, int mode=0, double tol=0.0); 
+
+// convenience functions
+void LICE_DrawRect(LICE_IBitmap *dest, int x, int y, int w, int h, LICE_pixel color, float alpha=1.0f, int mode=0);
+void LICE_BorderedRect(LICE_IBitmap *dest, int x, int y, int w, int h, LICE_pixel bgcolor, LICE_pixel fgcolor, float alpha=1.0f, int mode=0);
+
+// bitmap compare-by-value function
+int LICE_BitmapCmp(LICE_IBitmap* a, LICE_IBitmap* b, int *coordsOut=NULL);
+int LICE_BitmapCmpEx(LICE_IBitmap* a, LICE_IBitmap* b, LICE_pixel mask, int *coordsOut=NULL);
+
+// colorspace functions
+void LICE_RGB2HSV(int r, int g, int b, int* h, int* s, int* v); // rgb, sv: [0,256), h: [0,384)
+void LICE_HSV2RGB(int h, int s, int v, int* r, int* g, int* b); // rgb, sv: [0,256), h: [0,384)
+LICE_pixel LICE_HSV2Pix(int h, int s, int v, int alpha); // sv: [0,256), h: [0,384)
+
+LICE_pixel LICE_AlterColorHSV(LICE_pixel color, float d_hue, float d_saturation, float d_value);  // hue is rolled over, saturation and value are clamped, all 0..1
+void LICE_AlterBitmapHSV(LICE_IBitmap* src, float d_hue, float d_saturation, float d_value);  // hue is rolled over, saturation and value are clamped, all 0..1
+void LICE_AlterRectHSV(LICE_IBitmap* src, int x, int y, int w, int h, float d_hue, float d_saturation, float d_value, int mode=0);  // hue is rolled over, saturation and value are clamped, all 0..1. mode only used for scaling disable
+
+LICE_pixel LICE_CombinePixels(LICE_pixel dest, LICE_pixel src, float alpha, int mode);
+
+void LICE_CombinePixels2(LICE_pixel *destptr, int r, int g, int b, int a, int ia, int mode); // does not clamp
+void LICE_CombinePixels2Clamp(LICE_pixel *destptr, int r, int g, int b, int a, int ia, int mode);
+
+//// LVG
+
+class ProjectStateContext;
+void *LICE_LoadLVG(const char *filename);
+void *LICE_LoadLVGFromContext(ProjectStateContext *ctx, const char *nameInfo=NULL, int defw=0, int defh=0);
+void *LICE_GetSubLVG(void *lvg, const char *subname);
+LICE_IBitmap *LICE_RenderLVG(void *lvg, int reqw=0, int reqh=0, LICE_IBitmap *useBM=NULL);
+void LICE_DestroyLVG(void *lvg);
+
+/// palette
+
+void* LICE_CreateOctree(int maxcolors);
+void LICE_DestroyOctree(void* octree);
+void LICE_ResetOctree(void *octree, int maxcolors); // resets back to stock, but with spares (to avoid mallocs)
+int LICE_BuildOctree(void* octree, LICE_IBitmap* bmp);
+int LICE_BuildOctreeForAlpha(void* octree, LICE_IBitmap* bmp, unsigned int minalpha);
+int LICE_BuildOctreeForDiff(void* octree, LICE_IBitmap* bmp, LICE_IBitmap* refbmp, LICE_pixel mask=LICE_RGBA(255,255,255,0));
+int LICE_FindInOctree(void* octree, LICE_pixel color);
+int LICE_ExtractOctreePalette(void* octree, LICE_pixel* palette);
+
+// wrapper
+int LICE_BuildPalette(LICE_IBitmap* bmp, LICE_pixel* palette, int maxcolors);
+void LICE_TestPalette(LICE_IBitmap* bmp, LICE_pixel* palette, int numcolors);
+
+
+struct _LICE_ImageLoader_rec
+{
+  LICE_IBitmap *(*loadfunc)(const char *filename, bool checkFileName, LICE_IBitmap *bmpbase); 
+  const char *(*get_extlist)(); // returns GetOpenFileName sort of list "JPEG files (*.jpg)\0*.jpg\0"
+
+  struct _LICE_ImageLoader_rec *_next;
+};
+extern _LICE_ImageLoader_rec *LICE_ImageLoader_list;
+
+
+#endif // LICE_PROVIDED_BY_APP
+
+#ifdef __APPLE__
+#define LICE_Scale_BitBlt(hdc, x,y,w,h, src, sx,sy, mode) do { \
+   const int _x=(x), _y=(y), _w=(w), _h=(h), _sx = (sx), _sy = (sy), _mode=(mode); \
+   const int rsc = (int) (src)->Extended(LICE_EXT_GET_SCALING,NULL); \
+   if (rsc>0) \
+     StretchBlt(hdc,_x,_y,_w,_h,(src)->getDC(),(_sx*rsc)/256,(_sy*rsc)/256,(_w*rsc)>>8,(_h*rsc)>>8,_mode); \
+   else BitBlt(hdc,_x,_y,_w,_h,(src)->getDC(),_sx,_sy,_mode); \
+} while (0)
+#else
+#define LICE_Scale_BitBlt(hdc, x,y,w,h, src, sx,sy, mode) BitBlt(hdc,x,y,w,h,(src)->getDC(),sx,sy,mode)
+#endif
+
+#endif