/* GdkPixbuf library - convert X drawable information to RGB

 *

 * Copyright (C) 1999 Michael Zucchi

 *

 * Authors: Michael Zucchi <zucchi@zedzone.mmc.com.au>

 *          Cody Russell <bratsche@dfw.net>

 * 	    Federico Mena-Quintero <federico@gimp.org>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <stdio.h>

#include <string.h>

#include <gdk-pixbuf/gdk-pixbuf.h>

#include "gdkcolor.h"

#include "gdkimage.h"

#include "gdkvisual.h"

#include "gdkwindow.h"

#include "gdkpixbuf.h"

#include "gdkpixmap.h"

#include "gdkinternals.h"

#include "gdkalias.h"

/* Some convenient names

 */

#if (G_BYTE_ORDER == G_LITTLE_ENDIAN)

#define LITTLE

#undef BIG

#else

#define BIG

#undef LITTLE

#endif

#define d(x)

#define SWAP16(d) GUINT16_SWAP_LE_BE(d)

static const guint32 mask_table[] = {

  0x00000000, 0x00000001, 0x00000003, 0x00000007,

  0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,

  0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,

  0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,

  0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,

  0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,

  0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,

  0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,

  0xffffffff

};

/*

 * convert bitmap data to pixbuf without alpha,

 * without using a colormap 

 */

static void

bitmap1 (GdkImage    *image,

         guchar      *pixels,

         int          rowstride,

         int          x1,

         int          y1,

         int          x2,

         int          y2)

