flicvideo.c 28 KB
Newer Older
Mike Melanson's avatar
Mike Melanson committed
1 2
/*
 * FLI/FLC Animation Video Decoder
3
 * Copyright (C) 2003, 2004 the ffmpeg project
Mike Melanson's avatar
Mike Melanson committed
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
Mike Melanson's avatar
Mike Melanson committed
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
Mike Melanson's avatar
Mike Melanson committed
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
Mike Melanson's avatar
Mike Melanson committed
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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
Mike Melanson's avatar
Mike Melanson committed
20 21 22 23 24 25 26 27 28 29 30
 *
 */

/**
 * @file flic.c
 * Autodesk Animator FLI/FLC Video Decoder
 * by Mike Melanson (melanson@pcisys.net)
 * for more information on the .fli/.flc file format and all of its many
 * variations, visit:
 *   http://www.compuphase.com/flic.htm
 *
31 32
 * This decoder outputs PAL8/RGB555/RGB565 and maybe one day RGB24
 * colorspace data, depending on the FLC. To use this decoder, be
Mike Melanson's avatar
Mike Melanson committed
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
 * sure that your demuxer sends the FLI file header to the decoder via
 * the extradata chunk in AVCodecContext. The chunk should be 128 bytes
 * large. The only exception is for FLI files from the game "Magic Carpet",
 * in which the header is only 12 bytes.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "avcodec.h"
#include "bswap.h"

#define FLI_256_COLOR 4
#define FLI_DELTA     7
#define FLI_COLOR     11
#define FLI_LC        12
#define FLI_BLACK     13
#define FLI_BRUN      15
#define FLI_COPY      16
#define FLI_MINI      18
55 56 57 58 59 60 61 62
#define FLI_DTA_BRUN  25
#define FLI_DTA_COPY  26
#define FLI_DTA_LC    27

#define FLI_TYPE_CODE     (0xAF11)
#define FLC_FLX_TYPE_CODE (0xAF12)
#define FLC_DTA_TYPE_CODE (0xAF44) /* Marks an "Extended FLC" comes from Dave's Targa Animator (DTA) */
#define FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE (0xAF13)
Mike Melanson's avatar
Mike Melanson committed
63

64 65 66 67 68 69 70
#define CHECK_PIXEL_PTR(n) \
    if (pixel_ptr + n > pixel_limit) { \
        av_log (s->avctx, AV_LOG_INFO, "Problem: pixel_ptr >= pixel_limit (%d >= %d)\n", \
        pixel_ptr + n, pixel_limit); \
        return -1; \
    } \

Mike Melanson's avatar
Mike Melanson committed
71 72 73 74 75 76 77 78 79 80 81
typedef struct FlicDecodeContext {
    AVCodecContext *avctx;
    AVFrame frame;

    unsigned int palette[256];
    int new_palette;
    int fli_type;  /* either 0xAF11 or 0xAF12, affects palette resolution */
} FlicDecodeContext;

