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