Pileus Git - ~andy/gtk/blob - gdk-pixbuf/gdk-pixdata.c

   1 /* GdkPixbuf library - GdkPixdata - functions for inlined pixbuf handling
   2  * Copyright (C) 1999, 2001 Tim Janik
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 #include "gdk-pixdata.h"
  20
  21 #include "gdk-pixbuf-private.h"
  22 #include "gdk-pixbuf-i18n.h"
  23 #include <string.h>
  24
  25 #define APPEND g_string_append_printf
  26
  27 /* --- functions --- */
  28 static guint
  29 pixdata_get_length (const GdkPixdata *pixdata)
  30 {
  31   guint bpp, length;
  32
  33   if ((pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGB)
  34     bpp = 3;
  35   else if ((pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGBA)
  36     bpp = 4;
  37   else
  38     return 0;   /* invalid format */
  39   switch (pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK)
  40     {
  41       guint8 *rle_buffer;
  42       guint max_length;
  43     case GDK_PIXDATA_ENCODING_RAW:
  44       length = pixdata->rowstride * pixdata->height;
  45       break;
  46     case GDK_PIXDATA_ENCODING_RLE:
  47       /* need an RLE walk to determine size */
  48       max_length = pixdata->rowstride * pixdata->height;
  49       rle_buffer = pixdata->pixel_data;
  50       length = 0;
  51       while (length < max_length)
  52         {
  53           guint chunk_length = *(rle_buffer++);
  54
  55           if (chunk_length & 128)
  56             {
  57               chunk_length = chunk_length - 128;
  58               if (!chunk_length)        /* RLE data corrupted */
  59                 return 0;
  60               length += chunk_length * bpp;
  61               rle_buffer += bpp;
  62             }
  63           else
  64             {
  65               if (!chunk_length)        /* RLE data corrupted */
  66                 return 0;
  67               chunk_length *= bpp;
  68               length += chunk_length;
  69               rle_buffer += chunk_length;
  70             }
  71         }
  72       length = rle_buffer - pixdata->pixel_data;
  73       break;
  74     default:
  75       length = 0;
  76       break;
  77     }
  78   return length;
  79 }
  80
  81 /**
  82  * gdk_pixdata_serialize:
  83  * @pixdata: a valid #GdkPixdata structure to serialize.
  84  * @stream_length_p: location to store the resulting stream length in.
  85  *
  86  * Serializes a #GdkPixdata structure into a byte stream.
  87  * The byte stream consists of a straightforward writeout of the
  88  * #GdkPixdata fields in network byte order, plus the @pixel_data
  89  * bytes the structure points to.
  90  *
  91  * Return value: A newly-allocated string containing the serialized
  92  * #GdkPixdata structure.
  93  **/
  94 guint8* /* free result */
  95 gdk_pixdata_serialize (const GdkPixdata *pixdata,
  96                        guint            *stream_length_p)
  97 {
  98   guint8 *stream, *s;
  99   guint32 *istream;
 100   guint length;
 101
 102   /* check args passing */
 103   g_return_val_if_fail (pixdata != NULL, NULL);
 104   g_return_val_if_fail (stream_length_p != NULL, NULL);
 105   /* check pixdata contents */
 106   g_return_val_if_fail (pixdata->magic == GDK_PIXBUF_MAGIC_NUMBER, NULL);
 107   g_return_val_if_fail (pixdata->width > 0, NULL);
 108   g_return_val_if_fail (pixdata->height > 0, NULL);
 109   g_return_val_if_fail (pixdata->rowstride >= pixdata->width, NULL);
 110   g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGB ||
 111                         (pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGBA, NULL);
 112   g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_SAMPLE_WIDTH_MASK) == GDK_PIXDATA_SAMPLE_WIDTH_8, NULL);
 113   g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK) == GDK_PIXDATA_ENCODING_RAW ||
 114                         (pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK) == GDK_PIXDATA_ENCODING_RLE, NULL);
 115   g_return_val_if_fail (pixdata->pixel_data != NULL, NULL);
 116
 117   length = pixdata_get_length (pixdata);
 118
 119   /* check length field */
 120   g_return_val_if_fail (length != 0, NULL);
 121
 122   stream = g_malloc (GDK_PIXDATA_HEADER_LENGTH + length);
 123   istream = (guint32*) stream;
 124
 125   /* store header */
 126   *istream++ = g_htonl (GDK_PIXBUF_MAGIC_NUMBER);
 127   *istream++ = g_htonl (GDK_PIXDATA_HEADER_LENGTH + length);
 128   *istream++ = g_htonl (pixdata->pixdata_type);
 129   *istream++ = g_htonl (pixdata->rowstride);
 130   *istream++ = g_htonl (pixdata->width);
 131   *istream++ = g_htonl (pixdata->height);
 132
 133   /* copy pixel data */
 134   s = (guint8*) istream;
 135   memcpy (s, pixdata->pixel_data, length);
 136   s += length;
 137
 138   *stream_length_p = GDK_PIXDATA_HEADER_LENGTH + length;
 139   g_assert (s - stream == *stream_length_p);    /* paranoid */
 140
 141   return stream;
 142 }
 143
 144 #define return_header_corrupt(error)    { \
 145   g_set_error (error, GDK_PIXBUF_ERROR, \
 146                GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("Image header corrupt")); \
 147   return FALSE; \
 148 }
 149 #define return_invalid_format(error)    { \
 150   g_set_error (error, GDK_PIXBUF_ERROR, \
 151                GDK_PIXBUF_ERROR_UNKNOWN_TYPE, _("Image format unknown")); \
 152   return FALSE; \
 153 }
 154 #define return_pixel_corrupt(error)     { \
 155   g_set_error (error, GDK_PIXBUF_ERROR, \
 156                GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("Image pixel data corrupt")); \
 157   return FALSE; \
 158 }
 159
 160 static inline const guint8 *
 161 get_uint32 (const guint8 *stream, guint *result)
 162 {
 163   *result = (stream[0] << 24) + (stream[1] << 16) + (stream[2] << 8) + stream[3];
 164   return stream + 4;
 165 }
 166
 167 /**
 168  * gdk_pixdata_deserialize:
 169  * @pixdata: a #GdkPixdata structure to be filled in.
 170  * @stream_length: length of the stream used for deserialization.
 171  * @stream: stream of bytes containing a serialized #GdkPixdata structure.
 172  * @error: #GError location to indicate failures (maybe %NULL to ignore errors).
 173  *
 174  * Deserializes (reconstruct) a #GdkPixdata structure from a byte stream.
 175  * The byte stream consists of a straightforward writeout of the
 176  * #GdkPixdata fields in network byte order, plus the @pixel_data
 177  * bytes the structure points to.
 178  * The @pixdata contents are reconstructed byte by byte and are checked
 179  * for validity. This function may fail with %GDK_PIXBUF_CORRUPT_IMAGE
 180  * or %GDK_PIXBUF_ERROR_UNKNOWN_TYPE.
 181  *
 182  * Return value: Upon successful deserialization %TRUE is returned,
 183  * %FALSE otherwise.
 184  **/
 185 gboolean
 186 gdk_pixdata_deserialize (GdkPixdata   *pixdata,
 187                          guint         stream_length,
 188                          const guint8 *stream,
 189                          GError      **error)
 190 {
 191   guint color_type, sample_width, encoding;
 192
 193   g_return_val_if_fail (pixdata != NULL, FALSE);
 194   if (stream_length < GDK_PIXDATA_HEADER_LENGTH)
 195     return_header_corrupt (error);
 196   g_return_val_if_fail (stream != NULL, FALSE);
 197
 198
 199   /* deserialize header */
 200   stream = get_uint32 (stream, &pixdata->magic);
 201   stream = get_uint32 (stream, &pixdata->length);
 202   if (pixdata->magic != GDK_PIXBUF_MAGIC_NUMBER || pixdata->length < GDK_PIXDATA_HEADER_LENGTH)
 203     return_header_corrupt (error);
 204   stream = get_uint32 (stream, &pixdata->pixdata_type);
 205   stream = get_uint32 (stream, &pixdata->rowstride);
 206   stream = get_uint32 (stream, &pixdata->width);
 207   stream = get_uint32 (stream, &pixdata->height);
 208   if (pixdata->width < 1 || pixdata->height < 1 ||
 209       pixdata->rowstride < pixdata->width)
 210     return_header_corrupt (error);
 211   color_type = pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK;
 212   sample_width = pixdata->pixdata_type & GDK_PIXDATA_SAMPLE_WIDTH_MASK;
 213   encoding = pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK;
 214   if ((color_type != GDK_PIXDATA_COLOR_TYPE_RGB &&
 215        color_type != GDK_PIXDATA_COLOR_TYPE_RGBA) ||
 216       sample_width != GDK_PIXDATA_SAMPLE_WIDTH_8 ||
 217       (encoding != GDK_PIXDATA_ENCODING_RAW &&
 218        encoding != GDK_PIXDATA_ENCODING_RLE))
 219     return_invalid_format (error);
 220
 221   /* deserialize pixel data */
 222   if (stream_length < pixdata->length - GDK_PIXDATA_HEADER_LENGTH)
 223     return_pixel_corrupt (error);
 224   pixdata->pixel_data = (guint8 *)stream;
 225
 226   return TRUE;
 227 }
 228
 229 static gboolean
 230 diff2_rgb (guint8 *ip)
 231 {
 232   return ip[0] != ip[3] || ip[1] != ip[4] || ip[2] != ip[5];
 233 }
 234
 235 static gboolean
 236 diff2_rgba (guint8 *ip)
 237 {
 238   return ip[0] != ip[4] || ip[1] != ip[5] || ip[2] != ip[6] || ip[3] != ip[7];
 239 }
 240
 241 static guint8*                  /* dest buffer bound */
 242 rl_encode_rgbx (guint8 *bp,     /* dest buffer */
 243                 guint8 *ip,     /* image pointer */
 244                 guint8 *limit,  /* image upper bound */
 245                 guint   n_ch)
 246 {
 247   gboolean (*diff2_pix) (guint8 *) = n_ch > 3 ? diff2_rgba : diff2_rgb;
 248   guint8 *ilimit = limit - n_ch;
 249
 250   while (ip < limit)
 251     {
 252       g_assert (ip < ilimit); /* paranoid */
 253
 254       if (diff2_pix (ip))
 255         {
 256           guint8 *s_ip = ip;
 257           guint l = 1;
 258
 259           ip += n_ch;
 260           while (l < 127 && ip < ilimit && diff2_pix (ip))
 261             { ip += n_ch; l += 1; }
 262           if (ip == ilimit && l < 127)
 263             { ip += n_ch; l += 1; }
 264           *(bp++) = l;
 265           memcpy (bp, s_ip, l * n_ch);
 266           bp += l * n_ch;
 267         }
 268       else
 269         {
 270           guint l = 2;
 271
 272           ip += n_ch;
 273           while (l < 127 && ip < ilimit && !diff2_pix (ip))
 274             { ip += n_ch; l += 1; }
 275           *(bp++) = l | 128;
 276           memcpy (bp, ip, n_ch);
 277           ip += n_ch;
 278           bp += n_ch;
 279         }
 280       if (ip == ilimit)
 281         {
 282           *(bp++) = 1;
 283           memcpy (bp, ip, n_ch);
 284           ip += n_ch;
 285           bp += n_ch;
 286         }
 287     }
 288
 289   return bp;
 290 }
 291
 292 /**
 293  * gdk_pixdata_from_pixbuf:
 294  * @pixdata: a #GdkPixdata to fill.
 295  * @pixbuf: the data to fill @pixdata with.
 296  * @use_rle: whether to use run-length encoding for the pixel data.
 297  *
 298  * Converts a #GdkPixbuf to a #GdkPixdata. If @use_rle is %TRUE, the
 299  * pixel data is run-length encoded into newly-allocated memory and a
 300  * pointer to that memory is returned.
 301  *
 302  * Returns: If @ure_rle is %TRUE, a pointer to the newly-allocated memory
 303  *   for the run-length encoded pixel data, otherwise %NULL.
 304  **/
 305 gpointer
 306 gdk_pixdata_from_pixbuf (GdkPixdata      *pixdata,
 307                          const GdkPixbuf *pixbuf,
 308                          gboolean         use_rle)
 309 {
 310   gpointer free_me = NULL;
 311   guint height, rowstride, encoding, bpp, length;
 312   guint8 *img_buffer;
 313
 314   g_return_val_if_fail (pixdata != NULL, NULL);
 315   g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
 316   g_return_val_if_fail (pixbuf->bits_per_sample == 8, NULL);
 317   g_return_val_if_fail ((pixbuf->n_channels == 3 && !pixbuf->has_alpha) ||
 318                         (pixbuf->n_channels == 4 && pixbuf->has_alpha), NULL);
 319   g_return_val_if_fail (pixbuf->rowstride >= pixbuf->width, NULL);
 320
 321   height = pixbuf->height;
 322   rowstride = pixbuf->rowstride;
 323   encoding = use_rle ? GDK_PIXDATA_ENCODING_RLE : GDK_PIXDATA_ENCODING_RAW;
 324   bpp = pixbuf->has_alpha ? 4 : 3;
 325
 326   if (encoding == GDK_PIXDATA_ENCODING_RLE)
 327     {
 328       guint pad, n_bytes = rowstride * height;
 329       guint8 *img_buffer_end, *data;
 330
 331       pad = rowstride;
 332       pad = MAX (pad, 130 + n_bytes / 127);
 333       data = g_new (guint8, pad + n_bytes);
 334       free_me = data;
 335       img_buffer = data;
 336       img_buffer_end = rl_encode_rgbx (img_buffer,
 337                                        pixbuf->pixels, pixbuf->pixels + n_bytes,
 338                                        bpp);
 339       length = img_buffer_end - img_buffer;
 340     }
 341   else
 342     {
 343       img_buffer = pixbuf->pixels;
 344       length = rowstride * height;
 345     }
 346
 347   pixdata->magic = GDK_PIXBUF_MAGIC_NUMBER;
 348   pixdata->length = GDK_PIXDATA_HEADER_LENGTH + length;
 349   pixdata->pixdata_type = pixbuf->has_alpha ? GDK_PIXDATA_COLOR_TYPE_RGBA : GDK_PIXDATA_COLOR_TYPE_RGB;
 350   pixdata->pixdata_type |= GDK_PIXDATA_SAMPLE_WIDTH_8;
 351   pixdata->pixdata_type |= encoding;
 352   pixdata->rowstride = rowstride;
 353   pixdata->width = pixbuf->width;
 354   pixdata->height = height;
 355   pixdata->pixel_data = img_buffer;
 356
 357   return free_me;
 358 }
 359
 360 /**
 361  * gdk_pixbuf_from_pixdata:
 362  * @pixdata: a #GdkPixdata to convert into a #GdkPixbuf.
 363  * @copy_pixels: whether to copy raw pixel data; run-length encoded
 364  *     pixel data is always copied.
 365  * @error: location to store possible errors.
 366  *
 367  * Converts a #GdkPixdata to a #GdkPixbuf. If @copy_pixels is %TRUE or
 368  * if the pixel data is run-length-encoded, the pixel data is copied into
 369  * newly-allocated memory; otherwise it is reused.
 370  *
 371  * Returns: a new #GdkPixbuf.
 372  **/
 373 GdkPixbuf*
 374 gdk_pixbuf_from_pixdata (const GdkPixdata *pixdata,
 375                          gboolean          copy_pixels,
 376                          GError          **error)
 377 {
 378   guint encoding, bpp;
 379   guint8 *data = NULL;
 380
 381   g_return_val_if_fail (pixdata != NULL, NULL);
 382   g_return_val_if_fail (pixdata->width > 0, NULL);
 383   g_return_val_if_fail (pixdata->height > 0, NULL);
 384   g_return_val_if_fail (pixdata->rowstride >= pixdata->width, NULL);
 385   g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGB ||
 386                         (pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGBA, NULL);
 387   g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_SAMPLE_WIDTH_MASK) == GDK_PIXDATA_SAMPLE_WIDTH_8, NULL);
 388   g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK) == GDK_PIXDATA_ENCODING_RAW ||
 389                         (pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK) == GDK_PIXDATA_ENCODING_RLE, NULL);
 390   g_return_val_if_fail (pixdata->pixel_data != NULL, NULL);
 391
 392   bpp = (pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGB ? 3 : 4;
 393   encoding = pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK;
 394   if (encoding == GDK_PIXDATA_ENCODING_RLE)
 395     copy_pixels = TRUE;
 396   if (copy_pixels)
 397     {
 398       data = g_try_malloc (pixdata->rowstride * pixdata->height);
 399       if (!data)
 400         {
 401           g_set_error (error, GDK_PIXBUF_ERROR,
 402                        GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
 403                        _("failed to allocate image buffer of %u bytes"),
 404                        pixdata->rowstride * pixdata->height);
 405           return NULL;
 406         }
 407     }
 408   if (encoding == GDK_PIXDATA_ENCODING_RLE)
 409     {
 410       const guint8 *rle_buffer = pixdata->pixel_data;
 411       guint8 *image_buffer = data;
 412       guint8 *image_limit = data + pixdata->rowstride * pixdata->height;
 413       gboolean check_overrun = FALSE;
 414
 415       while (image_buffer < image_limit)
 416         {
 417           guint length = *(rle_buffer++);
 418
 419           if (length & 128)
 420             {
 421               length = length - 128;
 422               check_overrun = image_buffer + length * bpp > image_limit;
 423               if (check_overrun)
 424                 length = (image_limit - image_buffer) / bpp;
 425               if (bpp < 4)      /* RGB */
 426                 do
 427                   {
 428                     memcpy (image_buffer, rle_buffer, 3);
 429                     image_buffer += 3;
 430                   }
 431                 while (--length);
 432               else              /* RGBA */
 433                 do
 434                   {
 435                     memcpy (image_buffer, rle_buffer, 4);
 436                     image_buffer += 4;
 437                   }
 438                 while (--length);
 439               rle_buffer += bpp;
 440             }
 441           else
 442             {
 443               length *= bpp;
 444               check_overrun = image_buffer + length > image_limit;
 445               if (check_overrun)
 446                 length = image_limit - image_buffer;
 447               memcpy (image_buffer, rle_buffer, length);
 448               image_buffer += length;
 449               rle_buffer += length;
 450             }
 451         }
 452       if (check_overrun)
 453         {
 454           g_free (data);
 455           g_set_error (error, GDK_PIXBUF_ERROR,
 456                        GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
 457                        _("Image pixel data corrupt"));
 458           return NULL;
 459         }
 460     }
 461   else if (copy_pixels)
 462     memcpy (data, pixdata->pixel_data, pixdata->rowstride * pixdata->height);
 463   else
 464     data = pixdata->pixel_data;
 465
 466   return gdk_pixbuf_new_from_data (data, GDK_COLORSPACE_RGB,
 467                                    (pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGBA,
 468                                    8, pixdata->width, pixdata->height, pixdata->rowstride,
 469                                    copy_pixels ? (GdkPixbufDestroyNotify) g_free : NULL, data);
 470 }
 471
 472 typedef struct {
 473   /* config */
 474   gboolean     dump_stream;
 475   gboolean     dump_struct;
 476   gboolean     dump_macros;
 477   gboolean     dump_gtypes;
 478   gboolean     dump_rle_decoder;
 479   const gchar *static_prefix;
 480   const gchar *const_prefix;
 481   /* runtime */
 482   GString *gstring;
 483   guint    pos;
 484   gboolean pad;
 485 } CSourceData;
 486
 487 static inline void
 488 save_uchar (CSourceData *cdata,
 489             guint8       d)
 490 {
 491   GString *gstring = cdata->gstring;
 492
 493   if (cdata->pos > 70)
 494     {
 495       if (cdata->dump_struct || cdata->dump_stream)
 496         {
 497           g_string_append (gstring, "\"\n  \"");
 498           cdata->pos = 3;
 499           cdata->pad = FALSE;
 500         }
 501       if (cdata->dump_macros)
 502         {
 503           g_string_append (gstring, "\" \\\n  \"");
 504           cdata->pos = 3;
 505           cdata->pad = FALSE;
 506         }
 507     }
 508   if (d < 33 || d > 126)
 509     {
 510       APPEND (gstring, "\\%o", d);
 511       cdata->pos += 1 + 1 + (d > 7) + (d > 63);
 512       cdata->pad = d < 64;
 513       return;
 514     }
 515   if (d == '\\')
 516     {
 517       g_string_append (gstring, "\\\\");
 518       cdata->pos += 2;
 519     }
 520   else if (d == '"')
 521     {
 522       g_string_append (gstring, "\\\"");
 523       cdata->pos += 2;
 524     }
 525   else if (cdata->pad && d >= '0' && d <= '9')
 526     {
 527       g_string_append (gstring, "\"\"");
 528       g_string_append_c (gstring, d);
 529       cdata->pos += 3;
 530     }
 531   else
 532     {
 533       g_string_append_c (gstring, d);
 534       cdata->pos += 1;
 535     }
 536   cdata->pad = FALSE;
 537   return;
 538 }
 539
 540 static inline void
 541 save_rle_decoder (GString     *gstring,
 542                   const gchar *macro_name,
 543                   const gchar *s_uint,
 544                   const gchar *s_uint_8,
 545                   guint        n_ch)
 546 {
 547   APPEND (gstring, "#define %s_RUN_LENGTH_DECODE(image_buf, rle_data, size, bpp) do \\\n",
 548           macro_name);
 549   APPEND (gstring, "{ %s __bpp; %s *__ip; const %s *__il, *__rd; \\\n", s_uint, s_uint_8, s_uint_8);
 550   APPEND (gstring, "  __bpp = (bpp); __ip = (image_buf); __il = __ip + (size) * __bpp; \\\n");
 551
 552   APPEND (gstring, "  __rd = (rle_data); if (__bpp > 3) { /* RGBA */ \\\n");
 553
 554   APPEND (gstring, "    while (__ip < __il) { %s __l = *(__rd++); \\\n", s_uint);
 555   APPEND (gstring, "      if (__l & 128) { __l = __l - 128; \\\n");
 556   APPEND (gstring, "        do { memcpy (__ip, __rd, 4); __ip += 4; } while (--__l); __rd += 4; \\\n");
 557   APPEND (gstring, "      } else { __l *= 4; memcpy (__ip, __rd, __l); \\\n");
 558   APPEND (gstring, "               __ip += __l; __rd += __l; } } \\\n");
 559
 560   APPEND (gstring, "  } else { /* RGB */ \\\n");
 561
 562   APPEND (gstring, "    while (__ip < __il) { %s __l = *(__rd++); \\\n", s_uint);
 563   APPEND (gstring, "      if (__l & 128) { __l = __l - 128; \\\n");
 564   APPEND (gstring, "        do { memcpy (__ip, __rd, 3); __ip += 3; } while (--__l); __rd += 3; \\\n");
 565   APPEND (gstring, "      } else { __l *= 3; memcpy (__ip, __rd, __l); \\\n");
 566   APPEND (gstring, "               __ip += __l; __rd += __l; } } \\\n");
 567
 568   APPEND (gstring, "  } } while (0)\n");
 569 }
 570
 571 /**
 572  * gdk_pixdata_to_csource:
 573  * @pixdata: a #GdkPixdata to convert to C source.
 574  * @name: used for naming generated data structures or macros.
 575  * @dump_type: a #GdkPixdataDumpType determining the kind of C
 576  *   source to be generated.
 577  *
 578  * Generates C source code suitable for compiling images directly
 579  * into programs.
 580  *
 581  * GTK+ ships with a program called <command>gdk-pixbuf-csource</command>
 582  * which offers a cmdline interface to this functions.
 583  *
 584  * Returns: a newly-allocated string containing the C source form
 585  *   of @pixdata.
 586  **/
 587 GString*
 588 gdk_pixdata_to_csource (GdkPixdata        *pixdata,
 589                         const gchar       *name,
 590                         GdkPixdataDumpType dump_type)
 591 {
 592   CSourceData cdata = { 0, };
 593   gchar *s_uint_8, *s_uint_32, *s_uint, *s_char, *s_null;
 594   guint bpp, width, height, rowstride;
 595   gboolean rle_encoded;
 596   gchar *macro_name;
 597   guint8 *img_buffer, *img_buffer_end, *stream;
 598   guint stream_length;
 599   GString *gstring;
 600
 601   /* check args passing */
 602   g_return_val_if_fail (pixdata != NULL, NULL);
 603   g_return_val_if_fail (name != NULL, NULL);
 604   /* check pixdata contents */
 605   g_return_val_if_fail (pixdata->magic == GDK_PIXBUF_MAGIC_NUMBER, NULL);
 606   g_return_val_if_fail (pixdata->width > 0, NULL);
 607   g_return_val_if_fail (pixdata->height > 0, NULL);
 608   g_return_val_if_fail (pixdata->rowstride >= pixdata->width, NULL);
 609   g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGB ||
 610                         (pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGBA, NULL);
 611   g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_SAMPLE_WIDTH_MASK) == GDK_PIXDATA_SAMPLE_WIDTH_8, NULL);
 612   g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK) == GDK_PIXDATA_ENCODING_RAW ||
 613                         (pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK) == GDK_PIXDATA_ENCODING_RLE, NULL);
 614   g_return_val_if_fail (pixdata->pixel_data != NULL, NULL);
 615
 616   img_buffer = pixdata->pixel_data;
 617   if (pixdata->length < 1)
 618     img_buffer_end = img_buffer + pixdata_get_length (pixdata);
 619   else
 620     img_buffer_end = img_buffer + pixdata->length - GDK_PIXDATA_HEADER_LENGTH;
 621   g_return_val_if_fail (img_buffer < img_buffer_end, NULL);
 622
 623   bpp = (pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGB ? 3 : 4;
 624   width = pixdata->width;
 625   height = pixdata->height;
 626   rowstride = pixdata->rowstride;
 627   rle_encoded = (pixdata->pixdata_type & GDK_PIXDATA_ENCODING_RLE) > 0;
 628   macro_name = g_ascii_strup (name, -1);
 629
 630   cdata.dump_macros = (dump_type & GDK_PIXDATA_DUMP_MACROS) > 0;
 631   cdata.dump_struct = (dump_type & GDK_PIXDATA_DUMP_PIXDATA_STRUCT) > 0;
 632   cdata.dump_stream = !cdata.dump_macros && !cdata.dump_struct;
 633   g_return_val_if_fail (cdata.dump_macros + cdata.dump_struct + cdata.dump_stream == 1, NULL);
 634
 635   cdata.dump_gtypes = (dump_type & GDK_PIXDATA_DUMP_CTYPES) == 0;
 636   cdata.dump_rle_decoder = (dump_type & GDK_PIXDATA_DUMP_RLE_DECODER) > 0;
 637   cdata.static_prefix = (dump_type & GDK_PIXDATA_DUMP_STATIC) ? "static " : "";
 638   cdata.const_prefix = (dump_type & GDK_PIXDATA_DUMP_CONST) ? "const " : "";
 639   gstring = g_string_new ("");
 640   cdata.gstring = gstring;
 641
 642   if (!cdata.dump_macros && cdata.dump_gtypes)
 643     {
 644       s_uint_8 =  "guint8 ";
 645       s_uint_32 = "guint32";
 646       s_uint =    "guint  ";
 647       s_char =    "gchar  ";
 648       s_null =    "NULL";
 649     }
 650   else if (!cdata.dump_macros)
 651     {
 652       s_uint_8 =  "unsigned char";
 653       s_uint_32 = "unsigned int ";
 654       s_uint =    "unsigned int ";
 655       s_char =    "char         ";
 656       s_null =    "(char*) 0";
 657     }
 658   else if (cdata.dump_macros && cdata.dump_gtypes)
 659     {
 660       s_uint_8 =  "guint8";
 661       s_uint_32 = "guint32";
 662       s_uint  =   "guint";
 663       s_char =    "gchar";
 664       s_null =    "NULL";
 665     }
 666   else /* cdata.dump_macros && !cdata.dump_gtypes */
 667     {
 668       s_uint_8 =  "unsigned char";
 669       s_uint_32 = "unsigned int";
 670       s_uint =    "unsigned int";
 671       s_char =    "char";
 672       s_null =    "(char*) 0";
 673     }
 674
 675   /* initial comment
 676    */
 677   APPEND (gstring,
 678           "/* GdkPixbuf %s C-Source image dump %s*/\n\n",
 679           bpp > 3 ? "RGBA" : "RGB",
 680           rle_encoded ? "1-byte-run-length-encoded " : "");
 681
 682   /* dump RLE decoder for structures
 683    */
 684   if (cdata.dump_rle_decoder && cdata.dump_struct)
 685     save_rle_decoder (gstring,
 686                       macro_name,
 687                       cdata.dump_gtypes ? "guint" : "unsigned int",
 688                       cdata.dump_gtypes ? "guint8" : "unsigned char",
 689                       bpp);
 690
 691   /* format & size blurbs
 692    */
 693   if (cdata.dump_macros)
 694     {
 695       APPEND (gstring, "#define %s_ROWSTRIDE (%u)\n",
 696               macro_name, rowstride);
 697       APPEND (gstring, "#define %s_WIDTH (%u)\n",
 698               macro_name, width);
 699       APPEND (gstring, "#define %s_HEIGHT (%u)\n",
 700               macro_name, height);
 701       APPEND (gstring, "#define %s_BYTES_PER_PIXEL (%u) /* 3:RGB, 4:RGBA */\n",
 702               macro_name, bpp);
 703     }
 704   if (cdata.dump_struct)
 705     {
 706       APPEND (gstring, "%s%sGdkPixdata %s = {\n",
 707               cdata.static_prefix, cdata.const_prefix, name);
 708       APPEND (gstring, "  0x%x, /* Pixbuf magic: 'GdkP' */\n",
 709               GDK_PIXBUF_MAGIC_NUMBER);
 710       APPEND (gstring, "  %u + %lu, /* header length + pixel_data length */\n",
 711               GDK_PIXDATA_HEADER_LENGTH,
 712               rle_encoded ? (glong)(img_buffer_end - img_buffer) : (glong)rowstride * height);
 713       APPEND (gstring, "  0x%x, /* pixdata_type */\n",
 714               pixdata->pixdata_type);
 715       APPEND (gstring, "  %u, /* rowstride */\n",
 716               rowstride);
 717       APPEND (gstring, "  %u, /* width */\n",
 718               width);
 719       APPEND (gstring, "  %u, /* height */\n",
 720               height);
 721       APPEND (gstring, "  /* pixel_data: */\n");
 722     }
 723   if (cdata.dump_stream)
 724     {
 725       guint pix_length = img_buffer_end - img_buffer;
 726
 727       stream = gdk_pixdata_serialize (pixdata, &stream_length);
 728       img_buffer_end = stream + stream_length;
 729
 730       APPEND (gstring, "%s%s%s %s[] = \n",
 731               cdata.static_prefix, cdata.const_prefix,
 732               cdata.dump_gtypes ? "guint8" : "unsigned char",
 733               name);
 734       APPEND (gstring, "{ \"\"\n  /* Pixbuf magic (0x%x) */\n  \"",
 735               GDK_PIXBUF_MAGIC_NUMBER);
 736       cdata.pos = 3;
 737       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 738       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 739       APPEND (gstring, "\"\n  /* length: header (%u) + pixel_data (%u) */\n  \"",
 740               GDK_PIXDATA_HEADER_LENGTH,
 741               rle_encoded ? pix_length : rowstride * height);
 742       cdata.pos = 3;
 743       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 744       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 745       APPEND (gstring, "\"\n  /* pixdata_type (0x%x) */\n  \"",
 746               pixdata->pixdata_type);
 747       cdata.pos = 3;
 748       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 749       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 750       APPEND (gstring, "\"\n  /* rowstride (%u) */\n  \"",
 751               rowstride);
 752       cdata.pos = 3;
 753       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 754       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 755       APPEND (gstring, "\"\n  /* width (%u) */\n  \"", width);
 756       cdata.pos = 3;
 757       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 758       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 759       APPEND (gstring, "\"\n  /* height (%u) */\n  \"", height);
 760       cdata.pos = 3;
 761       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 762       save_uchar (&cdata, *stream++); save_uchar (&cdata, *stream++);
 763       APPEND (gstring, "\"\n  /* pixel_data: */\n");
 764       img_buffer = stream;
 765     }
 766
 767   /* pixel_data intro
 768    */
 769   if (cdata.dump_macros)
 770     {
 771       APPEND (gstring, "#define %s_%sPIXEL_DATA ((%s*) \\\n",
 772               macro_name,
 773               rle_encoded ? "RLE_" : "",
 774               s_uint_8);
 775       APPEND (gstring, "  \"");
 776       cdata.pos = 2;
 777     }
 778   if (cdata.dump_struct)
 779     {
 780       APPEND (gstring, "  \"");
 781       cdata.pos = 3;
 782     }
 783   if (cdata.dump_stream)
 784     {
 785       APPEND (gstring, "  \"");
 786       cdata.pos = 3;
 787     }
 788
 789   /* pixel_data
 790    */
 791   do
 792     save_uchar (&cdata, *img_buffer++);
 793   while (img_buffer < img_buffer_end);
 794
 795   /* pixel_data trailer
 796    */
 797   if (cdata.dump_macros)
 798     APPEND (gstring, "\")\n\n");
 799   if (cdata.dump_struct)
 800     APPEND (gstring, "\",\n};\n\n");
 801   if (cdata.dump_stream)
 802     APPEND (gstring, "\"};\n\n");
 803
 804   /* dump RLE decoder for macros
 805    */
 806   if (cdata.dump_rle_decoder && cdata.dump_macros)
 807     save_rle_decoder (gstring,
 808                       macro_name,
 809                       cdata.dump_gtypes ? "guint" : "unsigned int",
 810                       cdata.dump_gtypes ? "guint8" : "unsigned char",
 811                       bpp);
 812
 813   /* cleanup
 814    */
 815   g_free (macro_name);
 816
 817   return gstring;
 818 }
 819
 820 /**
 821  * gdk_pixbuf_new_from_inline:
 822  * @data_length: Length in bytes of the @data argument
 823  * @data: Byte data containing a serialized #GdkPixdata structure
 824  * @copy_pixels: Whether to copy the pixel data, or use direct pointers
 825  *               @data for the resulting pixbuf
 826  * @error: #GError return location, may be %NULL to ignore errors
 827  *
 828  * Create a #GdkPixbuf from a flat representation that is suitable for
 829  * storing as inline data in a program. This is useful if you want to
 830  * ship a program with images, but don't want to depend on any
 831  * external files.
 832  *
 833  * GTK+ ships with a program called <command>gdk-pixbuf-csource</command>
 834  * which allows for conversion of #GdkPixbufs into such a inline representation.
 835  * In almost all cases, you should pass the <option>--raw</option> flag to
 836  * <command>gdk-pixbuf-csource</command>. A sample invocation would be:
 837  *
 838  * <informalexample><programlisting>
 839  *  gdk-pixbuf-csource --raw --name=myimage_inline myimage.png
 840  * </programlisting></informalexample>
 841  *
 842  * For the typical case where the inline pixbuf is read-only static data,
 843  * you don't need to copy the pixel data unless you intend to write to
 844  * it, so you can pass %FALSE for @copy_pixels.  (If you pass
 845  * <option>--rle</option> to <command>gdk-pixbuf-csource</command>, a copy
 846  * will be made even if @copy_pixels is %FALSE, so using this option is
 847  * generally a bad idea.)
 848  *
 849  * If you create a pixbuf from const inline data compiled into your
 850  * program, it's probably safe to ignore errors, since things will
 851  * always succeed.  For non-const inline data, you could get out of
 852  * memory. For untrusted inline data located at runtime, you could
 853  * have corrupt inline data in addition.
 854  *
 855  * Return value: A newly-created #GdkPixbuf structure with a reference,
 856  *   count of 1, or %NULL if error is set.
 857  **/
 858 GdkPixbuf*
 859 gdk_pixbuf_new_from_inline (gint          data_length,
 860                             const guint8 *data,
 861                             gboolean      copy_pixels,
 862                             GError      **error)
 863 {
 864   GdkPixdata pixdata;
 865
 866   if (data_length != -1)
 867     g_return_val_if_fail (data_length > GDK_PIXDATA_HEADER_LENGTH, NULL);
 868   g_return_val_if_fail (data != NULL, NULL);
 869
 870   if (!gdk_pixdata_deserialize (&pixdata, data_length, data, error))
 871     return NULL;
 872
 873   return gdk_pixbuf_from_pixdata (&pixdata, copy_pixels, error);
 874 }