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
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.
42 #include "bytestream.h"
44 #define BITSTREAM_READER_LE
48 #define PALETTE_COUNT 256
50 typedef struct IpvideoContext
{
52 AVCodecContext
*avctx
;
54 AVFrame
*second_last_frame
;
56 const unsigned char *decoding_map
;
57 int decoding_map_size
;
60 GetByteContext stream_ptr
, mv_ptr
;
61 unsigned char *pixel_ptr
;
64 int upper_motion_limit_offset
;
69 static int copy_from(IpvideoContext
*s
, AVFrame
*src
, AVFrame
*dst
, int delta_x
, int delta_y
)
71 int current_offset
= s
->pixel_ptr
- dst
->data
[0];
72 int motion_offset
= current_offset
+ delta_y
* dst
->linesize
[0]
73 + delta_x
* (1 + s
->is_16bpp
);
74 if (motion_offset
< 0) {
75 av_log(s
->avctx
, AV_LOG_ERROR
, "motion offset < 0 (%d)\n", motion_offset
);
76 return AVERROR_INVALIDDATA
;
77 } else if (motion_offset
> s
->upper_motion_limit_offset
) {
78 av_log(s
->avctx
, AV_LOG_ERROR
, "motion offset above limit (%d >= %d)\n",
79 motion_offset
, s
->upper_motion_limit_offset
);
80 return AVERROR_INVALIDDATA
;
83 av_log(s
->avctx
, AV_LOG_ERROR
, "Invalid decode type, corrupted header?\n");
84 return AVERROR(EINVAL
);
86 s
->hdsp
.put_pixels_tab
[!s
->is_16bpp
][0](s
->pixel_ptr
, src
->data
[0] + motion_offset
,
91 static int ipvideo_decode_block_opcode_0x0(IpvideoContext
*s
, AVFrame
*frame
)
93 return copy_from(s
, s
->last_frame
, frame
, 0, 0);
96 static int ipvideo_decode_block_opcode_0x1(IpvideoContext
*s
, AVFrame
*frame
)
98 return copy_from(s
, s
->second_last_frame
, frame
, 0, 0);
101 static int ipvideo_decode_block_opcode_0x2(IpvideoContext
*s
, AVFrame
*frame
)
106 /* copy block from 2 frames ago using a motion vector; need 1 more byte */
108 B
= bytestream2_get_byte(&s
->stream_ptr
);
110 B
= bytestream2_get_byte(&s
->mv_ptr
);
117 x
= -14 + ((B
- 56) % 29);
118 y
= 8 + ((B
- 56) / 29);
121 av_dlog(s
->avctx
, "motion byte = %d, (x, y) = (%d, %d)\n", B
, x
, y
);
122 return copy_from(s
, s
->second_last_frame
, frame
, x
, y
);
125 static int ipvideo_decode_block_opcode_0x3(IpvideoContext
*s
, AVFrame
*frame
)
130 /* copy 8x8 block from current frame from an up/left block */
132 /* need 1 more byte for motion */
134 B
= bytestream2_get_byte(&s
->stream_ptr
);
136 B
= bytestream2_get_byte(&s
->mv_ptr
);
143 x
= -(-14 + ((B
- 56) % 29));
144 y
= -( 8 + ((B
- 56) / 29));
147 av_dlog(s
->avctx
, "motion byte = %d, (x, y) = (%d, %d)\n", B
, x
, y
);
148 return copy_from(s
, frame
, frame
, x
, y
);
151 static int ipvideo_decode_block_opcode_0x4(IpvideoContext
*s
, AVFrame
*frame
)
154 unsigned char B
, BL
, BH
;
156 /* copy a block from the previous frame; need 1 more byte */
158 B
= bytestream2_get_byte(&s
->stream_ptr
);
160 B
= bytestream2_get_byte(&s
->mv_ptr
);
164 BH
= (B
>> 4) & 0x0F;
168 av_dlog(s
->avctx
, "motion byte = %d, (x, y) = (%d, %d)\n", B
, x
, y
);
169 return copy_from(s
, s
->last_frame
, frame
, x
, y
);
172 static int ipvideo_decode_block_opcode_0x5(IpvideoContext
*s
, AVFrame
*frame
)
176 /* copy a block from the previous frame using an expanded range;
177 * need 2 more bytes */
178 x
= bytestream2_get_byte(&s
->stream_ptr
);
179 y
= bytestream2_get_byte(&s
->stream_ptr
);
181 av_dlog(s
->avctx
, "motion bytes = %d, %d\n", x
, y
);
182 return copy_from(s
, s
->last_frame
, frame
, x
, y
);
185 static int ipvideo_decode_block_opcode_0x6(IpvideoContext
*s
, AVFrame
*frame
)
187 /* mystery opcode? skip multiple blocks? */
188 av_log(s
->avctx
, AV_LOG_ERROR
, "Help! Mystery opcode 0x6 seen\n");
194 static int ipvideo_decode_block_opcode_0x7(IpvideoContext
*s
, AVFrame
*frame
)
200 if (bytestream2_get_bytes_left(&s
->stream_ptr
) < 4) {
201 av_log(s
->avctx
, AV_LOG_ERROR
, "too little data for opcode 0x7\n");
202 return AVERROR_INVALIDDATA
;
205 /* 2-color encoding */
206 P
[0] = bytestream2_get_byte(&s
->stream_ptr
);
207 P
[1] = bytestream2_get_byte(&s
->stream_ptr
);
211 /* need 8 more bytes from the stream */
212 for (y
= 0; y
< 8; y
++) {
213 flags
= bytestream2_get_byte(&s
->stream_ptr
) | 0x100;
214 for (; flags
!= 1; flags
>>= 1)
215 *s
->pixel_ptr
++ = P
[flags
& 1];
216 s
->pixel_ptr
+= s
->line_inc
;
221 /* need 2 more bytes from the stream */
222 flags
= bytestream2_get_le16(&s
->stream_ptr
);
223 for (y
= 0; y
< 8; y
+= 2) {
224 for (x
= 0; x
< 8; x
+= 2, flags
>>= 1) {
226 s
->pixel_ptr
[x
+ 1 ] =
227 s
->pixel_ptr
[x
+ s
->stride
] =
228 s
->pixel_ptr
[x
+ 1 + s
->stride
] = P
[flags
& 1];
230 s
->pixel_ptr
+= s
->stride
* 2;
238 static int ipvideo_decode_block_opcode_0x8(IpvideoContext
*s
, AVFrame
*frame
)
242 unsigned int flags
= 0;
244 if (bytestream2_get_bytes_left(&s
->stream_ptr
) < 12) {
245 av_log(s
->avctx
, AV_LOG_ERROR
, "too little data for opcode 0x8\n");
246 return AVERROR_INVALIDDATA
;
249 /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
250 * either top and bottom or left and right halves */
251 P
[0] = bytestream2_get_byte(&s
->stream_ptr
);
252 P
[1] = bytestream2_get_byte(&s
->stream_ptr
);
255 for (y
= 0; y
< 16; y
++) {
256 // new values for each 4x4 block
259 P
[0] = bytestream2_get_byte(&s
->stream_ptr
);
260 P
[1] = bytestream2_get_byte(&s
->stream_ptr
);
262 flags
= bytestream2_get_le16(&s
->stream_ptr
);
265 for (x
= 0; x
< 4; x
++, flags
>>= 1)
266 *s
->pixel_ptr
++ = P
[flags
& 1];
267 s
->pixel_ptr
+= s
->stride
- 4;
268 // switch to right half
269 if (y
== 7) s
->pixel_ptr
-= 8 * s
->stride
- 4;
273 flags
= bytestream2_get_le32(&s
->stream_ptr
);
274 P
[2] = bytestream2_get_byte(&s
->stream_ptr
);
275 P
[3] = bytestream2_get_byte(&s
->stream_ptr
);
279 /* vertical split; left & right halves are 2-color encoded */
281 for (y
= 0; y
< 16; y
++) {
282 for (x
= 0; x
< 4; x
++, flags
>>= 1)
283 *s
->pixel_ptr
++ = P
[flags
& 1];
284 s
->pixel_ptr
+= s
->stride
- 4;
285 // switch to right half
287 s
->pixel_ptr
-= 8 * s
->stride
- 4;
290 flags
= bytestream2_get_le32(&s
->stream_ptr
);
296 /* horizontal split; top & bottom halves are 2-color encoded */
298 for (y
= 0; y
< 8; y
++) {
302 flags
= bytestream2_get_le32(&s
->stream_ptr
);
305 for (x
= 0; x
< 8; x
++, flags
>>= 1)
306 *s
->pixel_ptr
++ = P
[flags
& 1];
307 s
->pixel_ptr
+= s
->line_inc
;
316 static int ipvideo_decode_block_opcode_0x9(IpvideoContext
*s
, AVFrame
*frame
)
321 if (bytestream2_get_bytes_left(&s
->stream_ptr
) < 8) {
322 av_log(s
->avctx
, AV_LOG_ERROR
, "too little data for opcode 0x9\n");
323 return AVERROR_INVALIDDATA
;
326 /* 4-color encoding */
327 bytestream2_get_buffer(&s
->stream_ptr
, P
, 4);
332 /* 1 of 4 colors for each pixel, need 16 more bytes */
333 for (y
= 0; y
< 8; y
++) {
334 /* get the next set of 8 2-bit flags */
335 int flags
= bytestream2_get_le16(&s
->stream_ptr
);
336 for (x
= 0; x
< 8; x
++, flags
>>= 2)
337 *s
->pixel_ptr
++ = P
[flags
& 0x03];
338 s
->pixel_ptr
+= s
->line_inc
;
344 /* 1 of 4 colors for each 2x2 block, need 4 more bytes */
345 flags
= bytestream2_get_le32(&s
->stream_ptr
);
347 for (y
= 0; y
< 8; y
+= 2) {
348 for (x
= 0; x
< 8; x
+= 2, flags
>>= 2) {
350 s
->pixel_ptr
[x
+ 1 ] =
351 s
->pixel_ptr
[x
+ s
->stride
] =
352 s
->pixel_ptr
[x
+ 1 + s
->stride
] = P
[flags
& 0x03];
354 s
->pixel_ptr
+= s
->stride
* 2;
361 /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */
362 flags
= bytestream2_get_le64(&s
->stream_ptr
);
364 for (y
= 0; y
< 8; y
++) {
365 for (x
= 0; x
< 8; x
+= 2, flags
>>= 2) {
367 s
->pixel_ptr
[x
+ 1] = P
[flags
& 0x03];
369 s
->pixel_ptr
+= s
->stride
;
372 for (y
= 0; y
< 8; y
+= 2) {
373 for (x
= 0; x
< 8; x
++, flags
>>= 2) {
375 s
->pixel_ptr
[x
+ s
->stride
] = P
[flags
& 0x03];
377 s
->pixel_ptr
+= s
->stride
* 2;
386 static int ipvideo_decode_block_opcode_0xA(IpvideoContext
*s
, AVFrame
*frame
)
392 if (bytestream2_get_bytes_left(&s
->stream_ptr
) < 16) {
393 av_log(s
->avctx
, AV_LOG_ERROR
, "too little data for opcode 0xA\n");
394 return AVERROR_INVALIDDATA
;
397 bytestream2_get_buffer(&s
->stream_ptr
, P
, 4);
399 /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
400 * either top and bottom or left and right halves */
403 /* 4-color encoding for each quadrant; need 32 bytes */
404 for (y
= 0; y
< 16; y
++) {
405 // new values for each 4x4 block
407 if (y
) bytestream2_get_buffer(&s
->stream_ptr
, P
, 4);
408 flags
= bytestream2_get_le32(&s
->stream_ptr
);
411 for (x
= 0; x
< 4; x
++, flags
>>= 2)
412 *s
->pixel_ptr
++ = P
[flags
& 0x03];
414 s
->pixel_ptr
+= s
->stride
- 4;
415 // switch to right half
416 if (y
== 7) s
->pixel_ptr
-= 8 * s
->stride
- 4;
422 uint64_t flags
= bytestream2_get_le64(&s
->stream_ptr
);
424 bytestream2_get_buffer(&s
->stream_ptr
, P
+ 4, 4);
427 /* 4-color encoding for either left and right or top and bottom
430 for (y
= 0; y
< 16; y
++) {
431 for (x
= 0; x
< 4; x
++, flags
>>= 2)
432 *s
->pixel_ptr
++ = P
[flags
& 0x03];
435 s
->pixel_ptr
+= s
->stride
- 4;
436 // switch to right half
437 if (y
== 7) s
->pixel_ptr
-= 8 * s
->stride
- 4;
438 } else if (y
& 1) s
->pixel_ptr
+= s
->line_inc
;
440 // load values for second half
443 flags
= bytestream2_get_le64(&s
->stream_ptr
);
452 static int ipvideo_decode_block_opcode_0xB(IpvideoContext
*s
, AVFrame
*frame
)
456 /* 64-color encoding (each pixel in block is a different color) */
457 for (y
= 0; y
< 8; y
++) {
458 bytestream2_get_buffer(&s
->stream_ptr
, s
->pixel_ptr
, 8);
459 s
->pixel_ptr
+= s
->stride
;
466 static int ipvideo_decode_block_opcode_0xC(IpvideoContext
*s
, AVFrame
*frame
)
470 /* 16-color block encoding: each 2x2 block is a different color */
471 for (y
= 0; y
< 8; y
+= 2) {
472 for (x
= 0; x
< 8; x
+= 2) {
474 s
->pixel_ptr
[x
+ 1 ] =
475 s
->pixel_ptr
[x
+ s
->stride
] =
476 s
->pixel_ptr
[x
+ 1 + s
->stride
] = bytestream2_get_byte(&s
->stream_ptr
);
478 s
->pixel_ptr
+= s
->stride
* 2;
485 static int ipvideo_decode_block_opcode_0xD(IpvideoContext
*s
, AVFrame
*frame
)
490 if (bytestream2_get_bytes_left(&s
->stream_ptr
) < 4) {
491 av_log(s
->avctx
, AV_LOG_ERROR
, "too little data for opcode 0xD\n");
492 return AVERROR_INVALIDDATA
;
495 /* 4-color block encoding: each 4x4 block is a different color */
496 for (y
= 0; y
< 8; y
++) {
498 P
[0] = bytestream2_get_byte(&s
->stream_ptr
);
499 P
[1] = bytestream2_get_byte(&s
->stream_ptr
);
501 memset(s
->pixel_ptr
, P
[0], 4);
502 memset(s
->pixel_ptr
+ 4, P
[1], 4);
503 s
->pixel_ptr
+= s
->stride
;
510 static int ipvideo_decode_block_opcode_0xE(IpvideoContext
*s
, AVFrame
*frame
)
515 /* 1-color encoding: the whole block is 1 solid color */
516 pix
= bytestream2_get_byte(&s
->stream_ptr
);
518 for (y
= 0; y
< 8; y
++) {
519 memset(s
->pixel_ptr
, pix
, 8);
520 s
->pixel_ptr
+= s
->stride
;
527 static int ipvideo_decode_block_opcode_0xF(IpvideoContext
*s
, AVFrame
*frame
)
530 unsigned char sample
[2];
532 /* dithered encoding */
533 sample
[0] = bytestream2_get_byte(&s
->stream_ptr
);
534 sample
[1] = bytestream2_get_byte(&s
->stream_ptr
);
536 for (y
= 0; y
< 8; y
++) {
537 for (x
= 0; x
< 8; x
+= 2) {
538 *s
->pixel_ptr
++ = sample
[ y
& 1 ];
539 *s
->pixel_ptr
++ = sample
[!(y
& 1)];
541 s
->pixel_ptr
+= s
->line_inc
;
548 static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext
*s
, AVFrame
*frame
)
552 /* copy a block from the second last frame using an expanded range */
553 x
= bytestream2_get_byte(&s
->stream_ptr
);
554 y
= bytestream2_get_byte(&s
->stream_ptr
);
556 av_dlog(s
->avctx
, "motion bytes = %d, %d\n", x
, y
);
557 return copy_from(s
, s
->second_last_frame
, frame
, x
, y
);
560 static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext
*s
, AVFrame
*frame
)
565 uint16_t *pixel_ptr
= (uint16_t*)s
->pixel_ptr
;
567 /* 2-color encoding */
568 P
[0] = bytestream2_get_le16(&s
->stream_ptr
);
569 P
[1] = bytestream2_get_le16(&s
->stream_ptr
);
571 if (!(P
[0] & 0x8000)) {
573 for (y
= 0; y
< 8; y
++) {
574 flags
= bytestream2_get_byte(&s
->stream_ptr
) | 0x100;
575 for (; flags
!= 1; flags
>>= 1)
576 *pixel_ptr
++ = P
[flags
& 1];
577 pixel_ptr
+= s
->line_inc
;
582 flags
= bytestream2_get_le16(&s
->stream_ptr
);
583 for (y
= 0; y
< 8; y
+= 2) {
584 for (x
= 0; x
< 8; x
+= 2, flags
>>= 1) {
587 pixel_ptr
[x
+ s
->stride
] =
588 pixel_ptr
[x
+ 1 + s
->stride
] = P
[flags
& 1];
590 pixel_ptr
+= s
->stride
* 2;
597 static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext
*s
, AVFrame
*frame
)
601 unsigned int flags
= 0;
602 uint16_t *pixel_ptr
= (uint16_t*)s
->pixel_ptr
;
604 /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
605 * either top and bottom or left and right halves */
606 P
[0] = bytestream2_get_le16(&s
->stream_ptr
);
607 P
[1] = bytestream2_get_le16(&s
->stream_ptr
);
609 if (!(P
[0] & 0x8000)) {
611 for (y
= 0; y
< 16; y
++) {
612 // new values for each 4x4 block
615 P
[0] = bytestream2_get_le16(&s
->stream_ptr
);
616 P
[1] = bytestream2_get_le16(&s
->stream_ptr
);
618 flags
= bytestream2_get_le16(&s
->stream_ptr
);
621 for (x
= 0; x
< 4; x
++, flags
>>= 1)
622 *pixel_ptr
++ = P
[flags
& 1];
623 pixel_ptr
+= s
->stride
- 4;
624 // switch to right half
625 if (y
== 7) pixel_ptr
-= 8 * s
->stride
- 4;
630 flags
= bytestream2_get_le32(&s
->stream_ptr
);
631 P
[2] = bytestream2_get_le16(&s
->stream_ptr
);
632 P
[3] = bytestream2_get_le16(&s
->stream_ptr
);
634 if (!(P
[2] & 0x8000)) {
636 /* vertical split; left & right halves are 2-color encoded */
638 for (y
= 0; y
< 16; y
++) {
639 for (x
= 0; x
< 4; x
++, flags
>>= 1)
640 *pixel_ptr
++ = P
[flags
& 1];
641 pixel_ptr
+= s
->stride
- 4;
642 // switch to right half
644 pixel_ptr
-= 8 * s
->stride
- 4;
647 flags
= bytestream2_get_le32(&s
->stream_ptr
);
653 /* horizontal split; top & bottom halves are 2-color encoded */
655 for (y
= 0; y
< 8; y
++) {
659 flags
= bytestream2_get_le32(&s
->stream_ptr
);
662 for (x
= 0; x
< 8; x
++, flags
>>= 1)
663 *pixel_ptr
++ = P
[flags
& 1];
664 pixel_ptr
+= s
->line_inc
;
673 static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext
*s
, AVFrame
*frame
)
677 uint16_t *pixel_ptr
= (uint16_t*)s
->pixel_ptr
;
679 /* 4-color encoding */
680 for (x
= 0; x
< 4; x
++)
681 P
[x
] = bytestream2_get_le16(&s
->stream_ptr
);
683 if (!(P
[0] & 0x8000)) {
684 if (!(P
[2] & 0x8000)) {
686 /* 1 of 4 colors for each pixel */
687 for (y
= 0; y
< 8; y
++) {
688 /* get the next set of 8 2-bit flags */
689 int flags
= bytestream2_get_le16(&s
->stream_ptr
);
690 for (x
= 0; x
< 8; x
++, flags
>>= 2)
691 *pixel_ptr
++ = P
[flags
& 0x03];
692 pixel_ptr
+= s
->line_inc
;
698 /* 1 of 4 colors for each 2x2 block */
699 flags
= bytestream2_get_le32(&s
->stream_ptr
);
701 for (y
= 0; y
< 8; y
+= 2) {
702 for (x
= 0; x
< 8; x
+= 2, flags
>>= 2) {
705 pixel_ptr
[x
+ s
->stride
] =
706 pixel_ptr
[x
+ 1 + s
->stride
] = P
[flags
& 0x03];
708 pixel_ptr
+= s
->stride
* 2;
715 /* 1 of 4 colors for each 2x1 or 1x2 block */
716 flags
= bytestream2_get_le64(&s
->stream_ptr
);
717 if (!(P
[2] & 0x8000)) {
718 for (y
= 0; y
< 8; y
++) {
719 for (x
= 0; x
< 8; x
+= 2, flags
>>= 2) {
721 pixel_ptr
[x
+ 1] = P
[flags
& 0x03];
723 pixel_ptr
+= s
->stride
;
726 for (y
= 0; y
< 8; y
+= 2) {
727 for (x
= 0; x
< 8; x
++, flags
>>= 2) {
729 pixel_ptr
[x
+ s
->stride
] = P
[flags
& 0x03];
731 pixel_ptr
+= s
->stride
* 2;
740 static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext
*s
, AVFrame
*frame
)
745 uint16_t *pixel_ptr
= (uint16_t*)s
->pixel_ptr
;
747 for (x
= 0; x
< 4; x
++)
748 P
[x
] = bytestream2_get_le16(&s
->stream_ptr
);
750 /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
751 * either top and bottom or left and right halves */
752 if (!(P
[0] & 0x8000)) {
754 /* 4-color encoding for each quadrant */
755 for (y
= 0; y
< 16; y
++) {
756 // new values for each 4x4 block
759 for (x
= 0; x
< 4; x
++)
760 P
[x
] = bytestream2_get_le16(&s
->stream_ptr
);
761 flags
= bytestream2_get_le32(&s
->stream_ptr
);
764 for (x
= 0; x
< 4; x
++, flags
>>= 2)
765 *pixel_ptr
++ = P
[flags
& 0x03];
767 pixel_ptr
+= s
->stride
- 4;
768 // switch to right half
769 if (y
== 7) pixel_ptr
-= 8 * s
->stride
- 4;
775 uint64_t flags
= bytestream2_get_le64(&s
->stream_ptr
);
777 for (x
= 4; x
< 8; x
++)
778 P
[x
] = bytestream2_get_le16(&s
->stream_ptr
);
779 vert
= !(P
[4] & 0x8000);
781 /* 4-color encoding for either left and right or top and bottom
784 for (y
= 0; y
< 16; y
++) {
785 for (x
= 0; x
< 4; x
++, flags
>>= 2)
786 *pixel_ptr
++ = P
[flags
& 0x03];
789 pixel_ptr
+= s
->stride
- 4;
790 // switch to right half
791 if (y
== 7) pixel_ptr
-= 8 * s
->stride
- 4;
792 } else if (y
& 1) pixel_ptr
+= s
->line_inc
;
794 // load values for second half
797 flags
= bytestream2_get_le64(&s
->stream_ptr
);
806 static int ipvideo_decode_block_opcode_0xB_16(IpvideoContext
*s
, AVFrame
*frame
)
809 uint16_t *pixel_ptr
= (uint16_t*)s
->pixel_ptr
;
811 /* 64-color encoding (each pixel in block is a different color) */
812 for (y
= 0; y
< 8; y
++) {
813 for (x
= 0; x
< 8; x
++)
814 pixel_ptr
[x
] = bytestream2_get_le16(&s
->stream_ptr
);
815 pixel_ptr
+= s
->stride
;
822 static int ipvideo_decode_block_opcode_0xC_16(IpvideoContext
*s
, AVFrame
*frame
)
825 uint16_t *pixel_ptr
= (uint16_t*)s
->pixel_ptr
;
827 /* 16-color block encoding: each 2x2 block is a different color */
828 for (y
= 0; y
< 8; y
+= 2) {
829 for (x
= 0; x
< 8; x
+= 2) {
832 pixel_ptr
[x
+ s
->stride
] =
833 pixel_ptr
[x
+ 1 + s
->stride
] = bytestream2_get_le16(&s
->stream_ptr
);
835 pixel_ptr
+= s
->stride
* 2;
842 static int ipvideo_decode_block_opcode_0xD_16(IpvideoContext
*s
, AVFrame
*frame
)
846 uint16_t *pixel_ptr
= (uint16_t*)s
->pixel_ptr
;
848 /* 4-color block encoding: each 4x4 block is a different color */
849 for (y
= 0; y
< 8; y
++) {
851 P
[0] = bytestream2_get_le16(&s
->stream_ptr
);
852 P
[1] = bytestream2_get_le16(&s
->stream_ptr
);
854 for (x
= 0; x
< 8; x
++)
855 pixel_ptr
[x
] = P
[x
>> 2];
856 pixel_ptr
+= s
->stride
;
863 static int ipvideo_decode_block_opcode_0xE_16(IpvideoContext
*s
, AVFrame
*frame
)
867 uint16_t *pixel_ptr
= (uint16_t*)s
->pixel_ptr
;
869 /* 1-color encoding: the whole block is 1 solid color */
870 pix
= bytestream2_get_le16(&s
->stream_ptr
);
872 for (y
= 0; y
< 8; y
++) {
873 for (x
= 0; x
< 8; x
++)
875 pixel_ptr
+= s
->stride
;
882 static int (* const ipvideo_decode_block
[])(IpvideoContext
*s
, AVFrame
*frame
) = {
883 ipvideo_decode_block_opcode_0x0
, ipvideo_decode_block_opcode_0x1
,
884 ipvideo_decode_block_opcode_0x2
, ipvideo_decode_block_opcode_0x3
,
885 ipvideo_decode_block_opcode_0x4
, ipvideo_decode_block_opcode_0x5
,
886 ipvideo_decode_block_opcode_0x6
, ipvideo_decode_block_opcode_0x7
,
887 ipvideo_decode_block_opcode_0x8
, ipvideo_decode_block_opcode_0x9
,
888 ipvideo_decode_block_opcode_0xA
, ipvideo_decode_block_opcode_0xB
,
889 ipvideo_decode_block_opcode_0xC
, ipvideo_decode_block_opcode_0xD
,
890 ipvideo_decode_block_opcode_0xE
, ipvideo_decode_block_opcode_0xF
,
893 static int (* const ipvideo_decode_block16
[])(IpvideoContext
*s
, AVFrame
*frame
) = {
894 ipvideo_decode_block_opcode_0x0
, ipvideo_decode_block_opcode_0x1
,
895 ipvideo_decode_block_opcode_0x2
, ipvideo_decode_block_opcode_0x3
,
896 ipvideo_decode_block_opcode_0x4
, ipvideo_decode_block_opcode_0x5
,
897 ipvideo_decode_block_opcode_0x6_16
, ipvideo_decode_block_opcode_0x7_16
,
898 ipvideo_decode_block_opcode_0x8_16
, ipvideo_decode_block_opcode_0x9_16
,
899 ipvideo_decode_block_opcode_0xA_16
, ipvideo_decode_block_opcode_0xB_16
,
900 ipvideo_decode_block_opcode_0xC_16
, ipvideo_decode_block_opcode_0xD_16
,
901 ipvideo_decode_block_opcode_0xE_16
, ipvideo_decode_block_opcode_0x1
,
904 static void ipvideo_decode_opcodes(IpvideoContext
*s
, AVFrame
*frame
)
907 unsigned char opcode
;
911 bytestream2_skip(&s
->stream_ptr
, 14); /* data starts 14 bytes in */
913 /* this is PAL8, so make the palette available */
914 memcpy(frame
->data
[1], s
->pal
, AVPALETTE_SIZE
);
916 s
->stride
= frame
->linesize
[0];
918 s
->stride
= frame
->linesize
[0] >> 1;
919 s
->mv_ptr
= s
->stream_ptr
;
920 bytestream2_skip(&s
->mv_ptr
, bytestream2_get_le16(&s
->stream_ptr
));
922 s
->line_inc
= s
->stride
- 8;
923 s
->upper_motion_limit_offset
= (s
->avctx
->height
- 8) * frame
->linesize
[0]
924 + (s
->avctx
->width
- 8) * (1 + s
->is_16bpp
);
926 init_get_bits(&gb
, s
->decoding_map
, s
->decoding_map_size
* 8);
927 for (y
= 0; y
< s
->avctx
->height
; y
+= 8) {
928 for (x
= 0; x
< s
->avctx
->width
; x
+= 8) {
929 opcode
= get_bits(&gb
, 4);
932 " block @ (%3d, %3d): encoding 0x%X, data ptr offset %d\n",
933 x
, y
, opcode
, bytestream2_tell(&s
->stream_ptr
));
936 s
->pixel_ptr
= frame
->data
[0] + x
937 + y
*frame
->linesize
[0];
938 ret
= ipvideo_decode_block
[opcode
](s
, frame
);
940 s
->pixel_ptr
= frame
->data
[0] + x
*2
941 + y
*frame
->linesize
[0];
942 ret
= ipvideo_decode_block16
[opcode
](s
, frame
);
945 av_log(s
->avctx
, AV_LOG_ERROR
, "decode problem on frame %d, @ block (%d, %d)\n",
946 s
->avctx
->frame_number
, x
, y
);
951 if (bytestream2_get_bytes_left(&s
->stream_ptr
) > 1) {
952 av_log(s
->avctx
, AV_LOG_ERROR
,
953 "decode finished with %d bytes left over\n",
954 bytestream2_get_bytes_left(&s
->stream_ptr
));
958 static av_cold
int ipvideo_decode_init(AVCodecContext
*avctx
)
960 IpvideoContext
*s
= avctx
->priv_data
;
964 s
->is_16bpp
= avctx
->bits_per_coded_sample
== 16;
965 avctx
->pix_fmt
= s
->is_16bpp
? AV_PIX_FMT_RGB555
: AV_PIX_FMT_PAL8
;
967 ff_hpeldsp_init(&s
->hdsp
, avctx
->flags
);
969 s
->last_frame
= av_frame_alloc();
970 s
->second_last_frame
= av_frame_alloc();
971 if (!s
->last_frame
|| !s
->second_last_frame
) {
972 av_frame_free(&s
->last_frame
);
973 av_frame_free(&s
->second_last_frame
);
974 return AVERROR(ENOMEM
);
980 static int ipvideo_decode_frame(AVCodecContext
*avctx
,
981 void *data
, int *got_frame
,
984 const uint8_t *buf
= avpkt
->data
;
985 int buf_size
= avpkt
->size
;
986 IpvideoContext
*s
= avctx
->priv_data
;
987 AVFrame
*frame
= data
;
990 /* decoding map contains 4 bits of information per 8x8 block */
991 s
->decoding_map_size
= avctx
->width
* avctx
->height
/ (8 * 8 * 2);
993 /* compressed buffer needs to be large enough to at least hold an entire
995 if (buf_size
< s
->decoding_map_size
)
998 if (av_packet_get_side_data(avpkt
, AV_PKT_DATA_PARAM_CHANGE
, NULL
)) {
999 av_frame_unref(s
->last_frame
);
1000 av_frame_unref(s
->second_last_frame
);
1003 s
->decoding_map
= buf
;
1004 bytestream2_init(&s
->stream_ptr
, buf
+ s
->decoding_map_size
,
1005 buf_size
- s
->decoding_map_size
);
1007 if ((ret
= ff_get_buffer(avctx
, frame
, AV_GET_BUFFER_FLAG_REF
)) < 0)
1011 const uint8_t *pal
= av_packet_get_side_data(avpkt
, AV_PKT_DATA_PALETTE
, NULL
);
1013 frame
->palette_has_changed
= 1;
1014 memcpy(s
->pal
, pal
, AVPALETTE_SIZE
);
1018 ipvideo_decode_opcodes(s
, frame
);
1022 /* shuffle frames */
1023 av_frame_unref(s
->second_last_frame
);
1024 FFSWAP(AVFrame
*, s
->second_last_frame
, s
->last_frame
);
1025 if ((ret
= av_frame_ref(s
->last_frame
, frame
)) < 0)
1028 /* report that the buffer was completely consumed */
1032 static av_cold
int ipvideo_decode_end(AVCodecContext
*avctx
)
1034 IpvideoContext
*s
= avctx
->priv_data
;
1036 av_frame_free(&s
->last_frame
);
1037 av_frame_free(&s
->second_last_frame
);
1042 AVCodec ff_interplay_video_decoder
= {
1043 .name
= "interplayvideo",
1044 .long_name
= NULL_IF_CONFIG_SMALL("Interplay MVE video"),
1045 .type
= AVMEDIA_TYPE_VIDEO
,
1046 .id
= AV_CODEC_ID_INTERPLAY_VIDEO
,
1047 .priv_data_size
= sizeof(IpvideoContext
),
1048 .init
= ipvideo_decode_init
,
1049 .close
= ipvideo_decode_end
,
1050 .decode
= ipvideo_decode_frame
,
1051 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_PARAM_CHANGE
,