static int flic_decode_init(AVCodecContext *avctx)
{
82
    FlicDecodeContext *s = avctx->priv_data;
Mike Melanson's avatar
Mike Melanson committed
83
    unsigned char *fli_header = (unsigned char *)avctx->extradata;
84
    int depth;
Mike Melanson's avatar
Mike Melanson committed
85 86 87

    s->avctx = avctx;

88 89
    s->fli_type = AV_RL16(&fli_header[4]); /* Might be overridden if a Magic Carpet FLC */
    depth       = AV_RL16(&fli_header[12]);
90

91 92 93 94
    if (depth == 0) {
      depth = 8; /* Some FLC generators set depth to zero, when they mean 8Bpp. Fix up here */
    }

Mike Melanson's avatar
Mike Melanson committed
95 96
    if (s->avctx->extradata_size == 12) {
        /* special case for magic carpet FLIs */
97 98
        s->fli_type = FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE;
    } else if (s->avctx->extradata_size != 128) {
99
        av_log(avctx, AV_LOG_ERROR, "Expected extradata of 12 or 128 bytes\n");
Mike Melanson's avatar
Mike Melanson committed
100 101 102
        return -1;
    }

103 104 105 106 107 108 109 110 111 112 113 114 115
    if ((s->fli_type == FLC_FLX_TYPE_CODE) && (depth == 16)) {
        depth = 15; /* Original Autodesk FLX's say the depth is 16Bpp when it is really 15Bpp */
    }

    switch (depth) {
        case 8  : avctx->pix_fmt = PIX_FMT_PAL8; break;
        case 15 : avctx->pix_fmt = PIX_FMT_RGB555; break;
        case 16 : avctx->pix_fmt = PIX_FMT_RGB565; break;
        case 24 : avctx->pix_fmt = PIX_FMT_BGR24; /* Supposedly BGR, but havent any files to test with */
                  av_log(avctx, AV_LOG_ERROR, "24Bpp FLC/FLX is unsupported due to no test files.\n");
                  return -1;
                  break;
        default :
Alex Beregszaszi's avatar
Alex Beregszaszi committed
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;
Mike Melanson's avatar
Mike Melanson committed
121 122 123 124 125
    s->new_palette = 0;

    return 0;
}

126 127 128
static int flic_decode_frame_8BPP(AVCodecContext *avctx,
                                  void *data, int *data_size,
                                  uint8_t *buf, int buf_size)
Mike Melanson's avatar
Mike Melanson committed
129
{
130
    FlicDecodeContext *s = avctx->priv_data;
Mike Melanson's avatar
Mike Melanson committed
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156

    int stream_ptr = 0;
    int stream_ptr_after_color_chunk;
    int pixel_ptr;
    int palette_ptr;
    unsigned char palette_idx1;
    unsigned char palette_idx2;

    unsigned int frame_size;
    int num_chunks;

    unsigned int chunk_size;
    int chunk_type;

    int i, j;

    int color_packets;
    int color_changes;
    int color_shift;
    unsigned char r, g, b;

    int lines;
    int compressed_lines;
    int starting_line;
    signed short line_packets;
    int y_ptr;
157
    int byte_run;
Mike Melanson's avatar
Mike Melanson committed
158 159 160
    int pixel_skip;
    int pixel_countdown;
    unsigned char *pixels;
161
    int pixel_limit;
162

Mike Melanson's avatar
Mike Melanson committed
163
    s->frame.reference = 1;
164 165 166
    s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
    if (avctx->reget_buffer(avctx, &s->frame) < 0) {
        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
Mike Melanson's avatar
Mike Melanson committed
167 168 169 170
        return -1;
    }

    pixels = s->frame.data[0];
171
    pixel_limit = s->avctx->height * s->frame.linesize[0];
Mike Melanson's avatar
Mike Melanson committed
172

173
    frame_size = AV_RL32(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
174
    stream_ptr += 6;  /* skip the magic number */
175
    num_chunks = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
176 177 178 179 180 181
    stream_ptr += 10;  /* skip padding */

    frame_size -= 16;

    /* iterate through the chunks */
    while ((frame_size > 0) && (num_chunks > 0)) {
182
        chunk_size = AV_RL32(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
183
        stream_ptr += 4;
184
        chunk_type = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
185 186 187 188 189 190 191
        stream_ptr += 2;

        switch (chunk_type) {
        case FLI_256_COLOR:
        case FLI_COLOR:
            stream_ptr_after_color_chunk = stream_ptr + chunk_size - 6;

192 193
            /* check special case: If this file is from the Magic Carpet
             * game and uses 6-bit colors even though it reports 256-color
Mike Melanson's avatar
Mike Melanson committed
194 195
             * chunks in a 0xAF12-type file (fli_type is set to 0xAF13 during
             * initialization) */
196
            if ((chunk_type == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE))
Mike Melanson's avatar
Mike Melanson committed
197 198 199 200
                color_shift = 0;
            else
                color_shift = 2;
            /* set up the palette */
201
            color_packets = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
202 203 204 205 206 207 208 209 210 211 212 213 214 215
            stream_ptr += 2;
            palette_ptr = 0;
            for (i = 0; i < color_packets; i++) {
                /* first byte is how many colors to skip */
                palette_ptr += buf[stream_ptr++];

                /* next byte indicates how many entries to change */
                color_changes = buf[stream_ptr++];

                /* if there are 0 color changes, there are actually 256 */
                if (color_changes == 0)
                    color_changes = 256;

                for (j = 0; j < color_changes; j++) {
216
                    unsigned int entry;
Mike Melanson's avatar
Mike Melanson committed
217 218

                    /* wrap around, for good measure */
219
                    if ((unsigned)palette_ptr >= 256)
Mike Melanson's avatar
Mike Melanson committed
220 221 222 223 224
                        palette_ptr = 0;

                    r = buf[stream_ptr++] << color_shift;
                    g = buf[stream_ptr++] << color_shift;
                    b = buf[stream_ptr++] << color_shift;
225 226 227 228
                    entry = (r << 16) | (g << 8) | b;
                    if (s->palette[palette_ptr] != entry)
                        s->new_palette = 1;
                    s->palette[palette_ptr++] = entry;
Mike Melanson's avatar
Mike Melanson committed
229 230 231 232 233 234 235 236 237 238 239 240 241
                }
            }

            /* color chunks sometimes have weird 16-bit alignment issues;
             * therefore, take the hardline approach and set the stream_ptr
             * to the value calculated w.r.t. the size specified by the color
             * chunk header */
            stream_ptr = stream_ptr_after_color_chunk;

            break;

        case FLI_DELTA:
            y_ptr = 0;
242
            compressed_lines = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
243 244
            stream_ptr += 2;
            while (compressed_lines > 0) {
245
                line_packets = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
246
                stream_ptr += 2;
247 248
                if ((line_packets & 0xC000) == 0xC000) {
                    // line skip opcode
Mike Melanson's avatar
Mike Melanson committed
249
                    line_packets = -line_packets;
250
                    y_ptr += line_packets * s->frame.linesize[0];
251 252 253 254 255
                } else if ((line_packets & 0xC000) == 0x4000) {
                    av_log(avctx, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", line_packets);
                } else if ((line_packets & 0xC000) == 0x8000) {
                    // "last byte" opcode
                    pixels[y_ptr + s->frame.linesize[0] - 1] = line_packets & 0xff;
Mike Melanson's avatar
Mike Melanson committed
256 257 258 259 260 261 262 263 264
                } else {
                    compressed_lines--;
                    pixel_ptr = y_ptr;
                    pixel_countdown = s->avctx->width;
                    for (i = 0; i < line_packets; i++) {
                        /* account for the skip bytes */
                        pixel_skip = buf[stream_ptr++];
                        pixel_ptr += pixel_skip;
                        pixel_countdown -= pixel_skip;
265
                        byte_run = (signed char)(buf[stream_ptr++]);
Mike Melanson's avatar
Mike Melanson committed
266 267 268 269
                        if (byte_run < 0) {
                            byte_run = -byte_run;
                            palette_idx1 = buf[stream_ptr++];
                            palette_idx2 = buf[stream_ptr++];
270
                            CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
271 272 273 274 275
                            for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {
                                pixels[pixel_ptr++] = palette_idx1;
                                pixels[pixel_ptr++] = palette_idx2;
                            }
                        } else {
276
                            CHECK_PIXEL_PTR(byte_run * 2);
Mike Melanson's avatar
Mike Melanson committed
277 278 279 280 281 282 283 284 285 286 287 288 289 290
                            for (j = 0; j < byte_run * 2; j++, pixel_countdown--) {
                                palette_idx1 = buf[stream_ptr++];
                                pixels[pixel_ptr++] = palette_idx1;
                            }
                        }
                    }

                    y_ptr += s->frame.linesize[0];
                }
            }
            break;

        case FLI_LC:
            /* line compressed */
291
            starting_line = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
292 293
            stream_ptr += 2;
            y_ptr = 0;
294
            y_ptr += starting_line * s->frame.linesize[0];
Mike Melanson's avatar
Mike Melanson committed
295

296
            compressed_lines = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
297 298 299 300 301 302 303 304 305 306 307
            stream_ptr += 2;
            while (compressed_lines > 0) {
                pixel_ptr = y_ptr;
                pixel_countdown = s->avctx->width;
                line_packets = buf[stream_ptr++];
                if (line_packets > 0) {
                    for (i = 0; i < line_packets; i++) {
                        /* account for the skip bytes */
                        pixel_skip = buf[stream_ptr++];
                        pixel_ptr += pixel_skip;
                        pixel_countdown -= pixel_skip;
308
                        byte_run = (signed char)(buf[stream_ptr++]);
Mike Melanson's avatar
Mike Melanson committed
309
                        if (byte_run > 0) {
310
                            CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
311 312 313 314
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
                                palette_idx1 = buf[stream_ptr++];
                                pixels[pixel_ptr++] = palette_idx1;
                            }
315
                        } else if (byte_run < 0) {
Mike Melanson's avatar
Mike Melanson committed
316 317
                            byte_run = -byte_run;
                            palette_idx1 = buf[stream_ptr++];
318
                            CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
                                pixels[pixel_ptr++] = palette_idx1;
                            }
                        }
                    }
                }

                y_ptr += s->frame.linesize[0];
                compressed_lines--;
            }
            break;

        case FLI_BLACK:
            /* set the whole frame to color 0 (which is usually black) */
            memset(pixels, 0,
                s->frame.linesize[0] * s->avctx->height);
            break;

        case FLI_BRUN:
            /* Byte run compression: This chunk type only occurs in the first
             * FLI frame and it will update the entire frame. */
            y_ptr = 0;
            for (lines = 0; lines < s->avctx->height; lines++) {
                pixel_ptr = y_ptr;
                /* disregard the line packets; instead, iterate through all
                 * pixels on a row */
                stream_ptr++;
                pixel_countdown = s->avctx->width;
                while (pixel_countdown > 0) {
348
                    byte_run = (signed char)(buf[stream_ptr++]);
Mike Melanson's avatar
Mike Melanson committed
349 350
                    if (byte_run > 0) {
                        palette_idx1 = buf[stream_ptr++];
351
                        CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
352 353 354 355
                        for (j = 0; j < byte_run; j++) {
                            pixels[pixel_ptr++] = palette_idx1;
                            pixel_countdown--;
                            if (pixel_countdown < 0)
356 357
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
Mike Melanson's avatar
Mike Melanson committed
358 359 360
                        }
                    } else {  /* copy bytes if byte_run < 0 */
                        byte_run = -byte_run;
361
                        CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
362 363 364 365 366
                        for (j = 0; j < byte_run; j++) {
                            palette_idx1 = buf[stream_ptr++];
                            pixels[pixel_ptr++] = palette_idx1;
                            pixel_countdown--;
                            if (pixel_countdown < 0)
367 368
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
Mike Melanson's avatar
Mike Melanson committed
369 370 371 372 373 374 375 376 377
                        }
                    }
                }

                y_ptr += s->frame.linesize[0];
            }
            break;

        case FLI_COPY:
378
            /* copy the chunk (uncompressed frame) */
Mike Melanson's avatar
Mike Melanson committed
379
            if (chunk_size - 6 > s->avctx->width * s->avctx->height) {
380 381
                av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
                       "bigger than image, skipping chunk\n", chunk_size - 6);
Mike Melanson's avatar
Mike Melanson committed
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
                stream_ptr += chunk_size - 6;
            } else {
                for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height;
                     y_ptr += s->frame.linesize[0]) {
                    memcpy(&pixels[y_ptr], &buf[stream_ptr],
                        s->avctx->width);
                    stream_ptr += s->avctx->width;
                }
            }
            break;

        case FLI_MINI:
            /* some sort of a thumbnail? disregard this chunk... */
            stream_ptr += chunk_size - 6;
            break;

        default:
399
            av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
Mike Melanson's avatar
Mike Melanson committed
400 401 402 403 404 405 406 407 408 409
            break;
        }

        frame_size -= chunk_size;
        num_chunks--;
    }

    /* by the end of the chunk, the stream ptr should equal the frame
     * size (minus 1, possibly); if it doesn't, issue a warning */
    if ((stream_ptr != buf_size) && (stream_ptr != buf_size - 1))
410 411
        av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
               "and final chunk ptr = %d\n", buf_size, stream_ptr);
