GIF/imgif.c

   1 #include "imgif.h"
   2 #include <gif_lib.h>
   3 #ifdef _MSC_VER
   4 #include <io.h>
   5 #else
   6 #include <unistd.h>
   7 #endif
   8 #include <errno.h>
   9 #include <string.h>
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12
  13 /*
  14 =head1 NAME
  15
  16 imgif.c - read and write gif files for Imager
  17
  18 =head1 SYNOPSIS
  19
  20   i_img *img;
  21   i_img *imgs[count];
  22   int fd;
  23   int *colour_table,
  24   int colours;
  25   int max_colours; // number of bits per colour
  26   int pixdev;  // how much noise to add
  27   i_color fixed[N]; // fixed palette entries
  28   int fixedlen; // number of fixed colours
  29   int success; // non-zero on success
  30   char *data; // a GIF file in memory
  31   int length; // how big data is
  32   int reader(char *, char *, int, int);
  33   int writer(char *, char *, int);
  34   char *userdata; // user's data, whatever it is
  35   i_quantize quant;
  36   i_gif_opts opts;
  37
  38   img = i_readgif(fd, &colour_table, &colours);
  39   success = i_writegif(img, fd, max_colours, pixdev, fixedlen, fixed);
  40   success = i_writegifmc(img, fd, max_colours);
  41   img = i_readgif_scalar(data, length, &colour_table, &colours);
  42   img = i_readgif_callback(cb, userdata, &colour_table, &colours);
  43   success = i_writegif_gen(&quant, fd, imgs, count, &opts);
  44   success = i_writegif_callback(&quant, writer, userdata, maxlength,
  45                                 imgs, count, &opts);
  46
  47 =head1 DESCRIPTION
  48
  49 This source file provides the C level interface to reading and writing
  50 GIF files for Imager.
  51
  52 This has been tested with giflib 3 and 4, though you lose the callback
  53 functionality with giflib3.
  54
  55 =head1 REFERENCE
  56
  57 =over
  58
  59 =cut
  60 */
  61
  62 #if defined(GIFLIB_MAJOR) && GIFLIB_MAJOR >= 5
  63 #define POST_SET_VERSION
  64 #define myDGifOpen(userPtr, readFunc, Error) DGifOpen((userPtr), (readFunc), (Error))
  65 #define myEGifOpen(userPtr, readFunc, Error) EGifOpen((userPtr), (readFunc), (Error))
  66 #define myGifError(gif) ((gif)->Error)
  67 #define MakeMapObject GifMakeMapObject
  68 #define FreeMapObject GifFreeMapObject
  69 #define gif_mutex_lock(mutex)
  70 #define gif_mutex_unlock(mutex)
  71 #else
  72 #define PRE_SET_VERSION
  73 static GifFileType *
  74 myDGifOpen(void *userPtr, InputFunc readFunc, int *error) {
  75   GifFileType *result = DGifOpen(userPtr, readFunc);
  76   if (!result)
  77     *error = GifLastError();
  78
  79   return result;
  80 }
  81 static GifFileType *
  82 myEGifOpen(void *userPtr, OutputFunc outputFunc, int *error) {
  83   GifFileType *result = EGifOpen(userPtr, outputFunc);
  84   if (!result)
  85     *error = GifLastError();
  86
  87   return result;
  88 }
  89 #define myGifError(gif) GifLastError()
  90 #define gif_mutex_lock(mutex) i_mutex_lock(mutex)
  91 #define gif_mutex_unlock(mutex) i_mutex_unlock(mutex)
  92
  93 #endif
  94
  95 static char const *gif_error_msg(int code);
  96 static void gif_push_error(int code);
  97
  98 /* Make some variables global, so we could access them faster: */
  99
 100 static const int
 101   InterlacedOffset[] = { 0, 4, 2, 1 }, /* The way Interlaced image should. */
 102   InterlacedJumps[] = { 8, 8, 4, 2 };    /* be read - offsets and jumps... */
 103
 104 #if !defined(GIFLIB_MAJOR) || GIFLIB_MAJOR < 5
 105 static i_mutex_t mutex;
 106 #endif
 107
 108 void
 109 i_init_gif(void) {
 110 #if !defined(GIFLIB_MAJOR) || GIFLIB_MAJOR < 5
 111   mutex = i_mutex_new();
 112 #endif
 113 }
 114
 115 static
 116 void
 117 i_colortable_copy(int **colour_table, int *colours, ColorMapObject *colourmap) {
 118   GifColorType *mapentry;
 119   int q;
 120   int colourmapsize = colourmap->ColorCount;
 121
 122   if(colours) *colours = colourmapsize;
 123   if(!colour_table) return;
 124
 125   *colour_table = mymalloc(sizeof(int) * colourmapsize * 3);
 126   memset(*colour_table, 0, sizeof(int) * colourmapsize * 3);
 127
 128   for(q=0; q<colourmapsize; q++) {
 129     mapentry = &colourmap->Colors[q];
 130     (*colour_table)[q*3 + 0] = mapentry->Red;
 131     (*colour_table)[q*3 + 1] = mapentry->Green;
 132     (*colour_table)[q*3 + 2] = mapentry->Blue;
 133   }
 134 }
 135
 136 #ifdef GIF_LIB_VERSION
 137
 138 static const
 139 char gif_version_str[] = GIF_LIB_VERSION;
 140
 141 double
 142 i_giflib_version(void) {
 143   const char *p = gif_version_str;
 144
 145   while (*p && (*p < '0' || *p > '9'))
 146     ++p;
 147
 148   if (!*p)
 149     return 0;
 150
 151   return strtod(p, NULL);
 152 }
 153
 154 #else
 155
 156 double
 157 i_giflib_version(void) {
 158   return GIFLIB_MAJOR + GIFLIB_MINOR * 0.1;
 159 }
 160
 161 #endif
 162
 163 /*
 164 =item i_readgif_low(GifFileType *GifFile, int **colour_table, int *colours)
 165
 166 Internal.  Low-level function for reading a GIF file.  The caller must
 167 create the appropriate GifFileType object and pass it in.
 168
 169 =cut
 170 */
 171
 172 i_img *
 173 i_readgif_low(GifFileType *GifFile, int **colour_table, int *colours) {
 174   i_img *im;
 175   int i, j, Size, Row, Col, Width, Height, ExtCode, Count, x;
 176   int cmapcnt = 0, ImageNum = 0, BackGround = 0, ColorMapSize = 0;
 177   ColorMapObject *ColorMap;
 178
 179   GifRecordType RecordType;
 180   GifByteType *Extension;
 181
 182   GifRowType GifRow;
 183   GifColorType *ColorMapEntry;
 184   i_color col;
 185
 186   mm_log((1,"i_readgif_low(GifFile %p, colour_table %p, colours %p)\n", GifFile, colour_table, colours));
 187
 188   /* it's possible that the caller has called us with *colour_table being
 189      non-NULL, but we check that to see if we need to free an allocated
 190      colour table on error.
 191   */
 192   if (colour_table) *colour_table = NULL;
 193
 194   BackGround = GifFile->SBackGroundColor;
 195   ColorMap = (GifFile->Image.ColorMap ? GifFile->Image.ColorMap : GifFile->SColorMap);
 196
 197   if (ColorMap) {
 198     ColorMapSize = ColorMap->ColorCount;
 199     i_colortable_copy(colour_table, colours, ColorMap);
 200     cmapcnt++;
 201   }
 202
 203   if (!i_int_check_image_file_limits(GifFile->SWidth, GifFile->SHeight, 3, sizeof(i_sample_t))) {
 204     if (colour_table && *colour_table) {
 205       myfree(*colour_table);
 206       *colour_table = NULL;
 207     }
 208     DGifCloseFile(GifFile);
 209     mm_log((1, "i_readgif: image size exceeds limits\n"));
 210     return NULL;
 211   }
 212
 213   im = i_img_8_new(GifFile->SWidth, GifFile->SHeight, 3);
 214   if (!im) {
 215     if (colour_table && *colour_table) {
 216       myfree(*colour_table);
 217       *colour_table = NULL;
 218     }
 219     DGifCloseFile(GifFile);
 220     return NULL;
 221   }
 222
 223   Size = GifFile->SWidth * sizeof(GifPixelType);
 224
 225   GifRow = mymalloc(Size);
 226
 227   for (i = 0; i < GifFile->SWidth; i++) GifRow[i] = GifFile->SBackGroundColor;
 228
 229   /* Scan the content of the GIF file and load the image(s) in: */
 230   do {
 231     if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) {
 232       gif_push_error(myGifError(GifFile));
 233       i_push_error(0, "Unable to get record type");
 234       if (colour_table && *colour_table) {
 235         myfree(*colour_table);
 236         *colour_table = NULL;
 237       }
 238       myfree(GifRow);
 239       i_img_destroy(im);
 240       DGifCloseFile(GifFile);
 241       return NULL;
 242     }
 243
 244     switch (RecordType) {
 245     case IMAGE_DESC_RECORD_TYPE:
 246       if (DGifGetImageDesc(GifFile) == GIF_ERROR) {
 247         gif_push_error(myGifError(GifFile));
 248         i_push_error(0, "Unable to get image descriptor");
 249         if (colour_table && *colour_table) {
 250           myfree(*colour_table);
 251           *colour_table = NULL;
 252         }
 253         myfree(GifRow);
 254         i_img_destroy(im);
 255         DGifCloseFile(GifFile);
 256         return NULL;
 257       }
 258
 259       if (( ColorMap = (GifFile->Image.ColorMap ? GifFile->Image.ColorMap : GifFile->SColorMap) )) {
 260         mm_log((1, "Adding local colormap\n"));
 261         ColorMapSize = ColorMap->ColorCount;
 262         if ( cmapcnt == 0) {
 263           i_colortable_copy(colour_table, colours, ColorMap);
 264           cmapcnt++;
 265         }
 266       } else {
 267         /* No colormap and we are about to read in the image - abandon for now */
 268         mm_log((1, "Going in with no colormap\n"));
 269         i_push_error(0, "Image does not have a local or a global color map");
 270         /* we can't have allocated a colour table here */
 271         myfree(GifRow);
 272         i_img_destroy(im);
 273         DGifCloseFile(GifFile);
 274         return NULL;
 275       }
 276
 277       Row = GifFile->Image.Top; /* Image Position relative to Screen. */
 278       Col = GifFile->Image.Left;
 279       Width = GifFile->Image.Width;
 280       Height = GifFile->Image.Height;
 281       ImageNum++;
 282       mm_log((1,"i_readgif_low: Image %d at (%d, %d) [%dx%d]: \n",ImageNum, Col, Row, Width, Height));
 283
 284       if (GifFile->Image.Left + GifFile->Image.Width > GifFile->SWidth ||
 285           GifFile->Image.Top + GifFile->Image.Height > GifFile->SHeight) {
 286         i_push_errorf(0, "Image %d is not confined to screen dimension, aborted.\n",ImageNum);
 287         if (colour_table && *colour_table) {
 288           myfree(*colour_table);
 289           *colour_table = NULL;
 290         }
 291         myfree(GifRow);
 292         i_img_destroy(im);
 293         DGifCloseFile(GifFile);
 294         return NULL;
 295       }
 296       if (GifFile->Image.Interlace) {
 297
 298         for (Count = i = 0; i < 4; i++) for (j = Row + InterlacedOffset[i]; j < Row + Height; j += InterlacedJumps[i]) {
 299           Count++;
 300           if (DGifGetLine(GifFile, GifRow, Width) == GIF_ERROR) {
 301             gif_push_error(myGifError(GifFile));
 302             i_push_error(0, "Reading GIF line");
 303             if (colour_table && *colour_table) {
 304               myfree(*colour_table);
 305               *colour_table = NULL;
 306             }
 307             myfree(GifRow);
 308             i_img_destroy(im);
 309             DGifCloseFile(GifFile);
 310             return NULL;
 311           }
 312
 313           for (x = 0; x < Width; x++) {
 314             ColorMapEntry = &ColorMap->Colors[GifRow[x]];
 315             col.rgb.r = ColorMapEntry->Red;
 316             col.rgb.g = ColorMapEntry->Green;
 317             col.rgb.b = ColorMapEntry->Blue;
 318             i_ppix(im,Col+x,j,&col);
 319           }
 320
 321         }
 322       }
 323       else {
 324         for (i = 0; i < Height; i++) {
 325           if (DGifGetLine(GifFile, GifRow, Width) == GIF_ERROR) {
 326             gif_push_error(myGifError(GifFile));
 327             i_push_error(0, "Reading GIF line");
 328             if (colour_table && *colour_table) {
 329               myfree(*colour_table);
 330               *colour_table = NULL;
 331             }
 332             myfree(GifRow);
 333             i_img_destroy(im);
 334             DGifCloseFile(GifFile);
 335             return NULL;
 336           }
 337
 338           for (x = 0; x < Width; x++) {
 339             ColorMapEntry = &ColorMap->Colors[GifRow[x]];
 340             col.rgb.r = ColorMapEntry->Red;
 341             col.rgb.g = ColorMapEntry->Green;
 342             col.rgb.b = ColorMapEntry->Blue;
 343             i_ppix(im, Col+x, Row, &col);
 344           }
 345           Row++;
 346         }
 347       }
 348       break;
 349     case EXTENSION_RECORD_TYPE:
 350       /* Skip any extension blocks in file: */
 351       if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {
 352         gif_push_error(myGifError(GifFile));
 353         i_push_error(0, "Reading extension record");
 354         if (colour_table && *colour_table) {
 355           myfree(*colour_table);
 356           *colour_table = NULL;
 357         }
 358         myfree(GifRow);
 359         i_img_destroy(im);
 360         DGifCloseFile(GifFile);
 361         return NULL;
 362       }
 363       while (Extension != NULL) {
 364         if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {
 365           gif_push_error(myGifError(GifFile));
 366           i_push_error(0, "reading next block of extension");
 367           if (colour_table && *colour_table) {
 368             myfree(*colour_table);
 369             *colour_table = NULL;
 370           }
 371           myfree(GifRow);
 372           i_img_destroy(im);
 373           DGifCloseFile(GifFile);
 374           return NULL;
 375         }
 376       }
 377       break;
 378     case TERMINATE_RECORD_TYPE:
 379       break;
 380     default:                /* Should be traps by DGifGetRecordType. */
 381       break;
 382     }
 383   } while (RecordType != TERMINATE_RECORD_TYPE);
 384
 385   myfree(GifRow);
 386
 387   if (DGifCloseFile(GifFile) == GIF_ERROR) {
 388     gif_push_error(myGifError(GifFile));
 389     i_push_error(0, "Closing GIF file object");
 390     if (colour_table && *colour_table) {
 391       myfree(*colour_table);
 392       *colour_table = NULL;
 393     }
 394     i_img_destroy(im);
 395     return NULL;
 396   }
 397
 398   i_tags_set(&im->tags, "i_format", "gif", -1);
 399
 400   return im;
 401 }
 402
 403 /*
 404
 405 Internal function called by i_readgif_multi_low() in error handling
 406
 407 */
 408 static void
 409 free_images(i_img **imgs, int count) {
 410   int i;
 411
 412   if (count) {
 413     for (i = 0; i < count; ++i)
 414       i_img_destroy(imgs[i]);
 415     myfree(imgs);
 416   }
 417 }
 418
 419 /*
 420 =item i_readgif_multi_low(GifFileType *gf, int *count, int page)
 421
 422 Reads one of more gif images from the given GIF file.
 423
 424 Returns a pointer to an array of i_img *, and puts the count into
 425 *count.
 426
 427 If page is not -1 then the given image _only_ is returned from the
 428 file, where the first image is 0, the second 1 and so on.
 429
 430 Unlike the normal i_readgif*() functions the images are paletted
 431 images rather than a combined RGB image.
 432
 433 This functions sets tags on the images returned:
 434
 435 =over
 436
 437 =item gif_left
 438
 439 the offset of the image from the left of the "screen" ("Image Left
 440 Position")
 441
 442 =item gif_top
 443
 444 the offset of the image from the top of the "screen" ("Image Top Position")
 445
 446 =item gif_interlace
 447
 448 non-zero if the image was interlaced ("Interlace Flag")
 449
 450 =item gif_screen_width
 451
 452 =item gif_screen_height
 453
 454 the size of the logical screen ("Logical Screen Width",
 455 "Logical Screen Height")
 456
 457 =item gif_local_map
 458
 459 Non-zero if this image had a local color map.
 460
 461 =item gif_background
 462
 463 The index in the global colormap of the logical screen's background
 464 color.  This is only set if the current image uses the global
 465 colormap.
 466
 467 =item gif_trans_index
 468
 469 The index of the color in the colormap used for transparency.  If the
 470 image has a transparency then it is returned as a 4 channel image with
 471 the alpha set to zero in this palette entry. ("Transparent Color Index")
 472
 473 =item gif_delay
 474
 475 The delay until the next frame is displayed, in 1/100 of a second.
 476 ("Delay Time").
 477
 478 =item gif_user_input
 479
 480 whether or not a user input is expected before continuing (view dependent)
 481 ("User Input Flag").
 482
 483 =item gif_disposal
 484
 485 how the next frame is displayed ("Disposal Method")
 486
 487 =item gif_loop
 488
 489 the number of loops from the Netscape Loop extension.  This may be zero.
 490
 491 =item gif_comment
 492
 493 the first block of the first gif comment before each image.
 494
 495 =back
 496
 497 Where applicable, the ("name") is the name of that field from the GIF89
 498 standard.
 499
 500 =cut
 501 */
 502
 503 i_img **
 504 i_readgif_multi_low(GifFileType *GifFile, int *count, int page) {
 505   i_img *img;
 506   int i, j, Size, Width, Height, ExtCode, Count;
 507   int ImageNum = 0, BackGround = 0, ColorMapSize = 0;
 508   ColorMapObject *ColorMap;
 509
 510   GifRecordType RecordType;
 511   GifByteType *Extension;
 512
 513   GifRowType GifRow;
 514   int got_gce = 0;
 515   int trans_index = 0; /* transparent index if we see a GCE */
 516   int gif_delay = 0; /* delay from a GCE */
 517   int user_input = 0; /* user input flag from a GCE */
 518   int disposal = 0; /* disposal method from a GCE */
 519   int got_ns_loop = 0;
 520   int ns_loop = 0;
 521   char *comment = NULL; /* a comment */
 522   i_img **results = NULL;
 523   int result_alloc = 0;
 524   int channels;
 525   int image_colors = 0;
 526   i_color black; /* used to expand the palette if needed */
 527
 528   for (i = 0; i < MAXCHANNELS; ++i)
 529     black.channel[i] = 0;
 530
 531   *count = 0;
 532
 533   mm_log((1,"i_readgif_multi_low(GifFile %p, , count %p)\n", GifFile, count));
 534
 535   BackGround = GifFile->SBackGroundColor;
 536
 537   Size = GifFile->SWidth * sizeof(GifPixelType);
 538
 539   GifRow = (GifRowType) mymalloc(Size);
 540
 541   /* Scan the content of the GIF file and load the image(s) in: */
 542   do {
 543     if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) {
 544       gif_push_error(myGifError(GifFile));
 545       i_push_error(0, "Unable to get record type");
 546       free_images(results, *count);
 547       DGifCloseFile(GifFile);
 548       myfree(GifRow);
 549       if (comment)
 550         myfree(comment);
 551       return NULL;
 552     }
 553
 554     switch (RecordType) {
 555     case IMAGE_DESC_RECORD_TYPE:
 556       if (DGifGetImageDesc(GifFile) == GIF_ERROR) {
 557         gif_push_error(myGifError(GifFile));
 558         i_push_error(0, "Unable to get image descriptor");
 559         free_images(results, *count);
 560         DGifCloseFile(GifFile);
 561         myfree(GifRow);
 562         if (comment)
 563           myfree(comment);
 564         return NULL;
 565       }
 566
 567       Width = GifFile->Image.Width;
 568       Height = GifFile->Image.Height;
 569       if (page == -1 || page == ImageNum) {
 570         if (( ColorMap = (GifFile->Image.ColorMap ? GifFile->Image.ColorMap : GifFile->SColorMap) )) {
 571           mm_log((1, "Adding local colormap\n"));
 572           ColorMapSize = ColorMap->ColorCount;
 573         } else {
 574           /* No colormap and we are about to read in the image -
 575              abandon for now */
 576           mm_log((1, "Going in with no colormap\n"));
 577           i_push_error(0, "Image does not have a local or a global color map");
 578           free_images(results, *count);
 579           DGifCloseFile(GifFile);
 580           myfree(GifRow);
 581           if (comment)
 582             myfree(comment);
 583           return NULL;
 584         }
 585
 586         channels = 3;
 587         if (got_gce && trans_index >= 0)
 588           channels = 4;
 589         if (!i_int_check_image_file_limits(Width, Height, channels, sizeof(i_sample_t))) {
 590           free_images(results, *count);
 591           mm_log((1, "i_readgif: image size exceeds limits\n"));
 592           DGifCloseFile(GifFile);
 593           myfree(GifRow);
 594           if (comment)
 595             myfree(comment);
 596           return NULL;
 597         }
 598         img = i_img_pal_new(Width, Height, channels, 256);
 599         if (!img) {
 600           free_images(results, *count);
 601           DGifCloseFile(GifFile);
 602           if (comment)
 603             myfree(comment);
 604           myfree(GifRow);
 605           return NULL;
 606         }
 607         /* populate the palette of the new image */
 608         mm_log((1, "ColorMapSize %d\n", ColorMapSize));
 609         for (i = 0; i < ColorMapSize; ++i) {
 610           i_color col;
 611           col.rgba.r = ColorMap->Colors[i].Red;
 612           col.rgba.g = ColorMap->Colors[i].Green;
 613           col.rgba.b = ColorMap->Colors[i].Blue;
 614           if (channels == 4 && trans_index == i)
 615             col.rgba.a = 0;
 616           else
 617             col.rgba.a = 255;
 618
 619           i_addcolors(img, &col, 1);
 620         }
 621         image_colors = ColorMapSize;
 622         ++*count;
 623         if (*count > result_alloc) {
 624           if (result_alloc == 0) {
 625             result_alloc = 5;
 626             results = mymalloc(result_alloc * sizeof(i_img *));
 627           }
 628           else {
 629             /* myrealloc never fails (it just dies if it can't allocate) */
 630             result_alloc *= 2;
 631             results = myrealloc(results, result_alloc * sizeof(i_img *));
 632           }
 633         }
 634         results[*count-1] = img;
 635         i_tags_set(&img->tags, "i_format", "gif", -1);
 636         i_tags_setn(&img->tags, "gif_left", GifFile->Image.Left);
 637         /**(char *)0 = 1;*/
 638         i_tags_setn(&img->tags, "gif_top",  GifFile->Image.Top);
 639         i_tags_setn(&img->tags, "gif_interlace", GifFile->Image.Interlace);
 640         i_tags_setn(&img->tags, "gif_screen_width", GifFile->SWidth);
 641         i_tags_setn(&img->tags, "gif_screen_height", GifFile->SHeight);
 642         i_tags_setn(&img->tags, "gif_colormap_size", ColorMapSize);
 643         if (GifFile->SColorMap && !GifFile->Image.ColorMap) {
 644           i_tags_setn(&img->tags, "gif_background",
 645                       GifFile->SBackGroundColor);
 646         }
 647         if (GifFile->Image.ColorMap) {
 648           i_tags_setn(&img->tags, "gif_localmap", 1);
 649         }
 650         if (got_gce) {
 651           if (trans_index >= 0) {
 652             i_color trans;
 653             i_tags_setn(&img->tags, "gif_trans_index", trans_index);
 654             i_getcolors(img, trans_index, &trans, 1);
 655             i_tags_set_color(&img->tags, "gif_trans_color", 0, &trans);
 656           }
 657           i_tags_setn(&img->tags, "gif_delay", gif_delay);
 658           i_tags_setn(&img->tags, "gif_user_input", user_input);
 659           i_tags_setn(&img->tags, "gif_disposal", disposal);
 660         }
 661         got_gce = 0;
 662         if (got_ns_loop)
 663           i_tags_setn(&img->tags, "gif_loop", ns_loop);
 664         if (comment) {
 665           i_tags_set(&img->tags, "gif_comment", comment, strlen(comment));
 666           myfree(comment);
 667           comment = NULL;
 668         }
 669
 670         mm_log((1,"i_readgif_multi_low: Image %d at (%d, %d) [%dx%d]: \n",
 671                 ImageNum, GifFile->Image.Left, GifFile->Image.Top, Width, Height));
 672
 673         if (GifFile->Image.Left + GifFile->Image.Width > GifFile->SWidth ||
 674             GifFile->Image.Top + GifFile->Image.Height > GifFile->SHeight) {
 675           i_push_errorf(0, "Image %d is not confined to screen dimension, aborted.\n",ImageNum);
 676           free_images(results, *count);
 677           DGifCloseFile(GifFile);
 678           myfree(GifRow);
 679           if (comment)
 680             myfree(comment);
 681           return(0);
 682         }
 683
 684         if (GifFile->Image.Interlace) {
 685           for (Count = i = 0; i < 4; i++) {
 686             for (j = InterlacedOffset[i]; j < Height;
 687                  j += InterlacedJumps[i]) {
 688               Count++;
 689               if (DGifGetLine(GifFile, GifRow, Width) == GIF_ERROR) {
 690                 gif_push_error(myGifError(GifFile));
 691                 i_push_error(0, "Reading GIF line");
 692                 free_images(results, *count);
 693                 DGifCloseFile(GifFile);
 694                 myfree(GifRow);
 695                 if (comment)
 696                   myfree(comment);
 697                 return NULL;
 698               }
 699
 700               /* range check the scanline if needed */
 701               if (image_colors != 256) {
 702                 int x;
 703                 for (x = 0; x < Width; ++x) {
 704                   while (GifRow[x] >= image_colors) {
 705                     /* expand the palette since a palette index is too big */
 706                     i_addcolors(img, &black, 1);
 707                     ++image_colors;
 708                   }
 709                 }
 710               }
 711
 712               i_ppal(img, 0, Width, j, GifRow);
 713             }
 714           }
 715         }
 716         else {
 717           for (i = 0; i < Height; i++) {
 718             if (DGifGetLine(GifFile, GifRow, Width) == GIF_ERROR) {
 719               gif_push_error(myGifError(GifFile));
 720               i_push_error(0, "Reading GIF line");
 721               free_images(results, *count);
 722               DGifCloseFile(GifFile);
 723               myfree(GifRow);
 724               if (comment)
 725                 myfree(comment);
 726               return NULL;
 727             }
 728
 729             /* range check the scanline if needed */
 730             if (image_colors != 256) {
 731               int x;
 732               for (x = 0; x < Width; ++x) {
 733                 while (GifRow[x] >= image_colors) {
 734                   /* expand the palette since a palette index is too big */
 735                   i_addcolors(img, &black, 1);
 736                   ++image_colors;
 737                 }
 738               }
 739             }
 740
 741             i_ppal(img, 0, Width, i, GifRow);
 742           }
 743         }
 744
 745         /* must be only one image wanted and that was it */
 746         if (page != -1) {
 747           myfree(GifRow);
 748           DGifCloseFile(GifFile);
 749           if (comment)
 750             myfree(comment);
 751           return results;
 752         }
 753       }
 754       else {
 755         /* skip the image */
 756         /* whether interlaced or not, it has the same number of lines */
 757         /* giflib does't have an interface to skip the image data */
 758         for (i = 0; i < Height; i++) {
 759           if (DGifGetLine(GifFile, GifRow, Width) == GIF_ERROR) {
 760             gif_push_error(myGifError(GifFile));
 761             i_push_error(0, "Reading GIF line");
 762             free_images(results, *count);
 763             myfree(GifRow);
 764             DGifCloseFile(GifFile);
 765             if (comment)
 766               myfree(comment);
 767             return NULL;
 768           }
 769         }
 770
 771         /* kill the comment so we get the right comment for the page */
 772         if (comment) {
 773           myfree(comment);
 774           comment = NULL;
 775         }
 776       }
 777       ImageNum++;
 778       break;
 779     case EXTENSION_RECORD_TYPE:
 780       /* Skip any extension blocks in file: */
 781       if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {
 782         gif_push_error(myGifError(GifFile));
 783         i_push_error(0, "Reading extension record");
 784         free_images(results, *count);
 785         myfree(GifRow);
 786         DGifCloseFile(GifFile);
 787         if (comment)
 788           myfree(comment);
 789         return NULL;
 790       }
 791       /* possibly this should be an error, but "be liberal in what you accept" */
 792       if (!Extension)
 793         break;
 794       if (ExtCode == 0xF9) {
 795         got_gce = 1;
 796         if (Extension[1] & 1)
 797           trans_index = Extension[4];
 798         else
 799           trans_index = -1;
 800         gif_delay = Extension[2] + 256 * Extension[3];
 801         user_input = (Extension[1] & 2) != 0;
 802         disposal = (Extension[1] >> 2) & 7;
 803       }
 804       if (ExtCode == 0xFF && *Extension == 11) {
 805         if (memcmp(Extension+1, "NETSCAPE2.0", 11) == 0) {
 806           if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {
 807             gif_push_error(myGifError(GifFile));
 808             i_push_error(0, "reading loop extension");
 809             free_images(results, *count);
 810             myfree(GifRow);
 811             DGifCloseFile(GifFile);
 812             if (comment)
 813               myfree(comment);
 814             return NULL;
 815           }
 816           if (Extension && *Extension == 3) {
 817             got_ns_loop = 1;
 818             ns_loop = Extension[2] + 256 * Extension[3];
 819           }
 820         }
 821       }
 822       else if (ExtCode == 0xFE) {
 823         /* while it's possible for a GIF file to contain more than one
 824            comment, I'm only implementing a single comment per image,
 825            with the comment saved into the following image.
 826            If someone wants more than that they can implement it.
 827            I also don't handle comments that take more than one block.
 828         */
 829         if (!comment) {
 830           comment = mymalloc(*Extension+1);
 831           memcpy(comment, Extension+1, *Extension);
 832           comment[*Extension] = '\0';
 833         }
 834       }
 835       while (Extension != NULL) {
 836         if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {
 837           gif_push_error(myGifError(GifFile));
 838           i_push_error(0, "reading next block of extension");
 839           free_images(results, *count);
 840           myfree(GifRow);
 841           DGifCloseFile(GifFile);
 842           if (comment)
 843             myfree(comment);
 844           return NULL;
 845         }
 846       }
 847       break;
 848     case TERMINATE_RECORD_TYPE:
 849       break;
 850     default:                /* Should be trapped by DGifGetRecordType. */
 851       break;
 852     }
 853   } while (RecordType != TERMINATE_RECORD_TYPE);
 854
 855   if (comment) {
 856     if (*count) {
 857       i_tags_set(&(results[*count-1]->tags), "gif_comment", comment,
 858                  strlen(comment));
 859     }
 860     myfree(comment);
 861   }
 862
 863   myfree(GifRow);
 864
 865   if (DGifCloseFile(GifFile) == GIF_ERROR) {
 866     gif_push_error(myGifError(GifFile));
 867     i_push_error(0, "Closing GIF file object");
 868     free_images(results, *count);
 869     return NULL;
 870   }
 871
 872   if (ImageNum && page != -1) {
 873     /* there were images, but the page selected wasn't found */
 874     i_push_errorf(0, "page %d not found (%d total)", page, ImageNum);
 875     free_images(results, *count);
 876     return NULL;
 877   }
 878
 879   return results;
 880 }
 881
 882 static int io_glue_read_cb(GifFileType *gft, GifByteType *buf, int length);
 883
 884 /*
 885 =item i_readgif_multi_wiol(ig, int *count)
 886
 887 =cut
 888 */
 889
 890 i_img **
 891 i_readgif_multi_wiol(io_glue *ig, int *count) {
 892   GifFileType *GifFile;
 893   int gif_error;
 894   i_img **result;
 895
 896   gif_mutex_lock(mutex);
 897
 898   i_clear_error();
 899
 900   if ((GifFile = myDGifOpen((void *)ig, io_glue_read_cb, &gif_error )) == NULL) {
 901     gif_push_error(gif_error);
 902     i_push_error(0, "Cannot create giflib callback object");
 903     mm_log((1,"i_readgif_multi_wiol: Unable to open callback datasource.\n"));
 904     gif_mutex_unlock(mutex);
 905     return NULL;
 906   }
 907
 908   result = i_readgif_multi_low(GifFile, count, -1);
 909
 910   gif_mutex_unlock(mutex);
 911
 912   return result;
 913 }
 914
 915 static int
 916 io_glue_read_cb(GifFileType *gft, GifByteType *buf, int length) {
 917   io_glue *ig = (io_glue *)gft->UserData;
 918
 919   return i_io_read(ig, buf, length);
 920 }
 921
 922 i_img *
 923 i_readgif_wiol(io_glue *ig, int **color_table, int *colors) {
 924   GifFileType *GifFile;
 925   int gif_error;
 926   i_img *result;
 927
 928   gif_mutex_lock(mutex);
 929
 930   i_clear_error();
 931
 932   if ((GifFile = myDGifOpen((void *)ig, io_glue_read_cb, &gif_error )) == NULL) {
 933     gif_push_error(gif_error);
 934     i_push_error(0, "Cannot create giflib callback object");
 935     mm_log((1,"i_readgif_wiol: Unable to open callback datasource.\n"));
 936     gif_mutex_unlock(mutex);
 937     return NULL;
 938   }
 939
 940   result = i_readgif_low(GifFile, color_table, colors);
 941
 942   gif_mutex_unlock(mutex);
 943
 944   return result;
 945 }
 946
 947 /*
 948 =item i_readgif_single_low(GifFile, page)
 949
 950 Lower level function to read a single image from a GIF.
 951
 952 page must be non-negative.
 953
 954 =cut
 955 */
 956 static i_img *
 957 i_readgif_single_low(GifFileType *GifFile, int page) {
 958   int count = 0;
 959   i_img **imgs;
 960
 961   imgs = i_readgif_multi_low(GifFile, &count, page);
 962
 963   if (imgs && count) {
 964     i_img *result = imgs[0];
 965
 966     myfree(imgs);
 967     return result;
 968   }
 969   else {
 970     /* i_readgif_multi_low() handles the errors appropriately */
 971     return NULL;
 972   }
 973 }
 974
 975 /*
 976 =item i_readgif_single_wiol(ig, page)
 977
 978 Read a single page from a GIF image file, where the page is indexed
 979 from 0.
 980
 981 Returns NULL if the page isn't found.
 982
 983 =cut
 984 */
 985
 986 i_img *
 987 i_readgif_single_wiol(io_glue *ig, int page) {
 988   GifFileType *GifFile;
 989   int gif_error;
 990   i_img *result;
 991
 992   i_clear_error();
 993   if (page < 0) {
 994     i_push_error(0, "page must be non-negative");
 995     return NULL;
 996   }
 997
 998   gif_mutex_lock(mutex);
 999
1000   if ((GifFile = myDGifOpen((void *)ig, io_glue_read_cb, &gif_error )) == NULL) {
1001     gif_push_error(gif_error);
1002     i_push_error(0, "Cannot create giflib callback object");
1003     mm_log((1,"i_readgif_wiol: Unable to open callback datasource.\n"));
1004     gif_mutex_unlock(mutex);
1005     return NULL;
1006   }
1007
1008   result = i_readgif_single_low(GifFile, page);
1009
1010   gif_mutex_unlock(mutex);
1011
1012   return result;
1013 }
1014
1015 /*
1016 =item do_write(GifFileType *gf, i_gif_opts *opts, i_img *img, i_palidx *data)
1017
1018 Internal.  Low level image write function.  Writes in interlace if
1019 that was requested in the GIF options.
1020
1021 Returns non-zero on success.
1022
1023 =cut
1024 */
1025 static undef_int
1026 do_write(GifFileType *gf, int interlace, i_img *img, i_palidx *data) {
1027   if (interlace) {
1028     int i, j;
1029     for (i = 0; i < 4; ++i) {
1030       for (j = InterlacedOffset[i]; j < img->ysize; j += InterlacedJumps[i]) {
1031         if (EGifPutLine(gf, data+j*img->xsize, img->xsize) == GIF_ERROR) {
1032           gif_push_error(myGifError(gf));
1033           i_push_error(0, "Could not save image data:");
1034           mm_log((1, "Error in EGifPutLine\n"));
1035           EGifCloseFile(gf);
1036           return 0;
1037         }
1038       }
1039     }
1040   }
1041   else {
1042     int y;
1043     for (y = 0; y < img->ysize; ++y) {
1044       if (EGifPutLine(gf, data, img->xsize) == GIF_ERROR) {
1045         gif_push_error(myGifError(gf));
1046         i_push_error(0, "Could not save image data:");
1047         mm_log((1, "Error in EGifPutLine\n"));
1048         EGifCloseFile(gf);
1049         return 0;
1050       }
1051       data += img->xsize;
1052     }
1053   }
1054
1055   return 1;
1056 }
1057
1058 /*
1059 =item do_gce(GifFileType *gf, int index, i_gif_opts *opts, int want_trans, int trans_index)
1060
1061 Internal. Writes the GIF graphics control extension, if necessary.
1062
1063 Returns non-zero on success.
1064
1065 =cut
1066 */
1067
1068 static int
1069 do_gce(GifFileType *gf, i_img *img, int want_trans, int trans_index)
1070 {
1071   unsigned char gce[4] = {0};
1072   int want_gce = 0;
1073   int delay;
1074   int user_input;
1075   int disposal_method;
1076
1077   if (want_trans) {
1078     gce[0] |= 1;
1079     gce[3] = trans_index;
1080     ++want_gce;
1081   }
1082   if (i_tags_get_int(&img->tags, "gif_delay", 0, &delay)) {
1083     gce[1] = delay % 256;
1084     gce[2] = delay / 256;
1085     ++want_gce;
1086   }
1087   if (i_tags_get_int(&img->tags, "gif_user_input", 0, &user_input)
1088       && user_input) {
1089     gce[0] |= 2;
1090     ++want_gce;
1091   }
1092   if (i_tags_get_int(&img->tags, "gif_disposal", 0, &disposal_method)) {
1093     gce[0] |= (disposal_method & 3) << 2;
1094     ++want_gce;
1095   }
1096   if (want_gce) {
1097     if (EGifPutExtension(gf, 0xF9, sizeof(gce), gce) == GIF_ERROR) {
1098       gif_push_error(myGifError(gf));
1099       i_push_error(0, "Could not save GCE");
1100     }
1101   }
1102   return 1;
1103 }
1104
1105 /*
1106 =item do_comments(gf, img)
1107
1108 Write any comments in the image.
1109
1110 =cut
1111 */
1112
1113 static int
1114 do_comments(GifFileType *gf, i_img *img) {
1115   int pos = -1;
1116
1117   while (i_tags_find(&img->tags, "gif_comment", pos+1, &pos)) {
1118     if (img->tags.tags[pos].data) {
1119       if (EGifPutComment(gf, img->tags.tags[pos].data) == GIF_ERROR) {
1120         return 0;
1121       }
1122     }
1123     else {
1124       char buf[50];
1125 #ifdef IMAGER_SNPRINTF
1126       snprintf(buf, sizeof(buf), "%d", img->tags.tags[pos].idata);
1127 #else
1128       sprintf(buf, "%d", img->tags.tags[pos].idata);
1129 #endif
1130       if (EGifPutComment(gf, buf) == GIF_ERROR) {
1131         return 0;
1132       }
1133     }
1134   }
1135
1136   return 1;
1137 }
1138
1139 /*
1140 =item do_ns_loop(GifFileType *gf, i_gif_opts *opts)
1141
1142 Internal.  Add the Netscape2.0 loop extension block, if requested.
1143
1144 Giflib/libungif prior to 4.1.1 didn't support writing application
1145 extension blocks, so we don't attempt to write them for older versions.
1146
1147 Giflib/libungif prior to 4.1.3 used the wrong write mechanism when
1148 writing extension blocks so that they could only be written to files.
1149
1150 =cut
1151 */
1152
1153 static int
1154 do_ns_loop(GifFileType *gf, i_img *img)
1155 {
1156   /* EGifPutExtension() doesn't appear to handle application
1157      extension blocks in any way
1158      Since giflib wraps the fd with a FILE * (and puts that in its
1159      private data), we can't do an end-run and write the data
1160      directly to the fd.
1161      There's no open interface that takes a FILE * either, so we
1162      can't workaround it that way either.
1163      If giflib's callback interface wasn't broken by default, I'd
1164      force file writes to use callbacks, but it is broken by default.
1165   */
1166   /* yes this was another attempt at supporting the loop extension */
1167   int loop_count;
1168   if (i_tags_get_int(&img->tags, "gif_loop", 0, &loop_count)) {
1169     unsigned char nsle[12] = "NETSCAPE2.0";
1170     unsigned char subblock[3];
1171
1172     subblock[0] = 1;
1173     subblock[1] = loop_count % 256;
1174     subblock[2] = loop_count / 256;
1175
1176 #if defined(GIFLIB_MAJOR) && GIFLIB_MAJOR >= 5
1177     if (EGifPutExtensionLeader(gf, APPLICATION_EXT_FUNC_CODE) == GIF_ERROR
1178         || EGifPutExtensionBlock(gf, 11, nsle) == GIF_ERROR
1179         || EGifPutExtensionBlock(gf, 3, subblock) == GIF_ERROR
1180         || EGifPutExtensionTrailer(gf) == GIF_ERROR) {
1181       gif_push_error(myGifError(gf));
1182       i_push_error(0, "writing loop extension");
1183       return 0;
1184     }
1185
1186 #else
1187     if (EGifPutExtensionFirst(gf, APPLICATION_EXT_FUNC_CODE, 11, nsle) == GIF_ERROR) {
1188       gif_push_error(myGifError(gf));
1189       i_push_error(0, "writing loop extension");
1190       return 0;
1191     }
1192     if (EGifPutExtensionLast(gf, APPLICATION_EXT_FUNC_CODE, 3, subblock) == GIF_ERROR) {
1193       gif_push_error(myGifError(gf));
1194       i_push_error(0, "writing loop extension sub-block");
1195       return 0;
1196     }
1197 #endif
1198   }
1199
1200   return 1;
1201 }
1202
1203 /*
1204 =item make_gif_map(i_quantize *quant, int want_trans)
1205
1206 Create a giflib color map object from an Imager color map.
1207
1208 =cut
1209 */
1210
1211 static ColorMapObject *
1212 make_gif_map(i_quantize *quant, i_img *img, int want_trans) {
1213   GifColorType colors[256];
1214   int i;
1215   int size = quant->mc_count;
1216   int map_size;
1217   ColorMapObject *map;
1218   i_color trans;
1219
1220   for (i = 0; i < quant->mc_count; ++i) {
1221     colors[i].Red = quant->mc_colors[i].rgb.r;
1222     colors[i].Green = quant->mc_colors[i].rgb.g;
1223     colors[i].Blue = quant->mc_colors[i].rgb.b;
1224   }
1225   if (want_trans) {
1226     if (!i_tags_get_color(&img->tags, "gif_trans_color", 0, &trans))
1227       trans.rgb.r = trans.rgb.g = trans.rgb.b = 0;
1228     colors[size].Red = trans.rgb.r;
1229     colors[size].Green = trans.rgb.g;
1230     colors[size].Blue = trans.rgb.b;
1231     ++size;
1232   }
1233   map_size = 1;
1234   while (map_size < size)
1235     map_size <<= 1;
1236   /* giflib spews for 1 colour maps, reasonable, I suppose */
1237   if (map_size == 1)
1238     map_size = 2;
1239   while (i < map_size) {
1240     colors[i].Red = colors[i].Green = colors[i].Blue = 0;
1241     ++i;
1242   }
1243
1244   map = MakeMapObject(map_size, colors);
1245   mm_log((1, "XXX map is at %p and colors at %p\n", map, map->Colors));
1246   if (!map) {
1247     i_push_error(0, "Could not create color map object");
1248     return NULL;
1249   }
1250 #if defined GIFLIB_MAJOR && GIFLIB_MAJOR >= 5
1251   map->SortFlag = 0;
1252 #endif
1253   return map;
1254 }
1255
1256 /*
1257 =item need_version_89a(i_quantize *quant, i_img *imgs, int count)
1258
1259 Return true if the file we're creating on these images needs a GIF89a
1260 header.
1261
1262 =cut
1263 */
1264
1265 static int
1266 need_version_89a(i_quantize *quant, i_img **imgs, int count) {
1267   int need_89a = 0;
1268   int temp;
1269   int i;
1270
1271   for (i = 0; i < count; ++i) {
1272     if (quant->transp != tr_none &&
1273         (imgs[i]->channels == 2 || imgs[i]->channels == 4)) {
1274       need_89a = 1;
1275       break;
1276     }
1277     if (i_tags_get_int(&imgs[i]->tags, "gif_delay", 0, &temp)) {
1278       need_89a = 1;
1279       break;
1280     }
1281     if (i_tags_get_int(&imgs[i]->tags, "gif_user_input", 0, &temp) && temp) {
1282       need_89a = 1;
1283       break;
1284     }
1285     if (i_tags_get_int(&imgs[i]->tags, "gif_disposal", 0, &temp)) {
1286       need_89a = 1;
1287       break;
1288     }
1289     if (i_tags_get_int(&imgs[i]->tags, "gif_loop", 0, &temp)) {
1290       need_89a = 1;
1291       break;
1292     }
1293   }
1294
1295   return need_89a;
1296 }
1297
1298 static int
1299 in_palette(i_color *c, i_quantize *quant, int size) {
1300   int i;
1301
1302   for (i = 0; i < size; ++i) {
1303     if (c->channel[0] == quant->mc_colors[i].channel[0]
1304         && c->channel[1] == quant->mc_colors[i].channel[1]
1305         && c->channel[2] == quant->mc_colors[i].channel[2]) {
1306       return i;
1307     }
1308   }
1309
1310   return -1;
1311 }
1312
1313 /*
1314 =item has_common_palette(imgs, count, quant)
1315
1316 Tests if all the given images are paletted and their colors are in the
1317 palette produced.
1318
1319 Previously this would build a consolidated palette from the source,
1320 but that meant that if the caller supplied a static palette (or
1321 specified a fixed palette like "webmap") then we wouldn't be
1322 quantizing to the caller specified palette.
1323
1324 =cut
1325 */
1326
1327 static int
1328 has_common_palette(i_img **imgs, int count, i_quantize *quant) {
1329   int i;
1330   int imgn;
1331   char used[256];
1332   int col_count;
1333
1334   /* we try to build a common palette here, if we can manage that, then
1335      that's the palette we use */
1336   for (imgn = 0; imgn < count; ++imgn) {
1337     int eliminate_unused;
1338     if (imgs[imgn]->type != i_palette_type)
1339       return 0;
1340
1341     if (!i_tags_get_int(&imgs[imgn]->tags, "gif_eliminate_unused", 0,
1342                         &eliminate_unused)) {
1343       eliminate_unused = 1;
1344     }
1345
1346     if (eliminate_unused) {
1347       i_palidx *line = mymalloc(sizeof(i_palidx) * imgs[imgn]->xsize);
1348       int x, y;
1349       memset(used, 0, sizeof(used));
1350
1351       for (y = 0; y < imgs[imgn]->ysize; ++y) {
1352         i_gpal(imgs[imgn], 0, imgs[imgn]->xsize, y, line);
1353         for (x = 0; x < imgs[imgn]->xsize; ++x)
1354           used[line[x]] = 1;
1355       }
1356
1357       myfree(line);
1358     }
1359     else {
1360       /* assume all are in use */
1361       memset(used, 1, sizeof(used));
1362     }
1363
1364     col_count = i_colorcount(imgs[imgn]);
1365     for (i = 0; i < col_count; ++i) {
1366       i_color c;
1367
1368       i_getcolors(imgs[imgn], i, &c, 1);
1369       if (used[i]) {
1370         if (in_palette(&c, quant, quant->mc_count) < 0) {
1371           mm_log((1, "  color not found in palette, no palette shortcut\n"));
1372
1373           return 0;
1374         }
1375       }
1376     }
1377   }
1378
1379   mm_log((1, "  all colors found in palette, palette shortcut\n"));
1380
1381   return 1;
1382 }
1383
1384 static i_palidx *
1385 quant_paletted(i_quantize *quant, i_img *img) {
1386   i_palidx *data = mymalloc(sizeof(i_palidx) * img->xsize * img->ysize);
1387   i_palidx *p = data;
1388   i_palidx trans[256];
1389   int i;
1390   i_img_dim x, y;
1391
1392   /* build a translation table */
1393   for (i = 0; i < i_colorcount(img); ++i) {
1394     i_color c;
1395     i_getcolors(img, i, &c, 1);
1396     trans[i] = in_palette(&c, quant, quant->mc_count);
1397   }
1398
1399   for (y = 0; y < img->ysize; ++y) {
1400     i_gpal(img, 0, img->xsize, y, data+img->xsize * y);
1401     for (x = 0; x < img->xsize; ++x) {
1402       *p = trans[*p];
1403       ++p;
1404     }
1405   }
1406
1407   return data;
1408 }
1409
1410 /*
1411 =item i_writegif_low(i_quantize *quant, GifFileType *gf, i_img **imgs, int count, i_gif_opts *opts)
1412
1413 Internal.  Low-level function that does the high-level GIF processing
1414 :)
1415
1416 Returns non-zero on success.
1417
1418 =cut
1419 */
1420
1421 static undef_int
1422 i_writegif_low(i_quantize *quant, GifFileType *gf, i_img **imgs, int count) {
1423   unsigned char *result = NULL;
1424   int color_bits;
1425   ColorMapObject *map;
1426   int scrw = 0, scrh = 0;
1427   int imgn, orig_count, orig_size;
1428   int posx, posy;
1429   int trans_index = -1;
1430   int *localmaps;
1431   int anylocal;
1432   i_img **glob_imgs; /* images that will use the global color map */
1433   int glob_img_count;
1434   i_color *orig_colors = quant->mc_colors;
1435   i_color *glob_colors = NULL;
1436   int glob_color_count = 0;
1437   int glob_want_trans;
1438   int glob_paletted = 0; /* the global map was made from the image palettes */
1439   int colors_paletted = 0;
1440   int want_trans = 0;
1441   int interlace;
1442   int gif_background;
1443
1444   mm_log((1, "i_writegif_low(quant %p, gf  %p, imgs %p, count %d)\n",
1445           quant, gf, imgs, count));
1446
1447   /* *((char *)0) = 1; */ /* used to break into the debugger */
1448
1449   if (count <= 0) {
1450     i_push_error(0, "No images provided to write");
1451     return 0; /* what are you smoking? */
1452   }
1453
1454   /* sanity is nice */
1455   if (quant->mc_size > 256)
1456     quant->mc_size = 256;
1457   if (quant->mc_count > quant->mc_size)
1458     quant->mc_count = quant->mc_size;
1459
1460   if (!i_tags_get_int(&imgs[0]->tags, "gif_screen_width", 0, &scrw))
1461     scrw = 0;
1462   if (!i_tags_get_int(&imgs[0]->tags, "gif_screen_height", 0, &scrh))
1463     scrh = 0;
1464
1465   anylocal = 0;
1466   localmaps = mymalloc(sizeof(int) * count);
1467   glob_imgs = mymalloc(sizeof(i_img *) * count);
1468   glob_img_count = 0;
1469   glob_want_trans = 0;
1470   for (imgn = 0; imgn < count; ++imgn) {
1471     i_img *im = imgs[imgn];
1472     if (im->xsize > 0xFFFF || im->ysize > 0xFFFF) {
1473       i_push_error(0, "image too large for GIF");
1474       return 0;
1475     }
1476
1477     posx = posy = 0;
1478     i_tags_get_int(&im->tags, "gif_left", 0, &posx);
1479     if (posx < 0) posx = 0;
1480     i_tags_get_int(&im->tags, "gif_top", 0, &posy);
1481     if (posy < 0) posy = 0;
1482     if (im->xsize + posx > scrw)
1483       scrw = im->xsize + posx;
1484     if (im->ysize + posy > scrh)
1485       scrh = im->ysize + posy;
1486     if (!i_tags_get_int(&im->tags, "gif_local_map", 0, localmaps+imgn))
1487       localmaps[imgn] = 0;
1488     if (localmaps[imgn])
1489       anylocal = 1;
1490     else {
1491       if (im->channels == 4) {
1492         glob_want_trans = 1;
1493       }
1494       glob_imgs[glob_img_count++] = im;
1495     }
1496   }
1497   glob_want_trans = glob_want_trans && quant->transp != tr_none ;
1498
1499   if (scrw > 0xFFFF || scrh > 0xFFFF) {
1500     i_push_error(0, "screen size too large for GIF");
1501     return 0;
1502   }
1503
1504   orig_count = quant->mc_count;
1505   orig_size = quant->mc_size;
1506
1507   if (glob_img_count) {
1508     /* this is ugly */
1509     glob_colors = mymalloc(sizeof(i_color) * quant->mc_size);
1510     quant->mc_colors = glob_colors;
1511     memcpy(glob_colors, orig_colors, sizeof(i_color) * quant->mc_count);
1512     /* we have some images that want to use the global map */
1513     if (glob_want_trans && quant->mc_count == 256) {
1514       mm_log((2, "  disabling transparency for global map - no space\n"));
1515       glob_want_trans = 0;
1516     }
1517     if (glob_want_trans && quant->mc_size == 256) {
1518       mm_log((2, "  reserving color for transparency\n"));
1519       --quant->mc_size;
1520     }
1521
1522     i_quant_makemap(quant, glob_imgs, glob_img_count);
1523     glob_paletted = has_common_palette(glob_imgs, glob_img_count, quant);
1524     glob_color_count = quant->mc_count;
1525     quant->mc_colors = orig_colors;
1526   }
1527
1528   /* use the global map if we have one, otherwise use the local map */
1529   gif_background = 0;
1530   if (glob_colors) {
1531     quant->mc_colors = glob_colors;
1532     quant->mc_count = glob_color_count;
1533     want_trans = glob_want_trans && imgs[0]->channels == 4;
1534
1535     if (!i_tags_get_int(&imgs[0]->tags, "gif_background", 0, &gif_background))
1536       gif_background = 0;
1537     if (gif_background < 0)
1538       gif_background = 0;
1539     if (gif_background >= glob_color_count)
1540       gif_background = 0;
1541   }
1542   else {
1543     want_trans = quant->transp != tr_none && imgs[0]->channels == 4;
1544     i_quant_makemap(quant, imgs, 1);
1545     colors_paletted = has_common_palette(imgs, 1, quant);
1546   }
1547
1548   if ((map = make_gif_map(quant, imgs[0], want_trans)) == NULL) {
1549     myfree(glob_colors);
1550     myfree(localmaps);
1551     myfree(glob_imgs);
1552     quant->mc_colors = orig_colors;
1553     EGifCloseFile(gf);
1554     mm_log((1, "Error in MakeMapObject"));
1555     return 0;
1556   }
1557   color_bits = 1;
1558   if (anylocal) {
1559     /* since we don't know how big some the local palettes could be
1560        we need to base the bits on the maximum number of colors */
1561     while (orig_size > (1 << color_bits))
1562       ++color_bits;
1563   }
1564   else {
1565     int count = quant->mc_count;
1566     if (want_trans)
1567       ++count;
1568     while (count > (1 << color_bits))
1569       ++color_bits;
1570   }
1571
1572   if (EGifPutScreenDesc(gf, scrw, scrh, color_bits,
1573                         gif_background, map) == GIF_ERROR) {
1574     myfree(glob_colors);
1575     myfree(localmaps);
1576     myfree(glob_imgs);
1577     quant->mc_colors = orig_colors;
1578     gif_push_error(myGifError(gf));
1579     i_push_error(0, "Could not save screen descriptor");
1580     FreeMapObject(map);
1581     myfree(result);
1582     EGifCloseFile(gf);
1583     mm_log((1, "Error in EGifPutScreenDesc."));
1584     return 0;
1585   }
1586   FreeMapObject(map);
1587
1588   if (!i_tags_get_int(&imgs[0]->tags, "gif_left", 0, &posx))
1589     posx = 0;
1590   if (!i_tags_get_int(&imgs[0]->tags, "gif_top", 0, &posy))
1591     posy = 0;
1592
1593   if (!localmaps[0]) {
1594     map = NULL;
1595     colors_paletted = glob_paletted;
1596   }
1597   else {
1598     /* if this image has a global map the colors in quant don't
1599        belong to this image, so build a palette */
1600     if (glob_colors) {
1601       /* generate the local map for this image */
1602       quant->mc_colors = orig_colors;
1603       quant->mc_size = orig_size;
1604       quant->mc_count = orig_count;
1605       want_trans = quant->transp != tr_none && imgs[0]->channels == 4;
1606
1607       /* if the caller gives us too many colours we can't do transparency */
1608       if (want_trans && quant->mc_count == 256)
1609         want_trans = 0;
1610       /* if they want transparency but give us a big size, make it smaller
1611          to give room for a transparency colour */
1612       if (want_trans && quant->mc_size == 256)
1613         --quant->mc_size;
1614       i_quant_makemap(quant, imgs, 1);
1615       colors_paletted = has_common_palette(imgs, 1, quant);
1616       if ((map = make_gif_map(quant, imgs[0], want_trans)) == NULL) {
1617         myfree(glob_colors);
1618         myfree(localmaps);
1619         myfree(glob_imgs);
1620         EGifCloseFile(gf);
1621         quant->mc_colors = orig_colors;
1622         mm_log((1, "Error in MakeMapObject"));
1623         return 0;
1624       }
1625     }
1626     else {
1627       /* the map we wrote was the map for this image - don't set the local
1628          map */
1629       map = NULL;
1630     }
1631   }
1632
1633   if (colors_paletted)
1634     result = quant_paletted(quant, imgs[0]);
1635   else
1636     result = i_quant_translate(quant, imgs[0]);
1637   if (!result) {
1638     myfree(glob_colors);
1639     myfree(localmaps);
1640     myfree(glob_imgs);
1641     quant->mc_colors = orig_colors;
1642     EGifCloseFile(gf);
1643     return 0;
1644   }
1645   if (want_trans) {
1646     i_quant_transparent(quant, result, imgs[0], quant->mc_count);
1647     trans_index = quant->mc_count;
1648   }
1649
1650   if (!do_ns_loop(gf, imgs[0])) {
1651     myfree(glob_colors);
1652     myfree(localmaps);
1653     myfree(glob_imgs);
1654     quant->mc_colors = orig_colors;
1655     return 0;
1656   }
1657
1658   if (!do_gce(gf, imgs[0], want_trans, trans_index)) {
1659     myfree(glob_colors);
1660     myfree(localmaps);
1661     myfree(glob_imgs);
1662     quant->mc_colors = orig_colors;
1663     myfree(result);
1664     EGifCloseFile(gf);
1665     return 0;
1666   }
1667
1668   if (!do_comments(gf, imgs[0])) {
1669     myfree(glob_colors);
1670     myfree(localmaps);
1671     myfree(glob_imgs);
1672     quant->mc_colors = orig_colors;
1673     myfree(result);
1674     EGifCloseFile(gf);
1675     return 0;
1676   }
1677
1678   if (!i_tags_get_int(&imgs[0]->tags, "gif_interlace", 0, &interlace))
1679     interlace = 0;
1680   if (EGifPutImageDesc(gf, posx, posy, imgs[0]->xsize, imgs[0]->ysize,
1681                        interlace, map) == GIF_ERROR) {
1682     myfree(glob_colors);
1683     myfree(localmaps);
1684     myfree(glob_imgs);
1685     quant->mc_colors = orig_colors;
1686     gif_push_error(myGifError(gf));
1687     i_push_error(0, "Could not save image descriptor");
1688     EGifCloseFile(gf);
1689     mm_log((1, "Error in EGifPutImageDesc."));
1690     return 0;
1691   }
1692   if (map)
1693     FreeMapObject(map);
1694
1695   if (!do_write(gf, interlace, imgs[0], result)) {
1696     myfree(glob_colors);
1697     myfree(localmaps);
1698     myfree(glob_imgs);
1699     quant->mc_colors = orig_colors;
1700     EGifCloseFile(gf);
1701     myfree(result);
1702     return 0;
1703   }
1704   myfree(result);
1705
1706   /* that first awful image is out of the way, do the rest */
1707   for (imgn = 1; imgn < count; ++imgn) {
1708     if (localmaps[imgn]) {
1709       quant->mc_colors = orig_colors;
1710       quant->mc_count = orig_count;
1711       quant->mc_size = orig_size;
1712
1713       want_trans = quant->transp != tr_none
1714         && imgs[imgn]->channels == 4;
1715       /* if the caller gives us too many colours we can't do transparency */
1716       if (want_trans && quant->mc_count == 256)
1717         want_trans = 0;
1718       /* if they want transparency but give us a big size, make it smaller
1719          to give room for a transparency colour */
1720       if (want_trans && quant->mc_size == 256)
1721         --quant->mc_size;
1722
1723       if (has_common_palette(imgs+imgn, 1, quant)) {
1724         result = quant_paletted(quant, imgs[imgn]);
1725       }
1726       else {
1727         i_quant_makemap(quant, imgs+imgn, 1);
1728         result = i_quant_translate(quant, imgs[imgn]);
1729       }
1730       if (!result) {
1731         myfree(glob_colors);
1732         myfree(localmaps);
1733         myfree(glob_imgs);
1734         quant->mc_colors = orig_colors;
1735         EGifCloseFile(gf);
1736         mm_log((1, "error in i_quant_translate()"));
1737         return 0;
1738       }
1739       if (want_trans) {
1740         i_quant_transparent(quant, result, imgs[imgn], quant->mc_count);
1741         trans_index = quant->mc_count;
1742       }
1743
1744       if ((map = make_gif_map(quant, imgs[imgn], want_trans)) == NULL) {
1745         myfree(glob_colors);
1746         myfree(localmaps);
1747         myfree(glob_imgs);
1748         quant->mc_colors = orig_colors;
1749         myfree(result);
1750         EGifCloseFile(gf);
1751         mm_log((1, "Error in MakeMapObject."));
1752         return 0;
1753       }
1754     }
1755     else {
1756       quant->mc_colors = glob_colors;
1757       quant->mc_count = glob_color_count;
1758       if (glob_paletted)
1759         result = quant_paletted(quant, imgs[imgn]);
1760       else
1761         result = i_quant_translate(quant, imgs[imgn]);
1762       want_trans = glob_want_trans && imgs[imgn]->channels == 4;
1763       if (want_trans) {
1764         i_quant_transparent(quant, result, imgs[imgn], quant->mc_count);
1765         trans_index = quant->mc_count;
1766       }
1767       map = NULL;
1768     }
1769
1770     if (!do_gce(gf, imgs[imgn], want_trans, trans_index)) {
1771       myfree(glob_colors);
1772       myfree(localmaps);
1773       myfree(glob_imgs);
1774       quant->mc_colors = orig_colors;
1775       myfree(result);
1776       EGifCloseFile(gf);
1777       return 0;
1778     }
1779
1780     if (!do_comments(gf, imgs[imgn])) {
1781       myfree(glob_colors);
1782       myfree(localmaps);
1783       myfree(glob_imgs);
1784       quant->mc_colors = orig_colors;
1785       myfree(result);
1786       EGifCloseFile(gf);
1787       return 0;
1788     }
1789
1790     if (!i_tags_get_int(&imgs[imgn]->tags, "gif_left", 0, &posx))
1791       posx = 0;
1792     if (!i_tags_get_int(&imgs[imgn]->tags, "gif_top", 0, &posy))
1793       posy = 0;
1794
1795     if (!i_tags_get_int(&imgs[imgn]->tags, "gif_interlace", 0, &interlace))
1796       interlace = 0;
1797     if (EGifPutImageDesc(gf, posx, posy, imgs[imgn]->xsize,
1798                          imgs[imgn]->ysize, interlace, map) == GIF_ERROR) {
1799       myfree(glob_colors);
1800       myfree(localmaps);
1801       myfree(glob_imgs);
1802       quant->mc_colors = orig_colors;
1803       gif_push_error(myGifError(gf));
1804       i_push_error(0, "Could not save image descriptor");
1805       myfree(result);
1806       if (map)
1807         FreeMapObject(map);
1808       EGifCloseFile(gf);
1809       mm_log((1, "Error in EGifPutImageDesc."));
1810       return 0;
1811     }
1812     if (map)
1813       FreeMapObject(map);
1814
1815     if (!do_write(gf, interlace, imgs[imgn], result)) {
1816       myfree(glob_colors);
1817       myfree(localmaps);
1818       myfree(glob_imgs);
1819       quant->mc_colors = orig_colors;
1820       EGifCloseFile(gf);
1821       myfree(result);
1822       return 0;
1823     }
1824     myfree(result);
1825   }
1826
1827   if (EGifCloseFile(gf) == GIF_ERROR) {
1828     myfree(glob_colors);
1829     myfree(localmaps);
1830     myfree(glob_imgs);
1831     gif_push_error(myGifError(gf));
1832     i_push_error(0, "Could not close GIF file");
1833     mm_log((1, "Error in EGifCloseFile\n"));
1834     return 0;
1835   }
1836   if (glob_colors) {
1837     int i;
1838     for (i = 0; i < glob_color_count; ++i)
1839       orig_colors[i] = glob_colors[i];
1840   }
1841
1842   myfree(glob_colors);
1843   myfree(localmaps);
1844   myfree(glob_imgs);
1845   quant->mc_colors = orig_colors;
1846
1847   return 1;
1848 }
1849
1850 static int
1851 io_glue_write_cb(GifFileType *gft, const GifByteType *data, int length) {
1852   io_glue *ig = (io_glue *)gft->UserData;
1853
1854   return i_io_write(ig, data, length);
1855 }
1856
1857
1858 /*
1859 =item i_writegif_wiol(ig, quant, opts, imgs, count)
1860
1861 =cut
1862 */
1863 undef_int
1864 i_writegif_wiol(io_glue *ig, i_quantize *quant, i_img **imgs,
1865                 int count) {
1866   GifFileType *GifFile;
1867   int gif_error;
1868   int result;
1869
1870   gif_mutex_lock(mutex);
1871
1872   i_clear_error();
1873
1874 #ifdef PRE_SET_VERSION
1875   EGifSetGifVersion(need_version_89a(quant, imgs, count) ? "89a" : "87a");
1876 #endif
1877
1878   if ((GifFile = myEGifOpen((void *)ig, io_glue_write_cb, &gif_error )) == NULL) {
1879     gif_push_error(gif_error);
1880     i_push_error(0, "Cannot create giflib callback object");
1881     mm_log((1,"i_writegif_wiol: Unable to open callback datasource.\n"));
1882     gif_mutex_unlock(mutex);
1883     return 0;
1884   }
1885
1886 #ifdef POST_SET_VERSION
1887   EGifSetGifVersion(GifFile, need_version_89a(quant, imgs, count));
1888 #endif
1889
1890   result = i_writegif_low(quant, GifFile, imgs, count);
1891
1892   gif_mutex_unlock(mutex);
1893
1894   if (i_io_close(ig))
1895     return 0;
1896
1897   return result;
1898 }
1899
1900 /*
1901 =item gif_error_msg(int code)
1902
1903 Grabs the most recent giflib error code from GifLastError() and
1904 returns a string that describes that error.
1905
1906 Returns NULL for unknown error codes.
1907
1908 =cut
1909 */
1910
1911 static char const *
1912 gif_error_msg(int code) {
1913 #if defined(GIFLIB_MAJOR) && GIFLIB_MAJOR >= 5
1914   return GifErrorString(code);
1915 #else
1916   switch (code) {
1917   case E_GIF_ERR_OPEN_FAILED: /* should not see this */
1918     return "Failed to open given file";
1919
1920   case E_GIF_ERR_WRITE_FAILED:
1921     return "Write failed";
1922
1923   case E_GIF_ERR_HAS_SCRN_DSCR: /* should not see this */
1924     return "Screen descriptor already passed to giflib";
1925
1926   case E_GIF_ERR_HAS_IMAG_DSCR: /* should not see this */
1927     return "Image descriptor already passed to giflib";
1928
1929   case E_GIF_ERR_NO_COLOR_MAP: /* should not see this */
1930     return "Neither global nor local color map set";
1931
1932   case E_GIF_ERR_DATA_TOO_BIG: /* should not see this */
1933     return "Too much pixel data passed to giflib";
1934
1935   case E_GIF_ERR_NOT_ENOUGH_MEM:
1936     return "Out of memory";
1937
1938   case E_GIF_ERR_DISK_IS_FULL:
1939     return "Disk is full";
1940
1941   case E_GIF_ERR_CLOSE_FAILED: /* should not see this */
1942     return "File close failed";
1943
1944   case E_GIF_ERR_NOT_WRITEABLE: /* should not see this */
1945     return "File not writable";
1946
1947   case D_GIF_ERR_OPEN_FAILED:
1948     return "Failed to open file";
1949
1950   case D_GIF_ERR_READ_FAILED:
1951     return "Failed to read from file";
1952
1953   case D_GIF_ERR_NOT_GIF_FILE:
1954     return "File is not a GIF file";
1955
1956   case D_GIF_ERR_NO_SCRN_DSCR:
1957     return "No screen descriptor detected - invalid file";
1958
1959   case D_GIF_ERR_NO_IMAG_DSCR:
1960     return "No image descriptor detected - invalid file";
1961
1962   case D_GIF_ERR_NO_COLOR_MAP:
1963     return "No global or local color map found";
1964
1965   case D_GIF_ERR_WRONG_RECORD:
1966     return "Wrong record type detected - invalid file?";
1967
1968   case D_GIF_ERR_DATA_TOO_BIG:
1969     return "Data in file too big for image";
1970
1971   case D_GIF_ERR_NOT_ENOUGH_MEM:
1972     return "Out of memory";
1973
1974   case D_GIF_ERR_CLOSE_FAILED:
1975     return "Close failed";
1976
1977   case D_GIF_ERR_NOT_READABLE:
1978     return "File not opened for read";
1979
1980   case D_GIF_ERR_IMAGE_DEFECT:
1981     return "Defective image";
1982
1983   case D_GIF_ERR_EOF_TOO_SOON:
1984     return "Unexpected EOF - invalid file";
1985
1986   default:
1987     return NULL;
1988   }
1989 #endif
1990 }
1991
1992 /*
1993 =item gif_push_error(code)
1994
1995 Utility function that takes the current GIF error code, converts it to
1996 an error message and pushes it on the error stack.
1997
1998 =cut
1999 */
2000
2001 static void
2002 gif_push_error(int code) {
2003   const char *msg = gif_error_msg(code);
2004   if (msg)
2005     i_push_error(code, msg);
2006   else
2007     i_push_errorf(code, "Unknown GIF error %d", code);
2008 }
2009
2010 /*
2011 =head1 AUTHOR
2012
2013 Arnar M. Hrafnkelsson, addi@umich.edu
2014
2015 Tony Cook <tonyc@cpan.org>
2016
2017 =head1 SEE ALSO
2018
2019 perl(1), Imager(3)
2020
2021 =cut
2022
2023 */