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