Mike Melanson's avatar
Mike Melanson committed
412 413

    /* make the palette available on the way out */
414 415
    memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE);
    if (s->new_palette) {
Mike Melanson's avatar
Mike Melanson committed
416 417 418 419 420 421 422 423 424 425
        s->frame.palette_has_changed = 1;
        s->new_palette = 0;
    }

    *data_size=sizeof(AVFrame);
    *(AVFrame*)data = s->frame;

    return buf_size;
}

426
static int flic_decode_frame_15_16BPP(AVCodecContext *avctx,
427 428 429 430 431
                                      void *data, int *data_size,
                                      uint8_t *buf, int buf_size)
{
    /* Note, the only difference between the 15Bpp and 16Bpp */
    /* Format is the pixel format, the packets are processed the same. */
432
    FlicDecodeContext *s = avctx->priv_data;
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449

    int stream_ptr = 0;
    int pixel_ptr;
    unsigned char palette_idx1;

    unsigned int frame_size;
    int num_chunks;

    unsigned int chunk_size;
    int chunk_type;

    int i, j;

    int lines;
    int compressed_lines;
    signed short line_packets;
    int y_ptr;
450
    int byte_run;
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
    int pixel_skip;
    int pixel_countdown;
    unsigned char *pixels;
    int pixel;
    int pixel_limit;

    s->frame.reference = 1;
    s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
    if (avctx->reget_buffer(avctx, &s->frame) < 0) {
        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
        return -1;
    }

    pixels = s->frame.data[0];
    pixel_limit = s->avctx->height * s->frame.linesize[0];

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 471 472 473 474 475
    stream_ptr += 10;  /* skip padding */

    frame_size -= 16;

    /* iterate through the chunks */
    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 480 481 482 483 484 485 486 487 488 489 490 491 492
        stream_ptr += 2;

        switch (chunk_type) {
        case FLI_256_COLOR:
        case FLI_COLOR:
            /* For some reason, it seems that non-paletised flics do include one of these */
            /* chunks in their first frame.  Why i do not know, it seems rather extraneous */
/*            av_log(avctx, AV_LOG_ERROR, "Unexpected Palette chunk %d in non-paletised FLC\n",chunk_type);*/
            stream_ptr = stream_ptr + chunk_size - 6;
            break;

        case FLI_DELTA:
        case FLI_DTA_LC:
            y_ptr = 0;
493
            compressed_lines = AV_RL16(&buf[stream_ptr]);
494 495
            stream_ptr += 2;
            while (compressed_lines > 0) {
496
                line_packets = AV_RL16(&buf[stream_ptr]);
497 498 499 500 501 502 503 504 505 506 507 508 509
                stream_ptr += 2;
                if (line_packets < 0) {
                    line_packets = -line_packets;
                    y_ptr += line_packets * s->frame.linesize[0];
                } else {
                    compressed_lines--;
                    pixel_ptr = y_ptr;
                    pixel_countdown = s->avctx->width;
                    for (i = 0; i < line_packets; i++) {
                        /* account for the skip bytes */
                        pixel_skip = buf[stream_ptr++];
                        pixel_ptr += (pixel_skip*2); /* Pixel is 2 bytes wide */
                        pixel_countdown -= pixel_skip;
510
                        byte_run = (signed char)(buf[stream_ptr++]);
511 512
                        if (byte_run < 0) {
                            byte_run = -byte_run;
513
                            pixel    = AV_RL16(&buf[stream_ptr]);
514 515 516 517 518 519 520 521 522
                            stream_ptr += 2;
                            CHECK_PIXEL_PTR(byte_run);
                            for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {
                                *((signed short*)(&pixels[pixel_ptr])) = pixel;
                                pixel_ptr += 2;
                            }
                        } else {
                            CHECK_PIXEL_PTR(byte_run);
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
523
                                *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]);
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
                                stream_ptr += 2;
                                pixel_ptr += 2;
                            }
                        }
                    }

                    y_ptr += s->frame.linesize[0];
                }
            }
            break;

        case FLI_LC:
            av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-paletised FLC\n");
            stream_ptr = stream_ptr + chunk_size - 6;
            break;

        case FLI_BLACK:
