X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fqtrle.c;h=32ad5d66b71a4a187747848d782c485e973238a5;hb=3f47d316cda9037024ffbc76f789332e62b729bc;hp=0ccca28c63629a6a08337860ad77559888477719;hpb=fead30d4440bc7b75006ae60f2742c63a05168b3;p=ffmpeg diff --git a/libavcodec/qtrle.c b/libavcodec/qtrle.c index 0ccca28c636..32ad5d66b71 100644 --- a/libavcodec/qtrle.c +++ b/libavcodec/qtrle.c @@ -2,26 +2,25 @@ * Quicktime Animation (RLE) Video Decoder * Copyright (C) 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 qtrle.c + * @file * QT RLE Video Decoder by Mike Melanson (melanson@pcisys.net) * For more information about the QT RLE format, visit: * http://www.pcisys.net/~melanson/codecs/ @@ -29,36 +28,24 @@ * The QT RLE decoder has seven modes of operation: * 1, 2, 4, 8, 16, 24, and 32 bits per pixel. For modes 1, 2, 4, and 8 * the decoder outputs PAL8 colorspace data. 16-bit data yields RGB555 - * data. 24-bit data is RGB24 and 32-bit data is RGBA32. + * data. 24-bit data is RGB24 and 32-bit data is RGB32. */ #include #include #include -#include -#include "common.h" #include "avcodec.h" -#include "dsputil.h" +#include "bytestream.h" typedef struct QtrleContext { - AVCodecContext *avctx; - DSPContext dsp; AVFrame frame; - unsigned char *buf; - int size; - + GetByteContext g; + uint32_t pal[256]; } QtrleContext; -#define CHECK_STREAM_PTR(n) \ - if ((stream_ptr + n) > s->size) { \ - av_log (s->avctx, AV_LOG_INFO, "Problem: stream_ptr out of bounds (%d >= %d)\n", \ - stream_ptr + n, s->size); \ - return; \ - } - #define CHECK_PIXEL_PTR(n) \ if ((pixel_ptr + n > pixel_limit) || (pixel_ptr + n < 0)) { \ av_log (s->avctx, AV_LOG_INFO, "Problem: pixel_ptr = %d, pixel_limit = %d\n", \ @@ -66,98 +53,103 @@ typedef struct QtrleContext { return; \ } \ -static void qtrle_decode_1bpp(QtrleContext *s) +static void qtrle_decode_1bpp(QtrleContext *s, int row_ptr, int lines_to_change) { -} + int rle_code; + int pixel_ptr = 0; + int row_inc = s->frame.linesize[0]; + unsigned char pi0, pi1; /* 2 8-pixel values */ + unsigned char *rgb = s->frame.data[0]; + int pixel_limit = s->frame.linesize[0] * s->avctx->height; + int skip; + + while (lines_to_change) { + skip = bytestream2_get_byte(&s->g); + rle_code = (signed char)bytestream2_get_byte(&s->g); + if (rle_code == 0) + break; + if(skip & 0x80) { + lines_to_change--; + row_ptr += row_inc; + pixel_ptr = row_ptr + 2 * (skip & 0x7f); + } else + pixel_ptr += 2 * skip; + CHECK_PIXEL_PTR(0); /* make sure pixel_ptr is positive */ + + if (rle_code < 0) { + /* decode the run length code */ + rle_code = -rle_code; + /* get the next 2 bytes from the stream, treat them as groups + * of 8 pixels, and output them rle_code times */ + + pi0 = bytestream2_get_byte(&s->g); + pi1 = bytestream2_get_byte(&s->g); + CHECK_PIXEL_PTR(rle_code * 2); + + while (rle_code--) { + rgb[pixel_ptr++] = pi0; + rgb[pixel_ptr++] = pi1; + } + } else { + /* copy the same pixel directly to output 2 times */ + rle_code *= 2; + CHECK_PIXEL_PTR(rle_code); -static void qtrle_decode_2bpp(QtrleContext *s) -{ + while (rle_code--) + rgb[pixel_ptr++] = bytestream2_get_byte(&s->g); + } + } } -static void qtrle_decode_4bpp(QtrleContext *s) +static inline void qtrle_decode_2n4bpp(QtrleContext *s, int row_ptr, + int lines_to_change, int bpp) { - int stream_ptr; - int header; - int start_line; - int lines_to_change; - int rle_code; - int row_ptr, pixel_ptr; + int rle_code, i; + int pixel_ptr; int row_inc = s->frame.linesize[0]; - unsigned char pi1, pi2, pi3, pi4, pi5, pi6, pi7, pi8; /* 8 palette indices */ + unsigned char pi[16]; /* 16 palette indices */ unsigned char *rgb = s->frame.data[0]; int pixel_limit = s->frame.linesize[0] * s->avctx->height; + int num_pixels = (bpp == 4) ? 8 : 16; - /* check if this frame is even supposed to change */ - if (s->size < 8) - return; - - /* start after the chunk size */ - stream_ptr = 4; - - /* fetch the header */ - CHECK_STREAM_PTR(2); - header = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 2; - - /* if a header is present, fetch additional decoding parameters */ - if (header & 0x0008) { - CHECK_STREAM_PTR(8); - start_line = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 4; - lines_to_change = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 4; - } else { - start_line = 0; - lines_to_change = s->avctx->height; - } - - row_ptr = row_inc * start_line; while (lines_to_change--) { - CHECK_STREAM_PTR(2); - pixel_ptr = row_ptr + (8 * (s->buf[stream_ptr++] - 1)); + pixel_ptr = row_ptr + (num_pixels * (bytestream2_get_byte(&s->g) - 1)); - while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) { + while ((rle_code = (signed char)bytestream2_get_byte(&s->g)) != -1) { if (rle_code == 0) { /* there's another skip code in the stream */ - CHECK_STREAM_PTR(1); - pixel_ptr += (8 * (s->buf[stream_ptr++] - 1)); + pixel_ptr += (num_pixels * (bytestream2_get_byte(&s->g) - 1)); CHECK_PIXEL_PTR(0); /* make sure pixel_ptr is positive */ } else if (rle_code < 0) { /* decode the run length code */ rle_code = -rle_code; /* get the next 4 bytes from the stream, treat them as palette - * indices, and output them rle_code times */ - CHECK_STREAM_PTR(4); - pi1 = ((s->buf[stream_ptr]) >> 4) & 0x0f; - pi2 = (s->buf[stream_ptr++]) & 0x0f; - pi3 = ((s->buf[stream_ptr]) >> 4) & 0x0f; - pi4 = (s->buf[stream_ptr++]) & 0x0f; - pi5 = ((s->buf[stream_ptr]) >> 4) & 0x0f; - pi6 = (s->buf[stream_ptr++]) & 0x0f; - pi7 = ((s->buf[stream_ptr]) >> 4) & 0x0f; - pi8 = (s->buf[stream_ptr++]) & 0x0f; - - CHECK_PIXEL_PTR(rle_code * 8); - + * indexes, and output them rle_code times */ + for (i = num_pixels-1; i >= 0; i--) { + pi[num_pixels-1-i] = (bytestream2_peek_byte(&s->g) >> ((i*bpp) & 0x07)) & ((1<g, ((i & ((num_pixels>>2)-1)) == 0)); + } + CHECK_PIXEL_PTR(rle_code * num_pixels); while (rle_code--) { - rgb[pixel_ptr++] = pi1; - rgb[pixel_ptr++] = pi2; - rgb[pixel_ptr++] = pi3; - rgb[pixel_ptr++] = pi4; - rgb[pixel_ptr++] = pi5; - rgb[pixel_ptr++] = pi6; - rgb[pixel_ptr++] = pi7; - rgb[pixel_ptr++] = pi8; + for (i = 0; i < num_pixels; i++) + rgb[pixel_ptr++] = pi[i]; } } else { /* copy the same pixel directly to output 4 times */ rle_code *= 4; - CHECK_STREAM_PTR(rle_code); - CHECK_PIXEL_PTR(rle_code*2); - + CHECK_PIXEL_PTR(rle_code*(num_pixels>>2)); while (rle_code--) { - rgb[pixel_ptr++] = ((s->buf[stream_ptr]) >> 4) & 0x0f; - rgb[pixel_ptr++] = (s->buf[stream_ptr++]) & 0x0f; + if(bpp == 4) { + int x = bytestream2_get_byte(&s->g); + rgb[pixel_ptr++] = (x >> 4) & 0x0f; + rgb[pixel_ptr++] = x & 0x0f; + } else { + int x = bytestream2_get_byte(&s->g); + rgb[pixel_ptr++] = (x >> 6) & 0x03; + rgb[pixel_ptr++] = (x >> 4) & 0x03; + rgb[pixel_ptr++] = (x >> 2) & 0x03; + rgb[pixel_ptr++] = x & 0x03; + } } } } @@ -165,64 +157,32 @@ static void qtrle_decode_4bpp(QtrleContext *s) } } -static void qtrle_decode_8bpp(QtrleContext *s) +static void qtrle_decode_8bpp(QtrleContext *s, int row_ptr, int lines_to_change) { - int stream_ptr; - int header; - int start_line; - int lines_to_change; int rle_code; - int row_ptr, pixel_ptr; + int pixel_ptr; int row_inc = s->frame.linesize[0]; - unsigned char pi1, pi2, pi3, pi4; /* 4 palette indices */ + unsigned char pi1, pi2, pi3, pi4; /* 4 palette indexes */ unsigned char *rgb = s->frame.data[0]; int pixel_limit = s->frame.linesize[0] * s->avctx->height; - /* check if this frame is even supposed to change */ - if (s->size < 8) - return; - - /* start after the chunk size */ - stream_ptr = 4; - - /* fetch the header */ - CHECK_STREAM_PTR(2); - header = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 2; - - /* if a header is present, fetch additional decoding parameters */ - if (header & 0x0008) { - CHECK_STREAM_PTR(8); - start_line = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 4; - lines_to_change = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 4; - } else { - start_line = 0; - lines_to_change = s->avctx->height; - } - - row_ptr = row_inc * start_line; while (lines_to_change--) { - CHECK_STREAM_PTR(2); - pixel_ptr = row_ptr + (4 * (s->buf[stream_ptr++] - 1)); + pixel_ptr = row_ptr + (4 * (bytestream2_get_byte(&s->g) - 1)); - while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) { + while ((rle_code = (signed char)bytestream2_get_byte(&s->g)) != -1) { if (rle_code == 0) { /* there's another skip code in the stream */ - CHECK_STREAM_PTR(1); - pixel_ptr += (4 * (s->buf[stream_ptr++] - 1)); + pixel_ptr += (4 * (bytestream2_get_byte(&s->g) - 1)); CHECK_PIXEL_PTR(0); /* make sure pixel_ptr is positive */ } else if (rle_code < 0) { /* decode the run length code */ rle_code = -rle_code; /* get the next 4 bytes from the stream, treat them as palette - * indices, and output them rle_code times */ - CHECK_STREAM_PTR(4); - pi1 = s->buf[stream_ptr++]; - pi2 = s->buf[stream_ptr++]; - pi3 = s->buf[stream_ptr++]; - pi4 = s->buf[stream_ptr++]; + * indexes, and output them rle_code times */ + pi1 = bytestream2_get_byte(&s->g); + pi2 = bytestream2_get_byte(&s->g); + pi3 = bytestream2_get_byte(&s->g); + pi4 = bytestream2_get_byte(&s->g); CHECK_PIXEL_PTR(rle_code * 4); @@ -235,11 +195,10 @@ static void qtrle_decode_8bpp(QtrleContext *s) } else { /* copy the same pixel directly to output 4 times */ rle_code *= 4; - CHECK_STREAM_PTR(rle_code); CHECK_PIXEL_PTR(rle_code); while (rle_code--) { - rgb[pixel_ptr++] = s->buf[stream_ptr++]; + rgb[pixel_ptr++] = bytestream2_get_byte(&s->g); } } } @@ -247,60 +206,27 @@ static void qtrle_decode_8bpp(QtrleContext *s) } } -static void qtrle_decode_16bpp(QtrleContext *s) +static void qtrle_decode_16bpp(QtrleContext *s, int row_ptr, int lines_to_change) { - int stream_ptr; - int header; - int start_line; - int lines_to_change; int rle_code; - int row_ptr, pixel_ptr; + int pixel_ptr; int row_inc = s->frame.linesize[0]; unsigned short rgb16; unsigned char *rgb = s->frame.data[0]; int pixel_limit = s->frame.linesize[0] * s->avctx->height; - /* check if this frame is even supposed to change */ - if (s->size < 8) - return; - - /* start after the chunk size */ - stream_ptr = 4; - - /* fetch the header */ - CHECK_STREAM_PTR(2); - header = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 2; - - /* if a header is present, fetch additional decoding parameters */ - if (header & 0x0008) { - CHECK_STREAM_PTR(8); - start_line = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 4; - lines_to_change = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 4; - } else { - start_line = 0; - lines_to_change = s->avctx->height; - } - - row_ptr = row_inc * start_line; while (lines_to_change--) { - CHECK_STREAM_PTR(2); - pixel_ptr = row_ptr + (s->buf[stream_ptr++] - 1) * 2; + pixel_ptr = row_ptr + (bytestream2_get_byte(&s->g) - 1) * 2; - while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) { + while ((rle_code = (signed char)bytestream2_get_byte(&s->g)) != -1) { if (rle_code == 0) { /* there's another skip code in the stream */ - CHECK_STREAM_PTR(1); - pixel_ptr += (s->buf[stream_ptr++] - 1) * 2; + pixel_ptr += (bytestream2_get_byte(&s->g) - 1) * 2; CHECK_PIXEL_PTR(0); /* make sure pixel_ptr is positive */ } else if (rle_code < 0) { /* decode the run length code */ rle_code = -rle_code; - CHECK_STREAM_PTR(2); - rgb16 = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 2; + rgb16 = bytestream2_get_be16(&s->g); CHECK_PIXEL_PTR(rle_code * 2); @@ -309,13 +235,11 @@ static void qtrle_decode_16bpp(QtrleContext *s) pixel_ptr += 2; } } else { - CHECK_STREAM_PTR(rle_code * 2); CHECK_PIXEL_PTR(rle_code * 2); /* copy pixels directly to output */ while (rle_code--) { - rgb16 = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 2; + rgb16 = bytestream2_get_be16(&s->g); *(unsigned short *)(&rgb[pixel_ptr]) = rgb16; pixel_ptr += 2; } @@ -325,61 +249,29 @@ static void qtrle_decode_16bpp(QtrleContext *s) } } -static void qtrle_decode_24bpp(QtrleContext *s) +static void qtrle_decode_24bpp(QtrleContext *s, int row_ptr, int lines_to_change) { - int stream_ptr; - int header; - int start_line; - int lines_to_change; int rle_code; - int row_ptr, pixel_ptr; + int pixel_ptr; int row_inc = s->frame.linesize[0]; unsigned char r, g, b; unsigned char *rgb = s->frame.data[0]; int pixel_limit = s->frame.linesize[0] * s->avctx->height; - /* check if this frame is even supposed to change */ - if (s->size < 8) - return; - - /* start after the chunk size */ - stream_ptr = 4; - - /* fetch the header */ - CHECK_STREAM_PTR(2); - header = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 2; - - /* if a header is present, fetch additional decoding parameters */ - if (header & 0x0008) { - CHECK_STREAM_PTR(8); - start_line = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 4; - lines_to_change = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 4; - } else { - start_line = 0; - lines_to_change = s->avctx->height; - } - - row_ptr = row_inc * start_line; while (lines_to_change--) { - CHECK_STREAM_PTR(2); - pixel_ptr = row_ptr + (s->buf[stream_ptr++] - 1) * 3; + pixel_ptr = row_ptr + (bytestream2_get_byte(&s->g) - 1) * 3; - while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) { + while ((rle_code = (signed char)bytestream2_get_byte(&s->g)) != -1) { if (rle_code == 0) { /* there's another skip code in the stream */ - CHECK_STREAM_PTR(1); - pixel_ptr += (s->buf[stream_ptr++] - 1) * 3; + pixel_ptr += (bytestream2_get_byte(&s->g) - 1) * 3; CHECK_PIXEL_PTR(0); /* make sure pixel_ptr is positive */ } else if (rle_code < 0) { /* decode the run length code */ rle_code = -rle_code; - CHECK_STREAM_PTR(3); - r = s->buf[stream_ptr++]; - g = s->buf[stream_ptr++]; - b = s->buf[stream_ptr++]; + r = bytestream2_get_byte(&s->g); + g = bytestream2_get_byte(&s->g); + b = bytestream2_get_byte(&s->g); CHECK_PIXEL_PTR(rle_code * 3); @@ -389,14 +281,13 @@ static void qtrle_decode_24bpp(QtrleContext *s) rgb[pixel_ptr++] = b; } } else { - CHECK_STREAM_PTR(rle_code * 3); CHECK_PIXEL_PTR(rle_code * 3); /* copy pixels directly to output */ while (rle_code--) { - rgb[pixel_ptr++] = s->buf[stream_ptr++]; - rgb[pixel_ptr++] = s->buf[stream_ptr++]; - rgb[pixel_ptr++] = s->buf[stream_ptr++]; + rgb[pixel_ptr++] = bytestream2_get_byte(&s->g); + rgb[pixel_ptr++] = bytestream2_get_byte(&s->g); + rgb[pixel_ptr++] = bytestream2_get_byte(&s->g); } } } @@ -404,84 +295,42 @@ static void qtrle_decode_24bpp(QtrleContext *s) } } -static void qtrle_decode_32bpp(QtrleContext *s) +static void qtrle_decode_32bpp(QtrleContext *s, int row_ptr, int lines_to_change) { - int stream_ptr; - int header; - int start_line; - int lines_to_change; int rle_code; - int row_ptr, pixel_ptr; + int pixel_ptr; int row_inc = s->frame.linesize[0]; - unsigned char a, r, g, b; unsigned int argb; unsigned char *rgb = s->frame.data[0]; int pixel_limit = s->frame.linesize[0] * s->avctx->height; - /* check if this frame is even supposed to change */ - if (s->size < 8) - return; - - /* start after the chunk size */ - stream_ptr = 4; - - /* fetch the header */ - CHECK_STREAM_PTR(2); - header = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 2; - - /* if a header is present, fetch additional decoding parameters */ - if (header & 0x0008) { - CHECK_STREAM_PTR(8); - start_line = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 4; - lines_to_change = AV_RB16(&s->buf[stream_ptr]); - stream_ptr += 4; - } else { - start_line = 0; - lines_to_change = s->avctx->height; - } - - row_ptr = row_inc * start_line; while (lines_to_change--) { - CHECK_STREAM_PTR(2); - pixel_ptr = row_ptr + (s->buf[stream_ptr++] - 1) * 4; + pixel_ptr = row_ptr + (bytestream2_get_byte(&s->g) - 1) * 4; - while ((rle_code = (signed char)s->buf[stream_ptr++]) != -1) { + while ((rle_code = (signed char)bytestream2_get_byte(&s->g)) != -1) { if (rle_code == 0) { /* there's another skip code in the stream */ - CHECK_STREAM_PTR(1); - pixel_ptr += (s->buf[stream_ptr++] - 1) * 4; + pixel_ptr += (bytestream2_get_byte(&s->g) - 1) * 4; CHECK_PIXEL_PTR(0); /* make sure pixel_ptr is positive */ } else if (rle_code < 0) { /* decode the run length code */ rle_code = -rle_code; - CHECK_STREAM_PTR(4); - a = s->buf[stream_ptr++]; - r = s->buf[stream_ptr++]; - g = s->buf[stream_ptr++]; - b = s->buf[stream_ptr++]; - argb = (a << 24) | (r << 16) | (g << 8) | (b << 0); + argb = bytestream2_get_be32(&s->g); CHECK_PIXEL_PTR(rle_code * 4); while (rle_code--) { - *(unsigned int *)(&rgb[pixel_ptr]) = argb; + AV_WN32A(rgb + pixel_ptr, argb); pixel_ptr += 4; } } else { - CHECK_STREAM_PTR(rle_code * 4); CHECK_PIXEL_PTR(rle_code * 4); /* copy pixels directly to output */ while (rle_code--) { - a = s->buf[stream_ptr++]; - r = s->buf[stream_ptr++]; - g = s->buf[stream_ptr++]; - b = s->buf[stream_ptr++]; - argb = (a << 24) | (r << 16) | (g << 8) | (b << 0); - *(unsigned int *)(&rgb[pixel_ptr]) = argb; - pixel_ptr += 4; + argb = bytestream2_get_be32(&s->g); + AV_WN32A(rgb + pixel_ptr, argb); + pixel_ptr += 4; } } } @@ -489,42 +338,43 @@ static void qtrle_decode_32bpp(QtrleContext *s) } } -static int qtrle_decode_init(AVCodecContext *avctx) +static av_cold int qtrle_decode_init(AVCodecContext *avctx) { - QtrleContext *s = (QtrleContext *)avctx->priv_data; + QtrleContext *s = avctx->priv_data; s->avctx = avctx; - switch (avctx->bits_per_sample) { + switch (avctx->bits_per_coded_sample) { case 1: + case 33: + avctx->pix_fmt = AV_PIX_FMT_MONOWHITE; + break; + case 2: case 4: case 8: - case 33: case 34: case 36: case 40: - avctx->pix_fmt = PIX_FMT_PAL8; + avctx->pix_fmt = AV_PIX_FMT_PAL8; break; case 16: - avctx->pix_fmt = PIX_FMT_RGB555; + avctx->pix_fmt = AV_PIX_FMT_RGB555; break; case 24: - avctx->pix_fmt = PIX_FMT_RGB24; + avctx->pix_fmt = AV_PIX_FMT_RGB24; break; case 32: - avctx->pix_fmt = PIX_FMT_RGBA32; + avctx->pix_fmt = AV_PIX_FMT_RGB32; break; default: av_log (avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n", - avctx->bits_per_sample); - break; + avctx->bits_per_coded_sample); + return AVERROR_INVALIDDATA; } - avctx->has_b_frames = 0; - dsputil_init(&s->dsp, avctx); s->frame.data[0] = NULL; @@ -532,83 +382,113 @@ static int qtrle_decode_init(AVCodecContext *avctx) } static int qtrle_decode_frame(AVCodecContext *avctx, - void *data, int *data_size, - uint8_t *buf, int buf_size) + void *data, int *got_frame, + AVPacket *avpkt) { - QtrleContext *s = (QtrleContext *)avctx->priv_data; - - s->buf = buf; - s->size = buf_size; + QtrleContext *s = avctx->priv_data; + int header, start_line; + int height, row_ptr; + int has_palette = 0; + int ret; + bytestream2_init(&s->g, avpkt->data, avpkt->size); s->frame.reference = 1; s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE | FF_BUFFER_HINTS_READABLE; - if (avctx->reget_buffer(avctx, &s->frame)) { + if ((ret = avctx->reget_buffer(avctx, &s->frame)) < 0) { av_log (s->avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); - return -1; + return ret; + } + + /* check if this frame is even supposed to change */ + if (avpkt->size < 8) + goto done; + + /* start after the chunk size */ + bytestream2_seek(&s->g, 4, SEEK_SET); + + /* fetch the header */ + header = bytestream2_get_be16(&s->g); + + /* if a header is present, fetch additional decoding parameters */ + if (header & 0x0008) { + if (avpkt->size < 14) + goto done; + start_line = bytestream2_get_be16(&s->g); + bytestream2_skip(&s->g, 2); + height = bytestream2_get_be16(&s->g); + bytestream2_skip(&s->g, 2); + } else { + start_line = 0; + height = s->avctx->height; } + row_ptr = s->frame.linesize[0] * start_line; - switch (avctx->bits_per_sample) { + switch (avctx->bits_per_coded_sample) { case 1: case 33: - qtrle_decode_1bpp(s); + qtrle_decode_1bpp(s, row_ptr, height); break; case 2: case 34: - qtrle_decode_2bpp(s); + qtrle_decode_2n4bpp(s, row_ptr, height, 2); + has_palette = 1; break; case 4: case 36: - qtrle_decode_4bpp(s); - /* make the palette available on the way out */ - memcpy(s->frame.data[1], s->avctx->palctrl->palette, AVPALETTE_SIZE); - if (s->avctx->palctrl->palette_changed) { - s->frame.palette_has_changed = 1; - s->avctx->palctrl->palette_changed = 0; - } + qtrle_decode_2n4bpp(s, row_ptr, height, 4); + has_palette = 1; break; case 8: case 40: - qtrle_decode_8bpp(s); - /* make the palette available on the way out */ - memcpy(s->frame.data[1], s->avctx->palctrl->palette, AVPALETTE_SIZE); - if (s->avctx->palctrl->palette_changed) { - s->frame.palette_has_changed = 1; - s->avctx->palctrl->palette_changed = 0; - } + qtrle_decode_8bpp(s, row_ptr, height); + has_palette = 1; break; case 16: - qtrle_decode_16bpp(s); + qtrle_decode_16bpp(s, row_ptr, height); break; case 24: - qtrle_decode_24bpp(s); + qtrle_decode_24bpp(s, row_ptr, height); break; case 32: - qtrle_decode_32bpp(s); + qtrle_decode_32bpp(s, row_ptr, height); break; default: av_log (s->avctx, AV_LOG_ERROR, "Unsupported colorspace: %d bits/sample?\n", - avctx->bits_per_sample); + avctx->bits_per_coded_sample); break; } - *data_size = sizeof(AVFrame); + if(has_palette) { + const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL); + + if (pal) { + s->frame.palette_has_changed = 1; + memcpy(s->pal, pal, AVPALETTE_SIZE); + } + + /* make the palette available on the way out */ + memcpy(s->frame.data[1], s->pal, AVPALETTE_SIZE); + } + +done: + *got_frame = 1; *(AVFrame*)data = s->frame; /* always report that the buffer was completely consumed */ - return buf_size; + return avpkt->size; } -static int qtrle_decode_end(AVCodecContext *avctx) +static av_cold int qtrle_decode_end(AVCodecContext *avctx) { - QtrleContext *s = (QtrleContext *)avctx->priv_data; + QtrleContext *s = avctx->priv_data; if (s->frame.data[0]) avctx->release_buffer(avctx, &s->frame); @@ -616,15 +496,14 @@ static int qtrle_decode_end(AVCodecContext *avctx) return 0; } -AVCodec qtrle_decoder = { - "qtrle", - CODEC_TYPE_VIDEO, - CODEC_ID_QTRLE, - sizeof(QtrleContext), - qtrle_decode_init, - NULL, - qtrle_decode_end, - qtrle_decode_frame, - CODEC_CAP_DR1, +AVCodec ff_qtrle_decoder = { + .name = "qtrle", + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_QTRLE, + .priv_data_size = sizeof(QtrleContext), + .init = qtrle_decode_init, + .close = qtrle_decode_end, + .decode = qtrle_decode_frame, + .capabilities = CODEC_CAP_DR1, + .long_name = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"), }; -