{

  int xx, yy;

  int bpl;

  register guint8 data;

  guint8 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl, *orow = pixels;

  d (printf ("bitmap, no alpha\n"));

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      o = orow;

      for (xx = x1; xx < x2; xx ++)

	{

          /* top 29 bits of xx (xx >> 3) indicate the byte the bit is inside,

           * bottom 3 bits (xx & 7) indicate bit inside that byte,

           * we don't bother to canonicalize data to 1 or 0, just

           * leave the relevant bit in-place.

           */

          data = srow[xx >> 3] & (image->byte_order == GDK_MSB_FIRST ?

                                  (0x80 >> (xx & 7)) :

                                  (1 << (xx & 7)));

          if (data)

            {

              *o++ = 255;

              *o++ = 255;

              *o++ = 255;

            }

          else

            {

              *o++ = 0;

              *o++ = 0;

              *o++ = 0;

            }

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert bitmap data to pixbuf with alpha,

 * without using a colormap 

 */

static void

bitmap1a (GdkImage    *image,

          guchar      *pixels,

          int          rowstride,

          int          x1,

          int          y1,

          int          x2,

          int          y2)

{

  int xx, yy;

  int bpl;

  register guint8 data;

  guint8 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl, *orow = pixels;

  d (printf ("bitmap, with alpha\n"));

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      o = orow;

      for (xx = x1; xx < x2; xx ++)

	{

          /* see comment in bitmap1() */

          data = srow[xx >> 3] & (image->byte_order == GDK_MSB_FIRST ?

                                  (0x80 >> (xx & 7)) :

                                  (1 << (xx & 7)));

          if (data)

            {

              *o++ = 255;

              *o++ = 255;

              *o++ = 255;

              *o++ = 255;

            }

          else

            {

              *o++ = 0;

              *o++ = 0;

              *o++ = 0;

              *o++ = 0;

            }

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 1 bits-pixel data

 * no alpha

 */

static void

rgb1 (GdkImage    *image,

      guchar      *pixels,

      int          rowstride,

      int          x1,

      int          y1,

      int          x2,

      int          y2,

      GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  register guint8 data;

  guint8 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl, *orow = pixels;

  d (printf ("1 bits/pixel\n"));

  /* convert upto 8 pixels/time */

  /* its probably not worth trying to make this run very fast, who uses

   * 1 bit displays anymore?

   */

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      o = orow;

      for (xx = x1; xx < x2; xx ++)

	{

          /* see comment in bitmap1() */

          data = srow[xx >> 3] & (image->byte_order == GDK_MSB_FIRST ?

                                  (0x80 >> (xx & 7)) :

                                  (1 << (xx & 7)));

	  *o++ = colormap->colors[data].red   >> 8;

	  *o++ = colormap->colors[data].green >> 8;

	  *o++ = colormap->colors[data].blue  >> 8;

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 1 bits/pixel data

 * with alpha

 */

static void

rgb1a (GdkImage    *image,

       guchar      *pixels,

       int          rowstride,

       int          x1,

       int          y1,

       int          x2,

       int          y2,

       GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  register guint8 data;

  guint8 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl, *orow = pixels;

  d (printf ("1 bits/pixel\n"));

  /* convert upto 8 pixels/time */

  /* its probably not worth trying to make this run very fast, who uses

   * 1 bit displays anymore? */

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      o = orow;

      for (xx = x1; xx < x2; xx ++)

	{

          /* see comment in bitmap1() */

          data = srow[xx >> 3] & (image->byte_order == GDK_MSB_FIRST ?

                                  (0x80 >> (xx & 7)) :

                                  (1 << (xx & 7)));

          *o++ = colormap->colors[data].red   >> 8;

	  *o++ = colormap->colors[data].green >> 8;

	  *o++ = colormap->colors[data].blue  >> 8;

	  *o++ = 255;

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 8 bits/pixel data

 * no alpha

 */

static void

rgb8 (GdkImage    *image,

      guchar      *pixels,

      int          rowstride,

      int          x1,

      int          y1,

      int          x2,

      int          y2,

      GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  guint32 mask;

  register guint32 data;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  register guint8 *s;

  register guint8 *o;

  bpl = image->bpl;

  d (printf ("8 bit, no alpha output\n"));

  mask = mask_table[image->depth];

  for (yy = y1; yy < y2; yy++)

    {

      s = srow;

      o = orow;

      for (xx = x1; xx < x2; xx++)

        {

          data = *s++ & mask;

          *o++ = colormap->colors[data].red   >> 8;

          *o++ = colormap->colors[data].green >> 8;

          *o++ = colormap->colors[data].blue  >> 8;

        }

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 8 bits/pixel data

 * with alpha

 */

static void

rgb8a (GdkImage    *image,

       guchar      *pixels,

       int          rowstride,

       int          x1,

       int          y1,

       int          x2,

       int          y2,

       GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  guint32 mask;

  register guint32 data;

  guint32 remap[256];

  register guint8 *s;	/* read 2 pixels at once */

  register guint32 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  bpl = image->bpl;

  d (printf ("8 bit, with alpha output\n"));

  mask = mask_table[image->depth];

  for (xx = x1; xx < colormap->size; xx++)

    {

#ifdef LITTLE

      remap[xx] = 0xff000000

	| (colormap->colors[xx].blue  & 0xff00) << 8

	| (colormap->colors[xx].green & 0xff00)

	| (colormap->colors[xx].red   >> 8);

#else

      remap[xx] = 0xff

	| (colormap->colors[xx].red   & 0xff00) << 16

	| (colormap->colors[xx].green & 0xff00) << 8

	| (colormap->colors[xx].blue  & 0xff00);

#endif

    }

  for (yy = y1; yy < y2; yy++)

    {

      s = srow;

      o = (guint32 *) orow;

      for (xx = x1; xx < x2; xx ++)

	{

	  data = *s++ & mask;

	  *o++ = remap[data];

	}

      srow += bpl;

      orow += rowstride;

    }

}

/* Bit shifting for 565 and 555 conversion routines

 *

 * RGB565 == rrrr rggg gggb bbbb, 16 bit native endian

 * RGB555 == xrrr rrgg gggb bbbb

 * ABGR8888: ARGB, 32-bit native endian

 * RGBA8888: RGBA, 32-bit native endian

 */

#define R8fromRGB565(d) ((((d) >> 8) & 0xf8) | (((d) >> 13) & 0x7))

#define G8fromRGB565(d) ((((d) >> 3) & 0xfc) | (((d) >> 9)  & 0x3))

#define B8fromRGB565(d) ((((d) << 3) & 0xf8) | (((d) >> 2)  & 0x7))

#define ABGR8888fromRGB565(d) (  ((d) & 0xf800) >> 8  | ((d) & 0xe000) >> 13 \

			       | ((d) & 0x07e0) << 5  | ((d) & 0x0600) >> 1  \

			       | ((d) & 0x001f) << 19 | ((d) & 0x001c) << 14 \

			       | 0xff000000)

#define RGBA8888fromRGB565(d) (  ((d) & 0xf800) << 16 | ((d) & 0xe000) << 11 \

			       | ((d) & 0x07e0) << 13 | ((d) & 0x0600) << 7  \

			       | ((d) & 0x001f) << 11 | ((d) & 0x001c) << 6  \

			       | 0xff)

#define R8fromRGB555(d) (((d) & 0x7c00) >> 7 | ((d) & 0x7000) >> 12)

#define G8fromRGB555(d) (((d) & 0x03e0) >> 2 | ((d) & 0x0380) >> 7)

#define B8fromRGB555(d) (((d) & 0x001f) << 3 | ((d) & 0x001c) >> 2)

#define ABGR8888fromRGB555(d) (  ((d) & 0x7c00) >> 7  | ((d) & 0x7000) >> 12 \

			       | ((d) & 0x03e0) << 6  | ((d) & 0x0380) << 1  \

			       | ((d) & 0x001f) << 19 | ((d) & 0x001c) << 14 \

			       | 0xff000000)

#define RGBA8888fromRGB555(d) (  ((d) & 0x7c00) << 17 | ((d) & 0x7000) << 12 \

			       | ((d) & 0x03e0) << 14 | ((d) & 0x0380) << 9  \

			       | ((d) & 0x001f) << 11 | ((d) & 0x001c) << 6  \

			       | 0xff)

/*

 * convert 16 bits/pixel data

 * no alpha

 * data in lsb format

 */

static void

rgb565lsb (GdkImage    *image,

	   guchar      *pixels,

	   int          rowstride,

	   int          x1,

	   int          y1,

	   int          x2,

	   int          y2,

	   GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  register guint16 *s;

  register guint8 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      s = (guint16 *) srow;

      o = (guint8 *) orow;

      for (xx = x1; xx < x2; xx ++)

	{

	  register guint32 data = *s++;

#ifdef BIG

	  data = SWAP16 (data);

#endif	  

	  *o++ = R8fromRGB565 (data);

	  *o++ = G8fromRGB565 (data);

	  *o++ = B8fromRGB565 (data);

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 16 bits/pixel data

 * no alpha

 * data in msb format

 */

static void

rgb565msb (GdkImage    *image,

	   guchar      *pixels,

	   int          rowstride,

           int          x1,

           int          y1,

           int          x2,

           int          y2,

	   GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  register guint16 *s;

  register guint8 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      s = (guint16 *) srow;

      o = (guint8 *) orow;

      for (xx = x1; xx < x2; xx ++)

	{

	  register guint32 data = *s++;

#ifdef LITTLE

	  data = SWAP16 (data);

#endif	  

	  *o++ = R8fromRGB565 (data);

	  *o++ = G8fromRGB565 (data);

	  *o++ = B8fromRGB565 (data);

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 16 bits/pixel data

 * with alpha

 * data in lsb format

 */

static void

rgb565alsb (GdkImage    *image,

	    guchar      *pixels,

	    int          rowstride,

            int          x1,

            int          y1,

            int          x2,

            int          y2,

	    GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  register guint16 *s;

  register guint32 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      s = (guint16 *) srow;

      o = (guint32 *) orow;

      for (xx = x1; xx < x2; xx ++)

	{

	  register guint32 data = *s++;

#ifdef LITTLE

	  *o++ = ABGR8888fromRGB565 (data);

#else

	  data = SWAP16 (data);

	  *o++ = RGBA8888fromRGB565 (data);

#endif

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 16 bits/pixel data

 * with alpha

 * data in msb format

 */

static void

rgb565amsb (GdkImage    *image,

	    guchar      *pixels,

	    int          rowstride,

            int          x1,

            int          y1,

            int          x2,

            int          y2,

	    GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  register guint16 *s;

  register guint32 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      s = (guint16 *) srow;

      o = (guint32 *) orow;

      for (xx = x1; xx < x2; xx ++)

	{

	  register guint32 data = *s++;

#ifdef LITTLE

	  data = SWAP16 (data);

	  *o++ = ABGR8888fromRGB565 (data);

#else

	  *o++ = RGBA8888fromRGB565 (data);

#endif

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 15 bits/pixel data

 * no alpha

 * data in lsb format

 */

static void

rgb555lsb (GdkImage     *image,

	   guchar       *pixels,

	   int           rowstride,

           int          x1,

           int          y1,

           int          x2,

           int          y2,

	   GdkColormap  *colormap)

{

  int xx, yy;

  int bpl;

  register guint16 *s;

  register guint8 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      s = (guint16 *) srow;

      o = (guint8 *) orow;

      for (xx = x1; xx < x2; xx ++)

	{

	  register guint32 data = *s++;

#ifdef BIG

	  data = SWAP16 (data);

#endif	  

	  *o++ = R8fromRGB555 (data);

	  *o++ = G8fromRGB555 (data);

	  *o++ = B8fromRGB555 (data);

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 15 bits/pixel data

 * no alpha

 * data in msb format

 */

static void

rgb555msb (GdkImage    *image,

	   guchar      *pixels,

	   int          rowstride,

           int          x1,

           int          y1,

           int          x2,

           int          y2,

	   GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  register guint16 *s;

  register guint8 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      s = (guint16 *) srow;

      o = (guint8 *) orow;

      for (xx = x1; xx < x2; xx ++)

	{

	  register guint32 data = *s++;

#ifdef LITTLE

	  data = SWAP16 (data);

#endif	  

	  *o++ = R8fromRGB555 (data);

	  *o++ = G8fromRGB555 (data);

	  *o++ = B8fromRGB555 (data);

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 15 bits/pixel data

 * with alpha

 * data in lsb format

 */

static void

rgb555alsb (GdkImage    *image,

	    guchar      *pixels,

	    int          rowstride,

            int          x1,

            int          y1,

            int          x2,

            int          y2,

	    GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  register guint16 *s;	/* read 1 pixels at once */

  register guint32 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      s = (guint16 *) srow;

      o = (guint32 *) orow;

      for (xx = x1; xx < x2; xx++)

	{

	  register guint32 data = *s++;

#ifdef LITTLE

	  *o++ = ABGR8888fromRGB555 (data);

#else

	  data = SWAP16 (data);

	  *o++ = RGBA8888fromRGB555 (data);

#endif

	}

      srow += bpl;

      orow += rowstride;

    }

}

/*

 * convert 15 bits/pixel data

 * with alpha

 * data in msb format

 */

static void

rgb555amsb (GdkImage    *image,

	    guchar      *pixels,

	    int          rowstride,

            int          x1,

            int          y1,

            int          x2,

            int          y2,

	    GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  register guint16 *s;

  register guint32 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  bpl = image->bpl;

  for (yy = y1; yy < y2; yy++)

    {

      s = (guint16 *) srow;

      o = (guint32 *) orow;

      for (xx = x1; xx < x2; xx++)

	{

	  register guint32 data = *s++;

#ifdef LITTLE

	  data = SWAP16 (data);

	  *o++ = ABGR8888fromRGB555 (data);

#else

	  *o++ = RGBA8888fromRGB555 (data);

#endif

	}

      srow += bpl;

      orow += rowstride;

    }

}

static void

rgb888alsb (GdkImage    *image,

	    guchar      *pixels,

	    int          rowstride,

            int          x1,

            int          y1,

            int          x2,

            int          y2,

	    GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  guint8 *s;	/* for byte order swapping */

  guint8 *o;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  bpl = image->bpl;

  d (printf ("32 bits/pixel with alpha\n"));

  /* lsb data */

  for (yy = y1; yy < y2; yy++)

    {

      s = srow;

      o = orow;

      for (xx = x1; xx < x2; xx++)

	{

	  *o++ = s[2];

	  *o++ = s[1];

	  *o++ = s[0];

	  *o++ = 0xff;

	  s += 4;

	}

      srow += bpl;

      orow += rowstride;

    }

}

static void

rgb888lsb (GdkImage    *image,

	   guchar      *pixels,

	   int          rowstride,

           int          x1,

           int          y1,

           int          x2,

           int          y2,

	   GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  guint8 *o, *s;

  bpl = image->bpl;

  d (printf ("32 bit, lsb, no alpha\n"));

  for (yy = y1; yy < y2; yy++)

    {

      s = srow;

      o = orow;

      for (xx = x1; xx < x2; xx++)

	{

	  *o++ = s[2];

	  *o++ = s[1];

	  *o++ = s[0];

	  s += 4;

	}

      srow += bpl;

      orow += rowstride;

    }

}

static void

rgb888amsb (GdkImage    *image,

	    guchar      *pixels,

	    int          rowstride,

            int          x1,

            int          y1,

            int          x2,

            int          y2,

	    GdkColormap *colormap)

{

  int xx, yy;

  int bpl;

  guint8 *srow = (guint8*)image->mem + y1 * image->bpl + x1 * image->bpp, *orow = pixels;

  guint32 *o;

  guint32 *s;

  d (printf ("32 bit, msb, with alpha\n"));

  bpl = image->bpl;

  /* msb data */

  for (yy = y1; yy < y2; yy++)

    {

      s = (guint32 *) srow;

      o = (guint32 *) orow;

      for (xx = x1; xx < x2; xx++)

	{

#ifdef LITTLE

	  *o++ = (*s++ >> 8) | 0xff000000;

#else

	  *o++ = (*s++ << 8) | 0xff;

#endif

	}

      srow += bpl;

      orow += rowstride;

    }

}

static void

rgb888msb (GdkImage    *image,

	   guchar      *pixels,

	   int          rowstride,

           int          x1,