Luca Barbato's avatar
typo  
Luca Barbato committed
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 545 546 547 548 549 550 551 552 553
            break;

        case FLI_BRUN:
            y_ptr = 0;
            for (lines = 0; lines < s->avctx->height; lines++) {
                pixel_ptr = y_ptr;
                /* disregard the line packets; instead, iterate through all
                 * pixels on a row */
                stream_ptr++;
                pixel_countdown = (s->avctx->width * 2);
554

555
                while (pixel_countdown > 0) {
556
                    byte_run = (signed char)(buf[stream_ptr++]);
557 558 559 560 561 562 563
                    if (byte_run > 0) {
                        palette_idx1 = buf[stream_ptr++];
                        CHECK_PIXEL_PTR(byte_run);
                        for (j = 0; j < byte_run; j++) {
                            pixels[pixel_ptr++] = palette_idx1;
                            pixel_countdown--;
                            if (pixel_countdown < 0)
564 565
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) (linea%d)\n",
                                       pixel_countdown, lines);
566 567 568 569 570 571 572 573 574
                        }
                    } else {  /* copy bytes if byte_run < 0 */
                        byte_run = -byte_run;
                        CHECK_PIXEL_PTR(byte_run);
                        for (j = 0; j < byte_run; j++) {
                            palette_idx1 = buf[stream_ptr++];
                            pixels[pixel_ptr++] = palette_idx1;
                            pixel_countdown--;
                            if (pixel_countdown < 0)
575 576
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
577 578 579 580 581
                        }
                    }
                }

                /* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed.
Diego Biurrun's avatar
Diego Biurrun committed
582 583
                 * This does not give us any good oportunity to perform word endian conversion
                 * during decompression. So if it is required (i.e., this is not a LE target, we do
584 585
                 * a second pass over the line here, swapping the bytes.
                 */
