deanimate.c

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