X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Finterplayvideo.c;h=8992a1de30f56ec7776a3e88477d6b8fb04b29bf;hb=b0e88ca6d3e0953e0537dd6747c72254e2a946f7;hp=ba314767fe7af79acfe5e64fa31969ad11ccdb84;hpb=fff60779172c21638e1c7276d5128770480c8f93;p=ffmpeg diff --git a/libavcodec/interplayvideo.c b/libavcodec/interplayvideo.c index ba314767fe7..8992a1de30f 100644 --- a/libavcodec/interplayvideo.c +++ b/libavcodec/interplayvideo.c @@ -37,11 +37,12 @@ #include #include #include -#include #include "avcodec.h" #include "bytestream.h" #include "dsputil.h" +#define ALT_BITSTREAM_READER_LE +#include "get_bits.h" #define PALETTE_COUNT 256 @@ -66,8 +67,11 @@ typedef struct IpvideoContext { const unsigned char *buf; int size; + int is_16bpp; const unsigned char *stream_ptr; const unsigned char *stream_end; + const uint8_t *mv_ptr; + const uint8_t *mv_end; unsigned char *pixel_ptr; int line_inc; int stride; @@ -75,96 +79,54 @@ typedef struct IpvideoContext { } 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); \ +#define CHECK_STREAM_PTR(stream_ptr, stream_end, n) \ + if (stream_end - stream_ptr < n) { \ + av_log(s->avctx, AV_LOG_ERROR, "Interplay video warning: stream_ptr out of bounds (%p >= %p)\n", \ + stream_ptr + n, stream_end); \ 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[1][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[1][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[1][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; + } + 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) { + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1); + B = *s->stream_ptr++; + } else { + CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1); + B = *s->mv_ptr++; + } if (B < 56) { x = 8 + (B % 7); @@ -175,24 +137,24 @@ static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s) } debug_interplay (" motion byte = %d, (x, y) = (%d, %d)\n", B, x, y); - COPY_FROM_SECOND_LAST(); - - /* report success */ - return 0; + 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) { + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1); + B = *s->stream_ptr++; + } else { + CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1); + B = *s->mv_ptr++; + } if (B < 56) { x = -(8 + (B % 7)); @@ -203,53 +165,45 @@ static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s) } debug_interplay (" motion byte = %d, (x, y) = (%d, %d)\n", B, x, y); - COPY_FROM_CURRENT(); - - /* report success */ - return 0; + 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) { + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1); + B = *s->stream_ptr++; + } else { + CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1); + B = *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; + 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); + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2); x = *s->stream_ptr++; y = *s->stream_ptr++; debug_interplay (" motion bytes = %d, %d\n", x, y); - COPY_FROM_PREVIOUS(); - - /* report success */ - return 0; + return copy_from(s, &s->last_frame, x, y); } static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s) @@ -264,55 +218,39 @@ 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); + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2); - P0 = *s->stream_ptr++; - P1 = *s->stream_ptr++; + P[0] = *s->stream_ptr++; + P[1] = *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++; + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8); 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 = *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); + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2); flags = bytestream_get_le16(&s->stream_ptr); - bitmask = 0x0001; 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; } @@ -325,120 +263,56 @@ 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[2]; 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); + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2); P[0] = *s->stream_ptr++; P[1] = *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++; + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 14); + s->stream_ptr -= 2; - 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 (y = 0; y < 16; y++) { + // new values for each 4x4 block + if (!(y & 3)) { + P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++; + flags = bytestream_get_le16(&s->stream_ptr); } - 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]; - } - - if (flags & bitmask) - *s->pixel_ptr++ = P1; - else - *s->pixel_ptr++ = P0; - } - 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++; + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 10); - if (P[2] <= P[3]) { + if (s->stream_ptr[4] <= s->stream_ptr[5]) { - /* vertical split; left & right halves are 2-color encoded */ + flags = bytestream_get_le32(&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; - } 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; - } + /* vertical split; left & right halves are 2-color encoded */ - 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; + 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] = *s->stream_ptr++; P[1] = *s->stream_ptr++; + flags = bytestream_get_le32(&s->stream_ptr); } - s->pixel_ptr += s->line_inc; } } else { @@ -446,23 +320,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] = *s->stream_ptr++; + P[1] = *s->stream_ptr++; } + flags = *s->stream_ptr++ | 0x100; - for (bitmask = 0x01; bitmask <= 0x80; bitmask <<= 1) { - - if (flags & bitmask) - *s->pixel_ptr++ = P1; - else - *s->pixel_ptr++ = P0; - } + for (; flags != 1; flags >>= 1) + *s->pixel_ptr++ = P[flags & 1]; s->pixel_ptr += s->line_inc; } } @@ -476,85 +341,131 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s) { int x, y; unsigned char P[4]; - unsigned int flags = 0; - int shifter = 0; - unsigned char pix; /* 4-color encoding */ - CHECK_STREAM_PTR(4); + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4); - for (y = 0; y < 4; y++) - P[y] = *s->stream_ptr++; + memcpy(P, s->stream_ptr, 4); + s->stream_ptr += 4; - if ((P[0] <= P[1]) && (P[2] <= P[3])) { + if (P[0] <= P[1]) { + if (P[2] <= P[3]) { - /* 1 of 4 colors for each pixel, need 16 more bytes */ - CHECK_STREAM_PTR(16); + /* 1 of 4 colors for each pixel, need 16 more bytes */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16); - for (y = 0; y < 8; y++) { - /* get the next set of 8 2-bit flags */ - flags = bytestream_get_le16(&s->stream_ptr); - for (x = 0, shifter = 0; x < 8; x++, shifter += 2) { - *s->pixel_ptr++ = P[(flags >> shifter) & 0x03]; + for (y = 0; y < 8; y++) { + /* get the next set of 8 2-bit flags */ + int flags = bytestream_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 */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4); - flags = bytestream_get_le32(&s->stream_ptr); - shifter = 0; + flags = bytestream_get_le32(&s->stream_ptr); - 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; + 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; } - s->pixel_ptr += s->stride * 2; - } - } else if ((P[0] > P[1]) && (P[2] <= P[3])) { + } + } else { + uint64_t flags; - /* 1 of 4 colors for each 2x1 block, need 8 more bytes */ - CHECK_STREAM_PTR(8); + /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8); - for (y = 0; y < 8; y++) { - /* time to reload flags? */ - if ((y == 0) || (y == 4)) { - flags = bytestream_get_le32(&s->stream_ptr); - shifter = 0; + flags = bytestream_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; } - 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; + } 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; } + } - } else { + /* report success */ + return 0; +} - /* 1 of 4 colors for each 1x2 block, need 8 more bytes */ - CHECK_STREAM_PTR(8); +static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s) +{ + int x, y; + unsigned char P[4]; + int flags = 0; - for (y = 0; y < 8; y += 2) { - /* time to reload flags? */ - if ((y == 0) || (y == 4)) { + /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on + * either top and bottom or left and right halves */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24); + + if (s->stream_ptr[0] <= s->stream_ptr[1]) { + + /* 4-color encoding for each quadrant; need 32 bytes */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 32); + + for (y = 0; y < 16; y++) { + // new values for each 4x4 block + if (!(y & 3)) { + memcpy(P, s->stream_ptr, 4); + s->stream_ptr += 4; flags = bytestream_get_le32(&s->stream_ptr); - 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; + + 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 = s->stream_ptr[12] <= s->stream_ptr[13]; + uint64_t flags = 0; + + /* 4-color encoding for either left and right or top and bottom + * halves */ + + for (y = 0; y < 16; y++) { + // load values for each half + if (!(y & 7)) { + memcpy(P, s->stream_ptr, 4); + s->stream_ptr += 4; + flags = bytestream_get_le64(&s->stream_ptr); } - s->pixel_ptr += s->stride * 2; + + 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; } } @@ -562,96 +473,309 @@ 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) */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 64); + + for (y = 0; y < 8; y++) { + memcpy(s->pixel_ptr, s->stream_ptr, 8); + s->stream_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 */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16); - for (y = 0; y < 4; y++) - P[y] = *s->stream_ptr++; + 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] = *s->stream_ptr++; + } + s->pixel_ptr += s->stride * 2; + } - if (P[0] <= P[1]) { + /* report success */ + return 0; +} - /* 4-color encoding for each quadrant; need 28 more bytes */ - CHECK_STREAM_PTR(28); +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 */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4); - 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++; + for (y = 0; y < 8; y++) { + if (!(y & 3)) { + P[0] = *s->stream_ptr++; + P[1] = *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; + + /* 1-color encoding: the whole block is 1 solid color */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1); + pix = *s->stream_ptr++; + + for (y = 0; y < 8; y++) { + memset(s->pixel_ptr, pix, 8); + s->pixel_ptr += s->stride; + } + + /* report success */ + return 0; +} + +static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s) +{ + int x, y; + unsigned char sample[2]; + + /* dithered encoding */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2); + sample[0] = *s->stream_ptr++; + sample[1] = *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; + } + + /* report success */ + return 0; +} + +static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext *s) +{ + signed char x, y; + + /* copy a block from the second last frame using an expanded range */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2); + + x = *s->stream_ptr++; + y = *s->stream_ptr++; + + debug_interplay (" 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 */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4); + + P[0] = bytestream_get_le16(&s->stream_ptr); + P[1] = bytestream_get_le16(&s->stream_ptr); + + if (!(P[0] & 0x8000)) { + + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8); for (y = 0; y < 8; y++) { + flags = *s->stream_ptr++ | 0x100; + for (; flags != 1; flags >>= 1) + *pixel_ptr++ = P[flags & 1]; + pixel_ptr += s->line_inc; + } + + } else { - lower_half = (y >= 4) ? 4 : 0; - flags = (B[y + 8] << 8) | B[y]; + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2); - 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]; + flags = bytestream_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; + } + } - s->pixel_ptr += s->line_inc; + return 0; +} + +static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s) +{ + int x, y; + uint16_t P[2]; + unsigned int flags = 0; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; + + /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on + * either top and bottom or left and right halves */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4); + + P[0] = bytestream_get_le16(&s->stream_ptr); + P[1] = bytestream_get_le16(&s->stream_ptr); + + if (!(P[0] & 0x8000)) { + + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24); + s->stream_ptr -= 4; + + for (y = 0; y < 16; y++) { + // new values for each 4x4 block + if (!(y & 3)) { + P[0] = bytestream_get_le16(&s->stream_ptr); + P[1] = bytestream_get_le16(&s->stream_ptr); + flags = bytestream_get_le16(&s->stream_ptr); + } + + 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 { - /* 4-color encoding for either left and right or top and bottom - * halves; need 20 more bytes */ - CHECK_STREAM_PTR(20); + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 12); - 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++; + if (!(AV_RL16(s->stream_ptr + 4) & 0x8000)) { - if (P[4] <= P[5]) { + flags = bytestream_get_le32(&s->stream_ptr); - /* block is divided into left and right halves */ - for (y = 0; y < 8; y++) { + /* 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] = bytestream_get_le16(&s->stream_ptr); + P[1] = bytestream_get_le16(&s->stream_ptr); + flags = bytestream_get_le32(&s->stream_ptr); + } + } - flags = (B[y + 8] << 8) | B[y]; - split = 0; + } else { + + /* horizontal split; top & bottom halves are 2-color encoded */ - 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 < 8; y++) { + if (y == 4) { + P[0] = bytestream_get_le16(&s->stream_ptr); + P[1] = bytestream_get_le16(&s->stream_ptr); } + flags = *s->stream_ptr++ | 0x100; - s->pixel_ptr += s->line_inc; + for (; flags != 1; flags >>= 1) + *pixel_ptr++ = P[flags & 1]; + pixel_ptr += s->line_inc; } + } + } - } else { + /* report success */ + return 0; +} + +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; + + /* 4-color encoding */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8); + + for (x = 0; x < 4; x++) + P[x] = bytestream_get_le16(&s->stream_ptr); + + if (!(P[0] & 0x8000)) { + if (!(P[2] & 0x8000)) { + + /* 1 of 4 colors for each pixel */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16); - /* block is divided into top and bottom halves */ - split = 0; for (y = 0; y < 8; y++) { + /* get the next set of 8 2-bit flags */ + int flags = bytestream_get_le16(&s->stream_ptr); + for (x = 0; x < 8; x++, flags >>= 2) + *pixel_ptr++ = P[flags & 0x03]; + pixel_ptr += s->line_inc; + } - flags = (B[y * 2 + 1] << 8) | B[y * 2]; - if (y == 4) - split = 4; + } else { + uint32_t flags; - for (x = 0, shifter = 0; x < 8; x++, shifter += 2) - *s->pixel_ptr++ = P[split + ((flags >> shifter) & 0x03)]; + /* 1 of 4 colors for each 2x2 block */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4); - s->pixel_ptr += s->line_inc; + flags = bytestream_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; + } + + } + } else { + uint64_t flags; + + /* 1 of 4 colors for each 2x1 or 1x2 block */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8); + + flags = bytestream_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; } } } @@ -660,118 +784,146 @@ 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_0xA_16(IpvideoContext *s) { int x, y; + uint16_t P[4]; + int flags = 0; + 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 each 4x4 quadrant, or 4-color encoding on + * either top and bottom or left and right halves */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24); - for (y = 0; y < 8; y++) { - for (x = 0; x < 8; x++) { - *s->pixel_ptr++ = *s->stream_ptr++; + if (!(AV_RL16(s->stream_ptr) & 0x8000)) { + + /* 4-color encoding for each quadrant */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 48); + + for (y = 0; y < 16; y++) { + // new values for each 4x4 block + if (!(y & 3)) { + for (x = 0; x < 4; x++) + P[x] = bytestream_get_le16(&s->stream_ptr); + flags = bytestream_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 = !(AV_RL16(s->stream_ptr + 16) & 0x8000); + uint64_t flags = 0; + + /* 4-color encoding for either left and right or top and bottom + * halves */ + + for (y = 0; y < 16; y++) { + // load values for each half + if (!(y & 7)) { + for (x = 0; x < 4; x++) + P[x] = bytestream_get_le16(&s->stream_ptr); + flags = bytestream_get_le64(&s->stream_ptr); + } + + 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; } - s->pixel_ptr += s->line_inc; } /* report success */ return 0; } -static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s) +static int ipvideo_decode_block_opcode_0xB_16(IpvideoContext *s) { int x, y; - unsigned char pix; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; - /* 16-color block encoding: each 2x2 block is a different color */ - CHECK_STREAM_PTR(16); + /* 64-color encoding (each pixel in block is a different color) */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 128); - 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; - } - s->pixel_ptr += s->stride * 2; + for (y = 0; y < 8; y++) { + for (x = 0; x < 8; x++) + pixel_ptr[x] = bytestream_get_le16(&s->stream_ptr); + pixel_ptr += s->stride; } /* report success */ return 0; } -static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s) +static int ipvideo_decode_block_opcode_0xC_16(IpvideoContext *s) { int x, y; - unsigned char P[4]; - unsigned char index = 0; - - /* 4-color block encoding: each 4x4 block is a different color */ - CHECK_STREAM_PTR(4); + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; - for (y = 0; y < 4; y++) - P[y] = *s->stream_ptr++; + /* 16-color block encoding: each 2x2 block is a different color */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 32); - 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]; + 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] = bytestream_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; + uint16_t P[2]; + uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr; - /* 1-color encoding: the whole block is 1 solid color */ - CHECK_STREAM_PTR(1); - pix = *s->stream_ptr++; + /* 4-color block encoding: each 4x4 block is a different color */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8); for (y = 0; y < 8; y++) { - for (x = 0; x < 8; x++) { - *s->pixel_ptr++ = pix; + if (!(y & 3)) { + P[0] = bytestream_get_le16(&s->stream_ptr); + P[1] = bytestream_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 */ + CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2); + pix = bytestream_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 */ @@ -789,58 +941,73 @@ static int (* const ipvideo_decode_block[])(IpvideoContext *s) = { 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); 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); + if (!s->is_16bpp) { + /* this is PAL8, so make the palette available */ + memcpy(s->current_frame.data[1], s->avctx->palctrl->palette, PALETTE_COUNT * 4); - 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]; + s->stream_ptr = s->buf + 14; /* data starts 14 bytes in */ + s->stream_end = s->buf + s->size; + } else { + s->stride = s->current_frame.linesize[0] >> 1; + s->stream_ptr = s->buf + 16; + s->stream_end = + s->mv_ptr = s->buf + 14 + AV_RL16(s->buf+14); + s->mv_end = s->buf + s->size; + } s->line_inc = s->stride - 8; - s->upper_motion_limit_offset = (s->avctx->height - 8) * s->stride - + s->avctx->width - 8; - - 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++; + 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); debug_interplay(" block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n", - x - y, y / s->stride, opcode, s->stream_ptr); - code_counts[opcode]++; + x, y, opcode, s->stream_ptr); - s->pixel_ptr = s->current_frame.data[0] + x; - ret = ipvideo_decode_block[opcode](s); + 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)) { + if (s->stream_end - s->stream_ptr > 1) { av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode finished with %td bytes left over\n", - s->stream_end - s->stream_ptr); + s->stream_end - s->stream_ptr); } } @@ -850,12 +1017,13 @@ static av_cold int ipvideo_decode_init(AVCodecContext *avctx) s->avctx = avctx; - if (s->avctx->palctrl == NULL) { + s->is_16bpp = avctx->bits_per_coded_sample == 16; + avctx->pix_fmt = s->is_16bpp ? PIX_FMT_RGB555 : PIX_FMT_PAL8; + if (!s->is_16bpp && s->avctx->palctrl == NULL) { av_log(avctx, AV_LOG_ERROR, " Interplay video: palette expected.\n"); return -1; } - avctx->pix_fmt = PIX_FMT_PAL8; dsputil_init(&s->dsp, avctx); /* decoding map contains 4 bits of information per 8x8 block */ @@ -869,8 +1037,10 @@ static av_cold int ipvideo_decode_init(AVCodecContext *avctx) static int ipvideo_decode_frame(AVCodecContext *avctx, void *data, int *data_size, - const 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; @@ -891,7 +1061,7 @@ static int ipvideo_decode_frame(AVCodecContext *avctx, ipvideo_decode_opcodes(s); - if (palette_control->palette_changed) { + if (!s->is_16bpp && palette_control->palette_changed) { palette_control->palette_changed = 0; s->current_frame.palette_has_changed = 1; }