gdk-pixbuf-data.c 7.75 KB
Newer Older
1
/* GdkPixbuf library - Image creation from in-memory buffers
2
 *
3 4 5 6 7
 * Copyright (C) 1999 The Free Software Foundation
 *
 * Author: Federico Mena-Quintero <federico@gimp.org>
 *
 * This library is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9 10 11 12 13 14
 * 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
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18 19 20
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
21 22 23
 */

#include <config.h>
24
#include "gdk-pixbuf.h"
25
#include "gdk-pixbuf-private.h"
26 27
#include <stdlib.h>
#include <string.h>
28

29

30

31 32 33
/**
 * gdk_pixbuf_new_from_data:
 * @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 38 39
 * @width: Width of the image in pixels.
 * @height: Height of the image in pixels.
 * @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 45
 * Creates a new #GdkPixbuf out of in-memory image data.  Currently only RGB
 * images with 8 bits per sample are supported.
46
 * 
Arturo Espinosa's avatar
Arturo Espinosa committed
47
 * Return value: A newly-created #GdkPixbuf structure with a reference count of
48 49 50
 * 1.
 **/
GdkPixbuf *
51 52 53
gdk_pixbuf_new_from_data (const guchar *data, GdkColorspace colorspace, gboolean has_alpha,
			  int bits_per_sample, int width, int height, int rowstride,
			  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 61
	g_return_val_if_fail (colorspace == GDK_COLORSPACE_RGB, NULL);
	g_return_val_if_fail (bits_per_sample == 8, NULL);
62 63
	g_return_val_if_fail (width > 0, NULL);
	g_return_val_if_fail (height > 0, NULL);
64

65
	pixbuf = g_object_new (GDK_TYPE_PIXBUF, NULL);
66
        
67 68 69 70 71 72 73 74 75 76
	pixbuf->colorspace = colorspace;
	pixbuf->n_channels = has_alpha ? 4 : 3;
	pixbuf->bits_per_sample = bits_per_sample;
	pixbuf->has_alpha = has_alpha ? TRUE : FALSE;
	pixbuf->width = width;
	pixbuf->height = height;
	pixbuf->rowstride = rowstride;
	pixbuf->pixels = (guchar *) data;
	pixbuf->destroy_fn = destroy_fn;
	pixbuf->destroy_fn_data = destroy_fn_data;
77

78
	return pixbuf;
79
}
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251

static guint32
read_int (const guchar **p)
{
        guint32 num;

        /* Note most significant bytes are first in the byte stream */
        num =
          (*p)[3]         |
          ((*p)[2] << 8)  |
          ((*p)[1] << 16) |
          ((*p)[0] << 24);

        *p += 4;

        return num;
}

static gboolean
read_bool (const guchar **p)
{
        gboolean val = **p != 0;
        
        ++(*p);
        
        return val;
}

static GdkPixbuf*
read_raw_inline (const guchar *data, gboolean copy_pixels, int length)
{
        GdkPixbuf *pixbuf;
        const guchar *p = data;
        guint32 rowstride, width, height, colorspace,
                n_channels, bits_per_sample;
        gboolean has_alpha;
        
        if (length >= 0 && length < 12) {
                /* Not enough buffer to hold the width/height/rowstride */
                return NULL;
        }

        rowstride = read_int (&p);
        width = read_int (&p);
        height = read_int (&p);

        if (rowstride < width)
                return NULL; /* bad data from untrusted source. */

        /* rowstride >= width, so we can trust width */
        
        length -= 12;

        /* There's some better way like G_MAXINT/height > rowstride
         * but I'm not sure it works, so stick to this for now.
         */
        if (((double)height) * ((double)rowstride) > (double)G_MAXINT)
                return NULL; /* overflow */
        
        if (length >= 0 &&
            length < (height * rowstride + 13)) {
                /* Not enough buffer to hold the remaining header
                 * information plus the data.
                 */
                
                return NULL;
        }
        
        /* Read the remaining 13 bytes of header information */
            
        has_alpha = read_bool (&p) != FALSE;
        colorspace = read_int (&p);
        n_channels = read_int (&p);
        bits_per_sample = read_int (&p);

        if (colorspace != GDK_COLORSPACE_RGB)
                return NULL;

        if (bits_per_sample != 8)
                return NULL;

        if (has_alpha && n_channels != 4)
                return NULL;

        if (!has_alpha && n_channels != 3)
                return NULL;

        if (copy_pixels) {
                guchar *pixels;
                gint dest_rowstride;
                gint row;
                
                pixbuf = gdk_pixbuf_new (colorspace,
                                         has_alpha, bits_per_sample,
                                         width, height);

                pixels = gdk_pixbuf_get_pixels (pixbuf);
                dest_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
	
                for (row = 0; row < height; row++) {
                        memcpy (pixels, p, rowstride);
                        pixels += dest_rowstride;
                        p += rowstride;
                }
        } else {
                pixbuf = gdk_pixbuf_new_from_data (p,
                                                   colorspace,
                                                   has_alpha,
                                                   bits_per_sample,
                                                   width, height,
                                                   rowstride,
                                                   NULL, NULL);
        }

        return pixbuf;
}

/**
 * gdk_pixbuf_new_from_inline:
 * @data: An inlined GdkPixbuf
 * @copy_pixels: whether to copy the pixels out of the inline data, or to use them in-place
 *
 * Create a #GdkPixbuf from a custom format invented to store pixbuf
 * data in C program code. This library comes with a program called "make-inline-pixbuf"
 * that can write out a variable definition containing an inlined pixbuf.
 * This is useful if you want to ship a program with images, but
 * don't want to depend on any external files.
 * 
 * The inline data format contains the pixels in #GdkPixbuf's native
 * format.  Since the inline pixbuf is read-only static data, you
 * don't need to copy it unless you intend to write to it.
 * 
 * Return value: A newly-created #GdkPixbuf structure with a reference count of
 * 1.
 **/
GdkPixbuf*
gdk_pixbuf_new_from_inline   (const guchar *inline_pixbuf,
                              gboolean      copy_pixels,
                              int           length)
{
        const guchar *p;
        GdkPixbuf *pixbuf;
        GdkPixbufInlineFormat format;

        if (length >= 0 && length < 8) {
                /* not enough bytes to contain even the magic number
                 * and format code.
                 */
                return NULL;
        }
        
        p = inline_pixbuf;

        if (read_int (&p) != GDK_PIXBUF_INLINE_MAGIC_NUMBER) {
                return NULL;
        }

        format = read_int (&p);

        switch (format)
        {
        case GDK_PIXBUF_INLINE_RAW:
                pixbuf = read_raw_inline (p, copy_pixels, length - 8);
                break;

        default:
                return NULL;
        }

        return pixbuf;
}