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