X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Finterplayvideo.c;h=bee7a68e52c7f21d982db1d1900edc3a60f4556c;hb=44dc9c6af0377faf2a99889d1f949e32a1102e84;hp=06816ba3e9e7e155b16558ec15a8f4bafa914b5d;hpb=6ce1a818e10e4a47669d941d7e36cbebe3e0a2f4;p=ffmpeg diff --git a/libavcodec/interplayvideo.c b/libavcodec/interplayvideo.c index 06816ba3e9e..bee7a68e52c 100644 --- a/libavcodec/interplayvideo.c +++ b/libavcodec/interplayvideo.c @@ -2,24 +2,25 @@ * Interplay MVE 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 interplayvideo.c + * @file * Interplay MVE Video Decoder by Mike Melanson (melanson@pcisys.net) * For more information about the Interplay MVE format, visit: * http://www.pcisys.net/~melanson/codecs/interplay-mve.txt @@ -36,22 +37,15 @@ #include #include #include -#include -#include "common.h" #include "avcodec.h" +#include "bytestream.h" #include "dsputil.h" +#define BITSTREAM_READER_LE +#include "get_bits.h" #define PALETTE_COUNT 256 -/* debugging support */ -#define DEBUG_INTERPLAY 0 -#if DEBUG_INTERPLAY -#define debug_interplay printf -#else -static inline void debug_interplay(const char *format, ...) { } -#endif - typedef struct IpvideoContext { AVCodecContext *avctx; @@ -59,111 +53,62 @@ typedef struct IpvideoContext { AVFrame second_last_frame; AVFrame last_frame; AVFrame current_frame; - unsigned char *decoding_map; + const unsigned char *decoding_map; int decoding_map_size; - unsigned char *buf; - int size; - - unsigned char *stream_ptr; - unsigned char *stream_end; + int is_16bpp; + GetByteContext stream_ptr, mv_ptr; unsigned char *pixel_ptr; int line_inc; int stride; int upper_motion_limit_offset; + uint32_t pal[256]; } IpvideoContext; -#define CHECK_STREAM_PTR(n) \ - if ((s->stream_ptr + n) > s->stream_end) { \ - av_log(s->avctx, AV_LOG_ERROR, "Interplay video warning: stream_ptr out of bounds (%p >= %p)\n", \ - s->stream_ptr + n, s->stream_end); \ - return -1; \ - } - -#define COPY_FROM_CURRENT() \ - motion_offset = current_offset; \ - motion_offset += y * s->stride; \ - motion_offset += x; \ - if (motion_offset < 0) { \ - av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset); \ - return -1; \ - } else if (motion_offset > s->upper_motion_limit_offset) { \ - av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n", \ - motion_offset, s->upper_motion_limit_offset); \ - return -1; \ - } \ - s->dsp.put_pixels_tab[0][0](s->pixel_ptr, \ - s->current_frame.data[0] + motion_offset, s->stride, 8); - -#define COPY_FROM_PREVIOUS() \ - motion_offset = current_offset; \ - motion_offset += y * s->stride; \ - motion_offset += x; \ - if (motion_offset < 0) { \ - av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset); \ - return -1; \ - } else if (motion_offset > s->upper_motion_limit_offset) { \ - av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n", \ - motion_offset, s->upper_motion_limit_offset); \ - return -1; \ - } \ - s->dsp.put_pixels_tab[0][0](s->pixel_ptr, \ - s->last_frame.data[0] + motion_offset, s->stride, 8); - -#define COPY_FROM_SECOND_LAST() \ - motion_offset = current_offset; \ - motion_offset += y * s->stride; \ - motion_offset += x; \ - if (motion_offset < 0) { \ - av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset); \ - return -1; \ - } else if (motion_offset > s->upper_motion_limit_offset) { \ - av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n", \ - motion_offset, s->upper_motion_limit_offset); \ - return -1; \ - } \ - s->dsp.put_pixels_tab[0][0](s->pixel_ptr, \ - s->second_last_frame.data[0] + motion_offset, s->stride, 8); - -static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s) +static int copy_from(IpvideoContext *s, AVFrame *src, int delta_x, int delta_y) { - int x, y; - int motion_offset; int current_offset = s->pixel_ptr - s->current_frame.data[0]; - - /* copy a block from the previous frame */ - x = y = 0; - COPY_FROM_PREVIOUS(); - - /* report success */ + int motion_offset = current_offset + delta_y * s->current_frame.linesize[0] + + delta_x * (1 + s->is_16bpp); + if (motion_offset < 0) { + av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset); + return -1; + } else if (motion_offset > s->upper_motion_limit_offset) { + av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n", + motion_offset, s->upper_motion_limit_offset); + return -1; + } + if (src->data[0] == NULL) { + av_log(s->avctx, AV_LOG_ERROR, "Invalid decode type, corrupted header?\n"); + return AVERROR(EINVAL); + } + s->dsp.put_pixels_tab[!s->is_16bpp][0](s->pixel_ptr, src->data[0] + motion_offset, + s->current_frame.linesize[0], 8); return 0; } -static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s) +static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s) { - int x, y; - int motion_offset; - int current_offset = s->pixel_ptr - s->current_frame.data[0]; - - /* copy block from 2 frames ago */ - x = y = 0; - COPY_FROM_SECOND_LAST(); + return copy_from(s, &s->last_frame, 0, 0); +} - /* report success */ - return 0; +static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s) +{ + return copy_from(s, &s->second_last_frame, 0, 0); } static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s) { unsigned char B; int x, y; - int motion_offset; - int current_offset = s->pixel_ptr - s->current_frame.data[0]; /* copy block from 2 frames ago using a motion vector; need 1 more byte */ - CHECK_STREAM_PTR(1); - B = *s->stream_ptr++; + if (!s->is_16bpp) { + B = bytestream2_get_byte(&s->stream_ptr); + } else { + B = bytestream2_get_byte(&s->mv_ptr); + } if (B < 56) { x = 8 + (B % 7); @@ -173,25 +118,23 @@ static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s) y = 8 + ((B - 56) / 29); } - debug_interplay (" motion byte = %d, (x, y) = (%d, %d)\n", B, x, y); - COPY_FROM_SECOND_LAST(); - - /* report success */ - return 0; + av_dlog(NULL, " motion byte = %d, (x, y) = (%d, %d)\n", B, x, y); + return copy_from(s, &s->second_last_frame, x, y); } static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s) { unsigned char B; int x, y; - int motion_offset; - int current_offset = s->pixel_ptr - s->current_frame.data[0]; /* copy 8x8 block from current frame from an up/left block */ /* need 1 more byte for motion */ - CHECK_STREAM_PTR(1); - B = *s->stream_ptr++; + if (!s->is_16bpp) { + B = bytestream2_get_byte(&s->stream_ptr); + } else { + B = bytestream2_get_byte(&s->mv_ptr); + } if (B < 56) { x = -(8 + (B % 7)); @@ -201,54 +144,42 @@ static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s) y = -( 8 + ((B - 56) / 29)); } - debug_interplay (" motion byte = %d, (x, y) = (%d, %d)\n", B, x, y); - COPY_FROM_CURRENT(); - - /* report success */ - return 0; + av_dlog(NULL, " motion byte = %d, (x, y) = (%d, %d)\n", B, x, y); + return copy_from(s, &s->current_frame, x, y); } static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s) { int x, y; unsigned char B, BL, BH; - int motion_offset; - int current_offset = s->pixel_ptr - s->current_frame.data[0]; /* copy a block from the previous frame; need 1 more byte */ - CHECK_STREAM_PTR(1); + if (!s->is_16bpp) { + B = bytestream2_get_byte(&s->stream_ptr); + } else { + B = bytestream2_get_byte(&s->mv_ptr); + } - B = *s->stream_ptr++; BL = B & 0x0F; BH = (B >> 4) & 0x0F; x = -8 + BL; y = -8 + BH; - debug_interplay (" motion byte = %d, (x, y) = (%d, %d)\n", B, x, y); - COPY_FROM_PREVIOUS(); - - /* report success */ - return 0; + av_dlog(NULL, " motion byte = %d, (x, y) = (%d, %d)\n", B, x, y); + return copy_from(s, &s->last_frame, x, y); } static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s) { signed char x, y; - int motion_offset; - int current_offset = s->pixel_ptr - s->current_frame.data[0]; /* copy a block from the previous frame using an expanded range; * need 2 more bytes */ - CHECK_STREAM_PTR(2); - - x = *s->stream_ptr++; - y = *s->stream_ptr++; + x = bytestream2_get_byte(&s->stream_ptr); + y = bytestream2_get_byte(&s->stream_ptr); - debug_interplay (" motion bytes = %d, %d\n", x, y); - COPY_FROM_PREVIOUS(); - - /* report success */ - return 0; + av_dlog(NULL, " motion bytes = %d, %d\n", x, y); + return copy_from(s, &s->last_frame, x, y); } static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s) @@ -263,57 +194,33 @@ static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s) static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s) { int x, y; - unsigned char P0, P1; - unsigned char B[8]; + unsigned char P[2]; unsigned int flags; - int bitmask; /* 2-color encoding */ - CHECK_STREAM_PTR(2); - - P0 = *s->stream_ptr++; - P1 = *s->stream_ptr++; + P[0] = bytestream2_get_byte(&s->stream_ptr); + P[1] = bytestream2_get_byte(&s->stream_ptr); - if (P0 <= P1) { + if (P[0] <= P[1]) { /* need 8 more bytes from the stream */ - CHECK_STREAM_PTR(8); - for (y = 0; y < 8; y++) - B[y] = *s->stream_ptr++; - for (y = 0; y < 8; y++) { - flags = B[y]; - for (x = 0x01; x <= 0x80; x <<= 1) { - if (flags & x) - *s->pixel_ptr++ = P1; - else - *s->pixel_ptr++ = P0; - } + flags = bytestream2_get_byte(&s->stream_ptr) | 0x100; + for (; flags != 1; flags >>= 1) + *s->pixel_ptr++ = P[flags & 1]; s->pixel_ptr += s->line_inc; } } else { /* need 2 more bytes from the stream */ - CHECK_STREAM_PTR(2); - B[0] = *s->stream_ptr++; - B[1] = *s->stream_ptr++; - - flags = (B[1] << 8) | B[0]; - bitmask = 0x0001; + flags = bytestream2_get_le16(&s->stream_ptr); for (y = 0; y < 8; y += 2) { - for (x = 0; x < 8; x += 2, bitmask <<= 1) { - if (flags & bitmask) { - *(s->pixel_ptr + x) = P1; - *(s->pixel_ptr + x + 1) = P1; - *(s->pixel_ptr + s->stride + x) = P1; - *(s->pixel_ptr + s->stride + x + 1) = P1; - } else { - *(s->pixel_ptr + x) = P0; - *(s->pixel_ptr + x + 1) = P0; - *(s->pixel_ptr + s->stride + x) = P0; - *(s->pixel_ptr + s->stride + x + 1) = P0; - } + for (x = 0; x < 8; x += 2, flags >>= 1) { + s->pixel_ptr[x ] = + s->pixel_ptr[x + 1 ] = + s->pixel_ptr[x + s->stride] = + s->pixel_ptr[x + 1 + s->stride] = P[flags & 1]; } s->pixel_ptr += s->stride * 2; } @@ -326,120 +233,52 @@ static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s) static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s) { int x, y; - unsigned char P[8]; - unsigned char B[8]; + unsigned char P[4]; unsigned int flags = 0; - unsigned int bitmask = 0; - unsigned char P0 = 0, P1 = 0; - int lower_half = 0; /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on * either top and bottom or left and right halves */ - CHECK_STREAM_PTR(2); - - P[0] = *s->stream_ptr++; - P[1] = *s->stream_ptr++; + P[0] = bytestream2_get_byte(&s->stream_ptr); + P[1] = bytestream2_get_byte(&s->stream_ptr); if (P[0] <= P[1]) { - - /* need 12 more bytes */ - CHECK_STREAM_PTR(12); - B[0] = *s->stream_ptr++; B[1] = *s->stream_ptr++; - P[2] = *s->stream_ptr++; P[3] = *s->stream_ptr++; - B[2] = *s->stream_ptr++; B[3] = *s->stream_ptr++; - P[4] = *s->stream_ptr++; P[5] = *s->stream_ptr++; - B[4] = *s->stream_ptr++; B[5] = *s->stream_ptr++; - P[6] = *s->stream_ptr++; P[7] = *s->stream_ptr++; - B[6] = *s->stream_ptr++; B[7] = *s->stream_ptr++; - - for (y = 0; y < 8; y++) { - - /* time to reload flags? */ - if (y == 0) { - flags = - ((B[0] & 0xF0) << 4) | ((B[4] & 0xF0) << 8) | - ((B[0] & 0x0F) ) | ((B[4] & 0x0F) << 4) | - ((B[1] & 0xF0) << 20) | ((B[5] & 0xF0) << 24) | - ((B[1] & 0x0F) << 16) | ((B[5] & 0x0F) << 20); - bitmask = 0x00000001; - lower_half = 0; /* still on top half */ - } else if (y == 4) { - flags = - ((B[2] & 0xF0) << 4) | ((B[6] & 0xF0) << 8) | - ((B[2] & 0x0F) ) | ((B[6] & 0x0F) << 4) | - ((B[3] & 0xF0) << 20) | ((B[7] & 0xF0) << 24) | - ((B[3] & 0x0F) << 16) | ((B[7] & 0x0F) << 20); - bitmask = 0x00000001; - lower_half = 2; - } - - for (x = 0; x < 8; x++, bitmask <<= 1) { - /* get the pixel values ready for this quadrant */ - if (x == 0) { - P0 = P[lower_half + 0]; - P1 = P[lower_half + 1]; - } else if (x == 4) { - P0 = P[lower_half + 4]; - P1 = P[lower_half + 5]; + for (y = 0; y < 16; y++) { + // new values for each 4x4 block + if (!(y & 3)) { + if (y) { + P[0] = bytestream2_get_byte(&s->stream_ptr); + P[1] = bytestream2_get_byte(&s->stream_ptr); } - - if (flags & bitmask) - *s->pixel_ptr++ = P1; - else - *s->pixel_ptr++ = P0; + flags = bytestream2_get_le16(&s->stream_ptr); } - s->pixel_ptr += s->line_inc; + + for (x = 0; x < 4; x++, flags >>= 1) + *s->pixel_ptr++ = P[flags & 1]; + s->pixel_ptr += s->stride - 4; + // switch to right half + if (y == 7) s->pixel_ptr -= 8 * s->stride - 4; } } else { - - /* need 10 more bytes */ - CHECK_STREAM_PTR(10); - B[0] = *s->stream_ptr++; B[1] = *s->stream_ptr++; - B[2] = *s->stream_ptr++; B[3] = *s->stream_ptr++; - P[2] = *s->stream_ptr++; P[3] = *s->stream_ptr++; - B[4] = *s->stream_ptr++; B[5] = *s->stream_ptr++; - B[6] = *s->stream_ptr++; B[7] = *s->stream_ptr++; + flags = bytestream2_get_le32(&s->stream_ptr); + P[2] = bytestream2_get_byte(&s->stream_ptr); + P[3] = bytestream2_get_byte(&s->stream_ptr); if (P[2] <= P[3]) { /* vertical split; left & right halves are 2-color encoded */ - for (y = 0; y < 8; y++) { - - /* time to reload flags? */ - if (y == 0) { - flags = - ((B[0] & 0xF0) << 4) | ((B[4] & 0xF0) << 8) | - ((B[0] & 0x0F) ) | ((B[4] & 0x0F) << 4) | - ((B[1] & 0xF0) << 20) | ((B[5] & 0xF0) << 24) | - ((B[1] & 0x0F) << 16) | ((B[5] & 0x0F) << 20); - bitmask = 0x00000001; - } else if (y == 4) { - flags = - ((B[2] & 0xF0) << 4) | ((B[6] & 0xF0) << 8) | - ((B[2] & 0x0F) ) | ((B[6] & 0x0F) << 4) | - ((B[3] & 0xF0) << 20) | ((B[7] & 0xF0) << 24) | - ((B[3] & 0x0F) << 16) | ((B[7] & 0x0F) << 20); - bitmask = 0x00000001; + for (y = 0; y < 16; y++) { + for (x = 0; x < 4; x++, flags >>= 1) + *s->pixel_ptr++ = P[flags & 1]; + s->pixel_ptr += s->stride - 4; + // switch to right half + if (y == 7) { + s->pixel_ptr -= 8 * s->stride - 4; + P[0] = P[2]; + P[1] = P[3]; + flags = bytestream2_get_le32(&s->stream_ptr); } - - for (x = 0; x < 8; x++, bitmask <<= 1) { - /* get the pixel values ready for this half */ - if (x == 0) { - P0 = P[0]; - P1 = P[1]; - } else if (x == 4) { - P0 = P[2]; - P1 = P[3]; - } - - if (flags & bitmask) - *s->pixel_ptr++ = P1; - else - *s->pixel_ptr++ = P0; - } - s->pixel_ptr += s->line_inc; } } else { @@ -447,23 +286,14 @@ static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s) /* horizontal split; top & bottom halves are 2-color encoded */ for (y = 0; y < 8; y++) { - - flags = B[y]; - if (y == 0) { - P0 = P[0]; - P1 = P[1]; - } else if (y == 4) { - P0 = P[2]; - P1 = P[3]; + if (y == 4) { + P[0] = P[2]; + P[1] = P[3]; + flags = bytestream2_get_le32(&s->stream_ptr); } - for (bitmask = 0x01; bitmask <= 0x80; bitmask <<= 1) { - - if (flags & bitmask) - *s->pixel_ptr++ = P1; - else - *s->pixel_ptr++ = P0; - } + for (x = 0; x < 8; x++, flags >>= 1) + *s->pixel_ptr++ = P[flags & 1]; s->pixel_ptr += s->line_inc; } } @@ -477,99 +307,121 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s) { int x, y; unsigned char P[4]; - unsigned char B[4]; - unsigned int flags = 0; - int shifter = 0; - unsigned char pix; /* 4-color encoding */ - CHECK_STREAM_PTR(4); + bytestream2_get_buffer(&s->stream_ptr, P, 4); - for (y = 0; y < 4; y++) - P[y] = *s->stream_ptr++; - - if ((P[0] <= P[1]) && (P[2] <= P[3])) { - - /* 1 of 4 colors for each pixel, need 16 more bytes */ - CHECK_STREAM_PTR(16); + if (P[0] <= P[1]) { + if (P[2] <= P[3]) { - for (y = 0; y < 8; y++) { - /* get the next set of 8 2-bit flags */ - flags = (s->stream_ptr[1] << 8) | s->stream_ptr[0]; - s->stream_ptr += 2; - for (x = 0, shifter = 0; x < 8; x++, shifter += 2) { - *s->pixel_ptr++ = P[(flags >> shifter) & 0x03]; + /* 1 of 4 colors for each pixel, need 16 more bytes */ + for (y = 0; y < 8; y++) { + /* get the next set of 8 2-bit flags */ + int flags = bytestream2_get_le16(&s->stream_ptr); + for (x = 0; x < 8; x++, flags >>= 2) + *s->pixel_ptr++ = P[flags & 0x03]; + s->pixel_ptr += s->line_inc; } - s->pixel_ptr += s->line_inc; - } - } else if ((P[0] <= P[1]) && (P[2] > P[3])) { + } else { + uint32_t flags; - /* 1 of 4 colors for each 2x2 block, need 4 more bytes */ - CHECK_STREAM_PTR(4); + /* 1 of 4 colors for each 2x2 block, need 4 more bytes */ + flags = bytestream2_get_le32(&s->stream_ptr); - B[0] = *s->stream_ptr++; - B[1] = *s->stream_ptr++; - B[2] = *s->stream_ptr++; - B[3] = *s->stream_ptr++; - flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; - shifter = 0; + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2, flags >>= 2) { + s->pixel_ptr[x ] = + s->pixel_ptr[x + 1 ] = + s->pixel_ptr[x + s->stride] = + s->pixel_ptr[x + 1 + s->stride] = P[flags & 0x03]; + } + s->pixel_ptr += s->stride * 2; + } - for (y = 0; y < 8; y += 2) { - for (x = 0; x < 8; x += 2, shifter += 2) { - pix = P[(flags >> shifter) & 0x03]; - *(s->pixel_ptr + x) = pix; - *(s->pixel_ptr + x + 1) = pix; - *(s->pixel_ptr + s->stride + x) = pix; - *(s->pixel_ptr + s->stride + x + 1) = pix; + } + } else { + uint64_t flags; + + /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */ + flags = bytestream2_get_le64(&s->stream_ptr); + if (P[2] <= P[3]) { + for (y = 0; y < 8; y++) { + for (x = 0; x < 8; x += 2, flags >>= 2) { + s->pixel_ptr[x ] = + s->pixel_ptr[x + 1] = P[flags & 0x03]; + } + s->pixel_ptr += s->stride; + } + } else { + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x++, flags >>= 2) { + s->pixel_ptr[x ] = + s->pixel_ptr[x + s->stride] = P[flags & 0x03]; + } + s->pixel_ptr += s->stride * 2; } - s->pixel_ptr += s->stride * 2; } + } - } else if ((P[0] > P[1]) && (P[2] <= P[3])) { + /* report success */ + return 0; +} + +static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s) +{ + int x, y; + unsigned char P[8]; + int flags = 0; - /* 1 of 4 colors for each 2x1 block, need 8 more bytes */ - CHECK_STREAM_PTR(8); + bytestream2_get_buffer(&s->stream_ptr, P, 4); - for (y = 0; y < 8; y++) { - /* time to reload flags? */ - if ((y == 0) || (y == 4)) { - B[0] = *s->stream_ptr++; - B[1] = *s->stream_ptr++; - B[2] = *s->stream_ptr++; - B[3] = *s->stream_ptr++; - flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; - shifter = 0; - } - for (x = 0; x < 8; x += 2, shifter += 2) { - pix = P[(flags >> shifter) & 0x03]; - *(s->pixel_ptr + x) = pix; - *(s->pixel_ptr + x + 1) = pix; + /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on + * either top and bottom or left and right halves */ + if (P[0] <= P[1]) { + + /* 4-color encoding for each quadrant; need 32 bytes */ + for (y = 0; y < 16; y++) { + // new values for each 4x4 block + if (!(y & 3)) { + if (y) bytestream2_get_buffer(&s->stream_ptr, P, 4); + flags = bytestream2_get_le32(&s->stream_ptr); } - s->pixel_ptr += s->stride; + + for (x = 0; x < 4; x++, flags >>= 2) + *s->pixel_ptr++ = P[flags & 0x03]; + + s->pixel_ptr += s->stride - 4; + // switch to right half + if (y == 7) s->pixel_ptr -= 8 * s->stride - 4; } } else { + // vertical split? + int vert; + uint64_t flags = bytestream2_get_le64(&s->stream_ptr); - /* 1 of 4 colors for each 1x2 block, need 8 more bytes */ - CHECK_STREAM_PTR(8); + bytestream2_get_buffer(&s->stream_ptr, P + 4, 4); + vert = P[4] <= P[5]; - for (y = 0; y < 8; y += 2) { - /* time to reload flags? */ - if ((y == 0) || (y == 4)) { - B[0] = *s->stream_ptr++; - B[1] = *s->stream_ptr++; - B[2] = *s->stream_ptr++; - B[3] = *s->stream_ptr++; - flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0]; - shifter = 0; - } - for (x = 0; x < 8; x++, shifter += 2) { - pix = P[(flags >> shifter) & 0x03]; - *(s->pixel_ptr + x) = pix; - *(s->pixel_ptr + s->stride + x) = pix; + /* 4-color encoding for either left and right or top and bottom + * halves */ + + for (y = 0; y < 16; y++) { + for (x = 0; x < 4; x++, flags >>= 2) + *s->pixel_ptr++ = P[flags & 0x03]; + + if (vert) { + s->pixel_ptr += s->stride - 4; + // switch to right half + if (y == 7) s->pixel_ptr -= 8 * s->stride - 4; + } else if (y & 1) s->pixel_ptr += s->line_inc; + + // load values for second half + if (y == 7) { + memcpy(P, P + 4, 4); + flags = bytestream2_get_le64(&s->stream_ptr); } - s->pixel_ptr += s->stride * 2; } } @@ -577,96 +429,214 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s) return 0; } -static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s) +static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s) +{ + int y; + + /* 64-color encoding (each pixel in block is a different color) */ + for (y = 0; y < 8; y++) { + bytestream2_get_buffer(&s->stream_ptr, s->pixel_ptr, 8); + s->pixel_ptr += s->stride; + } + + /* report success */ + return 0; +} + +static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s) { int x, y; - unsigned char P[16]; - unsigned char B[16]; - int flags = 0; - int shifter = 0; - int index; - int split; - int lower_half; - /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on - * either top and bottom or left and right halves */ - CHECK_STREAM_PTR(4); + /* 16-color block encoding: each 2x2 block is a different color */ + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2) { + s->pixel_ptr[x ] = + s->pixel_ptr[x + 1 ] = + s->pixel_ptr[x + s->stride] = + s->pixel_ptr[x + 1 + s->stride] = bytestream2_get_byte(&s->stream_ptr); + } + s->pixel_ptr += s->stride * 2; + } - for (y = 0; y < 4; y++) - P[y] = *s->stream_ptr++; + /* report success */ + return 0; +} - if (P[0] <= P[1]) { +static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s) +{ + int y; + unsigned char P[2]; + + /* 4-color block encoding: each 4x4 block is a different color */ + for (y = 0; y < 8; y++) { + if (!(y & 3)) { + P[0] = bytestream2_get_byte(&s->stream_ptr); + P[1] = bytestream2_get_byte(&s->stream_ptr); + } + memset(s->pixel_ptr, P[0], 4); + memset(s->pixel_ptr + 4, P[1], 4); + s->pixel_ptr += s->stride; + } + + /* report success */ + return 0; +} + +static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s) +{ + int y; + unsigned char pix; - /* 4-color encoding for each quadrant; need 28 more bytes */ - CHECK_STREAM_PTR(28); + /* 1-color encoding: the whole block is 1 solid color */ + pix = bytestream2_get_byte(&s->stream_ptr); + + for (y = 0; y < 8; y++) { + memset(s->pixel_ptr, pix, 8); + s->pixel_ptr += s->stride; + } - for (y = 0; y < 4; y++) - B[y] = *s->stream_ptr++; - for (y = 4; y < 16; y += 4) { - for (x = y; x < y + 4; x++) - P[x] = *s->stream_ptr++; - for (x = y; x < y + 4; x++) - B[x] = *s->stream_ptr++; + /* report success */ + return 0; +} + +static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s) +{ + int x, y; + unsigned char sample[2]; + + /* dithered encoding */ + sample[0] = bytestream2_get_byte(&s->stream_ptr); + sample[1] = bytestream2_get_byte(&s->stream_ptr); + + for (y = 0; y < 8; y++) { + for (x = 0; x < 8; x += 2) { + *s->pixel_ptr++ = sample[ y & 1 ]; + *s->pixel_ptr++ = sample[!(y & 1)]; } + s->pixel_ptr += s->line_inc; + } - for (y = 0; y < 8; y++) { + /* report success */ + return 0; +} - lower_half = (y >= 4) ? 4 : 0; - flags = (B[y + 8] << 8) | B[y]; +static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext *s) +{ + signed char x, y; - for (x = 0, shifter = 0; x < 8; x++, shifter += 2) { - split = (x >= 4) ? 8 : 0; - index = split + lower_half + ((flags >> shifter) & 0x03); - *s->pixel_ptr++ = P[index]; - } + /* copy a block from the second last frame using an expanded range */ + x = bytestream2_get_byte(&s->stream_ptr); + y = bytestream2_get_byte(&s->stream_ptr); - s->pixel_ptr += s->line_inc; + av_dlog(NULL, " motion bytes = %d, %d\n", x, y); + return copy_from(s, &s->second_last_frame, x, y); +} + +static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s) +{ + int x, y; + uint16_t P[2]; + unsigned int flags; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; + + /* 2-color encoding */ + P[0] = bytestream2_get_le16(&s->stream_ptr); + P[1] = bytestream2_get_le16(&s->stream_ptr); + + if (!(P[0] & 0x8000)) { + + for (y = 0; y < 8; y++) { + flags = bytestream2_get_byte(&s->stream_ptr) | 0x100; + for (; flags != 1; flags >>= 1) + *pixel_ptr++ = P[flags & 1]; + pixel_ptr += s->line_inc; } } else { - /* 4-color encoding for either left and right or top and bottom - * halves; need 20 more bytes */ - CHECK_STREAM_PTR(20); + flags = bytestream2_get_le16(&s->stream_ptr); + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2, flags >>= 1) { + pixel_ptr[x ] = + pixel_ptr[x + 1 ] = + pixel_ptr[x + s->stride] = + pixel_ptr[x + 1 + s->stride] = P[flags & 1]; + } + pixel_ptr += s->stride * 2; + } + } - for (y = 0; y < 8; y++) - B[y] = *s->stream_ptr++; - for (y = 4; y < 8; y++) - P[y] = *s->stream_ptr++; - for (y = 8; y < 16; y++) - B[y] = *s->stream_ptr++; + return 0; +} - if (P[4] <= P[5]) { +static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s) +{ + int x, y; + uint16_t P[4]; + unsigned int flags = 0; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; - /* block is divided into left and right halves */ - for (y = 0; y < 8; y++) { + /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on + * either top and bottom or left and right halves */ + P[0] = bytestream2_get_le16(&s->stream_ptr); + P[1] = bytestream2_get_le16(&s->stream_ptr); - flags = (B[y + 8] << 8) | B[y]; - split = 0; + if (!(P[0] & 0x8000)) { - for (x = 0, shifter = 0; x < 8; x++, shifter += 2) { - if (x == 4) - split = 4; - *s->pixel_ptr++ = P[split + ((flags >> shifter) & 0x03)]; + for (y = 0; y < 16; y++) { + // new values for each 4x4 block + if (!(y & 3)) { + if (y) { + P[0] = bytestream2_get_le16(&s->stream_ptr); + P[1] = bytestream2_get_le16(&s->stream_ptr); } + flags = bytestream2_get_le16(&s->stream_ptr); + } - s->pixel_ptr += s->line_inc; + for (x = 0; x < 4; x++, flags >>= 1) + *pixel_ptr++ = P[flags & 1]; + pixel_ptr += s->stride - 4; + // switch to right half + if (y == 7) pixel_ptr -= 8 * s->stride - 4; + } + + } else { + + flags = bytestream2_get_le32(&s->stream_ptr); + P[2] = bytestream2_get_le16(&s->stream_ptr); + P[3] = bytestream2_get_le16(&s->stream_ptr); + + if (!(P[2] & 0x8000)) { + + /* vertical split; left & right halves are 2-color encoded */ + + for (y = 0; y < 16; y++) { + for (x = 0; x < 4; x++, flags >>= 1) + *pixel_ptr++ = P[flags & 1]; + pixel_ptr += s->stride - 4; + // switch to right half + if (y == 7) { + pixel_ptr -= 8 * s->stride - 4; + P[0] = P[2]; + P[1] = P[3]; + flags = bytestream2_get_le32(&s->stream_ptr); + } } } else { - /* block is divided into top and bottom halves */ - split = 0; - for (y = 0; y < 8; y++) { - - flags = (B[y * 2 + 1] << 8) | B[y * 2]; - if (y == 4) - split = 4; + /* horizontal split; top & bottom halves are 2-color encoded */ - for (x = 0, shifter = 0; x < 8; x++, shifter += 2) - *s->pixel_ptr++ = P[split + ((flags >> shifter) & 0x03)]; + for (y = 0; y < 8; y++) { + if (y == 4) { + P[0] = P[2]; + P[1] = P[3]; + flags = bytestream2_get_le32(&s->stream_ptr); + } - s->pixel_ptr += s->line_inc; + for (x = 0; x < 8; x++, flags >>= 1) + *pixel_ptr++ = P[flags & 1]; + pixel_ptr += s->line_inc; } } } @@ -675,217 +645,305 @@ static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s) return 0; } -static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s) +static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s) { int x, y; + uint16_t P[4]; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; - /* 64-color encoding (each pixel in block is a different color) */ - CHECK_STREAM_PTR(64); + /* 4-color encoding */ + for (x = 0; x < 4; x++) + P[x] = bytestream2_get_le16(&s->stream_ptr); + + if (!(P[0] & 0x8000)) { + if (!(P[2] & 0x8000)) { + + /* 1 of 4 colors for each pixel */ + for (y = 0; y < 8; y++) { + /* get the next set of 8 2-bit flags */ + int flags = bytestream2_get_le16(&s->stream_ptr); + for (x = 0; x < 8; x++, flags >>= 2) + *pixel_ptr++ = P[flags & 0x03]; + pixel_ptr += s->line_inc; + } + + } else { + uint32_t flags; + + /* 1 of 4 colors for each 2x2 block */ + flags = bytestream2_get_le32(&s->stream_ptr); + + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2, flags >>= 2) { + pixel_ptr[x ] = + pixel_ptr[x + 1 ] = + pixel_ptr[x + s->stride] = + pixel_ptr[x + 1 + s->stride] = P[flags & 0x03]; + } + pixel_ptr += s->stride * 2; + } - for (y = 0; y < 8; y++) { - for (x = 0; x < 8; x++) { - *s->pixel_ptr++ = *s->stream_ptr++; } - s->pixel_ptr += s->line_inc; + } else { + uint64_t flags; + + /* 1 of 4 colors for each 2x1 or 1x2 block */ + flags = bytestream2_get_le64(&s->stream_ptr); + if (!(P[2] & 0x8000)) { + for (y = 0; y < 8; y++) { + for (x = 0; x < 8; x += 2, flags >>= 2) { + pixel_ptr[x ] = + pixel_ptr[x + 1] = P[flags & 0x03]; + } + pixel_ptr += s->stride; + } + } else { + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x++, flags >>= 2) { + pixel_ptr[x ] = + pixel_ptr[x + s->stride] = P[flags & 0x03]; + } + pixel_ptr += s->stride * 2; + } + } } /* report success */ return 0; } -static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s) +static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s) { int x, y; - unsigned char pix; + uint16_t P[8]; + int flags = 0; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; - /* 16-color block encoding: each 2x2 block is a different color */ - CHECK_STREAM_PTR(16); + for (x = 0; x < 4; x++) + P[x] = bytestream2_get_le16(&s->stream_ptr); - for (y = 0; y < 8; y += 2) { - for (x = 0; x < 8; x += 2) { - pix = *s->stream_ptr++; - *(s->pixel_ptr + x) = pix; - *(s->pixel_ptr + x + 1) = pix; - *(s->pixel_ptr + s->stride + x) = pix; - *(s->pixel_ptr + s->stride + x + 1) = pix; + /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on + * either top and bottom or left and right halves */ + if (!(P[0] & 0x8000)) { + + /* 4-color encoding for each quadrant */ + for (y = 0; y < 16; y++) { + // new values for each 4x4 block + if (!(y & 3)) { + if (y) + for (x = 0; x < 4; x++) + P[x] = bytestream2_get_le16(&s->stream_ptr); + flags = bytestream2_get_le32(&s->stream_ptr); + } + + for (x = 0; x < 4; x++, flags >>= 2) + *pixel_ptr++ = P[flags & 0x03]; + + pixel_ptr += s->stride - 4; + // switch to right half + if (y == 7) pixel_ptr -= 8 * s->stride - 4; + } + + } else { + // vertical split? + int vert; + uint64_t flags = bytestream2_get_le64(&s->stream_ptr); + + for (x = 4; x < 8; x++) + P[x] = bytestream2_get_le16(&s->stream_ptr); + vert = !(P[4] & 0x8000); + + /* 4-color encoding for either left and right or top and bottom + * halves */ + + for (y = 0; y < 16; y++) { + for (x = 0; x < 4; x++, flags >>= 2) + *pixel_ptr++ = P[flags & 0x03]; + + if (vert) { + pixel_ptr += s->stride - 4; + // switch to right half + if (y == 7) pixel_ptr -= 8 * s->stride - 4; + } else if (y & 1) pixel_ptr += s->line_inc; + + // load values for second half + if (y == 7) { + memcpy(P, P + 4, 8); + flags = bytestream2_get_le64(&s->stream_ptr); + } } - s->pixel_ptr += s->stride * 2; } /* report success */ return 0; } -static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s) +static int ipvideo_decode_block_opcode_0xB_16(IpvideoContext *s) { int x, y; - unsigned char P[4]; - unsigned char index = 0; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; - /* 4-color block encoding: each 4x4 block is a different color */ - CHECK_STREAM_PTR(4); + /* 64-color encoding (each pixel in block is a different color) */ + for (y = 0; y < 8; y++) { + for (x = 0; x < 8; x++) + pixel_ptr[x] = bytestream2_get_le16(&s->stream_ptr); + pixel_ptr += s->stride; + } + + /* report success */ + return 0; +} - for (y = 0; y < 4; y++) - P[y] = *s->stream_ptr++; +static int ipvideo_decode_block_opcode_0xC_16(IpvideoContext *s) +{ + int x, y; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; - for (y = 0; y < 8; y++) { - if (y < 4) - index = 0; - else - index = 2; - - for (x = 0; x < 8; x++) { - if (x == 4) - index++; - *s->pixel_ptr++ = P[index]; + /* 16-color block encoding: each 2x2 block is a different color */ + for (y = 0; y < 8; y += 2) { + for (x = 0; x < 8; x += 2) { + pixel_ptr[x ] = + pixel_ptr[x + 1 ] = + pixel_ptr[x + s->stride] = + pixel_ptr[x + 1 + s->stride] = bytestream2_get_le16(&s->stream_ptr); } - s->pixel_ptr += s->line_inc; + pixel_ptr += s->stride * 2; } /* report success */ return 0; } -static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s) +static int ipvideo_decode_block_opcode_0xD_16(IpvideoContext *s) { int x, y; - unsigned char pix; - - /* 1-color encoding: the whole block is 1 solid color */ - CHECK_STREAM_PTR(1); - pix = *s->stream_ptr++; + uint16_t P[2]; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; + /* 4-color block encoding: each 4x4 block is a different color */ for (y = 0; y < 8; y++) { - for (x = 0; x < 8; x++) { - *s->pixel_ptr++ = pix; + if (!(y & 3)) { + P[0] = bytestream2_get_le16(&s->stream_ptr); + P[1] = bytestream2_get_le16(&s->stream_ptr); } - s->pixel_ptr += s->line_inc; + for (x = 0; x < 8; x++) + pixel_ptr[x] = P[x >> 2]; + pixel_ptr += s->stride; } /* report success */ return 0; } -static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s) +static int ipvideo_decode_block_opcode_0xE_16(IpvideoContext *s) { int x, y; - unsigned char sample0, sample1; + uint16_t pix; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; - /* dithered encoding */ - CHECK_STREAM_PTR(2); - sample0 = *s->stream_ptr++; - sample1 = *s->stream_ptr++; + /* 1-color encoding: the whole block is 1 solid color */ + pix = bytestream2_get_le16(&s->stream_ptr); for (y = 0; y < 8; y++) { - for (x = 0; x < 8; x += 2) { - if (y & 1) { - *s->pixel_ptr++ = sample1; - *s->pixel_ptr++ = sample0; - } else { - *s->pixel_ptr++ = sample0; - *s->pixel_ptr++ = sample1; - } - } - s->pixel_ptr += s->line_inc; + for (x = 0; x < 8; x++) + pixel_ptr[x] = pix; + pixel_ptr += s->stride; } /* report success */ return 0; } -static int (*ipvideo_decode_block[16])(IpvideoContext *s); +static int (* const ipvideo_decode_block[])(IpvideoContext *s) = { + ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1, + ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3, + ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5, + ipvideo_decode_block_opcode_0x6, ipvideo_decode_block_opcode_0x7, + ipvideo_decode_block_opcode_0x8, ipvideo_decode_block_opcode_0x9, + ipvideo_decode_block_opcode_0xA, ipvideo_decode_block_opcode_0xB, + ipvideo_decode_block_opcode_0xC, ipvideo_decode_block_opcode_0xD, + ipvideo_decode_block_opcode_0xE, ipvideo_decode_block_opcode_0xF, +}; + +static int (* const ipvideo_decode_block16[])(IpvideoContext *s) = { + ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1, + ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3, + ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5, + ipvideo_decode_block_opcode_0x6_16, ipvideo_decode_block_opcode_0x7_16, + ipvideo_decode_block_opcode_0x8_16, ipvideo_decode_block_opcode_0x9_16, + ipvideo_decode_block_opcode_0xA_16, ipvideo_decode_block_opcode_0xB_16, + ipvideo_decode_block_opcode_0xC_16, ipvideo_decode_block_opcode_0xD_16, + ipvideo_decode_block_opcode_0xE_16, ipvideo_decode_block_opcode_0x1, +}; static void ipvideo_decode_opcodes(IpvideoContext *s) { int x, y; - int index = 0; unsigned char opcode; int ret; - int code_counts[16]; static int frame = 0; + GetBitContext gb; - debug_interplay("------------------ frame %d\n", frame); + av_dlog(NULL, "------------------ frame %d\n", frame); frame++; - for (x = 0; x < 16; x++) - code_counts[x] = 0; - - /* this is PAL8, so make the palette available */ - memcpy(s->current_frame.data[1], s->avctx->palctrl->palette, PALETTE_COUNT * 4); + bytestream2_skip(&s->stream_ptr, 14); /* data starts 14 bytes in */ + if (!s->is_16bpp) { + /* this is PAL8, so make the palette available */ + memcpy(s->current_frame.data[1], s->pal, AVPALETTE_SIZE); - s->stride = s->current_frame.linesize[0]; - s->stream_ptr = s->buf + 14; /* data starts 14 bytes in */ - s->stream_end = s->buf + s->size; + s->stride = s->current_frame.linesize[0]; + } else { + s->stride = s->current_frame.linesize[0] >> 1; + s->mv_ptr = s->stream_ptr; + bytestream2_skip(&s->mv_ptr, bytestream2_get_le16(&s->stream_ptr)); + } s->line_inc = s->stride - 8; - s->upper_motion_limit_offset = (s->avctx->height - 8) * s->stride - + s->avctx->width - 8; - s->dsp = s->dsp; - - for (y = 0; y < (s->stride * s->avctx->height); y += s->stride * 8) { - for (x = y; x < y + s->avctx->width; x += 8) { - /* bottom nibble first, then top nibble (which makes it - * hard to use a GetBitcontext) */ - if (index & 1) - opcode = s->decoding_map[index >> 1] >> 4; - else - opcode = s->decoding_map[index >> 1] & 0xF; - index++; - - debug_interplay(" block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n", - x - y, y / s->stride, opcode, s->stream_ptr); - code_counts[opcode]++; - - s->pixel_ptr = s->current_frame.data[0] + x; - ret = ipvideo_decode_block[opcode](s); + s->upper_motion_limit_offset = (s->avctx->height - 8) * s->current_frame.linesize[0] + + (s->avctx->width - 8) * (1 + s->is_16bpp); + + init_get_bits(&gb, s->decoding_map, s->decoding_map_size * 8); + for (y = 0; y < s->avctx->height; y += 8) { + for (x = 0; x < s->avctx->width; x += 8) { + opcode = get_bits(&gb, 4); + + av_dlog(s->avctx, + " block @ (%3d, %3d): encoding 0x%X, data ptr offset %d\n", + x, y, opcode, bytestream2_tell(&s->stream_ptr)); + + if (!s->is_16bpp) { + s->pixel_ptr = s->current_frame.data[0] + x + + y*s->current_frame.linesize[0]; + ret = ipvideo_decode_block[opcode](s); + } else { + s->pixel_ptr = s->current_frame.data[0] + x*2 + + y*s->current_frame.linesize[0]; + ret = ipvideo_decode_block16[opcode](s); + } if (ret != 0) { av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode problem on frame %d, @ block (%d, %d)\n", - frame, x - y, y / s->stride); + frame, x, y); return; } } } - if ((s->stream_ptr != s->stream_end) && - (s->stream_ptr + 1 != s->stream_end)) { - av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode finished with %d bytes left over\n", - s->stream_end - s->stream_ptr); + if (bytestream2_get_bytes_left(&s->stream_ptr) > 1) { + av_log(s->avctx, AV_LOG_ERROR, + "Interplay video: decode finished with %d bytes left over\n", + bytestream2_get_bytes_left(&s->stream_ptr)); } } -static int ipvideo_decode_init(AVCodecContext *avctx) +static av_cold int ipvideo_decode_init(AVCodecContext *avctx) { IpvideoContext *s = avctx->priv_data; s->avctx = avctx; - if (s->avctx->palctrl == NULL) { - av_log(avctx, AV_LOG_ERROR, " Interplay video: palette expected.\n"); - return -1; - } - - avctx->pix_fmt = PIX_FMT_PAL8; - avctx->has_b_frames = 0; - dsputil_init(&s->dsp, avctx); - - /* decoding map contains 4 bits of information per 8x8 block */ - s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2); + s->is_16bpp = avctx->bits_per_coded_sample == 16; + avctx->pix_fmt = s->is_16bpp ? PIX_FMT_RGB555 : PIX_FMT_PAL8; - /* assign block decode functions */ - ipvideo_decode_block[0x0] = ipvideo_decode_block_opcode_0x0; - ipvideo_decode_block[0x1] = ipvideo_decode_block_opcode_0x1; - ipvideo_decode_block[0x2] = ipvideo_decode_block_opcode_0x2; - ipvideo_decode_block[0x3] = ipvideo_decode_block_opcode_0x3; - ipvideo_decode_block[0x4] = ipvideo_decode_block_opcode_0x4; - ipvideo_decode_block[0x5] = ipvideo_decode_block_opcode_0x5; - ipvideo_decode_block[0x6] = ipvideo_decode_block_opcode_0x6; - ipvideo_decode_block[0x7] = ipvideo_decode_block_opcode_0x7; - ipvideo_decode_block[0x8] = ipvideo_decode_block_opcode_0x8; - ipvideo_decode_block[0x9] = ipvideo_decode_block_opcode_0x9; - ipvideo_decode_block[0xA] = ipvideo_decode_block_opcode_0xA; - ipvideo_decode_block[0xB] = ipvideo_decode_block_opcode_0xB; - ipvideo_decode_block[0xC] = ipvideo_decode_block_opcode_0xC; - ipvideo_decode_block[0xD] = ipvideo_decode_block_opcode_0xD; - ipvideo_decode_block[0xE] = ipvideo_decode_block_opcode_0xE; - ipvideo_decode_block[0xF] = ipvideo_decode_block_opcode_0xF; + ff_dsputil_init(&s->dsp, avctx); s->current_frame.data[0] = s->last_frame.data[0] = s->second_last_frame.data[0] = NULL; @@ -895,10 +953,14 @@ static int ipvideo_decode_init(AVCodecContext *avctx) static int ipvideo_decode_frame(AVCodecContext *avctx, void *data, int *data_size, - uint8_t *buf, int buf_size) + AVPacket *avpkt) { + const uint8_t *buf = avpkt->data; + int buf_size = avpkt->size; IpvideoContext *s = avctx->priv_data; - AVPaletteControl *palette_control = avctx->palctrl; + + /* decoding map contains 4 bits of information per 8x8 block */ + s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2); /* compressed buffer needs to be large enough to at least hold an entire * decoding map */ @@ -906,8 +968,8 @@ static int ipvideo_decode_frame(AVCodecContext *avctx, return buf_size; s->decoding_map = buf; - s->buf = buf + s->decoding_map_size; - s->size = buf_size - s->decoding_map_size; + bytestream2_init(&s->stream_ptr, buf + s->decoding_map_size, + buf_size - s->decoding_map_size); s->current_frame.reference = 3; if (avctx->get_buffer(avctx, &s->current_frame)) { @@ -915,13 +977,16 @@ static int ipvideo_decode_frame(AVCodecContext *avctx, return -1; } - ipvideo_decode_opcodes(s); - - if (palette_control->palette_changed) { - palette_control->palette_changed = 0; - s->current_frame.palette_has_changed = 1; + if (!s->is_16bpp) { + const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL); + if (pal) { + s->current_frame.palette_has_changed = 1; + memcpy(s->pal, pal, AVPALETTE_SIZE); + } } + ipvideo_decode_opcodes(s); + *data_size = sizeof(AVFrame); *(AVFrame*)data = s->current_frame; @@ -936,7 +1001,7 @@ static int ipvideo_decode_frame(AVCodecContext *avctx, return buf_size; } -static int ipvideo_decode_end(AVCodecContext *avctx) +static av_cold int ipvideo_decode_end(AVCodecContext *avctx) { IpvideoContext *s = avctx->priv_data; @@ -949,14 +1014,14 @@ static int ipvideo_decode_end(AVCodecContext *avctx) return 0; } -AVCodec interplay_video_decoder = { - "interplayvideo", - CODEC_TYPE_VIDEO, - CODEC_ID_INTERPLAY_VIDEO, - sizeof(IpvideoContext), - ipvideo_decode_init, - NULL, - ipvideo_decode_end, - ipvideo_decode_frame, - CODEC_CAP_DR1, +AVCodec ff_interplay_video_decoder = { + .name = "interplayvideo", + .type = AVMEDIA_TYPE_VIDEO, + .id = CODEC_ID_INTERPLAY_VIDEO, + .priv_data_size = sizeof(IpvideoContext), + .init = ipvideo_decode_init, + .close = ipvideo_decode_end, + .decode = ipvideo_decode_frame, + .capabilities = CODEC_CAP_DR1 | CODEC_CAP_PARAM_CHANGE, + .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"), };