Change license headers to say 'FFmpeg' instead of 'this program/this library'
[ffmpeg.git] / libavcodec / flicvideo.c
1 /*
2  * FLI/FLC Animation Video Decoder
3  * Copyright (C) 2003, 2004 the ffmpeg project
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  *
21  */
22
23 /**
24  * @file flic.c
25  * Autodesk Animator FLI/FLC Video Decoder
26  * by Mike Melanson (melanson@pcisys.net)
27  * for more information on the .fli/.flc file format and all of its many
28  * variations, visit:
29  *   http://www.compuphase.com/flic.htm
30  *
31  * This decoder outputs PAL8/RGB555/RGB565 and maybe one day RGB24
32  * colorspace data, depending on the FLC. To use this decoder, be
33  * sure that your demuxer sends the FLI file header to the decoder via
34  * the extradata chunk in AVCodecContext. The chunk should be 128 bytes
35  * large. The only exception is for FLI files from the game "Magic Carpet",
36  * in which the header is only 12 bytes.
37  */
38
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <unistd.h>
43
44 #include "common.h"
45 #include "avcodec.h"
46 #include "bswap.h"
47
48 #define FLI_256_COLOR 4
49 #define FLI_DELTA     7
50 #define FLI_COLOR     11
51 #define FLI_LC        12
52 #define FLI_BLACK     13
53 #define FLI_BRUN      15
54 #define FLI_COPY      16
55 #define FLI_MINI      18
56 #define FLI_DTA_BRUN  25
57 #define FLI_DTA_COPY  26
58 #define FLI_DTA_LC    27
59
60 #define FLI_TYPE_CODE     (0xAF11)
61 #define FLC_FLX_TYPE_CODE (0xAF12)
62 #define FLC_DTA_TYPE_CODE (0xAF44) /* Marks an "Extended FLC" comes from Dave's Targa Animator (DTA) */
63 #define FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE (0xAF13)
64
65 #define CHECK_PIXEL_PTR(n) \
66     if (pixel_ptr + n > pixel_limit) { \
67         av_log (s->avctx, AV_LOG_INFO, "Problem: pixel_ptr >= pixel_limit (%d >= %d)\n", \
68         pixel_ptr + n, pixel_limit); \
69         return -1; \
70     } \
71
72 typedef struct FlicDecodeContext {
73     AVCodecContext *avctx;
74     AVFrame frame;
75
76     unsigned int palette[256];
77     int new_palette;
78     int fli_type;  /* either 0xAF11 or 0xAF12, affects palette resolution */
79 } FlicDecodeContext;
80
81 static int flic_decode_init(AVCodecContext *avctx)
82 {
83     FlicDecodeContext *s = (FlicDecodeContext *)avctx->priv_data;
84     unsigned char *fli_header = (unsigned char *)avctx->extradata;
85     int depth;
86
87     s->avctx = avctx;
88     avctx->has_b_frames = 0;
89
90     s->fli_type = LE_16(&fli_header[4]); /* Might be overridden if a Magic Carpet FLC */
91     depth       = LE_16(&fli_header[12]);
92
93     if (depth == 0) {
94       depth = 8; /* Some FLC generators set depth to zero, when they mean 8Bpp. Fix up here */
95     }
96
97     if (s->avctx->extradata_size == 12) {
98         /* special case for magic carpet FLIs */
99         s->fli_type = FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE;
100     } else if (s->avctx->extradata_size != 128) {
101         av_log(avctx, AV_LOG_ERROR, "Expected extradata of 12 or 128 bytes\n");
102         return -1;
103     }
104
105     if ((s->fli_type == FLC_FLX_TYPE_CODE) && (depth == 16)) {
106         depth = 15; /* Original Autodesk FLX's say the depth is 16Bpp when it is really 15Bpp */
107     }
108
109     switch (depth) {
110         case 8  : avctx->pix_fmt = PIX_FMT_PAL8; break;
111         case 15 : avctx->pix_fmt = PIX_FMT_RGB555; break;
112         case 16 : avctx->pix_fmt = PIX_FMT_RGB565; break;
113         case 24 : avctx->pix_fmt = PIX_FMT_BGR24; /* Supposedly BGR, but havent any files to test with */
114                   av_log(avctx, AV_LOG_ERROR, "24Bpp FLC/FLX is unsupported due to no test files.\n");
115                   return -1;
116                   break;
117         default :
118                   av_log(avctx, AV_LOG_ERROR, "Unkown FLC/FLX depth of %d Bpp is unsupported.\n",depth);
119                   return -1;
120     }
121
122     s->frame.data[0] = NULL;
123     s->new_palette = 0;
124
125     return 0;
126 }
127
128 static int flic_decode_frame_8BPP(AVCodecContext *avctx,
129                                   void *data, int *data_size,
130                                   uint8_t *buf, int buf_size)
131 {
132     FlicDecodeContext *s = (FlicDecodeContext *)avctx->priv_data;
133
134     int stream_ptr = 0;
135     int stream_ptr_after_color_chunk;
136     int pixel_ptr;
137     int palette_ptr;
138     unsigned char palette_idx1;
139     unsigned char palette_idx2;
140
141     unsigned int frame_size;
142     int num_chunks;
143
144     unsigned int chunk_size;
145     int chunk_type;
146
147     int i, j;
148
149     int color_packets;
150     int color_changes;
151     int color_shift;
152     unsigned char r, g, b;
153
154     int lines;
155     int compressed_lines;
156     int starting_line;
157     signed short line_packets;
158     int y_ptr;
159     signed char byte_run;
160     int pixel_skip;
161     int pixel_countdown;
162     unsigned char *pixels;
163     int pixel_limit;
164
165     s->frame.reference = 1;
166     s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
167     if (avctx->reget_buffer(avctx, &s->frame) < 0) {
168         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
169         return -1;
170     }
171
172     pixels = s->frame.data[0];
173     pixel_limit = s->avctx->height * s->frame.linesize[0];
174
175     frame_size = LE_32(&buf[stream_ptr]);
176     stream_ptr += 6;  /* skip the magic number */
177     num_chunks = LE_16(&buf[stream_ptr]);
178     stream_ptr += 10;  /* skip padding */
179
180     frame_size -= 16;
181
182     /* iterate through the chunks */
183     while ((frame_size > 0) && (num_chunks > 0)) {
184         chunk_size = LE_32(&buf[stream_ptr]);
185         stream_ptr += 4;
186         chunk_type = LE_16(&buf[stream_ptr]);
187         stream_ptr += 2;
188
189         switch (chunk_type) {
190         case FLI_256_COLOR:
191         case FLI_COLOR:
192             stream_ptr_after_color_chunk = stream_ptr + chunk_size - 6;
193             s->new_palette = 1;
194
195             /* check special case: If this file is from the Magic Carpet
196              * game and uses 6-bit colors even though it reports 256-color
197              * chunks in a 0xAF12-type file (fli_type is set to 0xAF13 during
198              * initialization) */
199             if ((chunk_type == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE))
200                 color_shift = 0;
201             else
202                 color_shift = 2;
203             /* set up the palette */
204             color_packets = LE_16(&buf[stream_ptr]);
205             stream_ptr += 2;
206             palette_ptr = 0;
207             for (i = 0; i < color_packets; i++) {
208                 /* first byte is how many colors to skip */
209                 palette_ptr += buf[stream_ptr++];
210
211                 /* next byte indicates how many entries to change */
212                 color_changes = buf[stream_ptr++];
213
214                 /* if there are 0 color changes, there are actually 256 */
215                 if (color_changes == 0)
216                     color_changes = 256;
217
218                 for (j = 0; j < color_changes; j++) {
219
220                     /* wrap around, for good measure */
221                     if ((unsigned)palette_ptr >= 256)
222                         palette_ptr = 0;
223
224                     r = buf[stream_ptr++] << color_shift;
225                     g = buf[stream_ptr++] << color_shift;
226                     b = buf[stream_ptr++] << color_shift;
227                     s->palette[palette_ptr++] = (r << 16) | (g << 8) | b;
228                 }
229             }
230
231             /* color chunks sometimes have weird 16-bit alignment issues;
232              * therefore, take the hardline approach and set the stream_ptr
233              * to the value calculated w.r.t. the size specified by the color
234              * chunk header */
235             stream_ptr = stream_ptr_after_color_chunk;
236
237             break;
238
239         case FLI_DELTA:
240             y_ptr = 0;
241             compressed_lines = LE_16(&buf[stream_ptr]);
242             stream_ptr += 2;
243             while (compressed_lines > 0) {
244                 line_packets = LE_16(&buf[stream_ptr]);
245                 stream_ptr += 2;
246                 if (line_packets < 0) {
247                     line_packets = -line_packets;
248                     y_ptr += line_packets * s->frame.linesize[0];
249                 } else {
250                     compressed_lines--;
251                     pixel_ptr = y_ptr;
252                     pixel_countdown = s->avctx->width;
253                     for (i = 0; i < line_packets; i++) {
254                         /* account for the skip bytes */
255                         pixel_skip = buf[stream_ptr++];
256                         pixel_ptr += pixel_skip;
257                         pixel_countdown -= pixel_skip;
258                         byte_run = buf[stream_ptr++];
259                         if (byte_run < 0) {
260                             byte_run = -byte_run;
261                             palette_idx1 = buf[stream_ptr++];
262                             palette_idx2 = buf[stream_ptr++];
263                             CHECK_PIXEL_PTR(byte_run);
264                             for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {
265                                 pixels[pixel_ptr++] = palette_idx1;
266                                 pixels[pixel_ptr++] = palette_idx2;
267                             }
268                         } else {
269                             CHECK_PIXEL_PTR(byte_run * 2);
270                             for (j = 0; j < byte_run * 2; j++, pixel_countdown--) {
271                                 palette_idx1 = buf[stream_ptr++];
272                                 pixels[pixel_ptr++] = palette_idx1;
273                             }
274                         }
275                     }
276
277                     y_ptr += s->frame.linesize[0];
278                 }
279             }
280             break;
281
282         case FLI_LC:
283             /* line compressed */
284             starting_line = LE_16(&buf[stream_ptr]);
285             stream_ptr += 2;
286             y_ptr = 0;
287             y_ptr += starting_line * s->frame.linesize[0];
288
289             compressed_lines = LE_16(&buf[stream_ptr]);
290             stream_ptr += 2;
291             while (compressed_lines > 0) {
292                 pixel_ptr = y_ptr;
293                 pixel_countdown = s->avctx->width;
294                 line_packets = buf[stream_ptr++];
295                 if (line_packets > 0) {
296                     for (i = 0; i < line_packets; i++) {
297                         /* account for the skip bytes */
298                         pixel_skip = buf[stream_ptr++];
299                         pixel_ptr += pixel_skip;
300                         pixel_countdown -= pixel_skip;
301                         byte_run = buf[stream_ptr++];
302                         if (byte_run > 0) {
303                             CHECK_PIXEL_PTR(byte_run);
304                             for (j = 0; j < byte_run; j++, pixel_countdown--) {
305                                 palette_idx1 = buf[stream_ptr++];
306                                 pixels[pixel_ptr++] = palette_idx1;
307                             }
308                         } else {
309                             byte_run = -byte_run;
310                             palette_idx1 = buf[stream_ptr++];
311                             CHECK_PIXEL_PTR(byte_run);
312                             for (j = 0; j < byte_run; j++, pixel_countdown--) {
313                                 pixels[pixel_ptr++] = palette_idx1;
314                             }
315                         }
316                     }
317                 }
318
319                 y_ptr += s->frame.linesize[0];
320                 compressed_lines--;
321             }
322             break;
323
324         case FLI_BLACK:
325             /* set the whole frame to color 0 (which is usually black) */
326             memset(pixels, 0,
327                 s->frame.linesize[0] * s->avctx->height);
328             break;
329
330         case FLI_BRUN:
331             /* Byte run compression: This chunk type only occurs in the first
332              * FLI frame and it will update the entire frame. */
333             y_ptr = 0;
334             for (lines = 0; lines < s->avctx->height; lines++) {
335                 pixel_ptr = y_ptr;
336                 /* disregard the line packets; instead, iterate through all
337                  * pixels on a row */
338                 stream_ptr++;
339                 pixel_countdown = s->avctx->width;
340                 while (pixel_countdown > 0) {
341                     byte_run = buf[stream_ptr++];
342                     if (byte_run > 0) {
343                         palette_idx1 = buf[stream_ptr++];
344                         CHECK_PIXEL_PTR(byte_run);
345                         for (j = 0; j < byte_run; j++) {
346                             pixels[pixel_ptr++] = palette_idx1;
347                             pixel_countdown--;
348                             if (pixel_countdown < 0)
349                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
350                                        pixel_countdown);
351                         }
352                     } else {  /* copy bytes if byte_run < 0 */
353                         byte_run = -byte_run;
354                         CHECK_PIXEL_PTR(byte_run);
355                         for (j = 0; j < byte_run; j++) {
356                             palette_idx1 = buf[stream_ptr++];
357                             pixels[pixel_ptr++] = palette_idx1;
358                             pixel_countdown--;
359                             if (pixel_countdown < 0)
360                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
361                                        pixel_countdown);
362                         }
363                     }
364                 }
365
366                 y_ptr += s->frame.linesize[0];
367             }
368             break;
369
370         case FLI_COPY:
371             /* copy the chunk (uncompressed frame) */
372             if (chunk_size - 6 > s->avctx->width * s->avctx->height) {
373                 av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
374                        "bigger than image, skipping chunk\n", chunk_size - 6);
375                 stream_ptr += chunk_size - 6;
376             } else {
377                 for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height;
378                      y_ptr += s->frame.linesize[0]) {
379                     memcpy(&pixels[y_ptr], &buf[stream_ptr],
380                         s->avctx->width);
381                     stream_ptr += s->avctx->width;
382                 }
383             }
384             break;
385
386         case FLI_MINI:
387             /* some sort of a thumbnail? disregard this chunk... */
388             stream_ptr += chunk_size - 6;
389             break;
390
391         default:
392             av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
393             break;
394         }
395
396         frame_size -= chunk_size;
397         num_chunks--;
398     }
399
400     /* by the end of the chunk, the stream ptr should equal the frame
401      * size (minus 1, possibly); if it doesn't, issue a warning */
402     if ((stream_ptr != buf_size) && (stream_ptr != buf_size - 1))
403         av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
404                "and final chunk ptr = %d\n", buf_size, stream_ptr);
405
406     /* make the palette available on the way out */
407 //    if (s->new_palette) {
408     if (1) {
409         memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE);
410         s->frame.palette_has_changed = 1;
411         s->new_palette = 0;
412     }
413
414     *data_size=sizeof(AVFrame);
415     *(AVFrame*)data = s->frame;
416
417     return buf_size;
418 }
419
420 static int flic_decode_frame_15_16BPP(AVCodecContext *avctx,
421                                       void *data, int *data_size,
422                                       uint8_t *buf, int buf_size)
423 {
424     /* Note, the only difference between the 15Bpp and 16Bpp */
425     /* Format is the pixel format, the packets are processed the same. */
426     FlicDecodeContext *s = (FlicDecodeContext *)avctx->priv_data;
427
428     int stream_ptr = 0;
429     int pixel_ptr;
430     unsigned char palette_idx1;
431
432     unsigned int frame_size;
433     int num_chunks;
434
435     unsigned int chunk_size;
436     int chunk_type;
437
438     int i, j;
439
440     int lines;
441     int compressed_lines;
442     signed short line_packets;
443     int y_ptr;
444     signed char byte_run;
445     int pixel_skip;
446     int pixel_countdown;
447     unsigned char *pixels;
448     int pixel;
449     int pixel_limit;
450
451     s->frame.reference = 1;
452     s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
453     if (avctx->reget_buffer(avctx, &s->frame) < 0) {
454         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
455         return -1;
456     }
457
458     pixels = s->frame.data[0];
459     pixel_limit = s->avctx->height * s->frame.linesize[0];
460
461     frame_size = LE_32(&buf[stream_ptr]);
462     stream_ptr += 6;  /* skip the magic number */
463     num_chunks = LE_16(&buf[stream_ptr]);
464     stream_ptr += 10;  /* skip padding */
465
466     frame_size -= 16;
467
468     /* iterate through the chunks */
469     while ((frame_size > 0) && (num_chunks > 0)) {
470         chunk_size = LE_32(&buf[stream_ptr]);
471         stream_ptr += 4;
472         chunk_type = LE_16(&buf[stream_ptr]);
473         stream_ptr += 2;
474
475         switch (chunk_type) {
476         case FLI_256_COLOR:
477         case FLI_COLOR:
478             /* For some reason, it seems that non-paletised flics do include one of these */
479             /* chunks in their first frame.  Why i do not know, it seems rather extraneous */
480 /*            av_log(avctx, AV_LOG_ERROR, "Unexpected Palette chunk %d in non-paletised FLC\n",chunk_type);*/
481             stream_ptr = stream_ptr + chunk_size - 6;
482             break;
483
484         case FLI_DELTA:
485         case FLI_DTA_LC:
486             y_ptr = 0;
487             compressed_lines = LE_16(&buf[stream_ptr]);
488             stream_ptr += 2;
489             while (compressed_lines > 0) {
490                 line_packets = LE_16(&buf[stream_ptr]);
491                 stream_ptr += 2;
492                 if (line_packets < 0) {
493                     line_packets = -line_packets;
494                     y_ptr += line_packets * s->frame.linesize[0];
495                 } else {
496                     compressed_lines--;
497                     pixel_ptr = y_ptr;
498                     pixel_countdown = s->avctx->width;
499                     for (i = 0; i < line_packets; i++) {
500                         /* account for the skip bytes */
501                         pixel_skip = buf[stream_ptr++];
502                         pixel_ptr += (pixel_skip*2); /* Pixel is 2 bytes wide */
503                         pixel_countdown -= pixel_skip;
504                         byte_run = buf[stream_ptr++];
505                         if (byte_run < 0) {
506                             byte_run = -byte_run;
507                             pixel    = LE_16(&buf[stream_ptr]);
508                             stream_ptr += 2;
509                             CHECK_PIXEL_PTR(byte_run);
510                             for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {
511                                 *((signed short*)(&pixels[pixel_ptr])) = pixel;
512                                 pixel_ptr += 2;
513                             }
514                         } else {
515                             CHECK_PIXEL_PTR(byte_run);
516                             for (j = 0; j < byte_run; j++, pixel_countdown--) {
517                                 *((signed short*)(&pixels[pixel_ptr])) = LE_16(&buf[stream_ptr]);
518                                 stream_ptr += 2;
519                                 pixel_ptr += 2;
520                             }
521                         }
522                     }
523
524                     y_ptr += s->frame.linesize[0];
525                 }
526             }
527             break;
528
529         case FLI_LC:
530             av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-paletised FLC\n");
531             stream_ptr = stream_ptr + chunk_size - 6;
532             break;
533
534         case FLI_BLACK:
535             /* set the whole frame to 0x0000 which is balck in both 15Bpp and 16Bpp modes. */
536             memset(pixels, 0x0000,
537                    s->frame.linesize[0] * s->avctx->height * 2);
538             break;
539
540         case FLI_BRUN:
541             y_ptr = 0;
542             for (lines = 0; lines < s->avctx->height; lines++) {
543                 pixel_ptr = y_ptr;
544                 /* disregard the line packets; instead, iterate through all
545                  * pixels on a row */
546                 stream_ptr++;
547                 pixel_countdown = (s->avctx->width * 2);
548
549                 while (pixel_countdown > 0) {
550                     byte_run = buf[stream_ptr++];
551                     if (byte_run > 0) {
552                         palette_idx1 = buf[stream_ptr++];
553                         CHECK_PIXEL_PTR(byte_run);
554                         for (j = 0; j < byte_run; j++) {
555                             pixels[pixel_ptr++] = palette_idx1;
556                             pixel_countdown--;
557                             if (pixel_countdown < 0)
558                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
559                                        pixel_countdown);
560                         }
561                     } else {  /* copy bytes if byte_run < 0 */
562                         byte_run = -byte_run;
563                         CHECK_PIXEL_PTR(byte_run);
564                         for (j = 0; j < byte_run; j++) {
565                             palette_idx1 = buf[stream_ptr++];
566                             pixels[pixel_ptr++] = palette_idx1;
567                             pixel_countdown--;
568                             if (pixel_countdown < 0)
569                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
570                                        pixel_countdown);
571                         }
572                     }
573                 }
574
575                 /* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed.
576                  * This doesnt give us any good oportunity to perform word endian conversion
577                  * during decompression. So if its requried (ie, this isnt a LE target, we do
578                  * a second pass over the line here, swapping the bytes.
579                  */
580                 pixel = 0xFF00;
581                 if (0xFF00 != LE_16(&pixel)) /* Check if its not an LE Target */
582                 {
583                   pixel_ptr = y_ptr;
584                   pixel_countdown = s->avctx->width;
585                   while (pixel_countdown > 0) {
586                     *((signed short*)(&pixels[pixel_ptr])) = LE_16(&buf[pixel_ptr]);
587                     pixel_ptr += 2;
588                   }
589                 }
590                 y_ptr += s->frame.linesize[0];
591             }
592             break;
593
594         case FLI_DTA_BRUN:
595             y_ptr = 0;
596             for (lines = 0; lines < s->avctx->height; lines++) {
597                 pixel_ptr = y_ptr;
598                 /* disregard the line packets; instead, iterate through all
599                  * pixels on a row */
600                 stream_ptr++;
601                 pixel_countdown = s->avctx->width; /* Width is in pixels, not bytes */
602
603                 while (pixel_countdown > 0) {
604                     byte_run = buf[stream_ptr++];
605                     if (byte_run > 0) {
606                         pixel    = LE_16(&buf[stream_ptr]);
607                         stream_ptr += 2;
608                         CHECK_PIXEL_PTR(byte_run);
609                         for (j = 0; j < byte_run; j++) {
610                             *((signed short*)(&pixels[pixel_ptr])) = pixel;
611                             pixel_ptr += 2;
612                             pixel_countdown--;
613                             if (pixel_countdown < 0)
614                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
615                                        pixel_countdown);
616                         }
617                     } else {  /* copy pixels if byte_run < 0 */
618                         byte_run = -byte_run;
619                         CHECK_PIXEL_PTR(byte_run);
620                         for (j = 0; j < byte_run; j++) {
621                             *((signed short*)(&pixels[pixel_ptr])) = LE_16(&buf[stream_ptr]);
622                             stream_ptr += 2;
623                             pixel_ptr  += 2;
624                             pixel_countdown--;
625                             if (pixel_countdown < 0)
626                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
627                                        pixel_countdown);
628                         }
629                     }
630                 }
631
632                 y_ptr += s->frame.linesize[0];
633             }
634             break;
635
636         case FLI_COPY:
637         case FLI_DTA_COPY:
638             /* copy the chunk (uncompressed frame) */
639             if (chunk_size - 6 > (unsigned int)(s->avctx->width * s->avctx->height)*2) {
640                 av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
641                        "bigger than image, skipping chunk\n", chunk_size - 6);
642                 stream_ptr += chunk_size - 6;
643             } else {
644
645                 for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height;
646                      y_ptr += s->frame.linesize[0]) {
647
648                     pixel_countdown = s->avctx->width;
649                     pixel_ptr = 0;
650                     while (pixel_countdown > 0) {
651                       *((signed short*)(&pixels[y_ptr + pixel_ptr])) = LE_16(&buf[stream_ptr+pixel_ptr]);
652                       pixel_ptr += 2;
653                       pixel_countdown--;
654                     }
655                     stream_ptr += s->avctx->width*2;
656                 }
657             }
658             break;
659
660         case FLI_MINI:
661             /* some sort of a thumbnail? disregard this chunk... */
662             stream_ptr += chunk_size - 6;
663             break;
664
665         default:
666             av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
667             break;
668         }
669
670         frame_size -= chunk_size;
671         num_chunks--;
672     }
673
674     /* by the end of the chunk, the stream ptr should equal the frame
675      * size (minus 1, possibly); if it doesn't, issue a warning */
676     if ((stream_ptr != buf_size) && (stream_ptr != buf_size - 1))
677         av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
678                "and final chunk ptr = %d\n", buf_size, stream_ptr);
679
680
681     *data_size=sizeof(AVFrame);
682     *(AVFrame*)data = s->frame;
683
684     return buf_size;
685 }
686
687 static int flic_decode_frame_24BPP(AVCodecContext *avctx,
688                                    void *data, int *data_size,
689                                    uint8_t *buf, int buf_size)
690 {
691   av_log(avctx, AV_LOG_ERROR, "24Bpp FLC Unsupported due to lack of test files.\n");
692   return -1;
693 }
694
695 static int flic_decode_frame(AVCodecContext *avctx,
696                              void *data, int *data_size,
697                              uint8_t *buf, int buf_size)
698 {
699     if (avctx->pix_fmt == PIX_FMT_PAL8) {
700       return flic_decode_frame_8BPP(avctx, data, data_size,
701                                     buf, buf_size);
702     }
703     else if ((avctx->pix_fmt == PIX_FMT_RGB555) ||
704              (avctx->pix_fmt == PIX_FMT_RGB565)) {
705       return flic_decode_frame_15_16BPP(avctx, data, data_size,
706                                         buf, buf_size);
707     }
708     else if (avctx->pix_fmt == PIX_FMT_BGR24) {
709       return flic_decode_frame_24BPP(avctx, data, data_size,
710                                      buf, buf_size);
711     }
712
713     /* Shouldnt get  here, ever as the pix_fmt is processed */
714     /* in flic_decode_init and the above if should deal with */
715     /* the finite set of possibilites allowable by here. */
716     /* but in case we do, just error out. */
717     av_log(avctx, AV_LOG_ERROR, "Unknown Format of FLC. My Science cant explain how this happened\n");
718     return -1;
719 }
720
721
722 static int flic_decode_end(AVCodecContext *avctx)
723 {
724     FlicDecodeContext *s = avctx->priv_data;
725
726     if (s->frame.data[0])
727         avctx->release_buffer(avctx, &s->frame);
728
729     return 0;
730 }
731
732 AVCodec flic_decoder = {
733     "flic",
734     CODEC_TYPE_VIDEO,
735     CODEC_ID_FLIC,
736     sizeof(FlicDecodeContext),
737     flic_decode_init,
738     NULL,
739     flic_decode_end,
740     flic_decode_frame,
741     CODEC_CAP_DR1,
742     NULL,
743     NULL,
744     NULL,
745     NULL
746 };