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"),