586
                pixel = 0xFF00;
Diego Biurrun's avatar
Diego Biurrun committed
587
                if (0xFF00 != AV_RL16(&pixel)) /* Check if it is not an LE target */
588 589 590 591
                {
                  pixel_ptr = y_ptr;
                  pixel_countdown = s->avctx->width;
                  while (pixel_countdown > 0) {
592
                    *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[pixel_ptr]);
593 594
                    pixel_ptr += 2;
                  }
595
                }
596 597 598 599 600 601 602 603 604 605 606 607
                y_ptr += s->frame.linesize[0];
            }
            break;

        case FLI_DTA_BRUN:
            y_ptr = 0;
            for (lines = 0; lines < s->avctx->height; lines++) {
                pixel_ptr = y_ptr;
                /* disregard the line packets; instead, iterate through all
                 * pixels on a row */
                stream_ptr++;
                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 614 615 616
                        stream_ptr += 2;
                        CHECK_PIXEL_PTR(byte_run);
                        for (j = 0; j < byte_run; j++) {
                            *((signed short*)(&pixels[pixel_ptr])) = pixel;
617
                            pixel_ptr += 2;
618 619 620 621 622 623 624 625 626
                            pixel_countdown--;
                            if (pixel_countdown < 0)
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
                                       pixel_countdown);
                        }
                    } else {  /* copy pixels if byte_run < 0 */
                        byte_run = -byte_run;
                        CHECK_PIXEL_PTR(byte_run);
                        for (j = 0; j < byte_run; j++) {
627
                            *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]);
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
                            stream_ptr += 2;
                            pixel_ptr  += 2;
                            pixel_countdown--;
                            if (pixel_countdown < 0)
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
                                       pixel_countdown);
                        }
                    }
                }

                y_ptr += s->frame.linesize[0];
            }
            break;

        case FLI_COPY:
        case FLI_DTA_COPY:
            /* copy the chunk (uncompressed frame) */
            if (chunk_size - 6 > (unsigned int)(s->avctx->width * s->avctx->height)*2) {
                av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
                       "bigger than image, skipping chunk\n", chunk_size - 6);
                stream_ptr += chunk_size - 6;
            } else {
650

651 652 653 654 655 656
                for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height;
                     y_ptr += s->frame.linesize[0]) {

                    pixel_countdown = s->avctx->width;
                    pixel_ptr = 0;
                    while (pixel_countdown > 0) {
657
                      *((signed short*)(&pixels[y_ptr + pixel_ptr])) = AV_RL16(&buf[stream_ptr+pixel_ptr]);
658 659
                      pixel_ptr += 2;
                      pixel_countdown--;
660
                    }
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
                    stream_ptr += s->avctx->width*2;
                }
            }
            break;

        case FLI_MINI:
            /* some sort of a thumbnail? disregard this chunk... */
            stream_ptr += chunk_size - 6;
            break;

        default:
            av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
            break;
        }

        frame_size -= chunk_size;
        num_chunks--;
    }

    /* by the end of the chunk, the stream ptr should equal the frame
     * size (minus 1, possibly); if it doesn't, issue a warning */
    if ((stream_ptr != buf_size) && (stream_ptr != buf_size - 1))
        av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
               "and final chunk ptr = %d\n", buf_size, stream_ptr);


    *data_size=sizeof(AVFrame);
    *(AVFrame*)data = s->frame;

    return buf_size;
}

