Correcting function comments
[privoxy.git] / deanimate.c
1 const char deanimate_rcs[] = "$Id: deanimate.c,v 1.11 2002/03/26 22:29:54 swa 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 by the the SourceForge
13  *                Privoxy team. http://www.privoxy.org/
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.11  2002/03/26 22:29:54  swa
41  *    we have a new homepage!
42  *
43  *    Revision 1.10  2002/03/24 13:25:43  swa
44  *    name change related issues
45  *
46  *    Revision 1.9  2002/03/13 00:27:04  jongfoster
47  *    Killing warnings
48  *
49  *    Revision 1.8  2002/03/09 19:42:47  jongfoster
50  *    Fixing more warnings
51  *
52  *    Revision 1.7  2002/03/08 17:46:04  jongfoster
53  *    Fixing int/size_t warnings
54  *
55  *    Revision 1.6  2002/03/07 03:46:17  oes
56  *    Fixed compiler warnings
57  *
58  *    Revision 1.5  2001/09/10 10:16:06  oes
59  *    Silenced compiler warnings
60  *
61  *    Revision 1.4  2001/07/18 12:28:49  oes
62  *    - Added feature for extracting the first frame
63  *      to gif_deanimate
64  *    - Separated image buffer extension into buf_extend
65  *    - Extended gif deanimation to GIF87a (untested!)
66  *    - Cosmetics
67  *
68  *    Revision 1.3  2001/07/15 13:57:50  jongfoster
69  *    Adding #includes string.h and miscutil.h
70  *
71  *    Revision 1.2  2001/07/13 13:46:20  oes
72  *    Introduced GIF deanimation feature
73  *
74  *
75  **********************************************************************/
76 \f
77
78 #include "config.h"
79
80 #include <string.h>
81 #include <fcntl.h>
82
83 #include "project.h"
84 #include "deanimate.h"
85 #include "miscutil.h"
86
87 const char deanimate_h_rcs[] = DEANIMATE_H_VERSION;
88
89 /*********************************************************************
90  * 
91  * Function    :  buf_free
92  *
93  * Description :  Safely frees a struct binbuffer
94  *
95  * Parameters  :
96  *          1  :  buf = Pointer to the binbuffer to be freed
97  *
98  * Returns     :  N/A
99  *
100  *********************************************************************/
101 void buf_free(struct binbuffer *buf)
102 {
103    if (buf == NULL) return;
104
105    if (buf->buffer != NULL)
106    {
107       free(buf->buffer);
108    }
109
110    free(buf);
111
112 }
113
114
115 /*********************************************************************
116  * 
117  * Function    :  buf_extend
118  *
119  * Description :  Ensure that a given binbuffer can hold a given amount
120  *                of bytes, by reallocating its buffer if necessary.
121  *                Allocate new mem in chunks of 1024 bytes, so we don't
122  *                have to realloc() too often.
123  *
124  * Parameters  :
125  *          1  :  buf = Pointer to the binbuffer
126  *          2  :  length = Desired minimum size
127  *                
128  *
129  * Returns     :  0 on success, 1 on failiure.
130  *
131  *********************************************************************/
132 int buf_extend(struct binbuffer *buf, size_t length)
133 {
134    char *newbuf;
135
136    if (buf->offset + length > buf->size)
137    {
138       buf->size = ((buf->size + length + (size_t)1023) & ~(size_t)1023);
139       newbuf = (char *)realloc(buf->buffer, buf->size);
140
141       if (newbuf == NULL)
142       {
143          freez(buf->buffer);
144          return 1;
145       }
146       else
147       {
148          buf->buffer = newbuf;
149          return 0;
150       }
151    }
152    return 0;
153
154 }
155
156
157 /*********************************************************************
158  * 
159  * Function    :  buf_copy
160  *
161  * Description :  Safely copies a given amount of bytes from one
162  *                struct binbuffer to another, advancing the
163  *                offsets appropriately.
164  *
165  * Parameters  :
166  *          1  :  src = Pointer to the source binbuffer
167  *          2  :  dst = Pointer to the destination binbuffer
168  *          3  :  length = Number of bytes to be copied
169  *
170  * Returns     :  0 on success, 1 on failiure.
171  *
172  *********************************************************************/
173 int buf_copy(struct binbuffer *src, struct binbuffer *dst, size_t length)
174 {
175
176    /*
177     * Sanity check: Can't copy more data than we have
178     */
179    if (src->offset + length > src->size) 
180    {
181       return 1;
182    }
183
184    /*
185     * Ensure that dst can hold the new data
186     */
187    if (buf_extend(dst, length)) 
188    {
189       return 1;
190    }
191
192    /*
193     * Now that it's safe, memcpy() the desired amount of
194     * data from src to dst and adjust the offsets
195     */
196    memcpy(dst->buffer + dst->offset, src->buffer + src->offset, length);
197    src->offset += length;
198    dst->offset += length;
199
200    return 0;
201
202 }
203
204
205 /*********************************************************************
206  * 
207  * Function    :  buf_getbyte
208  *
209  * Description :  Safely gets a byte from a given binbuffer at a
210  *                given offset
211  *
212  * Parameters  :
213  *          1  :  src = Pointer to the source binbuffer
214  *          2  :  offset = Offset to the desired byte
215  *
216  * Returns     :  The byte on success, or 0 on failiure
217  *
218  *********************************************************************/
219 unsigned char buf_getbyte(struct binbuffer *src, size_t offset)
220 {
221    if (src->offset + offset < src->size)
222    {
223       return (unsigned char)*(src->buffer + src->offset + offset);
224    }
225    else
226    {
227       return '\0';
228    }
229
230 }
231
232
233 /*********************************************************************
234  * 
235  * Function    :  gif_skip_data_block
236  *
237  * Description :  Safely advances the offset of a given struct binbuffer
238  *                that contains a GIF image and whose offset is
239  *                positioned at the start of a data block, behind
240  *                that block.
241  *
242  * Parameters  :
243  *          1  :  buf = Pointer to the binbuffer
244  *
245  * Returns     :  0 on success, or 1 on failiure
246  *
247  *********************************************************************/
248 int gif_skip_data_block(struct binbuffer *buf)
249 {
250    unsigned char c;
251
252    /* 
253     * Data blocks are sequences of chunks, which are headed
254     * by a one-byte length field, with the last chunk having
255     * zero length.
256     */
257    while((c = buf_getbyte(buf, 0)) != '\0')
258    {
259       if ((buf->offset += c + 1) >= buf->size - 1)
260       {
261          return 1;
262       }
263    }
264    buf->offset++;
265
266    return 0;
267
268 }
269
270
271 /*********************************************************************
272  * 
273  * Function    :  gif_extract_image
274  *
275  * Description :  Safely extracts an image data block from a given
276  *                struct binbuffer that contains a GIF image and whose
277  *                offset is positioned at the start of a data block 
278  *                into a given destination binbuffer.
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_extract_image(struct binbuffer *src, struct binbuffer *dst)
288 {
289    unsigned char c;
290    
291    /*
292     * Remember the colormap flag and copy the image head
293     */
294    c = buf_getbyte(src, 9);
295    if (buf_copy(src, dst, 10))
296    {
297       return 1;
298    }
299
300    /*
301     * If the image has a local colormap, copy it.
302     */
303    if (c & 0x80)
304    {
305       if (buf_copy(src, dst, (size_t) 3 * (1 << ((c & 0x07) + 1))))
306       {
307          return 1;
308       }           
309    }
310    if (buf_copy(src, dst, 1)) return 1;
311
312    /*
313     * Copy the image chunk by chunk.
314     */
315    while((c = buf_getbyte(src, 0)) != '\0')
316    {
317       if (buf_copy(src, dst, 1 + (size_t) c)) return 1;
318    }
319    if (buf_copy(src, dst, 1)) return 1;
320
321    /*
322     * Trim and rewind the dst buffer
323     */
324    if (NULL == (dst->buffer = (char *)realloc(dst->buffer, dst->offset))) return 1;
325    dst->size = dst->offset;
326    dst->offset = 0;
327
328    return(0);
329
330 }
331
332 /*********************************************************************
333  * 
334  * Function    :  gif_deanimate
335  *
336  * Description :  Deanimate a given GIF image, i.e. given a GIF with
337  *                an (optional) image block and an arbitrary number
338  *                of image extension blocks, produce an output GIF with
339  *                only one image block that contains the last image
340  *                (extenstion) block of the original.
341  *                Also strip Comments, Application extenstions, etc.
342  *
343  * Parameters  :
344  *          1  :  src = Pointer to the source binbuffer
345  *          2  :  dst = Pointer to the destination binbuffer
346  *          3  :  get_first_image = Flag: If set, get the first image
347  *                                        If unset (default), get the last
348  *
349  * Returns     :  0 on success, or 1 on failiure
350  *
351  *********************************************************************/
352 int gif_deanimate(struct binbuffer *src, struct binbuffer *dst, int get_first_image)
353 {
354    unsigned char c;
355    struct binbuffer *image;
356
357    if (NULL == src || NULL == dst)
358    {
359       return 1;
360    }
361
362    c = buf_getbyte(src, 10);
363
364    /*
365     * Check & copy GIF header 
366     */
367    if (strncmp(src->buffer, "GIF89a", 6) && strncmp(src->buffer, "GIF87a", 6)) 
368    {
369       return 1;
370    }
371    else
372    {
373       if (buf_copy(src, dst, 13))
374       {
375          return 1;
376       }
377    }
378
379    /*
380     * Look for global colormap and  copy if found.
381     */
382    if(c & 0x80)
383    {
384       if (buf_copy(src, dst, (size_t) 3 * (1 << ((c & 0x07) + 1))))
385       {
386          return 1;
387       }
388    }
389
390    /*
391     * Reserve a buffer for the current image block
392     */
393    if (NULL == (image = (struct binbuffer *)zalloc(sizeof(*image))))
394    {
395       return 1;
396    }
397
398    /*
399     * Parse the GIF block by block and copy the relevant
400     * parts to dst
401     */
402    while(src->offset < src->size)
403    {
404       switch(buf_getbyte(src, 0))
405       {
406          /*
407           *  End-of-GIF Marker: Append current image and return
408           */
409       case 0x3b:
410          goto write;
411
412          /* 
413           * Image block: Extract to current image buffer.
414           */
415       case 0x2c:
416          image->offset = 0;
417          if (gif_extract_image(src, image)) goto failed;
418          if (get_first_image) goto write;
419          continue;
420
421          /*
422           * Extension block: Look at next byte and decide
423           */
424       case 0x21:
425          switch (buf_getbyte(src, 1))
426          {
427             /*
428              * Image extension: Copy extension  header and image
429              *                  to the current image buffer
430              */
431          case 0xf9:
432             image->offset = 0;
433             if (buf_copy(src, image, 8) || buf_getbyte(src, 0) != 0x2c) goto failed;
434             if (gif_extract_image(src, image)) goto failed;
435             if (get_first_image) goto write;
436             continue;
437
438             /*
439              * Application extension: Skip
440              */
441          case 0xff:
442             if ((src->offset += 14) >= src->size || gif_skip_data_block(src)) goto failed;
443             continue;
444
445             /*
446              * Comment extension: Skip
447              */
448          case 0xfe:
449             if ((src->offset += 2) >= src->size || gif_skip_data_block(src)) goto failed;
450             continue;
451
452             /*
453              * Plain text extension: Skip
454              */
455          case 0x01:
456             if ((src->offset += 15) >= src->size || gif_skip_data_block(src)) goto failed;
457             continue;
458
459             /*
460              * Ooops, what type of extension is that?
461              */
462          default:
463             goto failed;
464
465          }
466
467          /*
468           * Ooops, what type of block is that?
469           */
470       default:
471          goto failed;
472          
473       }
474    } /* -END- while src */
475
476    /*
477     * Either we got here by goto, or because the GIF is
478     * bogus and EOF was reached before an end-of-gif marker 
479     * was found.
480     */
481
482 failed:
483    buf_free(image);
484    return 1;
485
486    /*
487     * Append the current image to dst and return
488     */
489
490 write:
491    if (buf_copy(image, dst, image->size)) goto failed;
492    if (buf_extend(dst, 1)) goto failed;
493    *(dst->buffer + dst->offset++) = 0x3b;
494    buf_free(image);
495    return 0;
496
497 }
498
499
500 /*
501   Local Variables:
502   tab-width: 3
503   end:
504 */