deanimate.c

   1 const char deanimate_rcs[] = "$Id: deanimate.c,v 1.2 2001/07/13 13:46:20 oes Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/deanimate.c,v $
   5  *
   6  * Purpose     :  Declares functions to deanimate GIF images on the fly.
   7  *
   8  *                Functions declared include: gif_deanimate, buf_free,
   9  *                buf_copy,  buf_getbyte, gif_skip_data_block, and
  10  *                gif_extract_image
  11  *
  12  * Copyright   :  Written by and Copyright (C) 2001 Andreas S. Oesterhelt
  13  *                for the SourceForge IJBSWA team. http://ijbswa.sourceforge.net
  14  *
  15  *                Based on the GIF file format specification (see
  16  *                http://tronche.com/computer-graphics/gif/gif89a.html)
  17  *                and ideas from the Image::DeAnim Perl module by
  18  *                Ken MacFarlane, <ksm+cpan@universal.dca.net>
  19  *
  20  *                This program is free software; you can redistribute it
  21  *                and/or modify it under the terms of the GNU General
  22  *                Public License as published by the Free Software
  23  *                Foundation; either version 2 of the License, or (at
  24  *                your option) any later version.
  25  *
  26  *                This program is distributed in the hope that it will
  27  *                be useful, but WITHOUT ANY WARRANTY; without even the
  28  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  29  *                PARTICULAR PURPOSE.  See the GNU General Public
  30  *                License for more details.
  31  *
  32  *                The GNU General Public License should be included with
  33  *                this file.  If not, you can view it at
  34  *                http://www.gnu.org/copyleft/gpl.html
  35  *                or write to the Free Software Foundation, Inc., 59
  36  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  37  *
  38  * Revisions   :
  39  *    $Log: deanimate.c,v $
  40  *    Revision 1.2  2001/07/13 13:46:20  oes
  41  *    Introduced GIF deanimation feature
  42  *
  43  *
  44  **********************************************************************/
  45 \f
  46
  47 #include "config.h"
  48
  49 #include <string.h>
  50 #include <fcntl.h>
  51
  52 #include "project.h"
  53 #include "deanimate.h"
  54 #include "miscutil.h"
  55
  56 const char deanimate_h_rcs[] = DEANIMATE_H_VERSION;
  57
  58 /*********************************************************************
  59  *
  60  * Function    :  buf_free
  61  *
  62  * Description :  Safely frees a struct binbuffer
  63  *
  64  * Parameters  :
  65  *          1  :  buf = Pointer to the binbuffer to be freed
  66  *
  67  * Returns     :  N/A
  68  *
  69  *********************************************************************/
  70 void buf_free(struct binbuffer *buf)
  71 {
  72    if (buf == NULL) return;
  73
  74    if (buf->buffer != NULL)
  75    {
  76       free(buf->buffer);
  77    }
  78
  79    free(buf);
  80
  81 }
  82
  83
  84 /*********************************************************************
  85  *
  86  * Function    :  buf_copy
  87  *
  88  * Description :  Safely copies a given amount of bytes from one
  89  *                struct binbuffer to another, advancing the
  90  *                offsets appropriately.
  91  *
  92  * Parameters  :
  93  *          1  :  src = Pointer to the source binbuffer
  94  *          2  :  dst = Pointer to the destination binbuffer
  95  *          3  :  length = Number of bytes to be copied
  96  *
  97  * Returns     :  0 on success, 1 on failiure.
  98  *
  99  *********************************************************************/
 100 int buf_copy(struct binbuffer *src, struct binbuffer *dst, int length)
 101 {
 102    char *p;
 103
 104    /*
 105     * Sanity check: Can't copy more data than we have
 106     */
 107    if (src->offset + length > src->size)
 108    {
 109       return 1;
 110    }
 111
 112    /*
 113     * If dst can't hold the new data, get mem first. (In chunks
 114     * of 1000 bytes, so we don't have to realloc() too often)
 115     */
 116    if (dst->offset + length > dst->size)
 117    {
 118       dst->size = dst->size + length + 1000 - (dst->size + length) % 1000;
 119       p = dst->buffer;
 120       dst->buffer = (char *)realloc(dst->buffer, dst->size);
 121
 122       if (dst->buffer == NULL)
 123       {
 124          free(p);
 125          return 1;
 126       }
 127    }
 128
 129    /*
 130     * Now that it's safe, memcpy() the desired amount of
 131     * data from src to dst and adjust the offsets
 132     */
 133    memcpy(dst->buffer + dst->offset, src->buffer + src->offset, length);
 134    src->offset += length;
 135    dst->offset += length;
 136
 137    return 0;
 138
 139 }
 140
 141
 142 /*********************************************************************
 143  *
 144  * Function    :  buf_getbyte
 145  *
 146  * Description :  Safely gets a byte from a given binbuffer at a
 147  *                given offset
 148  *
 149  * Parameters  :
 150  *          1  :  buf = Pointer to the source binbuffer
 151  *          2  :  offset = Offset to the desired byte
 152  *
 153  * Returns     :  The byte on success, or 0 on failiure
 154  *
 155  *********************************************************************/
 156 unsigned char buf_getbyte(struct binbuffer *src, int offset)
 157 {
 158    if (src->offset + offset < src->size)
 159    {
 160       return (unsigned char)*(src->buffer + src->offset + offset);
 161    }
 162    else
 163    {
 164       return '\0';
 165    }
 166
 167 }
 168
 169
 170 /*********************************************************************
 171  *
 172  * Function    :  gif_skip_data_block
 173  *
 174  * Description :  Safely advances the offset of a given struct binbuffer
 175  *                that contains a GIF image and whose offset is
 176  *                positioned at the start of a data block behind
 177  *                that block.
 178  *
 179  * Parameters  :
 180  *          1  :  buf = Pointer to the binbuffer
 181  *
 182  * Returns     :  0 on success, or 1 on failiure
 183  *
 184  *********************************************************************/
 185 int gif_skip_data_block(struct binbuffer *buf)
 186 {
 187    unsigned char c;
 188
 189    /*
 190     * Data blocks are sequences of chunks, which are headed
 191     * by a one-byte length field, with the last chunk having
 192     * zero length.
 193     */
 194    while(c = buf_getbyte(buf, 0))
 195    {
 196       if ((buf->offset += c + 1) >= buf->size - 1)
 197       {
 198          return 1;
 199       }
 200    }
 201    buf->offset++;
 202
 203    return 0;
 204
 205 }
 206
 207
 208 /*********************************************************************
 209  *
 210  * Function    :  gif_extract_image
 211  *
 212  * Description :  Safely extracts an image data block from a given
 213  *                struct binbuffer that contains a GIF image and whose
 214  *                offset is positioned at the start of a data block
 215  *                into a given destination binbuffer.
 216  *
 217  * Parameters  :
 218  *          1  :  src = Pointer to the source binbuffer
 219  *          2  :  dst = Pointer to the destination binbuffer
 220  *
 221  * Returns     :  0 on success, or 1 on failiure
 222  *
 223  *********************************************************************/
 224 int gif_extract_image(struct binbuffer *src, struct binbuffer *dst)
 225 {
 226    unsigned char c;
 227
 228    /*
 229     * Remember the colormap flag and copy the image head
 230     */
 231    c = buf_getbyte(src, 9);
 232    if (buf_copy(src, dst, 10))
 233    {
 234       return 1;
 235    }
 236
 237    /*
 238     * If the image has a local colormap, copy it.
 239     */
 240    if (c & 0x80)
 241    {
 242       if (buf_copy(src, dst, 3 * (1 << ((c & 0x07) + 1))))
 243       {
 244          return 1;
 245       }
 246    }
 247    if (buf_copy(src, dst, 1)) return 1;
 248
 249    /*
 250     * Copy the image chunk by chunk.
 251     */
 252    while(c = buf_getbyte(src, 0))
 253    {
 254       if (buf_copy(src, dst, c + 1)) return 1;
 255    }
 256    if (buf_copy(src, dst, 1)) return 1;
 257
 258    /*
 259     * Trim and rewind the dst buffer
 260     */
 261    dst->buffer = (char *)realloc(dst->buffer, dst->offset);
 262    dst->size = dst->offset;
 263    dst->offset = 0;
 264
 265    return(0);
 266
 267 }
 268
 269 /*********************************************************************
 270  *
 271  * Function    :  gif_deanimate
 272  *
 273  * Description :  Deanimate a given GIF image, i.e. given a GIF with
 274  *                an (optional) image block and an arbitrary number
 275  *                of image extension blocks, produce an output GIF with
 276  *                only one image block that contains the last image
 277  *                (extenstion) block of the original.
 278  *                Also strip Comments, Application extenstions, etc.
 279  *
 280  * Parameters  :
 281  *          1  :  src = Pointer to the source binbuffer
 282  *          2  :  dst = Pointer to the destination binbuffer
 283  *
 284  * Returns     :  0 on success, or 1 on failiure
 285  *
 286  *********************************************************************/
 287 int gif_deanimate(struct binbuffer *src, struct binbuffer *dst)
 288 {
 289    unsigned char c;
 290    struct binbuffer *image;
 291
 292    if (NULL == src || NULL == dst)
 293    {
 294       return 1;
 295    }
 296
 297    c = buf_getbyte(src, 10);
 298
 299    /*
 300     * Check & copy GIF header
 301     */
 302    if (strncmp(src->buffer, "GIF89a", 6))
 303    {
 304       fprintf(stderr, "This is not a GIF98a!\n");
 305       return 1;
 306    }
 307    else
 308    {
 309       if (buf_copy(src, dst, 13))
 310       {
 311          return 1;
 312       }
 313    }
 314
 315    /*
 316     * Look for global colormap and  copy if found.
 317     */
 318    if(c & 0x80)
 319    {
 320       if (buf_copy(src, dst, 3 * (1 << ((c & 0x07) + 1))))
 321       {
 322          return 1;
 323       }
 324    }
 325
 326    /*
 327     * Reserve a buffer for the current image block
 328     */
 329    if (NULL == (image = (struct binbuffer *)zalloc(sizeof(*image))))
 330    {
 331       return 1;
 332    }
 333
 334    /*
 335     * Parse the GIF block by block and copy the relevant
 336     * parts to dst
 337     */
 338    while(src->offset < src->size)
 339    {
 340       switch(buf_getbyte(src, 0))
 341       {
 342          /*
 343           *  End-of-GIF Marker: Append current image and return
 344           */
 345       case 0x3b:
 346          if (buf_copy(image, dst, image->size) || buf_copy(src, dst, 1))
 347          {
 348             goto failed;
 349          }
 350          buf_free(image);
 351          return(0);
 352
 353          /*
 354           * Image block: Extract to current image buffer
 355           */
 356       case 0x2c:
 357          image->offset = 0;
 358          if (gif_extract_image(src, image))
 359          {
 360             goto failed;
 361          }
 362          continue;
 363
 364          /*
 365           * Extension block: Look at next byte and decide
 366           */
 367       case 0x21:
 368          switch (buf_getbyte(src, 1))
 369          {
 370             /*
 371              * Image extension: Copy extension  header and image
 372              *                  to the current image buffer
 373              */
 374          case 0xf9:
 375             image->offset = 0;
 376             if (buf_copy(src, image, 8) || buf_getbyte(src, 0) != 0x2c) goto failed;
 377             if (gif_extract_image(src, image)) goto failed;
 378             continue;
 379
 380             /*
 381              * Application extension: Skip
 382              */
 383          case 0xff:
 384             if ((src->offset += 14) >= src->size || gif_skip_data_block(src)) goto failed;
 385             continue;
 386
 387             /*
 388              * Comment extension: Skip
 389              */
 390          case 0xfe:
 391             if ((src->offset += 2) >= src->size || gif_skip_data_block(src)) goto failed;
 392             continue;
 393
 394             /*
 395              * Plain text extension: Skip
 396              */
 397          case 0x01:
 398             if ((src->offset += 15) >= src->size || gif_skip_data_block(src)) goto failed;
 399             continue;
 400
 401             /*
 402              * Ooops, what type of extension is that?
 403              */
 404          default:
 405             goto failed;
 406
 407          }
 408
 409          /*
 410           * Ooops, what type of block is that?
 411           */
 412       default:
 413          goto failed;
 414
 415       }
 416    } /* -END- while src */
 417
 418    /*
 419     * Either we got here by goto, or because the GIF is
 420     * bogus and EOF was reached before an end-of-gif marker
 421     * was found.
 422     */
 423
 424 failed:
 425    buf_free(image);
 426    return 1;
 427
 428 }
 429
 430
 431 /*
 432   Local Variables:
 433   tab-width: 3
 434   end:
 435 */