flicvideo.c 28.6 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
 * @file
Mike Melanson's avatar
Mike Melanson committed
24 25 26 27 28 29
 * 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
 *
30 31
 * 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
32 33 34 35 36 37 38 39 40 41
 * 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>

42
#include "libavutil/intreadwrite.h"
Mike Melanson's avatar
Mike Melanson committed
43 44 45 46 47 48 49 50 51 52
#include "avcodec.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
53 54 55 56 57 58 59 60
#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
61

62 63
#define CHECK_PIXEL_PTR(n) \
    if (pixel_ptr + n > pixel_limit) { \
64
        av_log (s->avctx, AV_LOG_ERROR, "Invalid pixel_ptr = %d > pixel_limit = %d\n", \
65
        pixel_ptr + n, pixel_limit); \
66
        return AVERROR_INVALIDDATA; \
67 68
    } \

Mike Melanson's avatar
Mike Melanson committed
69 70 71 72 73 74 75 76 77
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;

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

    s->avctx = avctx;

86
    s->fli_type = AV_RL16(&fli_header[4]); /* Might be overridden if a Magic Carpet FLC */
87

88
    depth = 0;
Mike Melanson's avatar
Mike Melanson committed
89 90
    if (s->avctx->extradata_size == 12) {
        /* special case for magic carpet FLIs */
91
        s->fli_type = FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE;
92
        depth = 8;
93
    } else if (s->avctx->extradata_size != 128) {
94
        av_log(avctx, AV_LOG_ERROR, "Expected extradata of 12 or 128 bytes\n");
Mike Melanson's avatar
Mike Melanson committed
95
        return -1;
96 97 98 99 100 101
    } else {
        depth = AV_RL16(&fli_header[12]);
    }

    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
102 103
    }

104 105 106 107 108 109 110 111 112 113 114 115 116
    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
117
                  av_log(avctx, AV_LOG_ERROR, "Unknown FLC/FLX depth of %d Bpp is unsupported.\n",depth);
118
                  return -1;
119
    }
120

121
    avcodec_get_frame_defaults(&s->frame);
122
    s->frame.data[0] = NULL;
Mike Melanson's avatar
Mike Melanson committed
123 124 125 126 127
    s->new_palette = 0;

    return 0;
}

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

    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;
159
    int byte_run;
Mike Melanson's avatar
Mike Melanson committed
160 161 162
    int pixel_skip;
    int pixel_countdown;
    unsigned char *pixels;
163
    unsigned int pixel_limit;
164

Mike Melanson's avatar
Mike Melanson committed
165
    s->frame.reference = 1;
166 167 168
    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
