X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fflicvideo.c;h=68f45b4c658209bbc4ae75994bcc3b217d57bffd;hb=5c4b98de4d101ea715ef86847306a510afd0db0c;hp=ea1d8c4261fd4938c140ebf7b6e2fca2dde7d937;hpb=6140271f545698b7084bb5e02c0cac25e5304289;p=ffmpeg diff --git a/libavcodec/flicvideo.c b/libavcodec/flicvideo.c index ea1d8c4261f..68f45b4c658 100644 --- a/libavcodec/flicvideo.c +++ b/libavcodec/flicvideo.c @@ -2,25 +2,25 @@ * FLI/FLC Animation Video Decoder * Copyright (C) 2003, 2004 the ffmpeg project * - * This file is part of FFmpeg. + * This file is part of Libav. * - * FFmpeg is free software; you can redistribute it and/or + * Libav is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * - * FFmpeg is distributed in the hope that it will be useful, + * Libav is distributed in the hope that it will be useful, * 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 - * License along with FFmpeg; if not, write to the Free Software + * License along with Libav; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /** - * @file flic.c + * @file * 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 @@ -38,10 +38,12 @@ #include #include #include -#include +#include "libavutil/intreadwrite.h" #include "avcodec.h" -#include "bswap.h" +#include "bytestream.h" +#include "internal.h" +#include "mathops.h" #define FLI_256_COLOR 4 #define FLI_DELTA 7 @@ -64,12 +66,12 @@ 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; \ + return AVERROR_INVALIDDATA; \ } \ typedef struct FlicDecodeContext { AVCodecContext *avctx; - AVFrame frame; + AVFrame *frame; unsigned int palette[256]; int new_palette; @@ -82,6 +84,12 @@ static av_cold int flic_decode_init(AVCodecContext *avctx) unsigned char *fli_header = (unsigned char *)avctx->extradata; int depth; + if (avctx->extradata_size != 12 && + avctx->extradata_size != 128) { + av_log(avctx, AV_LOG_ERROR, "Expected extradata of 12 or 128 bytes\n"); + return AVERROR_INVALIDDATA; + } + s->avctx = avctx; s->fli_type = AV_RL16(&fli_header[4]); /* Might be overridden if a Magic Carpet FLC */ @@ -91,9 +99,6 @@ static av_cold int flic_decode_init(AVCodecContext *avctx) /* special case for magic carpet FLIs */ s->fli_type = FLC_MAGIC_CARPET_SYNTHETIC_TYPE_CODE; depth = 8; - } else if (s->avctx->extradata_size != 128) { - av_log(avctx, AV_LOG_ERROR, "Expected extradata of 12 or 128 bytes\n"); - return -1; } else { depth = AV_RL16(&fli_header[12]); } @@ -107,31 +112,33 @@ static av_cold int flic_decode_init(AVCodecContext *avctx) } 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 */ + case 8 : avctx->pix_fmt = AV_PIX_FMT_PAL8; break; + case 15 : avctx->pix_fmt = AV_PIX_FMT_RGB555; break; + case 16 : avctx->pix_fmt = AV_PIX_FMT_RGB565; break; + case 24 : avctx->pix_fmt = AV_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; + return AVERROR_PATCHWELCOME; default : av_log(avctx, AV_LOG_ERROR, "Unknown FLC/FLX depth of %d Bpp is unsupported.\n",depth); - return -1; + return AVERROR_INVALIDDATA; } - s->frame.data[0] = NULL; + s->frame = av_frame_alloc(); + if (!s->frame) + return AVERROR(ENOMEM); + s->new_palette = 0; return 0; } static int flic_decode_frame_8BPP(AVCodecContext *avctx, - void *data, int *data_size, + void *data, int *got_frame, const uint8_t *buf, int buf_size) { FlicDecodeContext *s = avctx->priv_data; - int stream_ptr = 0; + GetByteContext g2; int stream_ptr_after_color_chunk; int pixel_ptr; int palette_ptr; @@ -144,7 +151,7 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, unsigned int chunk_size; int chunk_type; - int i, j; + int i, j, ret; int color_packets; int color_changes; @@ -160,36 +167,33 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, int pixel_skip; int pixel_countdown; unsigned char *pixels; - int pixel_limit; + unsigned 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) { + bytestream2_init(&g2, buf, buf_size); + + if ((ret = ff_reget_buffer(avctx, s->frame)) < 0) { av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); - return -1; + return ret; } - pixels = s->frame.data[0]; - pixel_limit = s->avctx->height * s->frame.linesize[0]; - - frame_size = AV_RL32(&buf[stream_ptr]); - stream_ptr += 6; /* skip the magic number */ - num_chunks = AV_RL16(&buf[stream_ptr]); - stream_ptr += 10; /* skip padding */ + pixels = s->frame->data[0]; + pixel_limit = s->avctx->height * s->frame->linesize[0]; + frame_size = bytestream2_get_le32(&g2); + bytestream2_skip(&g2, 2); /* skip the magic number */ + num_chunks = bytestream2_get_le16(&g2); + bytestream2_skip(&g2, 8); /* skip padding */ frame_size -= 16; /* iterate through the chunks */ while ((frame_size > 0) && (num_chunks > 0)) { - chunk_size = AV_RL32(&buf[stream_ptr]); - stream_ptr += 4; - chunk_type = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + chunk_size = bytestream2_get_le32(&g2); + chunk_type = bytestream2_get_le16(&g2); switch (chunk_type) { case FLI_256_COLOR: case FLI_COLOR: - stream_ptr_after_color_chunk = stream_ptr + chunk_size - 6; + stream_ptr_after_color_chunk = bytestream2_tell(&g2) + chunk_size - 6; /* check special case: If this file is from the Magic Carpet * game and uses 6-bit colors even though it reports 256-color @@ -200,15 +204,14 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, else color_shift = 2; /* set up the palette */ - color_packets = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + color_packets = bytestream2_get_le16(&g2); palette_ptr = 0; for (i = 0; i < color_packets; i++) { /* first byte is how many colors to skip */ - palette_ptr += buf[stream_ptr++]; + palette_ptr += bytestream2_get_byte(&g2); /* next byte indicates how many entries to change */ - color_changes = buf[stream_ptr++]; + color_changes = bytestream2_get_byte(&g2); /* if there are 0 color changes, there are actually 256 */ if (color_changes == 0) @@ -221,9 +224,9 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, if ((unsigned)palette_ptr >= 256) palette_ptr = 0; - r = buf[stream_ptr++] << color_shift; - g = buf[stream_ptr++] << color_shift; - b = buf[stream_ptr++] << color_shift; + r = bytestream2_get_byte(&g2) << color_shift; + g = bytestream2_get_byte(&g2) << color_shift; + b = bytestream2_get_byte(&g2) << color_shift; entry = (r << 16) | (g << 8) | b; if (s->palette[palette_ptr] != entry) s->new_palette = 1; @@ -232,44 +235,46 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, } /* color chunks sometimes have weird 16-bit alignment issues; - * therefore, take the hardline approach and set the stream_ptr + * therefore, take the hardline approach and skip * to the value calculated w.r.t. the size specified by the color * chunk header */ - stream_ptr = stream_ptr_after_color_chunk; + if (stream_ptr_after_color_chunk - bytestream2_tell(&g2) > 0) + bytestream2_skip(&g2, stream_ptr_after_color_chunk - bytestream2_tell(&g2)); break; case FLI_DELTA: y_ptr = 0; - compressed_lines = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + compressed_lines = bytestream2_get_le16(&g2); while (compressed_lines > 0) { - line_packets = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + line_packets = bytestream2_get_le16(&g2); if ((line_packets & 0xC000) == 0xC000) { // line skip opcode line_packets = -line_packets; - y_ptr += line_packets * s->frame.linesize[0]; + y_ptr += line_packets * s->frame->linesize[0]; } 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; + pixel_ptr= y_ptr + s->frame->linesize[0] - 1; + CHECK_PIXEL_PTR(0); + pixels[pixel_ptr] = line_packets & 0xff; } else { compressed_lines--; pixel_ptr = y_ptr; + CHECK_PIXEL_PTR(0); pixel_countdown = s->avctx->width; for (i = 0; i < line_packets; i++) { /* account for the skip bytes */ - pixel_skip = buf[stream_ptr++]; + pixel_skip = bytestream2_get_byte(&g2); pixel_ptr += pixel_skip; pixel_countdown -= pixel_skip; - byte_run = (signed char)(buf[stream_ptr++]); + byte_run = sign_extend(bytestream2_get_byte(&g2), 8); if (byte_run < 0) { byte_run = -byte_run; - palette_idx1 = buf[stream_ptr++]; - palette_idx2 = buf[stream_ptr++]; - CHECK_PIXEL_PTR(byte_run); + palette_idx1 = bytestream2_get_byte(&g2); + palette_idx2 = bytestream2_get_byte(&g2); + CHECK_PIXEL_PTR(byte_run * 2); for (j = 0; j < byte_run; j++, pixel_countdown -= 2) { pixels[pixel_ptr++] = palette_idx1; pixels[pixel_ptr++] = palette_idx2; @@ -277,46 +282,43 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, } else { CHECK_PIXEL_PTR(byte_run * 2); for (j = 0; j < byte_run * 2; j++, pixel_countdown--) { - palette_idx1 = buf[stream_ptr++]; - pixels[pixel_ptr++] = palette_idx1; + pixels[pixel_ptr++] = bytestream2_get_byte(&g2); } } } - y_ptr += s->frame.linesize[0]; + y_ptr += s->frame->linesize[0]; } } break; case FLI_LC: /* line compressed */ - starting_line = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + starting_line = bytestream2_get_le16(&g2); y_ptr = 0; - y_ptr += starting_line * s->frame.linesize[0]; + y_ptr += starting_line * s->frame->linesize[0]; - compressed_lines = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + compressed_lines = bytestream2_get_le16(&g2); while (compressed_lines > 0) { pixel_ptr = y_ptr; + CHECK_PIXEL_PTR(0); pixel_countdown = s->avctx->width; - line_packets = buf[stream_ptr++]; + line_packets = bytestream2_get_byte(&g2); if (line_packets > 0) { for (i = 0; i < line_packets; i++) { /* account for the skip bytes */ - pixel_skip = buf[stream_ptr++]; + pixel_skip = bytestream2_get_byte(&g2); pixel_ptr += pixel_skip; pixel_countdown -= pixel_skip; - byte_run = (signed char)(buf[stream_ptr++]); + byte_run = sign_extend(bytestream2_get_byte(&g2),8); if (byte_run > 0) { CHECK_PIXEL_PTR(byte_run); for (j = 0; j < byte_run; j++, pixel_countdown--) { - palette_idx1 = buf[stream_ptr++]; - pixels[pixel_ptr++] = palette_idx1; + pixels[pixel_ptr++] = bytestream2_get_byte(&g2); } } else if (byte_run < 0) { byte_run = -byte_run; - palette_idx1 = buf[stream_ptr++]; + palette_idx1 = bytestream2_get_byte(&g2); CHECK_PIXEL_PTR(byte_run); for (j = 0; j < byte_run; j++, pixel_countdown--) { pixels[pixel_ptr++] = palette_idx1; @@ -325,7 +327,7 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, } } - y_ptr += s->frame.linesize[0]; + y_ptr += s->frame->linesize[0]; compressed_lines--; } break; @@ -333,7 +335,7 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, case FLI_BLACK: /* set the whole frame to color 0 (which is usually black) */ memset(pixels, 0, - s->frame.linesize[0] * s->avctx->height); + s->frame->linesize[0] * s->avctx->height); break; case FLI_BRUN: @@ -344,12 +346,17 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, pixel_ptr = y_ptr; /* disregard the line packets; instead, iterate through all * pixels on a row */ - stream_ptr++; + bytestream2_skip(&g2, 1); pixel_countdown = s->avctx->width; while (pixel_countdown > 0) { - byte_run = (signed char)(buf[stream_ptr++]); + byte_run = sign_extend(bytestream2_get_byte(&g2), 8); + if (!byte_run) { + av_log(avctx, AV_LOG_ERROR, "Invalid byte run value.\n"); + return AVERROR_INVALIDDATA; + } + if (byte_run > 0) { - palette_idx1 = buf[stream_ptr++]; + palette_idx1 = bytestream2_get_byte(&g2); CHECK_PIXEL_PTR(byte_run); for (j = 0; j < byte_run; j++) { pixels[pixel_ptr++] = palette_idx1; @@ -362,8 +369,7 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, 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; + pixels[pixel_ptr++] = bytestream2_get_byte(&g2); pixel_countdown--; if (pixel_countdown < 0) av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n", @@ -372,7 +378,7 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, } } - y_ptr += s->frame.linesize[0]; + y_ptr += s->frame->linesize[0]; } break; @@ -381,20 +387,19 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, if (chunk_size - 6 > s->avctx->width * s->avctx->height) { 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; + bytestream2_skip(&g2, 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; + for (y_ptr = 0; y_ptr < s->frame->linesize[0] * s->avctx->height; + y_ptr += s->frame->linesize[0]) { + bytestream2_get_buffer(&g2, &pixels[y_ptr], + s->avctx->width); } } break; case FLI_MINI: /* some sort of a thumbnail? disregard this chunk... */ - stream_ptr += chunk_size - 6; + bytestream2_skip(&g2, chunk_size - 6); break; default: @@ -408,32 +413,36 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx, /* 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)) + if ((bytestream2_get_bytes_left(&g2) != 0) && + (bytestream2_get_bytes_left(&g2) != 1)) av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \ - "and final chunk ptr = %d\n", buf_size, stream_ptr); + "and final chunk ptr = %d\n", buf_size, + buf_size - bytestream2_get_bytes_left(&g2)); /* make the palette available on the way out */ - memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE); + memcpy(s->frame->data[1], s->palette, AVPALETTE_SIZE); if (s->new_palette) { - s->frame.palette_has_changed = 1; + s->frame->palette_has_changed = 1; s->new_palette = 0; } - *data_size=sizeof(AVFrame); - *(AVFrame*)data = s->frame; + if ((ret = av_frame_ref(data, s->frame)) < 0) + return ret; + + *got_frame = 1; return buf_size; } static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, - void *data, int *data_size, + void *data, int *got_frame, const 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. */ FlicDecodeContext *s = avctx->priv_data; - int stream_ptr = 0; + GetByteContext g2; int pixel_ptr; unsigned char palette_idx1; @@ -443,7 +452,7 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, unsigned int chunk_size; int chunk_type; - int i, j; + int i, j, ret; int lines; int compressed_lines; @@ -454,31 +463,29 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, int pixel_countdown; unsigned char *pixels; int pixel; - int pixel_limit; + unsigned 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) { + bytestream2_init(&g2, buf, buf_size); + + if ((ret = ff_reget_buffer(avctx, s->frame)) < 0) { av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); - return -1; + return ret; } - pixels = s->frame.data[0]; - pixel_limit = s->avctx->height * s->frame.linesize[0]; + pixels = s->frame->data[0]; + pixel_limit = s->avctx->height * s->frame->linesize[0]; - frame_size = AV_RL32(&buf[stream_ptr]); - stream_ptr += 6; /* skip the magic number */ - num_chunks = AV_RL16(&buf[stream_ptr]); - stream_ptr += 10; /* skip padding */ + frame_size = bytestream2_get_le32(&g2); + bytestream2_skip(&g2, 2); /* skip the magic number */ + num_chunks = bytestream2_get_le16(&g2); + bytestream2_skip(&g2, 8); /* skip padding */ frame_size -= 16; /* iterate through the chunks */ while ((frame_size > 0) && (num_chunks > 0)) { - chunk_size = AV_RL32(&buf[stream_ptr]); - stream_ptr += 4; - chunk_type = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + chunk_size = bytestream2_get_le32(&g2); + chunk_type = bytestream2_get_le16(&g2); switch (chunk_type) { case FLI_256_COLOR: @@ -486,64 +493,63 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, /* 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. */ -/* av_log(avctx, AV_LOG_ERROR, "Unexpected Palette chunk %d in non-paletised FLC\n",chunk_type);*/ - stream_ptr = stream_ptr + chunk_size - 6; + av_dlog(avctx, + "Unexpected Palette chunk %d in non-palettized FLC\n", + chunk_type); + bytestream2_skip(&g2, chunk_size - 6); break; case FLI_DELTA: case FLI_DTA_LC: y_ptr = 0; - compressed_lines = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + compressed_lines = bytestream2_get_le16(&g2); while (compressed_lines > 0) { - line_packets = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + line_packets = bytestream2_get_le16(&g2); if (line_packets < 0) { line_packets = -line_packets; - y_ptr += line_packets * s->frame.linesize[0]; + y_ptr += line_packets * s->frame->linesize[0]; } else { compressed_lines--; pixel_ptr = y_ptr; + CHECK_PIXEL_PTR(0); pixel_countdown = s->avctx->width; for (i = 0; i < line_packets; i++) { /* account for the skip bytes */ - pixel_skip = buf[stream_ptr++]; + pixel_skip = bytestream2_get_byte(&g2); pixel_ptr += (pixel_skip*2); /* Pixel is 2 bytes wide */ pixel_countdown -= pixel_skip; - byte_run = (signed char)(buf[stream_ptr++]); + byte_run = sign_extend(bytestream2_get_byte(&g2), 8); if (byte_run < 0) { byte_run = -byte_run; - pixel = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; - CHECK_PIXEL_PTR(byte_run); + pixel = bytestream2_get_le16(&g2); + CHECK_PIXEL_PTR(2 * 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); + CHECK_PIXEL_PTR(2 * byte_run); for (j = 0; j < byte_run; j++, pixel_countdown--) { - *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + *((signed short*)(&pixels[pixel_ptr])) = bytestream2_get_le16(&g2); pixel_ptr += 2; } } } - y_ptr += s->frame.linesize[0]; + 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; + av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-palettized FLC\n"); + bytestream2_skip(&g2, chunk_size - 6); break; case FLI_BLACK: /* set the whole frame to 0x0000 which is black in both 15Bpp and 16Bpp modes. */ memset(pixels, 0x0000, - s->frame.linesize[0] * s->avctx->height); + s->frame->linesize[0] * s->avctx->height); break; case FLI_BRUN: @@ -552,13 +558,13 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, pixel_ptr = y_ptr; /* disregard the line packets; instead, iterate through all * pixels on a row */ - stream_ptr++; + bytestream2_skip(&g2, 1); pixel_countdown = (s->avctx->width * 2); while (pixel_countdown > 0) { - byte_run = (signed char)(buf[stream_ptr++]); + byte_run = sign_extend(bytestream2_get_byte(&g2), 8); if (byte_run > 0) { - palette_idx1 = buf[stream_ptr++]; + palette_idx1 = bytestream2_get_byte(&g2); CHECK_PIXEL_PTR(byte_run); for (j = 0; j < byte_run; j++) { pixels[pixel_ptr++] = palette_idx1; @@ -571,7 +577,7 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, byte_run = -byte_run; CHECK_PIXEL_PTR(byte_run); for (j = 0; j < byte_run; j++) { - palette_idx1 = buf[stream_ptr++]; + palette_idx1 = bytestream2_get_byte(&g2); pixels[pixel_ptr++] = palette_idx1; pixel_countdown--; if (pixel_countdown < 0) @@ -582,11 +588,11 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, } /* Now FLX is strange, in that it is "byte" as opposed to "pixel" run length compressed. - * This does not give us any good oportunity to perform word endian conversion + * This does not give us any good opportunity to perform word endian conversion * during decompression. So if it is required (i.e., this is not a LE target, we do * a second pass over the line here, swapping the bytes. */ -#ifdef WORDS_BIGENDIAN +#if HAVE_BIGENDIAN pixel_ptr = y_ptr; pixel_countdown = s->avctx->width; while (pixel_countdown > 0) { @@ -594,7 +600,7 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, pixel_ptr += 2; } #endif - y_ptr += s->frame.linesize[0]; + y_ptr += s->frame->linesize[0]; } break; @@ -604,15 +610,14 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, pixel_ptr = y_ptr; /* disregard the line packets; instead, iterate through all * pixels on a row */ - stream_ptr++; + bytestream2_skip(&g2, 1); pixel_countdown = s->avctx->width; /* Width is in pixels, not bytes */ while (pixel_countdown > 0) { - byte_run = (signed char)(buf[stream_ptr++]); + byte_run = sign_extend(bytestream2_get_byte(&g2), 8); if (byte_run > 0) { - pixel = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; - CHECK_PIXEL_PTR(byte_run); + pixel = bytestream2_get_le16(&g2); + CHECK_PIXEL_PTR(2 * byte_run); for (j = 0; j < byte_run; j++) { *((signed short*)(&pixels[pixel_ptr])) = pixel; pixel_ptr += 2; @@ -623,10 +628,9 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, } } else { /* copy pixels if byte_run < 0 */ byte_run = -byte_run; - CHECK_PIXEL_PTR(byte_run); + CHECK_PIXEL_PTR(2 * byte_run); for (j = 0; j < byte_run; j++) { - *((signed short*)(&pixels[pixel_ptr])) = AV_RL16(&buf[stream_ptr]); - stream_ptr += 2; + *((signed short*)(&pixels[pixel_ptr])) = bytestream2_get_le16(&g2); pixel_ptr += 2; pixel_countdown--; if (pixel_countdown < 0) @@ -636,7 +640,7 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, } } - y_ptr += s->frame.linesize[0]; + y_ptr += s->frame->linesize[0]; } break; @@ -646,27 +650,26 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, 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; + bytestream2_skip(&g2, chunk_size - 6); } else { - for (y_ptr = 0; y_ptr < s->frame.linesize[0] * s->avctx->height; - y_ptr += s->frame.linesize[0]) { + 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) { - *((signed short*)(&pixels[y_ptr + pixel_ptr])) = AV_RL16(&buf[stream_ptr+pixel_ptr]); + *((signed short*)(&pixels[y_ptr + pixel_ptr])) = bytestream2_get_le16(&g2); pixel_ptr += 2; pixel_countdown--; } - stream_ptr += s->avctx->width*2; } } break; case FLI_MINI: /* some sort of a thumbnail? disregard this chunk... */ - stream_ptr += chunk_size - 6; + bytestream2_skip(&g2, chunk_size - 6); break; default: @@ -680,40 +683,43 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx, /* 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)) + if ((bytestream2_get_bytes_left(&g2) != 0) && (bytestream2_get_bytes_left(&g2) != 1)) av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \ - "and final chunk ptr = %d\n", buf_size, stream_ptr); + "and final chunk ptr = %d\n", buf_size, bytestream2_tell(&g2)); + if ((ret = av_frame_ref(data, s->frame)) < 0) + return ret; - *data_size=sizeof(AVFrame); - *(AVFrame*)data = s->frame; + *got_frame = 1; return buf_size; } static int flic_decode_frame_24BPP(AVCodecContext *avctx, - void *data, int *data_size, + void *data, int *got_frame, const uint8_t *buf, int buf_size) { av_log(avctx, AV_LOG_ERROR, "24Bpp FLC Unsupported due to lack of test files.\n"); - return -1; + return AVERROR_PATCHWELCOME; } static int flic_decode_frame(AVCodecContext *avctx, - void *data, int *data_size, - const uint8_t *buf, int buf_size) + void *data, int *got_frame, + AVPacket *avpkt) { - if (avctx->pix_fmt == PIX_FMT_PAL8) { - return flic_decode_frame_8BPP(avctx, data, data_size, + const uint8_t *buf = avpkt->data; + int buf_size = avpkt->size; + if (avctx->pix_fmt == AV_PIX_FMT_PAL8) { + return flic_decode_frame_8BPP(avctx, data, got_frame, 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, + else if ((avctx->pix_fmt == AV_PIX_FMT_RGB555) || + (avctx->pix_fmt == AV_PIX_FMT_RGB565)) { + return flic_decode_frame_15_16BPP(avctx, data, got_frame, buf, buf_size); } - else if (avctx->pix_fmt == PIX_FMT_BGR24) { - return flic_decode_frame_24BPP(avctx, data, data_size, + else if (avctx->pix_fmt == AV_PIX_FMT_BGR24) { + return flic_decode_frame_24BPP(avctx, data, got_frame, buf, buf_size); } @@ -722,7 +728,7 @@ static int flic_decode_frame(AVCodecContext *avctx, /* the finite set of possibilites allowable by here. */ /* 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"); - return -1; + return AVERROR_BUG; } @@ -730,25 +736,19 @@ static av_cold int flic_decode_end(AVCodecContext *avctx) { FlicDecodeContext *s = avctx->priv_data; - if (s->frame.data[0]) - avctx->release_buffer(avctx, &s->frame); + av_frame_free(&s->frame); 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, - NULL, - NULL, - NULL, - NULL, - .long_name = "Autodesk Animator Flic video", +AVCodec ff_flic_decoder = { + .name = "flic", + .long_name = NULL_IF_CONFIG_SMALL("Autodesk Animator Flic video"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_FLIC, + .priv_data_size = sizeof(FlicDecodeContext), + .init = flic_decode_init, + .close = flic_decode_end, + .decode = flic_decode_frame, + .capabilities = CODEC_CAP_DR1, };