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 55
 * 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 "common.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
56 57 58 59 60 61 62 63
#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
64

65 66 67 68 69 70 71
#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
72 73 74 75 76 77 78 79 80 81 82
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)
{
83
    FlicDecodeContext *s = avctx->priv_data;
Mike Melanson's avatar
Mike Melanson committed
84
    unsigned char *fli_header = (unsigned char *)avctx->extradata;
85
    int depth;
Mike Melanson's avatar
Mike Melanson committed
86 87 88

    s->avctx = avctx;

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

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

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
    s->frame.data[0] = NULL;
Mike Melanson's avatar
Mike Melanson committed
122 123 124 125 126
    s->new_palette = 0;

    return 0;
}

127 128 129
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
130
{
131
    FlicDecodeContext *s = avctx->priv_data;
Mike Melanson's avatar
Mike Melanson committed
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 157

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

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

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

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

    frame_size -= 16;

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

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

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

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

                    r = buf[stream_ptr++] << color_shift;
                    g = buf[stream_ptr++] << color_shift;
                    b = buf[stream_ptr++] << color_shift;
226 227 228 229
                    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
230 231 232 233 234 235 236 237 238 239 240 241 242
                }
            }

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

297
            compressed_lines = AV_RL16(&buf[stream_ptr]);
Mike Melanson's avatar
Mike Melanson committed
298 299 300 301 302 303 304 305 306 307 308
            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;
309
                        byte_run = (signed char)(buf[stream_ptr++]);
Mike Melanson's avatar
Mike Melanson committed
310
                        if (byte_run > 0) {
311
                            CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
312 313 314 315
                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
                                palette_idx1 = buf[stream_ptr++];
                                pixels[pixel_ptr++] = palette_idx1;
                            }
316
                        } else if (byte_run < 0) {
Mike Melanson's avatar
Mike Melanson committed
317 318
                            byte_run = -byte_run;
                            palette_idx1 = buf[stream_ptr++];
319
                            CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
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 348
                            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) {
349
                    byte_run = (signed char)(buf[stream_ptr++]);
Mike Melanson's avatar
Mike Melanson committed
350 351
                    if (byte_run > 0) {
                        palette_idx1 = buf[stream_ptr++];
352
                        CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
353 354 355 356
                        for (j = 0; j < byte_run; j++) {
                            pixels[pixel_ptr++] = palette_idx1;
                            pixel_countdown--;
                            if (pixel_countdown < 0)
357 358
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
Mike Melanson's avatar
Mike Melanson committed
359 360 361
                        }
                    } else {  /* copy bytes if byte_run < 0 */
                        byte_run = -byte_run;
362
                        CHECK_PIXEL_PTR(byte_run);
Mike Melanson's avatar
Mike Melanson committed
363 364 365 366 367
                        for (j = 0; j < byte_run; j++) {
                            palette_idx1 = buf[stream_ptr++];
                            pixels[pixel_ptr++] = palette_idx1;
                            pixel_countdown--;
                            if (pixel_countdown < 0)
368 369
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
Mike Melanson's avatar
Mike Melanson committed
370 371 372 373 374 375 376 377 378
                        }
                    }
                }

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

        case FLI_COPY:
379
            /* copy the chunk (uncompressed frame) */
Mike Melanson's avatar
Mike Melanson committed
380
            if (chunk_size - 6 > s->avctx->width * s->avctx->height) {
381 382
                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
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
                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:
400
            av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
Mike Melanson's avatar
Mike Melanson committed
401 402 403 404 405 406 407 408 409 410
            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))
411 412
        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
413 414

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

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

    return buf_size;
}

427
static int flic_decode_frame_15_16BPP(AVCodecContext *avctx,
428 429 430 431 432
                                      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. */
433
    FlicDecodeContext *s = avctx->priv_data;
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450

    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;
451
    int byte_run;
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
    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];

468
    frame_size = AV_RL32(&buf[stream_ptr]);
469
    stream_ptr += 6;  /* skip the magic number */
470
    num_chunks = AV_RL16(&buf[stream_ptr]);