169 170 171 172
        return -1;
    }

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

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

    frame_size -= 16;

    /* iterate through the chunks */
    while ((frame_size > 0) && (num_chunks > 0)) {
184
        chunk_size = AV_RL32(&buf[stream_ptr]);
185 186 187 188 189
        if (chunk_size > frame_size) {
            av_log(avctx, AV_LOG_WARNING,
                   "Invalid chunk_size = %u > frame_size = %u\n", chunk_size, frame_size);
            chunk_size = frame_size;
        }
Mike Melanson's avatar
Mike Melanson committed
190
        stream_ptr += 4;
191
        chunk_type = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
192 193 194 195 196 197 198
        stream_ptr += 2;

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

199 200
            /* 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
201 202
             * chunks in a 0xAF12-type file (fli_type is set to 0xAF13 during
             * initialization) */
203
            if ((chunk_type == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE))
Mike Melanson's avatar
Mike Melanson committed
204 205 206 207
                color_shift = 0;
            else
                color_shift = 2;
            /* set up the palette */
208
            color_packets = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
209 210 211 212 213 214 215 216 217 218 219 220 221 222
            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++) {
223
                    unsigned int entry;
Mike Melanson's avatar
Mike Melanson committed
224 225

                    /* wrap around, for good measure */
226
                    if ((unsigned)palette_ptr >= 256)
Mike Melanson's avatar
Mike Melanson committed
227 228 229 230 231
                        palette_ptr = 0;

                    r = buf[stream_ptr++] << color_shift;
                    g = buf[stream_ptr++] << color_shift;
                    b = buf[stream_ptr++] << color_shift;
232 233 234 235
                    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
236 237 238 239 240 241 242 243 244 245 246 247 248
                }
            }

            /* 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;
249
            compressed_lines = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
250 251
            stream_ptr += 2;
            while (compressed_lines > 0) {
252
                line_packets = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
253
                stream_ptr += 2;
254 255
                if ((line_packets & 0xC000) == 0xC000) {
                    // line skip opcode
Mike Melanson's avatar
Mike Melanson committed
256
                    line_packets = -line_packets;
257
                    y_ptr += line_packets * s->frame.linesize[0];
258 259 260 261
                } 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
262 263 264
                    pixel_ptr= y_ptr + s->frame.linesize[0] - 1;
                    CHECK_PIXEL_PTR(0);
                    pixels[pixel_ptr] = line_packets & 0xff;
Mike Melanson's avatar
Mike Melanson committed
265 266 267
                } else {
                    compressed_lines--;
                    pixel_ptr = y_ptr;
268
                    CHECK_PIXEL_PTR(0);
Mike Melanson's avatar
Mike Melanson committed
269 270 271 272 273 274
                    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;
275
                        byte_run = (signed char)(buf[stream_ptr++]);
Mike Melanson's avatar
Mike Melanson committed
276 277 278 279
                        if (byte_run < 0) {
                            byte_run = -byte_run;
                            palette_idx1 = buf[stream_ptr++];
                            palette_idx2 = buf[stream_ptr++];
280
                            CHECK_PIXEL_PTR(byte_run * 2);
Mike Melanson's avatar
Mike Melanson committed
281 282 283 284 285
                            for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {
                                pixels[pixel_ptr++] = palette_idx1;
                                pixels[pixel_ptr++] = palette_idx2;
                            }
                        } else {
286
                            CHECK_PIXEL_PTR(byte_run * 2);
Mike Melanson's avatar
Mike Melanson committed
287 288 289 290 291 292 293 294 295 296 297 298 299 300
                            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 */
301
            starting_line = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
302 303
            stream_ptr += 2;
            y_ptr = 0;
304
            y_ptr += starting_line * s->frame.linesize[0];
Mike Melanson's avatar
Mike Melanson committed
305

306
            compressed_lines = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
307 308 309
            stream_ptr += 2;
            while (compressed_lines > 0) {
                pixel_ptr = y_ptr;
310
                CHECK_PIXEL_PTR(0);
Mike Melanson's avatar
Mike Melanson committed
311 312 313 314 315 316 317 318
                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;
319
                        byte_run = (signed char)(buf[stream_ptr++]);
Mike Melanson's avatar
Mike Melanson committed
320
                        if (byte_run > 0) {
321
                            CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
322 323 324 325
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
                                palette_idx1 = buf[stream_ptr++];
                                pixels[pixel_ptr++] = palette_idx1;
                            }
326
                        } else if (byte_run < 0) {
Mike Melanson's avatar
Mike Melanson committed
327 328
                            byte_run = -byte_run;
                            palette_idx1 = buf[stream_ptr++];
329
                            CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
                            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) {
359
                    byte_run = (signed char)(buf[stream_ptr++]);
Mike Melanson's avatar
Mike Melanson committed
360 361
                    if (byte_run > 0) {
                        palette_idx1 = buf[stream_ptr++];
362
                        CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
363 364 365 366
                        for (j = 0; j < byte_run; j++) {
                            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
                        }
                    } else {  /* copy bytes if byte_run < 0 */
                        byte_run = -byte_run;
372
                        CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
373 374 375 376 377
                        for (j = 0; j < byte_run; j++) {
                            palette_idx1 = buf[stream_ptr++];
                            pixels[pixel_ptr++] = palette_idx1;
                            pixel_countdown--;
                            if (pixel_countdown < 0)
378 379
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
Mike Melanson's avatar
Mike Melanson committed
380 381 382 383 384 385 386 387 388
                        }
                    }
                }

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

        case FLI_COPY:
