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

   1 /* GdkPixbuf library - Image creation from in-memory buffers
   2  *
   3  * Copyright (C) 1999 The Free Software Foundation
   4  *
   5  * Author: Federico Mena-Quintero <federico@gimp.org>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <config.h>
  24 #include "gdk-pixbuf.h"
  25 #include "gdk-pixbuf-private.h"
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 \f
  30
  31 /**
  32  * gdk_pixbuf_new_from_data:
  33  * @data: Image data in 8-bit/sample packed format.
  34  * @colorspace: Colorspace for the image data.
  35  * @has_alpha: Whether the data has an opacity channel.
  36  * @bits_per_sample: Number of bits per sample.
  37  * @width: Width of the image in pixels.
  38  * @height: Height of the image in pixels.
  39  * @rowstride: Distance in bytes between rows.
  40  * @destroy_fn: Function used to free the data when the pixbuf's reference count
  41  * drops to zero, or NULL if the data should not be freed.
  42  * @destroy_fn_data: Closure data to pass to the destroy notification function.
  43  *
  44  * Creates a new #GdkPixbuf out of in-memory image data.  Currently only RGB
  45  * images with 8 bits per sample are supported.
  46  *
  47  * Return value: A newly-created #GdkPixbuf structure with a reference count of
  48  * 1.
  49  **/
  50 GdkPixbuf *
  51 gdk_pixbuf_new_from_data (const guchar *data, GdkColorspace colorspace, gboolean has_alpha,
  52                           int bits_per_sample, int width, int height, int rowstride,
  53                           GdkPixbufDestroyNotify destroy_fn, gpointer destroy_fn_data)
  54 {
  55         GdkPixbuf *pixbuf;
  56
  57         /* Only 8-bit/sample RGB buffers are supported for now */
  58
  59         g_return_val_if_fail (data != NULL, NULL);
  60         g_return_val_if_fail (colorspace == GDK_COLORSPACE_RGB, NULL);
  61         g_return_val_if_fail (bits_per_sample == 8, NULL);
  62         g_return_val_if_fail (width > 0, NULL);
  63         g_return_val_if_fail (height > 0, NULL);
  64
  65         pixbuf = g_object_new (GDK_TYPE_PIXBUF, NULL);
  66
  67         pixbuf->colorspace = colorspace;
  68         pixbuf->n_channels = has_alpha ? 4 : 3;
  69         pixbuf->bits_per_sample = bits_per_sample;
  70         pixbuf->has_alpha = has_alpha ? TRUE : FALSE;
  71         pixbuf->width = width;
  72         pixbuf->height = height;
  73         pixbuf->rowstride = rowstride;
  74         pixbuf->pixels = (guchar *) data;
  75         pixbuf->destroy_fn = destroy_fn;
  76         pixbuf->destroy_fn_data = destroy_fn_data;
  77
  78         return pixbuf;
  79 }
  80
  81 static guint32
  82 read_int (const guchar **p)
  83 {
  84         guint32 num;
  85
  86         /* Note most significant bytes are first in the byte stream */
  87         num =
  88           (*p)[3]         |
  89           ((*p)[2] << 8)  |
  90           ((*p)[1] << 16) |
  91           ((*p)[0] << 24);
  92
  93         *p += 4;
  94
  95         return num;
  96 }
  97
  98 static gboolean
  99 read_bool (const guchar **p)
 100 {
 101         gboolean val = **p != 0;
 102
 103         ++(*p);
 104
 105         return val;
 106 }
 107
 108 static GdkPixbuf*
 109 read_raw_inline (const guchar *data, gboolean copy_pixels, int length)
 110 {
 111         GdkPixbuf *pixbuf;
 112         const guchar *p = data;
 113         guint32 rowstride, width, height, colorspace,
 114                 n_channels, bits_per_sample;
 115         gboolean has_alpha;
 116
 117         if (length >= 0 && length < 12) {
 118                 /* Not enough buffer to hold the width/height/rowstride */
 119                 return NULL;
 120         }
 121
 122         rowstride = read_int (&p);
 123         width = read_int (&p);
 124         height = read_int (&p);
 125
 126         if (rowstride < width)
 127                 return NULL; /* bad data from untrusted source. */
 128
 129         /* rowstride >= width, so we can trust width */
 130
 131         length -= 12;
 132
 133         /* There's some better way like G_MAXINT/height > rowstride
 134          * but I'm not sure it works, so stick to this for now.
 135          */
 136         if (((double)height) * ((double)rowstride) > (double)G_MAXINT)
 137                 return NULL; /* overflow */
 138
 139         if (length >= 0 &&
 140             length < (height * rowstride + 13)) {
 141                 /* Not enough buffer to hold the remaining header
 142                  * information plus the data.
 143                  */
 144
 145                 return NULL;
 146         }
 147
 148         /* Read the remaining 13 bytes of header information */
 149
 150         has_alpha = read_bool (&p) != FALSE;
 151         colorspace = read_int (&p);
 152         n_channels = read_int (&p);
 153         bits_per_sample = read_int (&p);
 154
 155         if (colorspace != GDK_COLORSPACE_RGB)
 156                 return NULL;
 157
 158         if (bits_per_sample != 8)
 159                 return NULL;
 160
 161         if (has_alpha && n_channels != 4)
 162                 return NULL;
 163
 164         if (!has_alpha && n_channels != 3)
 165                 return NULL;
 166
 167         if (copy_pixels) {
 168                 guchar *pixels;
 169                 gint dest_rowstride;
 170                 gint row;
 171
 172                 pixbuf = gdk_pixbuf_new (colorspace,
 173                                          has_alpha, bits_per_sample,
 174                                          width, height);
 175
 176                 pixels = gdk_pixbuf_get_pixels (pixbuf);
 177                 dest_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
 178
 179                 for (row = 0; row < height; row++) {
 180                         memcpy (pixels, p, rowstride);
 181                         pixels += dest_rowstride;
 182                         p += rowstride;
 183                 }
 184         } else {
 185                 pixbuf = gdk_pixbuf_new_from_data (p,
 186                                                    colorspace,
 187                                                    has_alpha,
 188                                                    bits_per_sample,
 189                                                    width, height,
 190                                                    rowstride,
 191                                                    NULL, NULL);
 192         }
 193
 194         return pixbuf;
 195 }
 196
 197 /**
 198  * gdk_pixbuf_new_from_inline:
 199  * @data: An inlined GdkPixbuf
 200  * @copy_pixels: whether to copy the pixels out of the inline data, or to use them in-place
 201  *
 202  * Create a #GdkPixbuf from a custom format invented to store pixbuf
 203  * data in C program code. This library comes with a program called "make-inline-pixbuf"
 204  * that can write out a variable definition containing an inlined pixbuf.
 205  * This is useful if you want to ship a program with images, but
 206  * don't want to depend on any external files.
 207  *
 208  * The inline data format contains the pixels in #GdkPixbuf's native
 209  * format.  Since the inline pixbuf is read-only static data, you
 210  * don't need to copy it unless you intend to write to it.
 211  *
 212  * Return value: A newly-created #GdkPixbuf structure with a reference count of
 213  * 1.
 214  **/
 215 GdkPixbuf*
 216 gdk_pixbuf_new_from_inline   (const guchar *inline_pixbuf,
 217                               gboolean      copy_pixels,
 218                               int           length)
 219 {
 220         const guchar *p;
 221         GdkPixbuf *pixbuf;
 222         GdkPixbufInlineFormat format;
 223
 224         if (length >= 0 && length < 8) {
 225                 /* not enough bytes to contain even the magic number
 226                  * and format code.
 227                  */
 228                 return NULL;
 229         }
 230
 231         p = inline_pixbuf;
 232
 233         if (read_int (&p) != GDK_PIXBUF_INLINE_MAGIC_NUMBER) {
 234                 return NULL;
 235         }
 236
 237         format = read_int (&p);
 238
 239         switch (format)
 240         {
 241         case GDK_PIXBUF_INLINE_RAW:
 242                 pixbuf = read_raw_inline (p, copy_pixels, length - 8);
 243                 break;
 244
 245         default:
 246                 return NULL;
 247         }
 248
 249         return pixbuf;
 250 }
 251