X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fxan.c;h=4bf1d87f9db9dce199d491e06d42d17f3174cf47;hb=7f596368a404363d72b1be6d16c51420a71bc523;hp=68e3444ee55208136322ae00ef71e59f05b640ac;hpb=6f4915ac835af2ddfcdb25c0aa88162d22b2efb8;p=ffmpeg diff --git a/libavcodec/xan.c b/libavcodec/xan.c index 68e3444ee55..4bf1d87f9db 100644 --- a/libavcodec/xan.c +++ b/libavcodec/xan.c @@ -2,491 +2,244 @@ * Wing Commander/Xan Video Decoder * Copyright (C) 2003 the ffmpeg project * - * This library is free software; you can redistribute it and/or + * This file is part of Libav. + * + * 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 of the License, or (at your option) any later version. + * version 2.1 of the License, or (at your option) any later version. * - * This library 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 this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with Libav; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /** - * @file xan.c - * Xan video decoder for Wing Commander III & IV computer games + * @file + * Xan video decoder for Wing Commander III computer game * by Mario Brito (mbrito@student.dei.uc.pt) * and Mike Melanson (melanson@pcisys.net) * - * The xan_wc3 decoder outputs the following colorspaces natively: - * PAL8 (default), RGB555, RGB565, RGB24, BGR24, RGBA32, YUV444P + * The xan_wc3 decoder outputs PAL8 data. */ #include #include #include -#include -#include "common.h" +#include "libavutil/intreadwrite.h" +#include "libavutil/mem.h" #include "avcodec.h" -#include "dsputil.h" +#include "bytestream.h" +#define BITSTREAM_READER_LE +#include "get_bits.h" +#include "internal.h" + +#define RUNTIME_GAMMA 0 +#define VGA__TAG MKTAG('V', 'G', 'A', ' ') +#define PALT_TAG MKTAG('P', 'A', 'L', 'T') +#define SHOT_TAG MKTAG('S', 'H', 'O', 'T') #define PALETTE_COUNT 256 -#define PALETTE_CONTROL_SIZE ((256 * 3) + 1) +#define PALETTE_SIZE (PALETTE_COUNT * 3) +#define PALETTES_MAX 256 typedef struct XanContext { AVCodecContext *avctx; - DSPContext dsp; - AVFrame last_frame; - AVFrame current_frame; + AVFrame *last_frame; - unsigned char *buf; + const unsigned char *buf; int size; - unsigned char palette[PALETTE_COUNT * 4]; - /* scratch space */ unsigned char *buffer1; + int buffer1_size; unsigned char *buffer2; + int buffer2_size; + + unsigned *palettes; + int palettes_count; + int cur_palette; + + int frame_size; } XanContext; -#define BE_16(x) ((((uint8_t*)(x))[0] << 8) | ((uint8_t*)(x))[1]) -#define LE_16(x) ((((uint8_t*)(x))[1] << 8) | ((uint8_t*)(x))[0]) -#define LE_32(x) ((((uint8_t*)(x))[3] << 24) | \ - (((uint8_t*)(x))[2] << 16) | \ - (((uint8_t*)(x))[1] << 8) | \ - ((uint8_t*)(x))[0]) - -/* RGB -> YUV conversion stuff */ -#define SCALEFACTOR 65536 -#define CENTERSAMPLE 128 - -#define COMPUTE_Y(r, g, b) \ - (unsigned char) \ - ((y_r_table[r] + y_g_table[g] + y_b_table[b]) / SCALEFACTOR) -#define COMPUTE_U(r, g, b) \ - (unsigned char) \ - ((u_r_table[r] + u_g_table[g] + u_b_table[b]) / SCALEFACTOR + CENTERSAMPLE) -#define COMPUTE_V(r, g, b) \ - (unsigned char) \ - ((v_r_table[r] + v_g_table[g] + v_b_table[b]) / SCALEFACTOR + CENTERSAMPLE) - -#define Y_R (SCALEFACTOR * 0.29900) -#define Y_G (SCALEFACTOR * 0.58700) -#define Y_B (SCALEFACTOR * 0.11400) - -#define U_R (SCALEFACTOR * -0.16874) -#define U_G (SCALEFACTOR * -0.33126) -#define U_B (SCALEFACTOR * 0.50000) - -#define V_R (SCALEFACTOR * 0.50000) -#define V_G (SCALEFACTOR * -0.41869) -#define V_B (SCALEFACTOR * -0.08131) +static av_cold int xan_decode_end(AVCodecContext *avctx) +{ + XanContext *s = avctx->priv_data; -/* - * Precalculate all of the YUV tables since it requires fewer than - * 10 kilobytes to store them. - */ -static int y_r_table[256]; -static int y_g_table[256]; -static int y_b_table[256]; + av_frame_free(&s->last_frame); -static int u_r_table[256]; -static int u_g_table[256]; -static int u_b_table[256]; + av_freep(&s->buffer1); + av_freep(&s->buffer2); + av_freep(&s->palettes); -static int v_r_table[256]; -static int v_g_table[256]; -static int v_b_table[256]; + return 0; +} -static int xan_decode_init(AVCodecContext *avctx) +static av_cold int xan_decode_init(AVCodecContext *avctx) { XanContext *s = avctx->priv_data; - int i; s->avctx = avctx; - - if ((avctx->codec->id == CODEC_ID_XAN_WC3) && - (s->avctx->extradata_size != PALETTE_CONTROL_SIZE)) { - printf (" WC3 Xan video: expected extradata_size of %d\n", - PALETTE_CONTROL_SIZE); - return -1; + s->frame_size = 0; + + avctx->pix_fmt = AV_PIX_FMT_PAL8; + + s->buffer1_size = avctx->width * avctx->height; + s->buffer1 = av_malloc(s->buffer1_size); + if (!s->buffer1) + return AVERROR(ENOMEM); + s->buffer2_size = avctx->width * avctx->height; + s->buffer2 = av_malloc(s->buffer2_size + 130); + if (!s->buffer2) { + av_freep(&s->buffer1); + return AVERROR(ENOMEM); } - avctx->pix_fmt = PIX_FMT_PAL8; - avctx->has_b_frames = 0; - dsputil_init(&s->dsp, avctx); - - /* initialize the RGB -> YUV tables */ - for (i = 0; i < 256; i++) { - y_r_table[i] = Y_R * i; - y_g_table[i] = Y_G * i; - y_b_table[i] = Y_B * i; - - u_r_table[i] = U_R * i; - u_g_table[i] = U_G * i; - u_b_table[i] = U_B * i; - - v_r_table[i] = V_R * i; - v_g_table[i] = V_G * i; - v_b_table[i] = V_B * i; + s->last_frame = av_frame_alloc(); + if (!s->last_frame) { + xan_decode_end(avctx); + return AVERROR(ENOMEM); } - s->buffer1 = av_malloc(avctx->width * avctx->height); - s->buffer2 = av_malloc(avctx->width * avctx->height); - if (!s->buffer1 || !s->buffer2) - return -1; - return 0; } -/* This function is used in lieu of memcpy(). This decoder can not use - * memcpy because the memory locations often overlap and - * memcpy doesn't like that; it's not uncommon, for example, for - * dest = src+1, to turn byte A into pattern AAAAAAAA. - * This was originally repz movsb in Intel x86 ASM. */ -static inline void bytecopy(unsigned char *dest, unsigned char *src, int count) -{ - int i; - - for (i = 0; i < count; i++) - dest[i] = src[i]; -} - -static int xan_huffman_decode(unsigned char *dest, unsigned char *src) +static int xan_huffman_decode(unsigned char *dest, int dest_len, + const unsigned char *src, int src_len) { unsigned char byte = *src++; unsigned char ival = byte + 0x16; - unsigned char * ptr = src + byte*2; + const unsigned char * ptr = src + byte*2; + int ptr_len = src_len - 1 - byte*2; unsigned char val = ival; - int counter = 0; + unsigned char *dest_end = dest + dest_len; + unsigned char *dest_start = dest; + GetBitContext gb; + + if (ptr_len < 0) + return AVERROR_INVALIDDATA; - unsigned char bits = *ptr++; + init_get_bits(&gb, ptr, ptr_len * 8); - while ( val != 0x16 ) { - if ( (1 << counter) & bits ) - val = src[byte + val - 0x17]; - else - val = src[val - 0x17]; + while (val != 0x16) { + unsigned idx = val - 0x17 + get_bits1(&gb) * byte; + if (idx >= 2 * byte) + return AVERROR_INVALIDDATA; + val = src[idx]; - if ( val < 0x16 ) { + if (val < 0x16) { + if (dest >= dest_end) + return dest_len; *dest++ = val; val = ival; } - - if (counter++ == 7) { - counter = 0; - bits = *ptr++; - } } - return 0; + return dest - dest_start; } -static void xan_unpack(unsigned char *dest, unsigned char *src) +/** + * unpack simple compression + * + * @param dest destination buffer of dest_len, must be padded with at least 130 bytes + */ +static void xan_unpack(unsigned char *dest, int dest_len, + const unsigned char *src, int src_len) { unsigned char opcode; int size; - int offset; - int byte1, byte2, byte3; - - for (;;) { - opcode = *src++; - - if ( (opcode & 0x80) == 0 ) { - - offset = *src++; - - size = opcode & 3; - bytecopy(dest, src, size); dest += size; src += size; - - size = ((opcode & 0x1c) >> 2) + 3; - bytecopy (dest, dest - (((opcode & 0x60) << 3) + offset + 1), size); - dest += size; - - } else if ( (opcode & 0x40) == 0 ) { - - byte1 = *src++; - byte2 = *src++; - - size = byte1 >> 6; - bytecopy (dest, src, size); dest += size; src += size; - - size = (opcode & 0x3f) + 4; - bytecopy (dest, dest - (((byte1 & 0x3f) << 8) + byte2 + 1), size); - dest += size; - - } else if ( (opcode & 0x20) == 0 ) { - - byte1 = *src++; - byte2 = *src++; - byte3 = *src++; + unsigned char *dest_org = dest; + unsigned char *dest_end = dest + dest_len; + GetByteContext ctx; + + bytestream2_init(&ctx, src, src_len); + while (dest < dest_end && bytestream2_get_bytes_left(&ctx)) { + opcode = bytestream2_get_byte(&ctx); + + if (opcode < 0xe0) { + int size2, back; + if ((opcode & 0x80) == 0) { + size = opcode & 3; + + back = ((opcode & 0x60) << 3) + bytestream2_get_byte(&ctx) + 1; + size2 = ((opcode & 0x1c) >> 2) + 3; + } else if ((opcode & 0x40) == 0) { + size = bytestream2_peek_byte(&ctx) >> 6; + + back = (bytestream2_get_be16(&ctx) & 0x3fff) + 1; + size2 = (opcode & 0x3f) + 4; + } else { + size = opcode & 3; - size = opcode & 3; - bytecopy (dest, src, size); dest += size; src += size; + back = ((opcode & 0x10) << 12) + bytestream2_get_be16(&ctx) + 1; + size2 = ((opcode & 0x0c) << 6) + bytestream2_get_byte(&ctx) + 5; + } - size = byte3 + 5 + ((opcode & 0xc) << 6); - bytecopy (dest, - dest - ((((opcode & 0x10) >> 4) << 0x10) + 1 + (byte1 << 8) + byte2), - size); + if (dest_end - dest < size + size2 || + dest + size - dest_org < back || + bytestream2_get_bytes_left(&ctx) < size) + return; + bytestream2_get_buffer(&ctx, dest, size); dest += size; + av_memcpy_backptr(dest, back, size2); + dest += size2; } else { - size = ((opcode & 0x1f) << 2) + 4; + int finish = opcode >= 0xfc; + size = finish ? opcode & 3 : ((opcode & 0x1f) << 2) + 4; - if (size > 0x70) - break; - - bytecopy (dest, src, size); dest += size; src += size; - } - } - - size = opcode & 3; - bytecopy(dest, src, size); dest += size; src += size; -} - -static void inline xan_wc3_build_palette(XanContext *s, - unsigned char *palette_data) -{ - int i; - unsigned char r, g, b; - unsigned short *palette16; - unsigned int *palette32; - - /* transform the palette passed through the palette control structure - * into the necessary internal format depending on colorspace */ - - switch (s->avctx->pix_fmt) { - - case PIX_FMT_PAL8: - for (i = 0; i < PALETTE_COUNT; i++) { - r = *palette_data++; - g = *palette_data++; - b = *palette_data++; - s->palette[i * 4 + 0] = b; - s->palette[i * 4 + 1] = g; - s->palette[i * 4 + 2] = r; - } - break; - - case PIX_FMT_RGB555: - palette16 = (unsigned short *)s->palette; - for (i = 0; i < PALETTE_COUNT; i++) { - r = *palette_data++; - g = *palette_data++; - b = *palette_data++; - palette16[i] = - ((r >> 3) << 10) | - ((g >> 3) << 5) | - ((g >> 3) << 0); - } - break; - - case PIX_FMT_RGB565: - palette16 = (unsigned short *)s->palette; - for (i = 0; i < PALETTE_COUNT; i++) { - r = *palette_data++; - g = *palette_data++; - b = *palette_data++; - palette16[i] = - ((r >> 3) << 11) | - ((g >> 2) << 5) | - ((g >> 3) << 0); - } - break; - - case PIX_FMT_RGB24: - for (i = 0; i < PALETTE_COUNT; i++) { - s->palette[i * 4 + 0] = *palette_data++; - s->palette[i * 4 + 1] = *palette_data++; - s->palette[i * 4 + 2] = *palette_data++; - } - break; - - case PIX_FMT_BGR24: - for (i = 0; i < PALETTE_COUNT; i++) { - r = *palette_data++; - g = *palette_data++; - b = *palette_data++; - s->palette[i * 4 + 0] = b; - s->palette[i * 4 + 1] = g; - s->palette[i * 4 + 2] = r; - } - break; - - case PIX_FMT_RGBA32: - palette32 = (unsigned int *)s->palette; - for (i = 0; i < PALETTE_COUNT; i++) { - r = *palette_data++; - g = *palette_data++; - b = *palette_data++; - palette32[i] = (r << 16) | (g << 8) | (b); - } - break; - - case PIX_FMT_YUV444P: - for (i = 0; i < PALETTE_COUNT; i++) { - r = *palette_data++; - g = *palette_data++; - b = *palette_data++; - s->palette[i * 4 + 0] = COMPUTE_Y(r, g, b); - s->palette[i * 4 + 1] = COMPUTE_U(r, g, b); - s->palette[i * 4 + 2] = COMPUTE_V(r, g, b); + if (dest_end - dest < size || bytestream2_get_bytes_left(&ctx) < size) + return; + bytestream2_get_buffer(&ctx, dest, size); + dest += size; + if (finish) + return; } - break; - - default: - printf (" Xan WC3: Unhandled colorspace\n"); - break; } } -static void inline xan_wc3_output_pixel_run(XanContext *s, - unsigned char *pixel_buffer, int x, int y, int pixel_count) +static inline void xan_wc3_output_pixel_run(XanContext *s, AVFrame *frame, + const unsigned char *pixel_buffer, int x, int y, int pixel_count) { int stride; int line_inc; int index; int current_x; int width = s->avctx->width; - unsigned char pixel; unsigned char *palette_plane; - unsigned char *y_plane; - unsigned char *u_plane; - unsigned char *v_plane; - unsigned char *rgb_plane; - unsigned short *rgb16_plane; - unsigned short *palette16; - unsigned int *rgb32_plane; - unsigned int *palette32; - - switch (s->avctx->pix_fmt) { - - case PIX_FMT_PAL8: - palette_plane = s->current_frame.data[0]; - stride = s->current_frame.linesize[0]; - line_inc = stride - width; - index = y * stride + x; - current_x = x; - while(pixel_count--) { - - /* don't do a memcpy() here; keyframes generally copy an entire - * frame of data and the stride needs to be accounted for */ - palette_plane[index++] = *pixel_buffer++; - - current_x++; - if (current_x >= width) { - /* reset accounting variables */ - index += line_inc; - current_x = 0; - } - } - break; - - case PIX_FMT_RGB555: - case PIX_FMT_RGB565: - rgb16_plane = (unsigned short *)s->current_frame.data[0]; - palette16 = (unsigned short *)s->palette; - stride = s->current_frame.linesize[0] / 2; - line_inc = stride - width; - index = y * stride + x; - current_x = x; - while(pixel_count--) { - - rgb16_plane[index++] = palette16[*pixel_buffer++]; - - current_x++; - if (current_x >= width) { - /* reset accounting variables */ - index += line_inc; - current_x = 0; - } - } - break; - - case PIX_FMT_RGB24: - case PIX_FMT_BGR24: - rgb_plane = s->current_frame.data[0]; - stride = s->current_frame.linesize[0]; - line_inc = stride - width * 3; - index = y * stride + x * 3; - current_x = x; - while(pixel_count--) { - pixel = *pixel_buffer++; - - rgb_plane[index++] = s->palette[pixel * 4 + 0]; - rgb_plane[index++] = s->palette[pixel * 4 + 1]; - rgb_plane[index++] = s->palette[pixel * 4 + 2]; - - current_x++; - if (current_x >= width) { - /* reset accounting variables */ - index += line_inc; - current_x = 0; - } - } - break; - - case PIX_FMT_RGBA32: - rgb32_plane = (unsigned int *)s->current_frame.data[0]; - palette32 = (unsigned int *)s->palette; - stride = s->current_frame.linesize[0] / 4; - line_inc = stride - width; - index = y * stride + x; - current_x = x; - while(pixel_count--) { - - rgb32_plane[index++] = palette32[*pixel_buffer++]; - - current_x++; - if (current_x >= width) { - /* reset accounting variables */ - index += line_inc; - current_x = 0; - } - } - break; - - case PIX_FMT_YUV444P: - y_plane = s->current_frame.data[0]; - u_plane = s->current_frame.data[1]; - v_plane = s->current_frame.data[2]; - stride = s->current_frame.linesize[0]; - line_inc = stride - width; - index = y * stride + x; - current_x = x; - while(pixel_count--) { - pixel = *pixel_buffer++; - - y_plane[index] = s->palette[pixel * 4 + 0]; - u_plane[index] = s->palette[pixel * 4 + 1]; - v_plane[index] = s->palette[pixel * 4 + 2]; - - index++; - current_x++; - if (current_x >= width) { - /* reset accounting variables */ - index += line_inc; - current_x = 0; - } - } - break; - default: - printf (" Xan WC3: Unhandled colorspace\n"); - break; + palette_plane = frame->data[0]; + stride = frame->linesize[0]; + line_inc = stride - width; + index = y * stride + x; + current_x = x; + while (pixel_count && index < s->frame_size) { + int count = FFMIN(pixel_count, width - current_x); + memcpy(palette_plane + index, pixel_buffer, count); + pixel_count -= count; + index += count; + pixel_buffer += count; + current_x += count; + + if (current_x >= width) { + index += line_inc; + current_x = 0; + } } } -static void inline xan_wc3_copy_pixel_run(XanContext *s, - int x, int y, int pixel_count, int motion_x, int motion_y) +static inline void xan_wc3_copy_pixel_run(XanContext *s, AVFrame *frame, + int x, int y, + int pixel_count, int motion_x, + int motion_y) { int stride; int line_inc; @@ -494,216 +247,108 @@ static void inline xan_wc3_copy_pixel_run(XanContext *s, int curframe_x, prevframe_x; int width = s->avctx->width; unsigned char *palette_plane, *prev_palette_plane; - unsigned char *y_plane, *u_plane, *v_plane; - unsigned char *prev_y_plane, *prev_u_plane, *prev_v_plane; - unsigned char *rgb_plane, *prev_rgb_plane; - unsigned short *rgb16_plane, *prev_rgb16_plane; - unsigned int *rgb32_plane, *prev_rgb32_plane; - - switch (s->avctx->pix_fmt) { - - case PIX_FMT_PAL8: - palette_plane = s->current_frame.data[0]; - prev_palette_plane = s->last_frame.data[0]; - stride = s->current_frame.linesize[0]; - line_inc = stride - width; - curframe_index = y * stride + x; - curframe_x = x; - prevframe_index = (y + motion_y) * stride + x + motion_x; - prevframe_x = x + motion_x; - while(pixel_count--) { - - palette_plane[curframe_index++] = - prev_palette_plane[prevframe_index++]; - - curframe_x++; - if (curframe_x >= width) { - /* reset accounting variables */ - curframe_index += line_inc; - curframe_x = 0; - } - prevframe_x++; - if (prevframe_x >= width) { - /* reset accounting variables */ - prevframe_index += line_inc; - prevframe_x = 0; - } - } - break; - - case PIX_FMT_RGB555: - case PIX_FMT_RGB565: - rgb16_plane = (unsigned short *)s->current_frame.data[0]; - prev_rgb16_plane = (unsigned short *)s->last_frame.data[0]; - stride = s->current_frame.linesize[0] / 2; - line_inc = stride - width; - curframe_index = y * stride + x; - curframe_x = x; - prevframe_index = (y + motion_y) * stride + x + motion_x; - prevframe_x = x + motion_x; - while(pixel_count--) { - - rgb16_plane[curframe_index++] = - prev_rgb16_plane[prevframe_index++]; - - curframe_x++; - if (curframe_x >= width) { - /* reset accounting variables */ - curframe_index += line_inc; - curframe_x = 0; - } - - prevframe_x++; - if (prevframe_x >= width) { - /* reset accounting variables */ - prevframe_index += line_inc; - prevframe_x = 0; - } - } - break; - - case PIX_FMT_RGB24: - case PIX_FMT_BGR24: - rgb_plane = s->current_frame.data[0]; - prev_rgb_plane = s->last_frame.data[0]; - stride = s->current_frame.linesize[0]; - line_inc = stride - width * 3; - curframe_index = y * stride + x * 3; - curframe_x = x; - prevframe_index = (y + motion_y) * stride + - (3 * (x + motion_x)); - prevframe_x = x + motion_x; - while(pixel_count--) { - - rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++]; - rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++]; - rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++]; - - curframe_x++; - if (curframe_x >= width) { - /* reset accounting variables */ - curframe_index += line_inc; - curframe_x = 0; - } - - prevframe_x++; - if (prevframe_x >= width) { - /* reset accounting variables */ - prevframe_index += line_inc; - prevframe_x = 0; - } - } - break; - - case PIX_FMT_RGBA32: - rgb32_plane = (unsigned int *)s->current_frame.data[0]; - prev_rgb32_plane = (unsigned int *)s->last_frame.data[0]; - stride = s->current_frame.linesize[0] / 4; - line_inc = stride - width; - curframe_index = y * stride + x; - curframe_x = x; - prevframe_index = (y + motion_y) * stride + x + motion_x; - prevframe_x = x + motion_x; - while(pixel_count--) { - - rgb32_plane[curframe_index++] = - prev_rgb32_plane[prevframe_index++]; - - curframe_x++; - if (curframe_x >= width) { - /* reset accounting variables */ - curframe_index += line_inc; - curframe_x = 0; - } - - prevframe_x++; - if (prevframe_x >= width) { - /* reset accounting variables */ - prevframe_index += line_inc; - prevframe_x = 0; - } + if (y + motion_y < 0 || y + motion_y >= s->avctx->height || + x + motion_x < 0 || x + motion_x >= s->avctx->width) + return; + + palette_plane = frame->data[0]; + prev_palette_plane = s->last_frame->data[0]; + if (!prev_palette_plane) + prev_palette_plane = palette_plane; + stride = frame->linesize[0]; + line_inc = stride - width; + curframe_index = y * stride + x; + curframe_x = x; + prevframe_index = (y + motion_y) * stride + x + motion_x; + prevframe_x = x + motion_x; + while (pixel_count && + curframe_index < s->frame_size && + prevframe_index < s->frame_size) { + int count = FFMIN3(pixel_count, width - curframe_x, + width - prevframe_x); + + memcpy(palette_plane + curframe_index, + prev_palette_plane + prevframe_index, count); + pixel_count -= count; + curframe_index += count; + prevframe_index += count; + curframe_x += count; + prevframe_x += count; + + if (curframe_x >= width) { + curframe_index += line_inc; + curframe_x = 0; } - break; - - case PIX_FMT_YUV444P: - y_plane = s->current_frame.data[0]; - u_plane = s->current_frame.data[1]; - v_plane = s->current_frame.data[2]; - prev_y_plane = s->last_frame.data[0]; - prev_u_plane = s->last_frame.data[1]; - prev_v_plane = s->last_frame.data[2]; - stride = s->current_frame.linesize[0]; - line_inc = stride - width; - curframe_index = y * stride + x; - curframe_x = x; - prevframe_index = (y + motion_y) * stride + x + motion_x; - prevframe_x = x + motion_x; - while(pixel_count--) { - - y_plane[curframe_index] = prev_y_plane[prevframe_index]; - u_plane[curframe_index] = prev_u_plane[prevframe_index]; - v_plane[curframe_index] = prev_v_plane[prevframe_index]; - - curframe_index++; - curframe_x++; - if (curframe_x >= width) { - /* reset accounting variables */ - curframe_index += line_inc; - curframe_x = 0; - } - prevframe_index++; - prevframe_x++; - if (prevframe_x >= width) { - /* reset accounting variables */ - prevframe_index += line_inc; - prevframe_x = 0; - } + if (prevframe_x >= width) { + prevframe_index += line_inc; + prevframe_x = 0; } - break; - - default: - printf (" Xan WC3: Unhandled colorspace\n"); - break; } } -static void xan_wc3_decode_frame(XanContext *s) { +static int xan_wc3_decode_frame(XanContext *s, AVFrame *frame) +{ - int width = s->avctx->width; + int width = s->avctx->width; int height = s->avctx->height; int total_pixels = width * height; unsigned char opcode; unsigned char flag = 0; int size = 0; int motion_x, motion_y; - int x, y; + int x, y, ret; unsigned char *opcode_buffer = s->buffer1; - unsigned char *imagedata_buffer = s->buffer2; + unsigned char *opcode_buffer_end = s->buffer1 + s->buffer1_size; + int opcode_buffer_size = s->buffer1_size; + const unsigned char *imagedata_buffer = s->buffer2; /* pointers to segments inside the compressed chunk */ - unsigned char *huffman_segment; - unsigned char *size_segment; - unsigned char *vector_segment; - unsigned char *imagedata_segment; - - huffman_segment = s->buf + LE_16(&s->buf[0]); - size_segment = s->buf + LE_16(&s->buf[2]); - vector_segment = s->buf + LE_16(&s->buf[4]); - imagedata_segment = s->buf + LE_16(&s->buf[6]); - - xan_huffman_decode(opcode_buffer, huffman_segment); - - if (imagedata_segment[0] == 2) - xan_unpack(imagedata_buffer, &imagedata_segment[1]); - else + const unsigned char *huffman_segment; + GetByteContext size_segment; + GetByteContext vector_segment; + const unsigned char *imagedata_segment; + int huffman_offset, size_offset, vector_offset, imagedata_offset, + imagedata_size; + + if (s->size < 8) + return AVERROR_INVALIDDATA; + + huffman_offset = AV_RL16(&s->buf[0]); + size_offset = AV_RL16(&s->buf[2]); + vector_offset = AV_RL16(&s->buf[4]); + imagedata_offset = AV_RL16(&s->buf[6]); + + if (huffman_offset >= s->size || + size_offset >= s->size || + vector_offset >= s->size || + imagedata_offset >= s->size) + return AVERROR_INVALIDDATA; + + huffman_segment = s->buf + huffman_offset; + bytestream2_init(&size_segment, s->buf + size_offset, s->size - size_offset); + bytestream2_init(&vector_segment, s->buf + vector_offset, s->size - vector_offset); + imagedata_segment = s->buf + imagedata_offset; + + if ((ret = xan_huffman_decode(opcode_buffer, opcode_buffer_size, + huffman_segment, s->size - huffman_offset)) < 0) + return AVERROR_INVALIDDATA; + opcode_buffer_end = opcode_buffer + ret; + + if (imagedata_segment[0] == 2) { + xan_unpack(s->buffer2, s->buffer2_size, + &imagedata_segment[1], s->size - imagedata_offset - 1); + imagedata_size = s->buffer2_size; + } else { + imagedata_size = s->size - imagedata_offset - 1; imagedata_buffer = &imagedata_segment[1]; + } /* use the decoded data segments to build the frame */ x = y = 0; - while (total_pixels) { + while (total_pixels && opcode_buffer < opcode_buffer_end) { opcode = *opcode_buffer++; size = 0; @@ -737,151 +382,243 @@ static void xan_wc3_decode_frame(XanContext *s) { case 9: case 19: - size = *size_segment++; + size = bytestream2_get_byte(&size_segment); break; case 10: case 20: - size = BE_16(&size_segment[0]); - size_segment += 2; + size = bytestream2_get_be16(&size_segment); break; case 11: case 21: - size = (size_segment[0] << 16) | (size_segment[1] << 8) | - size_segment[2]; - size_segment += 3; + size = bytestream2_get_be24(&size_segment); break; } + if (size > total_pixels) + break; + if (opcode < 12) { flag ^= 1; if (flag) { /* run of (size) pixels is unchanged from last frame */ - xan_wc3_copy_pixel_run(s, x, y, size, 0, 0); + xan_wc3_copy_pixel_run(s, frame, x, y, size, 0, 0); } else { /* output a run of pixels from imagedata_buffer */ - xan_wc3_output_pixel_run(s, imagedata_buffer, x, y, size); + if (imagedata_size < size) + break; + xan_wc3_output_pixel_run(s, frame, imagedata_buffer, x, y, size); imagedata_buffer += size; + imagedata_size -= size; } } else { /* run-based motion compensation from last frame */ - motion_x = (*vector_segment >> 4) & 0xF; - motion_y = *vector_segment & 0xF; - vector_segment++; - - /* sign extension */ - if (motion_x & 0x8) - motion_x |= 0xFFFFFFF0; - if (motion_y & 0x8) - motion_y |= 0xFFFFFFF0; + uint8_t vector = bytestream2_get_byte(&vector_segment); + motion_x = sign_extend(vector >> 4, 4); + motion_y = sign_extend(vector & 0xF, 4); /* copy a run of pixels from the previous frame */ - xan_wc3_copy_pixel_run(s, x, y, size, motion_x, motion_y); + xan_wc3_copy_pixel_run(s, frame, x, y, size, motion_x, motion_y); flag = 0; } /* coordinate accounting */ total_pixels -= size; - while (size) { - if (x + size >= width) { - y++; - size -= (width - x); - x = 0; - } else { - x += size; - size = 0; - } - } + y += (x + size) / width; + x = (x + size) % width; } + return 0; +} - /* for PAL8, make the palette available on the way out */ - if (s->avctx->pix_fmt == PIX_FMT_PAL8) - memcpy(s->current_frame.data[1], s->palette, PALETTE_COUNT * 4); +#if RUNTIME_GAMMA +static inline unsigned mul(unsigned a, unsigned b) +{ + return (a * b) >> 16; } -static void xan_wc4_decode_frame(XanContext *s) { +static inline unsigned pow4(unsigned a) +{ + unsigned square = mul(a, a); + return mul(square, square); +} + +static inline unsigned pow5(unsigned a) +{ + return mul(pow4(a), a); } +static uint8_t gamma_corr(uint8_t in) { + unsigned lo, hi = 0xff40, target; + int i = 15; + in = (in << 2) | (in >> 6); + /* equivalent float code: + if (in >= 252) + return 253; + return round(pow(in / 256.0, 0.8) * 256); + */ + lo = target = in << 8; + do { + unsigned mid = (lo + hi) >> 1; + unsigned pow = pow5(mid); + if (pow > target) hi = mid; + else lo = mid; + } while (--i); + return (pow4((lo + hi) >> 1) + 0x80) >> 8; +} +#else +/** + * This is a gamma correction that xan3 applies to all palette entries. + * + * There is a peculiarity, namely that the values are clamped to 253 - + * it seems likely that this table was calculated by a buggy fixed-point + * implementation, the one above under RUNTIME_GAMMA behaves like this for + * example. + * The exponent value of 0.8 can be explained by this as well, since 0.8 = 4/5 + * and thus pow(x, 0.8) is still easy to calculate. + * Also, the input values are first rotated to the left by 2. + */ +static const uint8_t gamma_lookup[256] = { + 0x00, 0x09, 0x10, 0x16, 0x1C, 0x21, 0x27, 0x2C, + 0x31, 0x35, 0x3A, 0x3F, 0x43, 0x48, 0x4C, 0x50, + 0x54, 0x59, 0x5D, 0x61, 0x65, 0x69, 0x6D, 0x71, + 0x75, 0x79, 0x7D, 0x80, 0x84, 0x88, 0x8C, 0x8F, + 0x93, 0x97, 0x9A, 0x9E, 0xA2, 0xA5, 0xA9, 0xAC, + 0xB0, 0xB3, 0xB7, 0xBA, 0xBE, 0xC1, 0xC5, 0xC8, + 0xCB, 0xCF, 0xD2, 0xD5, 0xD9, 0xDC, 0xDF, 0xE3, + 0xE6, 0xE9, 0xED, 0xF0, 0xF3, 0xF6, 0xFA, 0xFD, + 0x03, 0x0B, 0x12, 0x18, 0x1D, 0x23, 0x28, 0x2D, + 0x32, 0x36, 0x3B, 0x40, 0x44, 0x49, 0x4D, 0x51, + 0x56, 0x5A, 0x5E, 0x62, 0x66, 0x6A, 0x6E, 0x72, + 0x76, 0x7A, 0x7D, 0x81, 0x85, 0x89, 0x8D, 0x90, + 0x94, 0x98, 0x9B, 0x9F, 0xA2, 0xA6, 0xAA, 0xAD, + 0xB1, 0xB4, 0xB8, 0xBB, 0xBF, 0xC2, 0xC5, 0xC9, + 0xCC, 0xD0, 0xD3, 0xD6, 0xDA, 0xDD, 0xE0, 0xE4, + 0xE7, 0xEA, 0xED, 0xF1, 0xF4, 0xF7, 0xFA, 0xFD, + 0x05, 0x0D, 0x13, 0x19, 0x1F, 0x24, 0x29, 0x2E, + 0x33, 0x38, 0x3C, 0x41, 0x45, 0x4A, 0x4E, 0x52, + 0x57, 0x5B, 0x5F, 0x63, 0x67, 0x6B, 0x6F, 0x73, + 0x77, 0x7B, 0x7E, 0x82, 0x86, 0x8A, 0x8D, 0x91, + 0x95, 0x99, 0x9C, 0xA0, 0xA3, 0xA7, 0xAA, 0xAE, + 0xB2, 0xB5, 0xB9, 0xBC, 0xBF, 0xC3, 0xC6, 0xCA, + 0xCD, 0xD0, 0xD4, 0xD7, 0xDA, 0xDE, 0xE1, 0xE4, + 0xE8, 0xEB, 0xEE, 0xF1, 0xF5, 0xF8, 0xFB, 0xFD, + 0x07, 0x0E, 0x15, 0x1A, 0x20, 0x25, 0x2A, 0x2F, + 0x34, 0x39, 0x3D, 0x42, 0x46, 0x4B, 0x4F, 0x53, + 0x58, 0x5C, 0x60, 0x64, 0x68, 0x6C, 0x70, 0x74, + 0x78, 0x7C, 0x7F, 0x83, 0x87, 0x8B, 0x8E, 0x92, + 0x96, 0x99, 0x9D, 0xA1, 0xA4, 0xA8, 0xAB, 0xAF, + 0xB2, 0xB6, 0xB9, 0xBD, 0xC0, 0xC4, 0xC7, 0xCB, + 0xCE, 0xD1, 0xD5, 0xD8, 0xDB, 0xDF, 0xE2, 0xE5, + 0xE9, 0xEC, 0xEF, 0xF2, 0xF6, 0xF9, 0xFC, 0xFD +}; +#endif + static int xan_decode_frame(AVCodecContext *avctx, - void *data, int *data_size, - uint8_t *buf, int buf_size) + void *data, int *got_frame, + AVPacket *avpkt) { + AVFrame *frame = data; + const uint8_t *buf = avpkt->data; + int ret, buf_size = avpkt->size; XanContext *s = avctx->priv_data; - unsigned char *palette_control = avctx->extradata; - int keyframe = 0; - - if (palette_control[0]) { - /* load the new palette and reset the palette control */ - xan_wc3_build_palette(s, &palette_control[1]); - palette_control[0] = 0; - keyframe = 1; + GetByteContext ctx; + int tag = 0; + + bytestream2_init(&ctx, buf, buf_size); + while (bytestream2_get_bytes_left(&ctx) > 8 && tag != VGA__TAG) { + unsigned *tmpptr; + uint32_t new_pal; + int size; + int i; + tag = bytestream2_get_le32(&ctx); + size = bytestream2_get_be32(&ctx); + size = FFMIN(size, bytestream2_get_bytes_left(&ctx)); + switch (tag) { + case PALT_TAG: + if (size < PALETTE_SIZE) + return AVERROR_INVALIDDATA; + if (s->palettes_count >= PALETTES_MAX) + return AVERROR_INVALIDDATA; + tmpptr = av_realloc(s->palettes, + (s->palettes_count + 1) * AVPALETTE_SIZE); + if (!tmpptr) + return AVERROR(ENOMEM); + s->palettes = tmpptr; + tmpptr += s->palettes_count * AVPALETTE_COUNT; + for (i = 0; i < PALETTE_COUNT; i++) { +#if RUNTIME_GAMMA + int r = gamma_corr(bytestream2_get_byteu(&ctx)); + int g = gamma_corr(bytestream2_get_byteu(&ctx)); + int b = gamma_corr(bytestream2_get_byteu(&ctx)); +#else + int r = gamma_lookup[bytestream2_get_byteu(&ctx)]; + int g = gamma_lookup[bytestream2_get_byteu(&ctx)]; + int b = gamma_lookup[bytestream2_get_byteu(&ctx)]; +#endif + *tmpptr++ = (r << 16) | (g << 8) | b; + } + s->palettes_count++; + break; + case SHOT_TAG: + if (size < 4) + return AVERROR_INVALIDDATA; + new_pal = bytestream2_get_le32(&ctx); + if (new_pal < s->palettes_count) { + s->cur_palette = new_pal; + } else + av_log(avctx, AV_LOG_ERROR, "Invalid palette selected\n"); + break; + case VGA__TAG: + break; + default: + bytestream2_skip(&ctx, size); + break; + } } + buf_size = bytestream2_get_bytes_left(&ctx); - if (avctx->get_buffer(avctx, &s->current_frame)) { - printf (" Interplay Video: get_buffer() failed\n"); - return -1; + if (s->palettes_count <= 0) { + av_log(s->avctx, AV_LOG_ERROR, "No palette found\n"); + return AVERROR_INVALIDDATA; } - s->current_frame.reference = 3; - s->buf = buf; - s->size = buf_size; - - if (avctx->codec->id == CODEC_ID_XAN_WC3) - xan_wc3_decode_frame(s); - else if (avctx->codec->id == CODEC_ID_XAN_WC4) - xan_wc4_decode_frame(s); - - /* release the last frame if it is allocated */ - if (s->last_frame.data[0]) - avctx->release_buffer(avctx, &s->last_frame); + if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF))) { + av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); + return ret; + } - /* shuffle frames */ - s->last_frame = s->current_frame; + if (!s->frame_size) + s->frame_size = frame->linesize[0] * s->avctx->height; - *data_size = sizeof(AVFrame); - *(AVFrame*)data = s->current_frame; + memcpy(frame->data[1], + s->palettes + s->cur_palette * AVPALETTE_COUNT, AVPALETTE_SIZE); - /* always report that the buffer was completely consumed */ - return buf_size; -} + s->buf = ctx.buffer; + s->size = buf_size; -static int xan_decode_end(AVCodecContext *avctx) -{ - XanContext *s = avctx->priv_data; + if (xan_wc3_decode_frame(s, frame) < 0) + return AVERROR_INVALIDDATA; - /* release the last frame */ - avctx->release_buffer(avctx, &s->last_frame); + av_frame_unref(s->last_frame); + if ((ret = av_frame_ref(s->last_frame, frame)) < 0) + return ret; - av_free(s->buffer1); - av_free(s->buffer2); + *got_frame = 1; - return 0; + /* always report that the buffer was completely consumed */ + return buf_size; } -AVCodec xan_wc3_decoder = { - "xan_wc3", - CODEC_TYPE_VIDEO, - CODEC_ID_XAN_WC3, - sizeof(XanContext), - xan_decode_init, - NULL, - xan_decode_end, - xan_decode_frame, - CODEC_CAP_DR1, -}; - -/* -AVCodec xan_wc4_decoder = { - "xan_wc4", - CODEC_TYPE_VIDEO, - CODEC_ID_XAN_WC4, - sizeof(XanContext), - xan_decode_init, - NULL, - xan_decode_end, - xan_decode_frame, - CODEC_CAP_DR1, +AVCodec ff_xan_wc3_decoder = { + .name = "xan_wc3", + .long_name = NULL_IF_CONFIG_SMALL("Wing Commander III / Xan"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_XAN_WC3, + .priv_data_size = sizeof(XanContext), + .init = xan_decode_init, + .close = xan_decode_end, + .decode = xan_decode_frame, + .capabilities = CODEC_CAP_DR1, }; -*/