471 472 473 474 475 476
    stream_ptr += 10;  /* skip padding */

    frame_size -= 16;

    /* iterate through the chunks */
    while ((frame_size > 0) && (num_chunks > 0)) {
477
        chunk_size = AV_RL32(&buf[stream_ptr]);
478
        stream_ptr += 4;
479
        chunk_type = AV_RL16(&buf[stream_ptr]);
480 481 482 483 484 485 486 487 488 489 490 491 492 493
        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;
494
            compressed_lines = AV_RL16(&buf[stream_ptr]);
495 496
            stream_ptr += 2;
            while (compressed_lines > 0) {
497
                line_packets = AV_RL16(&buf[stream_ptr]);
498 499 500 501 502 503 504 505 506 507 508 509 510
                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;
511
                        byte_run = (signed char)(buf[stream_ptr++]);
512 513
                        if (byte_run < 0) {
                            byte_run = -byte_run;
514
                            pixel    = AV_RL16(&buf[stream_ptr]);
515 516 517 518 519 520 521 522 523
                            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--) {
524
                                *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]);
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
                                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
542
            /* set the whole frame to 0x0000 which is black in both 15Bpp and 16Bpp modes. */
543
            memset(pixels, 0x0000,
544
                   s->frame.linesize[0] * s->avctx->height);
545 546 547 548 549 550 551 552 553 554
            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);
555

556
                while (pixel_countdown > 0) {
557
                    byte_run = (signed char)(buf[stream_ptr++]);
558 559 560 561 562 563 564
                    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)
565 566
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) (linea%d)\n",
                                       pixel_countdown, lines);
567 568 569 570 571 572 573 574 575
                        }
                    } 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)
576 577
                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
                                       pixel_countdown, lines);
578 579 580 581 582 583
                        }
                    }
                }

                /* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed.
                 * This doesnt give us any good oportunity to perform word endian conversion
584
                 * during decompression. So if its requried (ie, this isnt a LE target, we do
585 586
                 * a second pass over the line here, swapping the bytes.
                 */
587
                pixel = 0xFF00;
588
                if (0xFF00 != AV_RL16(&pixel)) /* Check if its not an LE Target */
589 590 591 592
                {
                  pixel_ptr = y_ptr;
                  pixel_countdown = s->avctx->width;
                  while (pixel_countdown > 0) {
593
                    *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[pixel_ptr]);
594 595
                    pixel_ptr += 2;
                  }
596
                }
597 598 599 600 601 602 603 604 605 606 607 608
                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 */
609

610
                while (pixel_countdown > 0) {
611
                    byte_run = (signed char)(buf[stream_ptr++]);
612
                    if (byte_run > 0) {
613
                        pixel    = AV_RL16(&buf[stream_ptr]);
614 615 616 617
                        stream_ptr += 2;
                        CHECK_PIXEL_PTR(byte_run);
                        for (j = 0; j < byte_run; j++) {
                            *((signed short*)(&pixels[pixel_ptr])) = pixel;
618
                            pixel_ptr += 2;
619 620 621 622 623 624 625 626 627
                            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++) {
628
                            *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]);
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650
                            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 {
651

652 653 654 655 656 657
                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) {
658
                      *((signed short*)(&pixels[y_ptr + pixel_ptr])) = AV_RL16(&buf[stream_ptr+pixel_ptr]);
659 660
                      pixel_ptr += 2;
                      pixel_countdown--;
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 713
                    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);
714
    }
715 716 717 718 719 720 721 722
    else if (avctx->pix_fmt == PIX_FMT_BGR24) {
      return flic_decode_frame_24BPP(avctx, data, data_size,
                                     buf, buf_size);
    }

    /* Shouldnt get  here, ever as the pix_fmt is processed */
    /* in flic_decode_init and the above if should deal with */
    /* the finite set of possibilites allowable by here. */
723
    /* but in case we do, just error out. */
724 725
    av_log(avctx, AV_LOG_ERROR, "Unknown Format of FLC. My Science cant explain how this happened\n");
    return -1;
726
}
727 728


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

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

    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,
749 750 751
    NULL,
    NULL,
    NULL,
Mike Melanson's avatar
Mike Melanson committed
752 753
    NULL
};