389
            /* copy the chunk (uncompressed frame) */
Mike Melanson's avatar
Mike Melanson committed
390
            if (chunk_size - 6 > s->avctx->width * s->avctx->height) {
391 392
                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
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
                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:
410
            av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
Mike Melanson's avatar
Mike Melanson committed
411 412 413 414 415 416 417 418 419 420
            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))
421 422
        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
423 424

    /* make the palette available on the way out */
425 426
    memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE);
    if (s->new_palette) {
Mike Melanson's avatar
Mike Melanson committed
427 428 429 430 431 432 433 434 435 436
        s->frame.palette_has_changed = 1;
        s->new_palette = 0;
    }

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

    return buf_size;
}

437
static int flic_decode_frame_15_16BPP(AVCodecContext *avctx,
438
                                      void *data, int *data_size,
Michael Niedermayer's avatar
Michael Niedermayer committed
439
                                      const uint8_t *buf, int buf_size)
440 441 442
{
    /* Note, the only difference between the 15Bpp and 16Bpp */
    /* Format is the pixel format, the packets are processed the same. */
443
    FlicDecodeContext *s = avctx->priv_data;
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460

    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;
461
    int byte_run;
462 463 464 465
    int pixel_skip;
    int pixel_countdown;
    unsigned char *pixels;
    int pixel;
466
    unsigned int pixel_limit;
467 468 469 470 471 472 473 474 475 476 477

    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];

478
    frame_size = AV_RL32(&buf[stream_ptr]);
479
    stream_ptr += 6;  /* skip the magic number */
480
    num_chunks = AV_RL16(&buf[stream_ptr]);
481 482 483 484 485 486
    stream_ptr += 10;  /* skip padding */

    frame_size -= 16;

    /* iterate through the chunks */
    while ((frame_size > 0) && (num_chunks > 0)) {
487
        chunk_size = AV_RL32(&buf[stream_ptr]);
488
        stream_ptr += 4;
489
        chunk_type = AV_RL16(&buf[stream_ptr]);
490 491 492 493 494
        stream_ptr += 2;

        switch (chunk_type) {
        case FLI_256_COLOR:
        case FLI_COLOR:
Diego Biurrun's avatar
Diego Biurrun committed
495 496 497
            /* For some reason, it seems that non-palettized flics do
             * include one of these chunks in their first frame.
             * Why I do not know, it seems rather extraneous. */
498 499 500 501 502 503 504
/*            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;
505
            compressed_lines = AV_RL16(&buf[stream_ptr]);
506 507
            stream_ptr += 2;
            while (compressed_lines > 0) {
508
                line_packets = AV_RL16(&buf[stream_ptr]);
509 510 511 512 513 514 515
                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;
516
                    CHECK_PIXEL_PTR(0);
517 518 519 520 521 522
                    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;
523
                        byte_run = (signed char)(buf[stream_ptr++]);
524 525
                        if (byte_run < 0) {
                            byte_run = -byte_run;
526
                            pixel    = AV_RL16(&buf[stream_ptr]);
527
                            stream_ptr += 2;
528
                            CHECK_PIXEL_PTR(2 * byte_run);
529 530 531 532 533
                            for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {
                                *((signed short*)(&pixels[pixel_ptr])) = pixel;
                                pixel_ptr += 2;
                            }
                        } else {
534
                            CHECK_PIXEL_PTR(2 * byte_run);
535
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
536
                                *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]);
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
                                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
Luca Barbato committed
554
            /* set the whole frame to 0x0000 which is black in both 15Bpp and 16Bpp modes. */
555
            memset(pixels, 0x0000,
556
                   s->frame.linesize[0] * s->avctx->height);
557 558 559 560 561 562 563 564 565 566
            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);
567

568
                while (pixel_countdown > 0) {
569
                    byte_run = (signed char)(buf[stream_ptr++]);
570 571 572 573 574 575 576
                    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)
577 578
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) (linea%d)\n",
                                       pixel_countdown, lines);
