2 * Interplay MVE Video Decoder
3 * Copyright (C) 2003 the ffmpeg project
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * @file libavcodec/interplayvideo.c
24 * Interplay MVE Video Decoder by Mike Melanson (melanson@pcisys.net)
25 * For more information about the Interplay MVE format, visit:
26 * http://www.pcisys.net/~melanson/codecs/interplay-mve.txt
27 * This code is written in such a way that the identifiers match up
28 * with the encoding descriptions in the document.
30 * This decoder presently only supports a PAL8 output colorspace.
32 * An Interplay video frame consists of 2 parts: The decoding map and
33 * the video data. A demuxer must load these 2 parts together in a single
34 * buffer before sending it through the stream to this decoder.
43 #include "bytestream.h"
45 #define ALT_BITSTREAM_READER_LE
48 #define PALETTE_COUNT 256
50 /* debugging support */
51 #define DEBUG_INTERPLAY 0
53 #define debug_interplay(x,...) av_log(NULL, AV_LOG_DEBUG, x, __VA_ARGS__)
55 static inline void debug_interplay(const char *format, ...) { }
58 typedef struct IpvideoContext {
60 AVCodecContext *avctx;
62 AVFrame second_last_frame;
64 AVFrame current_frame;
65 const unsigned char *decoding_map;
66 int decoding_map_size;
68 const unsigned char *buf;
71 const unsigned char *stream_ptr;
72 const unsigned char *stream_end;
73 unsigned char *pixel_ptr;
76 int upper_motion_limit_offset;
80 #define CHECK_STREAM_PTR(n) \
81 if (s->stream_end - s->stream_ptr < n) { \
82 av_log(s->avctx, AV_LOG_ERROR, "Interplay video warning: stream_ptr out of bounds (%p >= %p)\n", \
83 s->stream_ptr + n, s->stream_end); \
87 static int copy_from(IpvideoContext *s, AVFrame *src, int delta_x, int delta_y)
89 int current_offset = s->pixel_ptr - s->current_frame.data[0];
90 int motion_offset = current_offset + delta_y * s->stride + delta_x;
91 if (motion_offset < 0) {
92 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset);
94 } else if (motion_offset > s->upper_motion_limit_offset) {
95 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n",
96 motion_offset, s->upper_motion_limit_offset);
99 s->dsp.put_pixels_tab[1][0](s->pixel_ptr, src->data[0] + motion_offset, s->stride, 8);
103 static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s)
105 return copy_from(s, &s->last_frame, 0, 0);
108 static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s)
110 return copy_from(s, &s->second_last_frame, 0, 0);
113 static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s)
118 /* copy block from 2 frames ago using a motion vector; need 1 more byte */
120 B = *s->stream_ptr++;
126 x = -14 + ((B - 56) % 29);
127 y = 8 + ((B - 56) / 29);
130 debug_interplay (" motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
131 return copy_from(s, &s->second_last_frame, x, y);
134 static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s)
139 /* copy 8x8 block from current frame from an up/left block */
141 /* need 1 more byte for motion */
143 B = *s->stream_ptr++;
149 x = -(-14 + ((B - 56) % 29));
150 y = -( 8 + ((B - 56) / 29));
153 debug_interplay (" motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
154 return copy_from(s, &s->current_frame, x, y);
157 static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s)
160 unsigned char B, BL, BH;
162 /* copy a block from the previous frame; need 1 more byte */
165 B = *s->stream_ptr++;
167 BH = (B >> 4) & 0x0F;
171 debug_interplay (" motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
172 return copy_from(s, &s->last_frame, x, y);
175 static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s)
179 /* copy a block from the previous frame using an expanded range;
180 * need 2 more bytes */
183 x = *s->stream_ptr++;
184 y = *s->stream_ptr++;
186 debug_interplay (" motion bytes = %d, %d\n", x, y);
187 return copy_from(s, &s->last_frame, x, y);
190 static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s)
192 /* mystery opcode? skip multiple blocks? */
193 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: Help! Mystery opcode 0x6 seen\n");
199 static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)
205 /* 2-color encoding */
208 P[0] = *s->stream_ptr++;
209 P[1] = *s->stream_ptr++;
213 /* need 8 more bytes from the stream */
216 for (y = 0; y < 8; y++) {
217 flags = *s->stream_ptr++ | 0x100;
218 for (; flags != 1; flags >>= 1)
219 *s->pixel_ptr++ = P[flags & 1];
220 s->pixel_ptr += s->line_inc;
225 /* need 2 more bytes from the stream */
228 flags = bytestream_get_le16(&s->stream_ptr);
229 for (y = 0; y < 8; y += 2) {
230 for (x = 0; x < 8; x += 2, flags >>= 1) {
232 s->pixel_ptr[x + 1 ] =
233 s->pixel_ptr[x + s->stride] =
234 s->pixel_ptr[x + 1 + s->stride] = P[flags & 1];
236 s->pixel_ptr += s->stride * 2;
244 static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
248 unsigned int flags = 0;
250 /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
251 * either top and bottom or left and right halves */
254 P[0] = *s->stream_ptr++;
255 P[1] = *s->stream_ptr++;
259 CHECK_STREAM_PTR(14);
262 for (y = 0; y < 16; y++) {
263 // new values for each 4x4 block
265 P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
266 flags = bytestream_get_le16(&s->stream_ptr);
269 for (x = 0; x < 4; x++, flags >>= 1)
270 *s->pixel_ptr++ = P[flags & 1];
271 s->pixel_ptr += s->stride - 4;
272 // switch to right half
273 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
278 /* need 10 more bytes */
279 CHECK_STREAM_PTR(10);
281 if (s->stream_ptr[4] <= s->stream_ptr[5]) {
283 flags = bytestream_get_le32(&s->stream_ptr);
285 /* vertical split; left & right halves are 2-color encoded */
287 for (y = 0; y < 16; y++) {
288 for (x = 0; x < 4; x++, flags >>= 1)
289 *s->pixel_ptr++ = P[flags & 1];
290 s->pixel_ptr += s->stride - 4;
291 // switch to right half
293 s->pixel_ptr -= 8 * s->stride - 4;
294 P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
295 flags = bytestream_get_le32(&s->stream_ptr);
301 /* horizontal split; top & bottom halves are 2-color encoded */
303 for (y = 0; y < 8; y++) {
305 P[0] = *s->stream_ptr++;
306 P[1] = *s->stream_ptr++;
308 flags = *s->stream_ptr++ | 0x100;
310 for (; flags != 1; flags >>= 1)
311 *s->pixel_ptr++ = P[flags & 1];
312 s->pixel_ptr += s->line_inc;
321 static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
326 /* 4-color encoding */
329 memcpy(P, s->stream_ptr, 4);
335 /* 1 of 4 colors for each pixel, need 16 more bytes */
336 CHECK_STREAM_PTR(16);
338 for (y = 0; y < 8; y++) {
339 /* get the next set of 8 2-bit flags */
340 int flags = bytestream_get_le16(&s->stream_ptr);
341 for (x = 0; x < 8; x++, flags >>= 2)
342 *s->pixel_ptr++ = P[flags & 0x03];
343 s->pixel_ptr += s->line_inc;
349 /* 1 of 4 colors for each 2x2 block, need 4 more bytes */
352 flags = bytestream_get_le32(&s->stream_ptr);
354 for (y = 0; y < 8; y += 2) {
355 for (x = 0; x < 8; x += 2, flags >>= 2) {
357 s->pixel_ptr[x + 1 ] =
358 s->pixel_ptr[x + s->stride] =
359 s->pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];
361 s->pixel_ptr += s->stride * 2;
368 /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */
371 flags = bytestream_get_le64(&s->stream_ptr);
373 for (y = 0; y < 8; y++) {
374 for (x = 0; x < 8; x += 2, flags >>= 2) {
376 s->pixel_ptr[x + 1] = P[flags & 0x03];
378 s->pixel_ptr += s->stride;
381 for (y = 0; y < 8; y += 2) {
382 for (x = 0; x < 8; x++, flags >>= 2) {
384 s->pixel_ptr[x + s->stride] = P[flags & 0x03];
386 s->pixel_ptr += s->stride * 2;
395 static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
401 /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
402 * either top and bottom or left and right halves */
403 CHECK_STREAM_PTR(24);
405 if (s->stream_ptr[0] <= s->stream_ptr[1]) {
407 /* 4-color encoding for each quadrant; need 32 bytes */
408 CHECK_STREAM_PTR(32);
410 for (y = 0; y < 16; y++) {
411 // new values for each 4x4 block
413 memcpy(P, s->stream_ptr, 4);
415 flags = bytestream_get_le32(&s->stream_ptr);
418 for (x = 0; x < 4; x++, flags >>= 2)
419 *s->pixel_ptr++ = P[flags & 0x03];
421 s->pixel_ptr += s->stride - 4;
422 // switch to right half
423 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
428 int vert = s->stream_ptr[12] <= s->stream_ptr[13];
431 /* 4-color encoding for either left and right or top and bottom
434 for (y = 0; y < 16; y++) {
435 // load values for each half
437 memcpy(P, s->stream_ptr, 4);
439 flags = bytestream_get_le64(&s->stream_ptr);
442 for (x = 0; x < 4; x++, flags >>= 2)
443 *s->pixel_ptr++ = P[flags & 0x03];
446 s->pixel_ptr += s->stride - 4;
447 // switch to right half
448 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
449 } else if (y & 1) s->pixel_ptr += s->line_inc;
457 static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s)
461 /* 64-color encoding (each pixel in block is a different color) */
462 CHECK_STREAM_PTR(64);
464 for (y = 0; y < 8; y++) {
465 memcpy(s->pixel_ptr, s->stream_ptr, 8);
467 s->pixel_ptr += s->stride;
474 static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s)
478 /* 16-color block encoding: each 2x2 block is a different color */
479 CHECK_STREAM_PTR(16);
481 for (y = 0; y < 8; y += 2) {
482 for (x = 0; x < 8; x += 2) {
484 s->pixel_ptr[x + 1 ] =
485 s->pixel_ptr[x + s->stride] =
486 s->pixel_ptr[x + 1 + s->stride] = *s->stream_ptr++;
488 s->pixel_ptr += s->stride * 2;
495 static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s)
500 /* 4-color block encoding: each 4x4 block is a different color */
503 for (y = 0; y < 8; y++) {
505 P[0] = *s->stream_ptr++;
506 P[1] = *s->stream_ptr++;
508 memset(s->pixel_ptr, P[0], 4);
509 memset(s->pixel_ptr + 4, P[1], 4);
510 s->pixel_ptr += s->stride;
517 static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s)
522 /* 1-color encoding: the whole block is 1 solid color */
524 pix = *s->stream_ptr++;
526 for (y = 0; y < 8; y++) {
527 memset(s->pixel_ptr, pix, 8);
528 s->pixel_ptr += s->stride;
535 static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s)
538 unsigned char sample[2];
540 /* dithered encoding */
542 sample[0] = *s->stream_ptr++;
543 sample[1] = *s->stream_ptr++;
545 for (y = 0; y < 8; y++) {
546 for (x = 0; x < 8; x += 2) {
547 *s->pixel_ptr++ = sample[ y & 1 ];
548 *s->pixel_ptr++ = sample[!(y & 1)];
550 s->pixel_ptr += s->line_inc;
557 static int (* const ipvideo_decode_block[])(IpvideoContext *s) = {
558 ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1,
559 ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3,
560 ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5,
561 ipvideo_decode_block_opcode_0x6, ipvideo_decode_block_opcode_0x7,
562 ipvideo_decode_block_opcode_0x8, ipvideo_decode_block_opcode_0x9,
563 ipvideo_decode_block_opcode_0xA, ipvideo_decode_block_opcode_0xB,
564 ipvideo_decode_block_opcode_0xC, ipvideo_decode_block_opcode_0xD,
565 ipvideo_decode_block_opcode_0xE, ipvideo_decode_block_opcode_0xF,
568 static void ipvideo_decode_opcodes(IpvideoContext *s)
571 unsigned char opcode;
573 static int frame = 0;
576 debug_interplay("------------------ frame %d\n", frame);
579 /* this is PAL8, so make the palette available */
580 memcpy(s->current_frame.data[1], s->avctx->palctrl->palette, PALETTE_COUNT * 4);
582 s->stride = s->current_frame.linesize[0];
583 s->stream_ptr = s->buf + 14; /* data starts 14 bytes in */
584 s->stream_end = s->buf + s->size;
585 s->line_inc = s->stride - 8;
586 s->upper_motion_limit_offset = (s->avctx->height - 8) * s->stride
587 + s->avctx->width - 8;
589 init_get_bits(&gb, s->decoding_map, s->decoding_map_size * 8);
590 for (y = 0; y < (s->stride * s->avctx->height); y += s->stride * 8) {
591 for (x = y; x < y + s->avctx->width; x += 8) {
592 opcode = get_bits(&gb, 4);
594 debug_interplay(" block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",
595 x - y, y / s->stride, opcode, s->stream_ptr);
597 s->pixel_ptr = s->current_frame.data[0] + x;
598 ret = ipvideo_decode_block[opcode](s);
600 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode problem on frame %d, @ block (%d, %d)\n",
601 frame, x - y, y / s->stride);
606 if (s->stream_end - s->stream_ptr > 1) {
607 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode finished with %td bytes left over\n",
608 s->stream_end - s->stream_ptr);
612 static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
614 IpvideoContext *s = avctx->priv_data;
618 if (s->avctx->palctrl == NULL) {
619 av_log(avctx, AV_LOG_ERROR, " Interplay video: palette expected.\n");
623 avctx->pix_fmt = PIX_FMT_PAL8;
624 dsputil_init(&s->dsp, avctx);
626 /* decoding map contains 4 bits of information per 8x8 block */
627 s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2);
629 s->current_frame.data[0] = s->last_frame.data[0] =
630 s->second_last_frame.data[0] = NULL;
635 static int ipvideo_decode_frame(AVCodecContext *avctx,
636 void *data, int *data_size,
639 const uint8_t *buf = avpkt->data;
640 int buf_size = avpkt->size;
641 IpvideoContext *s = avctx->priv_data;
642 AVPaletteControl *palette_control = avctx->palctrl;
644 /* compressed buffer needs to be large enough to at least hold an entire
646 if (buf_size < s->decoding_map_size)
649 s->decoding_map = buf;
650 s->buf = buf + s->decoding_map_size;
651 s->size = buf_size - s->decoding_map_size;
653 s->current_frame.reference = 3;
654 if (avctx->get_buffer(avctx, &s->current_frame)) {
655 av_log(avctx, AV_LOG_ERROR, " Interplay Video: get_buffer() failed\n");
659 ipvideo_decode_opcodes(s);
661 if (palette_control->palette_changed) {
662 palette_control->palette_changed = 0;
663 s->current_frame.palette_has_changed = 1;
666 *data_size = sizeof(AVFrame);
667 *(AVFrame*)data = s->current_frame;
670 if (s->second_last_frame.data[0])
671 avctx->release_buffer(avctx, &s->second_last_frame);
672 s->second_last_frame = s->last_frame;
673 s->last_frame = s->current_frame;
674 s->current_frame.data[0] = NULL; /* catch any access attempts */
676 /* report that the buffer was completely consumed */
680 static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
682 IpvideoContext *s = avctx->priv_data;
684 /* release the last frame */
685 if (s->last_frame.data[0])
686 avctx->release_buffer(avctx, &s->last_frame);
687 if (s->second_last_frame.data[0])
688 avctx->release_buffer(avctx, &s->second_last_frame);
693 AVCodec interplay_video_decoder = {
696 CODEC_ID_INTERPLAY_VIDEO,
697 sizeof(IpvideoContext),
701 ipvideo_decode_frame,
703 .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"),