static int flic_decode_frame_24BPP(AVCodecContext *avctx,
                                   void *data, int *data_size,
                                   uint8_t *buf, int buf_size)
{
  av_log(avctx, AV_LOG_ERROR, "24Bpp FLC Unsupported due to lack of test files.\n");
  return -1;
}

static int flic_decode_frame(AVCodecContext *avctx,
                             void *data, int *data_size,
                             uint8_t *buf, int buf_size)
{
    if (avctx->pix_fmt == PIX_FMT_PAL8) {
      return flic_decode_frame_8BPP(avctx, data, data_size,
                                    buf, buf_size);
    }
    else if ((avctx->pix_fmt == PIX_FMT_RGB555) ||
             (avctx->pix_fmt == PIX_FMT_RGB565)) {
      return flic_decode_frame_15_16BPP(avctx, data, data_size,
                                        buf, buf_size);
713
    }
714 715 716 717 718
    else if (avctx->pix_fmt == PIX_FMT_BGR24) {
      return flic_decode_frame_24BPP(avctx, data, data_size,
                                     buf, buf_size);
    }

Diego Biurrun's avatar
Diego Biurrun committed
719
    /* Should not get  here, ever as the pix_fmt is processed */
720 721
    /* in flic_decode_init and the above if should deal with */
    /* the finite set of possibilites allowable by here. */
Diego Biurrun's avatar
Diego Biurrun committed
722 723
    /* But in case we do, just error out. */
    av_log(avctx, AV_LOG_ERROR, "Unknown FLC format, my science cannot explain how this happened.\n");
724
    return -1;
725
}
726 727


Mike Melanson's avatar
Mike Melanson committed
728 729 730 731
static int flic_decode_end(AVCodecContext *avctx)
{
    FlicDecodeContext *s = avctx->priv_data;

732 733
    if (s->frame.data[0])
        avctx->release_buffer(avctx, &s->frame);
Mike Melanson's avatar
Mike Melanson committed
734 735 736 737 738 739 740 741 742 743 744 745 746 747

    return 0;
}

AVCodec flic_decoder = {
    "flic",
    CODEC_TYPE_VIDEO,
    CODEC_ID_FLIC,
    sizeof(FlicDecodeContext),
    flic_decode_init,
    NULL,
    flic_decode_end,
    flic_decode_frame,
    CODEC_CAP_DR1,
748 749 750
    NULL,
    NULL,
    NULL,
Mike Melanson's avatar
Mike Melanson committed
751 752
    NULL
};