579 580 581 582 583 584 585 586 587
                        }
                    } 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)
588 589
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
590 591 592 593 594
                        }
                    }
                }

                /* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed.
Diego Biurrun's avatar
Diego Biurrun committed
595 596
                 * 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
597 598
                 * a second pass over the line here, swapping the bytes.
                 */
599
#if HAVE_BIGENDIAN
Måns Rullgård's avatar
Måns Rullgård committed
600 601 602
                pixel_ptr = y_ptr;
                pixel_countdown = s->avctx->width;
                while (pixel_countdown > 0) {
603
                    *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[pixel_ptr]);
604
                    pixel_ptr += 2;
Måns Rullgård's avatar
Måns Rullgård committed
605
                }
606
#endif
607 608 609 610 611 612 613 614 615 616 617 618
                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 */
619

620
                while (pixel_countdown > 0) {
621
                    byte_run = (signed char)(buf[stream_ptr++]);
622
                    if (byte_run > 0) {
623
                        pixel    = AV_RL16(&buf[stream_ptr]);
624
                        stream_ptr += 2;
625
                        CHECK_PIXEL_PTR(2 * byte_run);
626 627
                        for (j = 0; j < byte_run; j++) {
                            *((signed short*)(&pixels[pixel_ptr])) = pixel;
628
                            pixel_ptr += 2;
629 630 631 632 633 634 635
                            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;
636
                        CHECK_PIXEL_PTR(2 * byte_run);
637
                        for (j = 0; j < byte_run; j++) {
638
                            *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]);
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
                            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 {
661

662 663 664 665 666 667
                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) {
668
                      *((signed short*)(&pixels[y_ptr + pixel_ptr])) = AV_RL16(&buf[stream_ptr+pixel_ptr]);
669 670
                      pixel_ptr += 2;
                      pixel_countdown--;
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
                    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,
Michael Niedermayer's avatar
Michael Niedermayer committed
706
                                   const uint8_t *buf, int buf_size)
707 708 709 710 711 712 713
{
  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,
714
                             AVPacket *avpkt)
715
{
716 717
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
718 719 720 721 722 723 724 725
    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);
726
    }
727 728 729 730 731
    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
732
    /* Should not get  here, ever as the pix_fmt is processed */
733 734
    /* 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
735 736
    /* 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");
737
    return -1;
738
}
739 740


741
static av_cold int flic_decode_end(AVCodecContext *avctx)
Mike Melanson's avatar
Mike Melanson committed
742 743 744
{
    FlicDecodeContext *s = avctx->priv_data;

745 746
    if (s->frame.data[0])
        avctx->release_buffer(avctx, &s->frame);
Mike Melanson's avatar
Mike Melanson committed
747 748 749 750

    return 0;
}

751
AVCodec ff_flic_decoder = {
Mike Melanson's avatar
Mike Melanson committed
752
    "flic",
753
    AVMEDIA_TYPE_VIDEO,
Mike Melanson's avatar
Mike Melanson committed
754 755 756 757 758 759 760
    CODEC_ID_FLIC,
    sizeof(FlicDecodeContext),
    flic_decode_init,
    NULL,
    flic_decode_end,
    flic_decode_frame,
    CODEC_CAP_DR1,
761 762 763
    NULL,
    NULL,
    NULL,
764
    NULL,
765
    .long_name = NULL_IF_CONFIG_SMALL("Autodesk Animator Flic video"),
Mike Melanson's avatar
Mike Melanson committed
766
};