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

   1 /* -*- mode: C; c-file-style: "linux" -*- */
   2 /* GdkPixbuf library - XBM image loader
   3  *
   4  * Copyright (C) 1999 Mark Crichton
   5  * Copyright (C) 1999 The Free Software Foundation
   6  * Copyright (C) 2001 Eazel, Inc.
   7  *
   8  * Authors: Mark Crichton <crichton@gimp.org>
   9  *          Federico Mena-Quintero <federico@gimp.org>
  10  *          Jonathan Blandford <jrb@redhat.com>
  11  *          John Harper <jsh@eazel.com>
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Library General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Library General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Library General Public
  24  * License along with this library; if not, write to the
  25  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  26  * Boston, MA 02111-1307, USA.
  27  */
  28
  29 /* Following code adapted from io-tiff.c, which was ``(almost) blatantly
  30    ripped from Imlib'' */
  31
  32 #include <config.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #ifdef HAVE_UNISTD_H
  36 #include <unistd.h>
  37 #endif
  38 #include <stdio.h>
  39 #include <errno.h>
  40 #include "gdk-pixbuf-private.h"
  41 #include "gdk-pixbuf-io.h"
  42
  43 \f
  44
  45 typedef struct _XBMData XBMData;
  46 struct _XBMData
  47 {
  48         GdkPixbufModulePreparedFunc prepare_func;
  49         GdkPixbufModuleUpdatedFunc update_func;
  50         gpointer user_data;
  51
  52         gchar *tempname;
  53         FILE *file;
  54         gboolean all_okay;
  55 };
  56
  57 \f
  58 /* xbm parser borrowed from xc/lib/X11/RdBitF.c */
  59
  60 #define MAX_SIZE 255
  61
  62 /* shared data for the image read/parse logic */
  63 static short hex_table[256];            /* conversion value */
  64 static gboolean initialized = FALSE;    /* easier to fill in at run time */
  65
  66
  67 /* Table index for the hex values. Initialized once, first time.
  68  * Used for translation value or delimiter significance lookup.
  69  */
  70 static void
  71 init_hex_table (void)
  72 {
  73         /*
  74          * We build the table at run time for several reasons:
  75          *
  76          * 1. portable to non-ASCII machines.
  77          * 2. still reentrant since we set the init flag after setting table.
  78          * 3. easier to extend.
  79          * 4. less prone to bugs.
  80          */
  81         hex_table['0'] = 0;
  82         hex_table['1'] = 1;
  83         hex_table['2'] = 2;
  84         hex_table['3'] = 3;
  85         hex_table['4'] = 4;
  86         hex_table['5'] = 5;
  87         hex_table['6'] = 6;
  88         hex_table['7'] = 7;
  89         hex_table['8'] = 8;
  90         hex_table['9'] = 9;
  91         hex_table['A'] = 10;
  92         hex_table['B'] = 11;
  93         hex_table['C'] = 12;
  94         hex_table['D'] = 13;
  95         hex_table['E'] = 14;
  96         hex_table['F'] = 15;
  97         hex_table['a'] = 10;
  98         hex_table['b'] = 11;
  99         hex_table['c'] = 12;
 100         hex_table['d'] = 13;
 101         hex_table['e'] = 14;
 102         hex_table['f'] = 15;
 103
 104         /* delimiters of significance are flagged w/ negative value */
 105         hex_table[' '] = -1;
 106         hex_table[','] = -1;
 107         hex_table['}'] = -1;
 108         hex_table['\n'] = -1;
 109         hex_table['\t'] = -1;
 110
 111         initialized = TRUE;
 112 }
 113
 114 /* Read next hex value in the input stream, return -1 if EOF */
 115 static int
 116 next_int (FILE *fstream)
 117 {
 118         int ch;
 119         int value = 0;
 120         int gotone = 0;
 121         int done = 0;
 122
 123         /* loop, accumulate hex value until find delimiter
 124            skip any initial delimiters found in read stream */
 125
 126         while (!done) {
 127                 ch = getc (fstream);
 128                 if (ch == EOF) {
 129                         value = -1;
 130                         done++;
 131                 } else {
 132                         /* trim high bits, check type and accumulate */
 133                         ch &= 0xff;
 134                         if (g_ascii_isxdigit (ch)) {
 135                                 value = (value << 4) + g_ascii_xdigit_value (ch);
 136                                 gotone++;
 137                         } else if ((hex_table[ch]) < 0 && gotone) {
 138                                 done++;
 139                         }
 140                 }
 141         }
 142         return value;
 143 }
 144
 145 static gboolean
 146 read_bitmap_file_data (FILE *fstream,
 147                        guint *width, guint *height,
 148                        guchar **data,
 149                        int *x_hot, int *y_hot)
 150 {
 151         guchar *bits = NULL;            /* working variable */
 152         char line[MAX_SIZE];            /* input line from file */
 153         int size;                       /* number of bytes of data */
 154         char name_and_type[MAX_SIZE];   /* an input line */
 155         char *type;                     /* for parsing */
 156         int value;                      /* from an input line */
 157         int version10p;                 /* boolean, old format */
 158         int padding;                    /* to handle alignment */
 159         int bytes_per_line;             /* per scanline of data */
 160         guint ww = 0;                   /* width */
 161         guint hh = 0;                   /* height */
 162         int hx = -1;                    /* x hotspot */
 163         int hy = -1;                    /* y hotspot */
 164
 165         /* first time initialization */
 166         if (!initialized) {
 167                 init_hex_table ();
 168         }
 169
 170         /* error cleanup and return macro */
 171 #define RETURN(code) { g_free (bits); return code; }
 172
 173         while (fgets (line, MAX_SIZE, fstream)) {
 174                 if (strlen (line) == MAX_SIZE-1)
 175                         RETURN (FALSE);
 176                 if (sscanf (line,"#define %s %d",name_and_type,&value) == 2) {
 177                         if (!(type = strrchr (name_and_type, '_')))
 178                                 type = name_and_type;
 179                         else {
 180                                 type++;
 181                         }
 182
 183                         if (!strcmp ("width", type))
 184                                 ww = (unsigned int) value;
 185                         if (!strcmp ("height", type))
 186                                 hh = (unsigned int) value;
 187                         if (!strcmp ("hot", type)) {
 188                                 if (type-- == name_and_type
 189                                     || type-- == name_and_type)
 190                                         continue;
 191                                 if (!strcmp ("x_hot", type))
 192                                         hx = value;
 193                                 if (!strcmp ("y_hot", type))
 194                                         hy = value;
 195                         }
 196                         continue;
 197                 }
 198
 199                 if (sscanf (line, "static short %s = {", name_and_type) == 1)
 200                         version10p = 1;
 201                 else if (sscanf (line,"static unsigned char %s = {",name_and_type) == 1)
 202                         version10p = 0;
 203                 else if (sscanf (line, "static char %s = {", name_and_type) == 1)
 204                         version10p = 0;
 205                 else
 206                         continue;
 207
 208                 if (!(type = strrchr (name_and_type, '_')))
 209                         type = name_and_type;
 210                 else
 211                         type++;
 212
 213                 if (strcmp ("bits[]", type))
 214                         continue;
 215
 216                 if (!ww || !hh)
 217                         RETURN (FALSE);
 218
 219                 if ((ww % 16) && ((ww % 16) < 9) && version10p)
 220                         padding = 1;
 221                 else
 222                         padding = 0;
 223
 224                 bytes_per_line = (ww+7)/8 + padding;
 225
 226                 size = bytes_per_line * hh;
 227                 bits = g_malloc (size);
 228
 229                 if (version10p) {
 230                         unsigned char *ptr;
 231                         int bytes;
 232
 233                         for (bytes = 0, ptr = bits; bytes < size; (bytes += 2)) {
 234                                 if ((value = next_int (fstream)) < 0)
 235                                         RETURN (FALSE);
 236                                 *(ptr++) = value;
 237                                 if (!padding || ((bytes+2) % bytes_per_line))
 238                                         *(ptr++) = value >> 8;
 239                         }
 240                 } else {
 241                         unsigned char *ptr;
 242                         int bytes;
 243
 244                         for (bytes = 0, ptr = bits; bytes < size; bytes++, ptr++) {
 245                                 if ((value = next_int (fstream)) < 0)
 246                                         RETURN (FALSE);
 247                                 *ptr=value;
 248                         }
 249                 }
 250                 break;
 251         }
 252
 253         if (!bits)
 254                 RETURN (FALSE);
 255
 256         *data = bits;
 257         *width = ww;
 258         *height = hh;
 259         if (x_hot)
 260                 *x_hot = hx;
 261         if (y_hot)
 262                 *y_hot = hy;
 263
 264         return TRUE;
 265 }
 266
 267 \f
 268
 269 static GdkPixbuf *
 270 gdk_pixbuf__xbm_image_load_real (FILE *f, XBMData *context, GError **error)
 271 {
 272         guint w, h;
 273         int x_hot, y_hot;
 274         guchar *data, *ptr;
 275         guchar *pixels;
 276         guint row_stride;
 277         int x, y;
 278         int reg = 0; /* Quiet compiler */
 279         int bits;
 280
 281         GdkPixbuf *pixbuf;
 282
 283         if (!read_bitmap_file_data (f, &w, &h, &data, &x_hot, &y_hot)) {
 284                 g_set_error (error,
 285                              GDK_PIXBUF_ERROR,
 286                              GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
 287                              _("Invalid XBM file"));
 288                 return NULL;
 289         }
 290
 291         pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, w, h);
 292
 293         if (pixbuf == NULL) {
 294                 g_set_error (error,
 295                              GDK_PIXBUF_ERROR,
 296                              GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
 297                              _("Insufficient memory to load XBM image file"));
 298                 return NULL;
 299         }
 300
 301         if (x_hot != -1 && y_hot != -1) {
 302                 gchar hot[10];
 303                 g_snprintf (hot, 10, "%d", x_hot);
 304                 gdk_pixbuf_set_option (pixbuf, "x_hot", hot);
 305                 g_snprintf (hot, 10, "%d", y_hot);
 306                 gdk_pixbuf_set_option (pixbuf, "y_hot", hot);
 307         }
 308
 309         pixels = gdk_pixbuf_get_pixels (pixbuf);
 310         row_stride = gdk_pixbuf_get_rowstride (pixbuf);
 311
 312         if (context)
 313                 (* context->prepare_func) (pixbuf, NULL, context->user_data);
 314
 315
 316         /* Initialize PIXBUF */
 317
 318         ptr = data;
 319         for (y = 0; y < h; y++) {
 320                 bits = 0;
 321                 for (x = 0; x < w; x++) {
 322                         guchar channel;
 323                         if (bits == 0) {
 324                                 reg = *ptr++;
 325                                 bits = 8;
 326                         }
 327
 328                         channel = (reg & 1) ? 0 : 255;
 329                         reg >>= 1;
 330                         bits--;
 331
 332                         pixels[x*3+0] = channel;
 333                         pixels[x*3+1] = channel;
 334                         pixels[x*3+2] = channel;
 335                 }
 336                 pixels += row_stride;
 337         }
 338         g_free (data);
 339
 340         if (context) {
 341                 (* context->update_func) (pixbuf, 0, 0, w, h, context->user_data);
 342                 g_object_unref (pixbuf);
 343                 pixbuf = NULL;
 344         }
 345
 346         return pixbuf;
 347 }
 348
 349 \f
 350 /* Static loader */
 351
 352 static GdkPixbuf *
 353 gdk_pixbuf__xbm_image_load (FILE *f, GError **error)
 354 {
 355         return gdk_pixbuf__xbm_image_load_real (f, NULL, error);
 356 }
 357
 358 \f
 359 /* Progressive loader */
 360
 361 /*
 362  * Proper XBM progressive loading isn't implemented.  Instead we write
 363  * it to a file, then load the file when it's done.  It's not pretty.
 364  */
 365
 366 static gpointer
 367 gdk_pixbuf__xbm_image_begin_load (GdkPixbufModuleSizeFunc size_func,
 368                                   GdkPixbufModulePreparedFunc prepare_func,
 369                                   GdkPixbufModuleUpdatedFunc update_func,
 370                                   gpointer user_data,
 371                                   GError **error)
 372 {
 373         XBMData *context;
 374         gint fd;
 375
 376         context = g_new (XBMData, 1);
 377         context->prepare_func = prepare_func;
 378         context->update_func = update_func;
 379         context->user_data = user_data;
 380         context->all_okay = TRUE;
 381         fd = g_file_open_tmp ("gdkpixbuf-xbm-tmp.XXXXXX",
 382                               &context->tempname,
 383                               NULL);
 384         if (fd < 0) {
 385                 g_free (context);
 386                 return NULL;
 387         }
 388
 389         context->file = fdopen (fd, "w+");
 390         if (context->file == NULL) {
 391                 g_free (context->tempname);
 392                 g_free (context);
 393                 return NULL;
 394         }
 395
 396         return context;
 397 }
 398
 399 static gboolean
 400 gdk_pixbuf__xbm_image_stop_load (gpointer data,
 401                                  GError **error)
 402 {
 403         XBMData *context = (XBMData*) data;
 404         gboolean retval = TRUE;
 405
 406         g_return_val_if_fail (data != NULL, TRUE);
 407
 408         fflush (context->file);
 409         rewind (context->file);
 410         if (context->all_okay) {
 411                 GdkPixbuf *pixbuf;
 412                 pixbuf = gdk_pixbuf__xbm_image_load_real (context->file, context,
 413                                                           error);
 414                 if (pixbuf == NULL)
 415                         retval = FALSE;
 416         }
 417
 418         fclose (context->file);
 419         unlink (context->tempname);
 420         g_free (context->tempname);
 421         g_free ((XBMData *) context);
 422
 423         return retval;
 424 }
 425
 426 static gboolean
 427 gdk_pixbuf__xbm_image_load_increment (gpointer data,
 428                                       const guchar  *buf,
 429                                       guint    size,
 430                                       GError **error)
 431 {
 432         XBMData *context = (XBMData *) data;
 433
 434         g_return_val_if_fail (data != NULL, FALSE);
 435
 436         if (fwrite (buf, sizeof (guchar), size, context->file) != size) {
 437                 context->all_okay = FALSE;
 438                 g_set_error (error,
 439                              G_FILE_ERROR,
 440                              g_file_error_from_errno (errno),
 441                              _("Failed to write to temporary file when loading XBM image"));
 442                 return FALSE;
 443         }
 444
 445         return TRUE;
 446 }
 447
 448 void
 449 MODULE_ENTRY (xbm, fill_vtable) (GdkPixbufModule *module)
 450 {
 451         module->load = gdk_pixbuf__xbm_image_load;
 452         module->begin_load = gdk_pixbuf__xbm_image_begin_load;
 453         module->stop_load = gdk_pixbuf__xbm_image_stop_load;
 454         module->load_increment = gdk_pixbuf__xbm_image_load_increment;
 455 }
 456
 457 void
 458 MODULE_ENTRY (xbm, fill_info) (GdkPixbufFormat *info)
 459 {
 460         static GdkPixbufModulePattern signature[] = {
 461                 { "#define ", NULL, 100 },
 462                 { "/*", NULL, 50 },
 463                 { NULL, NULL, 0 }
 464         };
 465         static gchar * mime_types[] = {
 466                 "image/x-xbitmap",
 467                 NULL
 468         };
 469         static gchar * extensions[] = {
 470                 "xbm",
 471                 NULL
 472         };
 473
 474         info->name = "xbm";
 475         info->signature = signature;
 476         info->description = N_("The XBM image format");
 477         info->mime_types = mime_types;
 478         info->extensions = extensions;
 479         info->flags = 0;
 480 }