falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
31447 Commits
32 Branches
283MB
Tree: 7fc85451fd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7fc85451fd'
${ noResults }
FFmpeg/libavcodec/flicvideo.c

781 lines
29KB
Raw Blame History 

  1. /*

  2.  * FLI/FLC Animation Video Decoder

  3.  * Copyright (C) 2003, 2004 the ffmpeg project

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. /**

  23.  * @file

  24.  * Autodesk Animator FLI/FLC Video Decoder

  25.  * by Mike Melanson (melanson@pcisys.net)

  26.  * for more information on the .fli/.flc file format and all of its many

  27.  * variations, visit:

  28.  *   http://www.compuphase.com/flic.htm

  29.  *

  30.  * This decoder outputs PAL8/RGB555/RGB565 and maybe one day RGB24

  31.  * colorspace data, depending on the FLC. To use this decoder, be

  32.  * sure that your demuxer sends the FLI file header to the decoder via

  33.  * the extradata chunk in AVCodecContext. The chunk should be 128 bytes

  34.  * large. The only exception is for FLI files from the game "Magic Carpet",

  35.  * in which the header is only 12 bytes.

  36.  */

  37. 

  38. #include <stdio.h>

  39. #include <stdlib.h>

  40. #include <string.h>

  41. 

  42. #include "libavutil/intreadwrite.h"

  43. #include "avcodec.h"

  44. 

  45. #define FLI_256_COLOR 4

  46. #define FLI_DELTA     7

  47. #define FLI_COLOR     11

  48. #define FLI_LC        12

  49. #define FLI_BLACK     13

  50. #define FLI_BRUN      15

  51. #define FLI_COPY      16

  52. #define FLI_MINI      18

  53. #define FLI_DTA_BRUN  25

  54. #define FLI_DTA_COPY  26

  55. #define FLI_DTA_LC    27

  56. 

  57. #define FLI_TYPE_CODE     (0xAF11)

  58. #define FLC_FLX_TYPE_CODE (0xAF12)

  59. #define FLC_DTA_TYPE_CODE (0xAF44) /* Marks an "Extended FLC" comes from Dave's Targa Animator (DTA) */

  60. #define FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE (0xAF13)

  61. 

  62. #define CHECK_PIXEL_PTR(n) \

  63.     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. 

  69. typedef struct FlicDecodeContext {

  70.     AVCodecContext *avctx;

  71.     AVFrame frame;

  72. 

  73.     unsigned int palette[256];

  74.     int new_palette;

  75.     int fli_type;  /* either 0xAF11 or 0xAF12, affects palette resolution */

  76. } FlicDecodeContext;

  77. 

  78. static av_cold int flic_decode_init(AVCodecContext *avctx)

  79. {

  80.     FlicDecodeContext *s = avctx->priv_data;

  81.     unsigned char *fli_header = (unsigned char *)avctx->extradata;

  82.     int depth;

  83. 

  84.     s->avctx = avctx;

  85. 

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

  87. 

  88.     depth = 0;

  89.     if (s->avctx->extradata_size == 12) {

  90.         /* 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");

  95.         return -1;

  96.     } else {

  97.         depth = AV_RL16(&fli_header[12]);

  98.     }

  99. 

  100.     if (depth == 0) {

  101.         depth = 8; /* Some FLC generators set depth to zero, when they mean 8Bpp. Fix up here */

  102.     }

  103. 

  104.     if ((s->fli_type == FLC_FLX_TYPE_CODE) && (depth == 16)) {

  105.         depth = 15; /* Original Autodesk FLX's say the depth is 16Bpp when it is really 15Bpp */

  106.     }

  107. 

  108.     switch (depth) {

  109.         case 8  : avctx->pix_fmt = PIX_FMT_PAL8; break;

  110.         case 15 : avctx->pix_fmt = PIX_FMT_RGB555; break;

  111.         case 16 : avctx->pix_fmt = PIX_FMT_RGB565; break;

  112.         case 24 : avctx->pix_fmt = PIX_FMT_BGR24; /* Supposedly BGR, but havent any files to test with */

  113.                   av_log(avctx, AV_LOG_ERROR, "24Bpp FLC/FLX is unsupported due to no test files.\n");

  114.                   return -1;

  115.                   break;

  116.         default :

  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;

  123.     s->new_palette = 0;

  124. 

  125.     return 0;

  126. }

  127. 

  128. static int flic_decode_frame_8BPP(AVCodecContext *avctx,

  129.                                   void *data, int *data_size,

  130.                                   const uint8_t *buf, int buf_size)

  131. {

  132.     FlicDecodeContext *s = avctx->priv_data;

  133. 

  134.     int stream_ptr = 0;

  135.     int pixel_ptr;

  136.     int palette_ptr;

  137.     unsigned char palette_idx1;

  138.     unsigned char palette_idx2;

  139. 

  140.     unsigned int frame_size;

  141.     int num_chunks;

  142. 

  143.     unsigned int chunk_size;

  144.     int chunk_type;

  145. 

  146.     int i, j;

  147. 

  148.     int color_packets;

  149.     int color_changes;

  150.     int color_shift;

  151.     unsigned char r, g, b;

  152. 

  153.     int lines;

  154.     int compressed_lines;

  155.     int starting_line;

  156.     signed short line_packets;

  157.     int y_ptr;

  158.     int byte_run;

  159.     int pixel_skip;

  160.     int pixel_countdown;

  161.     unsigned char *pixels;

  162.     unsigned int pixel_limit;

  163. 

  164.     s->frame.reference = 1;

  165.     s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;

  166.     if (avctx->reget_buffer(avctx, &s->frame) < 0) {

  167.         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");

  168.         return -1;

  169.     }

  170. 

  171.     pixels = s->frame.data[0];

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

  173. 

  174.     if (buf_size < 16 || buf_size > INT_MAX - (3 * 256 + FF_INPUT_BUFFER_PADDING_SIZE))

  175.         return AVERROR_INVALIDDATA;

  176.     frame_size = AV_RL32(&buf[stream_ptr]);

  177.     if (frame_size > buf_size)

  178.         frame_size = buf_size;

  179.     stream_ptr += 6;  /* skip the magic number */

  180.     num_chunks = AV_RL16(&buf[stream_ptr]);

  181.     stream_ptr += 10;  /* skip padding */

  182. 

  183.     frame_size -= 16;

  184. 

  185.     /* iterate through the chunks */

  186.     while ((frame_size >= 6) && (num_chunks > 0)) {

  187.         int stream_ptr_after_chunk;

  188.         chunk_size = AV_RL32(&buf[stream_ptr]);

  189.         if (chunk_size > frame_size) {

  190.             av_log(avctx, AV_LOG_WARNING,

  191.                    "Invalid chunk_size = %u > frame_size = %u\n", chunk_size, frame_size);

  192.             chunk_size = frame_size;

  193.         }

  194.         stream_ptr_after_chunk = stream_ptr + chunk_size;

  195. 

  196.         stream_ptr += 4;

  197.         chunk_type = AV_RL16(&buf[stream_ptr]);

  198.         stream_ptr += 2;

  199. 

  200.         switch (chunk_type) {

  201.         case FLI_256_COLOR:

  202.         case FLI_COLOR:

  203.             /* check special case: If this file is from the Magic Carpet

  204.              * game and uses 6-bit colors even though it reports 256-color

  205.              * chunks in a 0xAF12-type file (fli_type is set to 0xAF13 during

  206.              * initialization) */

  207.             if ((chunk_type == FLI_256_COLOR) && (s->fli_type != FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE))

  208.                 color_shift = 0;

  209.             else

  210.                 color_shift = 2;

  211.             /* set up the palette */

  212.             color_packets = AV_RL16(&buf[stream_ptr]);

  213.             stream_ptr += 2;

  214.             palette_ptr = 0;

  215.             for (i = 0; i < color_packets; i++) {

  216.                 /* first byte is how many colors to skip */

  217.                 palette_ptr += buf[stream_ptr++];

  218. 

  219.                 /* next byte indicates how many entries to change */

  220.                 color_changes = buf[stream_ptr++];

  221. 

  222.                 /* if there are 0 color changes, there are actually 256 */

  223.                 if (color_changes == 0)

  224.                     color_changes = 256;

  225. 

  226.                 if (stream_ptr + color_changes * 3 > stream_ptr_after_chunk)

  227.                     break;

  228. 

  229.                 for (j = 0; j < color_changes; j++) {

  230.                     unsigned int entry;

  231. 

  232.                     /* wrap around, for good measure */

  233.                     if ((unsigned)palette_ptr >= 256)

  234.                         palette_ptr = 0;

  235. 

  236.                     r = buf[stream_ptr++] << color_shift;

  237.                     g = buf[stream_ptr++] << color_shift;

  238.                     b = buf[stream_ptr++] << color_shift;

  239.                     entry = (r << 16) | (g << 8) | b;

  240.                     if (s->palette[palette_ptr] != entry)

  241.                         s->new_palette = 1;

  242.                     s->palette[palette_ptr++] = entry;

  243.                 }

  244.             }

  245.             break;

  246. 

  247.         case FLI_DELTA:

  248.             y_ptr = 0;

  249.             compressed_lines = AV_RL16(&buf[stream_ptr]);

  250.             stream_ptr += 2;

  251.             while (compressed_lines > 0) {

  252.                 if (stream_ptr + 2 > stream_ptr_after_chunk)

  253.                     break;

  254.                 line_packets = AV_RL16(&buf[stream_ptr]);

  255.                 stream_ptr += 2;

  256.                 if ((line_packets & 0xC000) == 0xC000) {

  257.                     // line skip opcode

  258.                     line_packets = -line_packets;

  259.                     y_ptr += line_packets * s->frame.linesize[0];

  260.                 } else if ((line_packets & 0xC000) == 0x4000) {

  261.                     av_log(avctx, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", line_packets);

  262.                 } else if ((line_packets & 0xC000) == 0x8000) {

  263.                     // "last byte" opcode

  264.                     pixel_ptr= y_ptr + s->frame.linesize[0] - 1;

  265.                     CHECK_PIXEL_PTR(0);

  266.                     pixels[pixel_ptr] = line_packets & 0xff;

  267.                 } else {

  268.                     compressed_lines--;

  269.                     pixel_ptr = y_ptr;

  270.                     CHECK_PIXEL_PTR(0);

  271.                     pixel_countdown = s->avctx->width;

  272.                     for (i = 0; i < line_packets; i++) {

  273.                         if (stream_ptr + 2 > stream_ptr_after_chunk)

  274.                             break;

  275.                         /* account for the skip bytes */

  276.                         pixel_skip = buf[stream_ptr++];

  277.                         pixel_ptr += pixel_skip;

  278.                         pixel_countdown -= pixel_skip;

  279.                         byte_run = (signed char)(buf[stream_ptr++]);

  280.                         if (byte_run < 0) {

  281.                             byte_run = -byte_run;

  282.                             palette_idx1 = buf[stream_ptr++];

  283.                             palette_idx2 = buf[stream_ptr++];

  284.                             CHECK_PIXEL_PTR(byte_run * 2);

  285.                             for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {

  286.                                 pixels[pixel_ptr++] = palette_idx1;

  287.                                 pixels[pixel_ptr++] = palette_idx2;

  288.                             }

  289.                         } else {

  290.                             CHECK_PIXEL_PTR(byte_run * 2);

  291.                             if (stream_ptr + byte_run * 2 > stream_ptr_after_chunk)

  292.                                 break;

  293.                             for (j = 0; j < byte_run * 2; j++, pixel_countdown--) {

  294.                                 palette_idx1 = buf[stream_ptr++];

  295.                                 pixels[pixel_ptr++] = palette_idx1;

  296.                             }

  297.                         }

  298.                     }

  299. 

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

  301.                 }

  302.             }

  303.             break;

  304. 

  305.         case FLI_LC:

  306.             /* line compressed */

  307.             starting_line = AV_RL16(&buf[stream_ptr]);

  308.             stream_ptr += 2;

  309.             y_ptr = 0;

  310.             y_ptr += starting_line * s->frame.linesize[0];

  311. 

  312.             compressed_lines = AV_RL16(&buf[stream_ptr]);

  313.             stream_ptr += 2;

  314.             while (compressed_lines > 0) {

  315.                 pixel_ptr = y_ptr;

  316.                 CHECK_PIXEL_PTR(0);

  317.                 pixel_countdown = s->avctx->width;

  318.                 line_packets = buf[stream_ptr++];

  319.                 if (stream_ptr + 2 * line_packets > stream_ptr_after_chunk)

  320.                     break;

  321.                 if (line_packets > 0) {

  322.                     for (i = 0; i < line_packets; i++) {

  323.                         /* account for the skip bytes */

  324.                         pixel_skip = buf[stream_ptr++];

  325.                         pixel_ptr += pixel_skip;

  326.                         pixel_countdown -= pixel_skip;

  327.                         byte_run = (signed char)(buf[stream_ptr++]);

  328.                         if (byte_run > 0) {

  329.                             CHECK_PIXEL_PTR(byte_run);

  330.                             if (stream_ptr + byte_run > stream_ptr_after_chunk)

  331.                                 break;

  332.                             for (j = 0; j < byte_run; j++, pixel_countdown--) {

  333.                                 palette_idx1 = buf[stream_ptr++];

  334.                                 pixels[pixel_ptr++] = palette_idx1;

  335.                             }

  336.                         } else if (byte_run < 0) {

  337.                             byte_run = -byte_run;

  338.                             palette_idx1 = buf[stream_ptr++];

  339.                             CHECK_PIXEL_PTR(byte_run);

  340.                             for (j = 0; j < byte_run; j++, pixel_countdown--) {

  341.                                 pixels[pixel_ptr++] = palette_idx1;

  342.                             }

  343.                         }

  344.                     }

  345.                 }

  346. 

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

  348.                 compressed_lines--;

  349.             }

  350.             break;

  351. 

  352.         case FLI_BLACK:

  353.             /* set the whole frame to color 0 (which is usually black) */

  354.             memset(pixels, 0,

  355.                 s->frame.linesize[0] * s->avctx->height);

  356.             break;

  357. 

  358.         case FLI_BRUN:

  359.             /* Byte run compression: This chunk type only occurs in the first

  360.              * FLI frame and it will update the entire frame. */

  361.             y_ptr = 0;

  362.             for (lines = 0; lines < s->avctx->height; lines++) {

  363.                 pixel_ptr = y_ptr;

  364.                 /* disregard the line packets; instead, iterate through all

  365.                  * pixels on a row */

  366.                 stream_ptr++;

  367.                 pixel_countdown = s->avctx->width;

  368.                 while (pixel_countdown > 0) {

  369.                     if (stream_ptr + 1 > stream_ptr_after_chunk)

  370.                         break;

  371.                     byte_run = (signed char)(buf[stream_ptr++]);

  372.                     if (byte_run > 0) {

  373.                         palette_idx1 = buf[stream_ptr++];

  374.                         CHECK_PIXEL_PTR(byte_run);

  375.                         for (j = 0; j < byte_run; j++) {

  376.                             pixels[pixel_ptr++] = palette_idx1;

  377.                             pixel_countdown--;

  378.                             if (pixel_countdown < 0)

  379.                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",

  380.                                        pixel_countdown, lines);

  381.                         }

  382.                     } else {  /* copy bytes if byte_run < 0 */

  383.                         byte_run = -byte_run;

  384.                         CHECK_PIXEL_PTR(byte_run);

  385.                         if (stream_ptr + byte_run > stream_ptr_after_chunk)

  386.                             break;

  387.                         for (j = 0; j < byte_run; j++) {

  388.                             palette_idx1 = buf[stream_ptr++];

  389.                             pixels[pixel_ptr++] = palette_idx1;

  390.                             pixel_countdown--;

  391.                             if (pixel_countdown < 0)

  392.                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",

  393.                                        pixel_countdown, lines);

  394.                         }

  395.                     }

  396.                 }

  397. 

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

  399.             }

  400.             break;

  401. 

  402.         case FLI_COPY:

  403.             /* copy the chunk (uncompressed frame) */

  404.             if (chunk_size - 6 != s->avctx->width * s->avctx->height) {

  405.                 av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \

  406.                        "has incorrect size, skipping chunk\n", chunk_size - 6);

  407.             } else {

  408.                 for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height;

  409.                      y_ptr += s->frame.linesize[0]) {

  410.                     memcpy(&pixels[y_ptr], &buf[stream_ptr],

  411.                         s->avctx->width);

  412.                     stream_ptr += s->avctx->width;

  413.                 }

  414.             }

  415.             break;

  416. 

  417.         case FLI_MINI:

  418.             /* some sort of a thumbnail? disregard this chunk... */

  419.             break;

  420. 

  421.         default:

  422.             av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);

  423.             break;

  424.         }

  425. 

  426.         stream_ptr = stream_ptr_after_chunk;

  427. 

  428.         frame_size -= chunk_size;

  429.         num_chunks--;

  430.     }

  431. 

  432.     /* by the end of the chunk, the stream ptr should equal the frame

  433.      * size (minus 1, possibly); if it doesn't, issue a warning */

  434.     if ((stream_ptr != buf_size) && (stream_ptr != buf_size - 1))

  435.         av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \

  436.                "and final chunk ptr = %d\n", buf_size, stream_ptr);

  437. 

  438.     /* make the palette available on the way out */

  439.     memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE);

  440.     if (s->new_palette) {

  441.         s->frame.palette_has_changed = 1;

  442.         s->new_palette = 0;

  443.     }

  444. 

  445.     *data_size=sizeof(AVFrame);

  446.     *(AVFrame*)data = s->frame;

  447. 

  448.     return buf_size;

  449. }

  450. 

  451. static int flic_decode_frame_15_16BPP(AVCodecContext *avctx,

  452.                                       void *data, int *data_size,

  453.                                       const uint8_t *buf, int buf_size)

  454. {

  455.     /* Note, the only difference between the 15Bpp and 16Bpp */

  456.     /* Format is the pixel format, the packets are processed the same. */

  457.     FlicDecodeContext *s = avctx->priv_data;

  458. 

  459.     int stream_ptr = 0;

  460.     int pixel_ptr;

  461.     unsigned char palette_idx1;

  462. 

  463.     unsigned int frame_size;

  464.     int num_chunks;

  465. 

  466.     unsigned int chunk_size;

  467.     int chunk_type;

  468. 

  469.     int i, j;

  470. 

  471.     int lines;

  472.     int compressed_lines;

  473.     signed short line_packets;

  474.     int y_ptr;

  475.     int byte_run;

  476.     int pixel_skip;

  477.     int pixel_countdown;

  478.     unsigned char *pixels;

  479.     int pixel;

  480.     unsigned int pixel_limit;

  481. 

  482.     s->frame.reference = 1;

  483.     s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;

  484.     if (avctx->reget_buffer(avctx, &s->frame) < 0) {

  485.         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");

  486.         return -1;

  487.     }

  488. 

  489.     pixels = s->frame.data[0];

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

  491. 

  492.     frame_size = AV_RL32(&buf[stream_ptr]);

  493.     stream_ptr += 6;  /* skip the magic number */

  494.     num_chunks = AV_RL16(&buf[stream_ptr]);

  495.     stream_ptr += 10;  /* skip padding */

  496. 

  497.     frame_size -= 16;

  498. 

  499.     /* iterate through the chunks */

  500.     while ((frame_size > 0) && (num_chunks > 0)) {

  501.         chunk_size = AV_RL32(&buf[stream_ptr]);

  502.         stream_ptr += 4;

  503.         chunk_type = AV_RL16(&buf[stream_ptr]);

  504.         stream_ptr += 2;

  505. 

  506.         switch (chunk_type) {

  507.         case FLI_256_COLOR:

  508.         case FLI_COLOR:

  509.             /* For some reason, it seems that non-palettized flics do

  510.              * include one of these chunks in their first frame.

  511.              * Why I do not know, it seems rather extraneous. */

  512. /*            av_log(avctx, AV_LOG_ERROR, "Unexpected Palette chunk %d in non-paletised FLC\n",chunk_type);*/

  513.             stream_ptr = stream_ptr + chunk_size - 6;

  514.             break;

  515. 

  516.         case FLI_DELTA:

  517.         case FLI_DTA_LC:

  518.             y_ptr = 0;

  519.             compressed_lines = AV_RL16(&buf[stream_ptr]);

  520.             stream_ptr += 2;

  521.             while (compressed_lines > 0) {

  522.                 line_packets = AV_RL16(&buf[stream_ptr]);

  523.                 stream_ptr += 2;

  524.                 if (line_packets < 0) {

  525.                     line_packets = -line_packets;

  526.                     y_ptr += line_packets * s->frame.linesize[0];

  527.                 } else {

  528.                     compressed_lines--;

  529.                     pixel_ptr = y_ptr;

  530.                     CHECK_PIXEL_PTR(0);

  531.                     pixel_countdown = s->avctx->width;

  532.                     for (i = 0; i < line_packets; i++) {

  533.                         /* account for the skip bytes */

  534.                         pixel_skip = buf[stream_ptr++];

  535.                         pixel_ptr += (pixel_skip*2); /* Pixel is 2 bytes wide */

  536.                         pixel_countdown -= pixel_skip;

  537.                         byte_run = (signed char)(buf[stream_ptr++]);

  538.                         if (byte_run < 0) {

  539.                             byte_run = -byte_run;

  540.                             pixel    = AV_RL16(&buf[stream_ptr]);

  541.                             stream_ptr += 2;

  542.                             CHECK_PIXEL_PTR(2 * byte_run);

  543.                             for (j = 0; j < byte_run; j++, pixel_countdown -= 2) {

  544.                                 *((signed short*)(&pixels[pixel_ptr])) = pixel;

  545.                                 pixel_ptr += 2;

  546.                             }

  547.                         } else {

  548.                             CHECK_PIXEL_PTR(2 * byte_run);

  549.                             for (j = 0; j < byte_run; j++, pixel_countdown--) {

  550.                                 *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]);

  551.                                 stream_ptr += 2;

  552.                                 pixel_ptr += 2;

  553.                             }

  554.                         }

  555.                     }

  556. 

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

  558.                 }

  559.             }

  560.             break;

  561. 

  562.         case FLI_LC:

  563.             av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-paletised FLC\n");

  564.             stream_ptr = stream_ptr + chunk_size - 6;

  565.             break;

  566. 

  567.         case FLI_BLACK:

  568.             /* set the whole frame to 0x0000 which is black in both 15Bpp and 16Bpp modes. */

  569.             memset(pixels, 0x0000,

  570.                    s->frame.linesize[0] * s->avctx->height);

  571.             break;

  572. 

  573.         case FLI_BRUN:

  574.             y_ptr = 0;

  575.             for (lines = 0; lines < s->avctx->height; lines++) {

  576.                 pixel_ptr = y_ptr;

  577.                 /* disregard the line packets; instead, iterate through all

  578.                  * pixels on a row */

  579.                 stream_ptr++;

  580.                 pixel_countdown = (s->avctx->width * 2);

  581. 

  582.                 while (pixel_countdown > 0) {

  583.                     byte_run = (signed char)(buf[stream_ptr++]);

  584.                     if (byte_run > 0) {

  585.                         palette_idx1 = buf[stream_ptr++];

  586.                         CHECK_PIXEL_PTR(byte_run);

  587.                         for (j = 0; j < byte_run; j++) {

  588.                             pixels[pixel_ptr++] = palette_idx1;

  589.                             pixel_countdown--;

  590.                             if (pixel_countdown < 0)

  591.                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) (linea%d)\n",

  592.                                        pixel_countdown, lines);

  593.                         }

  594.                     } else {  /* copy bytes if byte_run < 0 */

  595.                         byte_run = -byte_run;

  596.                         CHECK_PIXEL_PTR(byte_run);

  597.                         for (j = 0; j < byte_run; j++) {

  598.                             palette_idx1 = buf[stream_ptr++];

  599.                             pixels[pixel_ptr++] = palette_idx1;

  600.                             pixel_countdown--;

  601.                             if (pixel_countdown < 0)

  602.                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",

  603.                                        pixel_countdown, lines);

  604.                         }

  605.                     }

  606.                 }

  607. 

  608.                 /* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed.

  609.                  * This does not give us any good oportunity to perform word endian conversion

  610.                  * during decompression. So if it is required (i.e., this is not a LE target, we do

  611.                  * a second pass over the line here, swapping the bytes.

  612.                  */

  613. #if HAVE_BIGENDIAN

  614.                 pixel_ptr = y_ptr;

  615.                 pixel_countdown = s->avctx->width;

  616.                 while (pixel_countdown > 0) {

  617.                     *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[pixel_ptr]);

  618.                     pixel_ptr += 2;

  619.                 }

  620. #endif

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

  622.             }

  623.             break;

  624. 

  625.         case FLI_DTA_BRUN:

  626.             y_ptr = 0;

  627.             for (lines = 0; lines < s->avctx->height; lines++) {

  628.                 pixel_ptr = y_ptr;

  629.                 /* disregard the line packets; instead, iterate through all

  630.                  * pixels on a row */

  631.                 stream_ptr++;

  632.                 pixel_countdown = s->avctx->width; /* Width is in pixels, not bytes */

  633. 

  634.                 while (pixel_countdown > 0) {

  635.                     byte_run = (signed char)(buf[stream_ptr++]);

  636.                     if (byte_run > 0) {

  637.                         pixel    = AV_RL16(&buf[stream_ptr]);

  638.                         stream_ptr += 2;

  639.                         CHECK_PIXEL_PTR(2 * byte_run);

  640.                         for (j = 0; j < byte_run; j++) {

  641.                             *((signed short*)(&pixels[pixel_ptr])) = pixel;

  642.                             pixel_ptr += 2;

  643.                             pixel_countdown--;

  644.                             if (pixel_countdown < 0)

  645.                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",

  646.                                        pixel_countdown);

  647.                         }

  648.                     } else {  /* copy pixels if byte_run < 0 */

  649.                         byte_run = -byte_run;

  650.                         CHECK_PIXEL_PTR(2 * byte_run);

  651.                         for (j = 0; j < byte_run; j++) {

  652.                             *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]);

  653.                             stream_ptr += 2;

  654.                             pixel_ptr  += 2;

  655.                             pixel_countdown--;

  656.                             if (pixel_countdown < 0)

  657.                                 av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",

  658.                                        pixel_countdown);

  659.                         }

  660.                     }

  661.                 }

  662. 

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

  664.             }

  665.             break;

  666. 

  667.         case FLI_COPY:

  668.         case FLI_DTA_COPY:

  669.             /* copy the chunk (uncompressed frame) */

  670.             if (chunk_size - 6 > (unsigned int)(s->avctx->width * s->avctx->height)*2) {

  671.                 av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \

  672.                        "bigger than image, skipping chunk\n", chunk_size - 6);

  673.                 stream_ptr += chunk_size - 6;

  674.             } else {

  675. 

  676.                 for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height;

  677.                      y_ptr += s->frame.linesize[0]) {

  678. 

  679.                     pixel_countdown = s->avctx->width;

  680.                     pixel_ptr = 0;

  681.                     while (pixel_countdown > 0) {

  682.                       *((signed short*)(&pixels[y_ptr + pixel_ptr])) = AV_RL16(&buf[stream_ptr+pixel_ptr]);

  683.                       pixel_ptr += 2;

  684.                       pixel_countdown--;

  685.                     }

  686.                     stream_ptr += s->avctx->width*2;

  687.                 }

  688.             }

  689.             break;

  690. 

  691.         case FLI_MINI:

  692.             /* some sort of a thumbnail? disregard this chunk... */

  693.             stream_ptr += chunk_size - 6;

  694.             break;

  695. 

  696.         default:

  697.             av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);

  698.             break;

  699.         }

  700. 

  701.         frame_size -= chunk_size;

  702.         num_chunks--;

  703.     }

  704. 

  705.     /* by the end of the chunk, the stream ptr should equal the frame

  706.      * size (minus 1, possibly); if it doesn't, issue a warning */

  707.     if ((stream_ptr != buf_size) && (stream_ptr != buf_size - 1))

  708.         av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \

  709.                "and final chunk ptr = %d\n", buf_size, stream_ptr);

  710. 

  711. 

  712.     *data_size=sizeof(AVFrame);

  713.     *(AVFrame*)data = s->frame;

  714. 

  715.     return buf_size;

  716. }

  717. 

  718. static int flic_decode_frame_24BPP(AVCodecContext *avctx,

  719.                                    void *data, int *data_size,

  720.                                    const uint8_t *buf, int buf_size)

  721. {

  722.   av_log(avctx, AV_LOG_ERROR, "24Bpp FLC Unsupported due to lack of test files.\n");

  723.   return -1;

  724. }

  725. 

  726. static int flic_decode_frame(AVCodecContext *avctx,

  727.                              void *data, int *data_size,

  728.                              AVPacket *avpkt)

  729. {

  730.     const uint8_t *buf = avpkt->data;

  731.     int buf_size = avpkt->size;

  732.     if (avctx->pix_fmt == PIX_FMT_PAL8) {

  733.       return flic_decode_frame_8BPP(avctx, data, data_size,

  734.                                     buf, buf_size);

  735.     }

  736.     else if ((avctx->pix_fmt == PIX_FMT_RGB555) ||

  737.              (avctx->pix_fmt == PIX_FMT_RGB565)) {

  738.       return flic_decode_frame_15_16BPP(avctx, data, data_size,

  739.                                         buf, buf_size);

  740.     }

  741.     else if (avctx->pix_fmt == PIX_FMT_BGR24) {

  742.       return flic_decode_frame_24BPP(avctx, data, data_size,

  743.                                      buf, buf_size);

  744.     }

  745. 

  746.     /* Should not get  here, ever as the pix_fmt is processed */

  747.     /* in flic_decode_init and the above if should deal with */

  748.     /* the finite set of possibilites allowable by here. */

  749.     /* But in case we do, just error out. */

  750.     av_log(avctx, AV_LOG_ERROR, "Unknown FLC format, my science cannot explain how this happened.\n");

  751.     return -1;

  752. }

  753. 

  754. 

  755. static av_cold int flic_decode_end(AVCodecContext *avctx)

  756. {

  757.     FlicDecodeContext *s = avctx->priv_data;

  758. 

  759.     if (s->frame.data[0])

  760.         avctx->release_buffer(avctx, &s->frame);

  761. 

  762.     return 0;

  763. }

  764. 

  765. AVCodec ff_flic_decoder = {

  766.     "flic",

  767.     AVMEDIA_TYPE_VIDEO,

  768.     CODEC_ID_FLIC,

  769.     sizeof(FlicDecodeContext),

  770.     flic_decode_init,

  771.     NULL,

  772.     flic_decode_end,

  773.     flic_decode_frame,

  774.     CODEC_CAP_DR1,

  775.     NULL,

  776.     NULL,

  777.     NULL,

  778.     NULL,

  779.     .long_name = NULL_IF_CONFIG_SMALL("Autodesk Animator Flic video"),

  780. };