lavc: set defaults in internal codec frames
[ffmpeg.git] / libavcodec / interplayvideo.c
1 /*
2  * Interplay MVE Video Decoder
3  * Copyright (C) 2003 the ffmpeg project
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 /**
23  * @file
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.
29  *
30  * This decoder presently only supports a PAL8 output colorspace.
31  *
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.
35  */
36
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40
41 #include "avcodec.h"
42 #include "bytestream.h"
43 #include "dsputil.h"
44 #define ALT_BITSTREAM_READER_LE
45 #include "get_bits.h"
46
47 #define PALETTE_COUNT 256
48
49 /* debugging support */
50 #define DEBUG_INTERPLAY 0
51 #if DEBUG_INTERPLAY
52 #define debug_interplay(x,...) av_log(NULL, AV_LOG_DEBUG, x, __VA_ARGS__)
53 #else
54 static inline void debug_interplay(const char *format, ...) { }
55 #endif
56
57 typedef struct IpvideoContext {
58
59     AVCodecContext *avctx;
60     DSPContext dsp;
61     AVFrame second_last_frame;
62     AVFrame last_frame;
63     AVFrame current_frame;
64     const unsigned char *decoding_map;
65     int decoding_map_size;
66
67     const unsigned char *buf;
68     int size;
69
70     int is_16bpp;
71     const unsigned char *stream_ptr;
72     const unsigned char *stream_end;
73     const uint8_t *mv_ptr;
74     const uint8_t *mv_end;
75     unsigned char *pixel_ptr;
76     int line_inc;
77     int stride;
78     int upper_motion_limit_offset;
79
80     uint32_t pal[256];
81 } IpvideoContext;
82
83 #define CHECK_STREAM_PTR(stream_ptr, stream_end, n) \
84     if (stream_end - stream_ptr < n) { \
85         av_log(s->avctx, AV_LOG_ERROR, "Interplay video warning: stream_ptr out of bounds (%p >= %p)\n", \
86                stream_ptr + n, stream_end); \
87         return -1; \
88     }
89
90 static int copy_from(IpvideoContext *s, AVFrame *src, int delta_x, int delta_y)
91 {
92     int current_offset = s->pixel_ptr - s->current_frame.data[0];
93     int motion_offset = current_offset + delta_y * s->current_frame.linesize[0]
94                        + delta_x * (1 + s->is_16bpp);
95     if (motion_offset < 0) {
96         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset);
97         return -1;
98     } else if (motion_offset > s->upper_motion_limit_offset) {
99         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n",
100             motion_offset, s->upper_motion_limit_offset);
101         return -1;
102     }
103     if (src->data[0] == NULL) {
104         av_log(s->avctx, AV_LOG_ERROR, "Invalid decode type, corrupted header?\n");
105         return AVERROR(EINVAL);
106     }
107     s->dsp.put_pixels_tab[!s->is_16bpp][0](s->pixel_ptr, src->data[0] + motion_offset,
108                                            s->current_frame.linesize[0], 8);
109     return 0;
110 }
111
112 static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s)
113 {
114     return copy_from(s, &s->last_frame, 0, 0);
115 }
116
117 static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s)
118 {
119     return copy_from(s, &s->second_last_frame, 0, 0);
120 }
121
122 static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s)
123 {
124     unsigned char B;
125     int x, y;
126
127     /* copy block from 2 frames ago using a motion vector; need 1 more byte */
128     if (!s->is_16bpp) {
129         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
130         B = *s->stream_ptr++;
131     } else {
132         CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);
133         B = *s->mv_ptr++;
134     }
135
136     if (B < 56) {
137         x = 8 + (B % 7);
138         y = B / 7;
139     } else {
140         x = -14 + ((B - 56) % 29);
141         y =   8 + ((B - 56) / 29);
142     }
143
144     debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
145     return copy_from(s, &s->second_last_frame, x, y);
146 }
147
148 static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s)
149 {
150     unsigned char B;
151     int x, y;
152
153     /* copy 8x8 block from current frame from an up/left block */
154
155     /* need 1 more byte for motion */
156     if (!s->is_16bpp) {
157         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
158         B = *s->stream_ptr++;
159     } else {
160         CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);
161         B = *s->mv_ptr++;
162     }
163
164     if (B < 56) {
165         x = -(8 + (B % 7));
166         y = -(B / 7);
167     } else {
168         x = -(-14 + ((B - 56) % 29));
169         y = -(  8 + ((B - 56) / 29));
170     }
171
172     debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
173     return copy_from(s, &s->current_frame, x, y);
174 }
175
176 static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s)
177 {
178     int x, y;
179     unsigned char B, BL, BH;
180
181     /* copy a block from the previous frame; need 1 more byte */
182     if (!s->is_16bpp) {
183         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
184         B = *s->stream_ptr++;
185     } else {
186         CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);
187         B = *s->mv_ptr++;
188     }
189
190     BL = B & 0x0F;
191     BH = (B >> 4) & 0x0F;
192     x = -8 + BL;
193     y = -8 + BH;
194
195     debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
196     return copy_from(s, &s->last_frame, x, y);
197 }
198
199 static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s)
200 {
201     signed char x, y;
202
203     /* copy a block from the previous frame using an expanded range;
204      * need 2 more bytes */
205     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
206
207     x = *s->stream_ptr++;
208     y = *s->stream_ptr++;
209
210     debug_interplay ("    motion bytes = %d, %d\n", x, y);
211     return copy_from(s, &s->last_frame, x, y);
212 }
213
214 static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s)
215 {
216     /* mystery opcode? skip multiple blocks? */
217     av_log(s->avctx, AV_LOG_ERROR, "  Interplay video: Help! Mystery opcode 0x6 seen\n");
218
219     /* report success */
220     return 0;
221 }
222
223 static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)
224 {
225     int x, y;
226     unsigned char P[2];
227     unsigned int flags;
228
229     /* 2-color encoding */
230     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
231
232     P[0] = *s->stream_ptr++;
233     P[1] = *s->stream_ptr++;
234
235     if (P[0] <= P[1]) {
236
237         /* need 8 more bytes from the stream */
238         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
239
240         for (y = 0; y < 8; y++) {
241             flags = *s->stream_ptr++ | 0x100;
242             for (; flags != 1; flags >>= 1)
243                 *s->pixel_ptr++ = P[flags & 1];
244             s->pixel_ptr += s->line_inc;
245         }
246
247     } else {
248
249         /* need 2 more bytes from the stream */
250         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
251
252         flags = bytestream_get_le16(&s->stream_ptr);
253         for (y = 0; y < 8; y += 2) {
254             for (x = 0; x < 8; x += 2, flags >>= 1) {
255                 s->pixel_ptr[x                ] =
256                 s->pixel_ptr[x + 1            ] =
257                 s->pixel_ptr[x +     s->stride] =
258                 s->pixel_ptr[x + 1 + s->stride] = P[flags & 1];
259             }
260             s->pixel_ptr += s->stride * 2;
261         }
262     }
263
264     /* report success */
265     return 0;
266 }
267
268 static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
269 {
270     int x, y;
271     unsigned char P[2];
272     unsigned int flags = 0;
273
274     /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
275      * either top and bottom or left and right halves */
276     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
277
278     P[0] = *s->stream_ptr++;
279     P[1] = *s->stream_ptr++;
280
281     if (P[0] <= P[1]) {
282
283         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 14);
284         s->stream_ptr -= 2;
285
286         for (y = 0; y < 16; y++) {
287             // new values for each 4x4 block
288             if (!(y & 3)) {
289                 P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
290                 flags = bytestream_get_le16(&s->stream_ptr);
291             }
292
293             for (x = 0; x < 4; x++, flags >>= 1)
294                 *s->pixel_ptr++ = P[flags & 1];
295             s->pixel_ptr += s->stride - 4;
296             // switch to right half
297             if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
298         }
299
300     } else {
301
302         /* need 10 more bytes */
303         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 10);
304
305         if (s->stream_ptr[4] <= s->stream_ptr[5]) {
306
307             flags = bytestream_get_le32(&s->stream_ptr);
308
309             /* vertical split; left & right halves are 2-color encoded */
310
311             for (y = 0; y < 16; y++) {
312                 for (x = 0; x < 4; x++, flags >>= 1)
313                     *s->pixel_ptr++ = P[flags & 1];
314                 s->pixel_ptr += s->stride - 4;
315                 // switch to right half
316                 if (y == 7) {
317                     s->pixel_ptr -= 8 * s->stride - 4;
318                     P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
319                     flags = bytestream_get_le32(&s->stream_ptr);
320                 }
321             }
322
323         } else {
324
325             /* horizontal split; top & bottom halves are 2-color encoded */
326
327             for (y = 0; y < 8; y++) {
328                 if (y == 4) {
329                     P[0] = *s->stream_ptr++;
330                     P[1] = *s->stream_ptr++;
331                 }
332                 flags = *s->stream_ptr++ | 0x100;
333
334                 for (; flags != 1; flags >>= 1)
335                     *s->pixel_ptr++ = P[flags & 1];
336                 s->pixel_ptr += s->line_inc;
337             }
338         }
339     }
340
341     /* report success */
342     return 0;
343 }
344
345 static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
346 {
347     int x, y;
348     unsigned char P[4];
349
350     /* 4-color encoding */
351     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
352
353     memcpy(P, s->stream_ptr, 4);
354     s->stream_ptr += 4;
355
356     if (P[0] <= P[1]) {
357         if (P[2] <= P[3]) {
358
359             /* 1 of 4 colors for each pixel, need 16 more bytes */
360             CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);
361
362             for (y = 0; y < 8; y++) {
363                 /* get the next set of 8 2-bit flags */
364                 int flags = bytestream_get_le16(&s->stream_ptr);
365                 for (x = 0; x < 8; x++, flags >>= 2)
366                     *s->pixel_ptr++ = P[flags & 0x03];
367                 s->pixel_ptr += s->line_inc;
368             }
369
370         } else {
371             uint32_t flags;
372
373             /* 1 of 4 colors for each 2x2 block, need 4 more bytes */
374             CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
375
376             flags = bytestream_get_le32(&s->stream_ptr);
377
378             for (y = 0; y < 8; y += 2) {
379                 for (x = 0; x < 8; x += 2, flags >>= 2) {
380                     s->pixel_ptr[x                ] =
381                     s->pixel_ptr[x + 1            ] =
382                     s->pixel_ptr[x +     s->stride] =
383                     s->pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];
384                 }
385                 s->pixel_ptr += s->stride * 2;
386             }
387
388         }
389     } else {
390         uint64_t flags;
391
392         /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */
393         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
394
395         flags = bytestream_get_le64(&s->stream_ptr);
396         if (P[2] <= P[3]) {
397             for (y = 0; y < 8; y++) {
398                 for (x = 0; x < 8; x += 2, flags >>= 2) {
399                     s->pixel_ptr[x    ] =
400                     s->pixel_ptr[x + 1] = P[flags & 0x03];
401                 }
402                 s->pixel_ptr += s->stride;
403             }
404         } else {
405             for (y = 0; y < 8; y += 2) {
406                 for (x = 0; x < 8; x++, flags >>= 2) {
407                     s->pixel_ptr[x            ] =
408                     s->pixel_ptr[x + s->stride] = P[flags & 0x03];
409                 }
410                 s->pixel_ptr += s->stride * 2;
411             }
412         }
413     }
414
415     /* report success */
416     return 0;
417 }
418
419 static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
420 {
421     int x, y;
422     unsigned char P[4];
423     int flags = 0;
424
425     /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
426      * either top and bottom or left and right halves */
427     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);
428
429     if (s->stream_ptr[0] <= s->stream_ptr[1]) {
430
431         /* 4-color encoding for each quadrant; need 32 bytes */
432         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 32);
433
434         for (y = 0; y < 16; y++) {
435             // new values for each 4x4 block
436             if (!(y & 3)) {
437                 memcpy(P, s->stream_ptr, 4);
438                 s->stream_ptr += 4;
439                 flags = bytestream_get_le32(&s->stream_ptr);
440             }
441
442             for (x = 0; x < 4; x++, flags >>= 2)
443                 *s->pixel_ptr++ = P[flags & 0x03];
444
445             s->pixel_ptr += s->stride - 4;
446             // switch to right half
447             if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
448         }
449
450     } else {
451         // vertical split?
452         int vert = s->stream_ptr[12] <= s->stream_ptr[13];
453         uint64_t flags = 0;
454
455         /* 4-color encoding for either left and right or top and bottom
456          * halves */
457
458         for (y = 0; y < 16; y++) {
459             // load values for each half
460             if (!(y & 7)) {
461                 memcpy(P, s->stream_ptr, 4);
462                 s->stream_ptr += 4;
463                 flags = bytestream_get_le64(&s->stream_ptr);
464             }
465
466             for (x = 0; x < 4; x++, flags >>= 2)
467                 *s->pixel_ptr++ = P[flags & 0x03];
468
469             if (vert) {
470                 s->pixel_ptr += s->stride - 4;
471                 // switch to right half
472                 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
473             } else if (y & 1) s->pixel_ptr += s->line_inc;
474         }
475     }
476
477     /* report success */
478     return 0;
479 }
480
481 static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s)
482 {
483     int y;
484
485     /* 64-color encoding (each pixel in block is a different color) */
486     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 64);
487
488     for (y = 0; y < 8; y++) {
489         memcpy(s->pixel_ptr, s->stream_ptr, 8);
490         s->stream_ptr += 8;
491         s->pixel_ptr  += s->stride;
492     }
493
494     /* report success */
495     return 0;
496 }
497
498 static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s)
499 {
500     int x, y;
501
502     /* 16-color block encoding: each 2x2 block is a different color */
503     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);
504
505     for (y = 0; y < 8; y += 2) {
506         for (x = 0; x < 8; x += 2) {
507             s->pixel_ptr[x                ] =
508             s->pixel_ptr[x + 1            ] =
509             s->pixel_ptr[x +     s->stride] =
510             s->pixel_ptr[x + 1 + s->stride] = *s->stream_ptr++;
511         }
512         s->pixel_ptr += s->stride * 2;
513     }
514
515     /* report success */
516     return 0;
517 }
518
519 static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s)
520 {
521     int y;
522     unsigned char P[2];
523
524     /* 4-color block encoding: each 4x4 block is a different color */
525     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
526
527     for (y = 0; y < 8; y++) {
528         if (!(y & 3)) {
529             P[0] = *s->stream_ptr++;
530             P[1] = *s->stream_ptr++;
531         }
532         memset(s->pixel_ptr,     P[0], 4);
533         memset(s->pixel_ptr + 4, P[1], 4);
534         s->pixel_ptr += s->stride;
535     }
536
537     /* report success */
538     return 0;
539 }
540
541 static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s)
542 {
543     int y;
544     unsigned char pix;
545
546     /* 1-color encoding: the whole block is 1 solid color */
547     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
548     pix = *s->stream_ptr++;
549
550     for (y = 0; y < 8; y++) {
551         memset(s->pixel_ptr, pix, 8);
552         s->pixel_ptr += s->stride;
553     }
554
555     /* report success */
556     return 0;
557 }
558
559 static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s)
560 {
561     int x, y;
562     unsigned char sample[2];
563
564     /* dithered encoding */
565     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
566     sample[0] = *s->stream_ptr++;
567     sample[1] = *s->stream_ptr++;
568
569     for (y = 0; y < 8; y++) {
570         for (x = 0; x < 8; x += 2) {
571             *s->pixel_ptr++ = sample[  y & 1 ];
572             *s->pixel_ptr++ = sample[!(y & 1)];
573         }
574         s->pixel_ptr += s->line_inc;
575     }
576
577     /* report success */
578     return 0;
579 }
580
581 static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext *s)
582 {
583     signed char x, y;
584
585     /* copy a block from the second last frame using an expanded range */
586     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
587
588     x = *s->stream_ptr++;
589     y = *s->stream_ptr++;
590
591     debug_interplay ("    motion bytes = %d, %d\n", x, y);
592     return copy_from(s, &s->second_last_frame, x, y);
593 }
594
595 static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s)
596 {
597     int x, y;
598     uint16_t P[2];
599     unsigned int flags;
600     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
601
602     /* 2-color encoding */
603     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
604
605     P[0] = bytestream_get_le16(&s->stream_ptr);
606     P[1] = bytestream_get_le16(&s->stream_ptr);
607
608     if (!(P[0] & 0x8000)) {
609
610         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
611
612         for (y = 0; y < 8; y++) {
613             flags = *s->stream_ptr++ | 0x100;
614             for (; flags != 1; flags >>= 1)
615                 *pixel_ptr++ = P[flags & 1];
616             pixel_ptr += s->line_inc;
617         }
618
619     } else {
620
621         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
622
623         flags = bytestream_get_le16(&s->stream_ptr);
624         for (y = 0; y < 8; y += 2) {
625             for (x = 0; x < 8; x += 2, flags >>= 1) {
626                 pixel_ptr[x                ] =
627                 pixel_ptr[x + 1            ] =
628                 pixel_ptr[x +     s->stride] =
629                 pixel_ptr[x + 1 + s->stride] = P[flags & 1];
630             }
631             pixel_ptr += s->stride * 2;
632         }
633     }
634
635     return 0;
636 }
637
638 static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)
639 {
640     int x, y;
641     uint16_t P[2];
642     unsigned int flags = 0;
643     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
644
645     /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
646      * either top and bottom or left and right halves */
647     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
648
649     P[0] = bytestream_get_le16(&s->stream_ptr);
650     P[1] = bytestream_get_le16(&s->stream_ptr);
651
652     if (!(P[0] & 0x8000)) {
653
654         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);
655         s->stream_ptr -= 4;
656
657         for (y = 0; y < 16; y++) {
658             // new values for each 4x4 block
659             if (!(y & 3)) {
660                 P[0] = bytestream_get_le16(&s->stream_ptr);
661                 P[1] = bytestream_get_le16(&s->stream_ptr);
662                 flags = bytestream_get_le16(&s->stream_ptr);
663             }
664
665             for (x = 0; x < 4; x++, flags >>= 1)
666                 *pixel_ptr++ = P[flags & 1];
667             pixel_ptr += s->stride - 4;
668             // switch to right half
669             if (y == 7) pixel_ptr -= 8 * s->stride - 4;
670         }
671
672     } else {
673
674         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 12);
675
676         if (!(AV_RL16(s->stream_ptr + 4) & 0x8000)) {
677
678             flags = bytestream_get_le32(&s->stream_ptr);
679
680             /* vertical split; left & right halves are 2-color encoded */
681
682             for (y = 0; y < 16; y++) {
683                 for (x = 0; x < 4; x++, flags >>= 1)
684                     *pixel_ptr++ = P[flags & 1];
685                 pixel_ptr += s->stride - 4;
686                 // switch to right half
687                 if (y == 7) {
688                     pixel_ptr -= 8 * s->stride - 4;
689                     P[0] = bytestream_get_le16(&s->stream_ptr);
690                     P[1] = bytestream_get_le16(&s->stream_ptr);
691                     flags = bytestream_get_le32(&s->stream_ptr);
692                 }
693             }
694
695         } else {
696
697             /* horizontal split; top & bottom halves are 2-color encoded */
698
699             for (y = 0; y < 8; y++) {
700                 if (y == 4) {
701                     P[0] = bytestream_get_le16(&s->stream_ptr);
702                     P[1] = bytestream_get_le16(&s->stream_ptr);
703                 }
704                 flags = *s->stream_ptr++ | 0x100;
705
706                 for (; flags != 1; flags >>= 1)
707                     *pixel_ptr++ = P[flags & 1];
708                 pixel_ptr += s->line_inc;
709             }
710         }
711     }
712
713     /* report success */
714     return 0;
715 }
716
717 static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)
718 {
719     int x, y;
720     uint16_t P[4];
721     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
722
723     /* 4-color encoding */
724     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
725
726     for (x = 0; x < 4; x++)
727         P[x] = bytestream_get_le16(&s->stream_ptr);
728
729     if (!(P[0] & 0x8000)) {
730         if (!(P[2] & 0x8000)) {
731
732             /* 1 of 4 colors for each pixel */
733             CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);
734
735             for (y = 0; y < 8; y++) {
736                 /* get the next set of 8 2-bit flags */
737                 int flags = bytestream_get_le16(&s->stream_ptr);
738                 for (x = 0; x < 8; x++, flags >>= 2)
739                     *pixel_ptr++ = P[flags & 0x03];
740                 pixel_ptr += s->line_inc;
741             }
742
743         } else {
744             uint32_t flags;
745
746             /* 1 of 4 colors for each 2x2 block */
747             CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
748
749             flags = bytestream_get_le32(&s->stream_ptr);
750
751             for (y = 0; y < 8; y += 2) {
752                 for (x = 0; x < 8; x += 2, flags >>= 2) {
753                     pixel_ptr[x                ] =
754                     pixel_ptr[x + 1            ] =
755                     pixel_ptr[x +     s->stride] =
756                     pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];
757                 }
758                 pixel_ptr += s->stride * 2;
759             }
760
761         }
762     } else {
763         uint64_t flags;
764
765         /* 1 of 4 colors for each 2x1 or 1x2 block */
766         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
767
768         flags = bytestream_get_le64(&s->stream_ptr);
769         if (!(P[2] & 0x8000)) {
770             for (y = 0; y < 8; y++) {
771                 for (x = 0; x < 8; x += 2, flags >>= 2) {
772                     pixel_ptr[x    ] =
773                     pixel_ptr[x + 1] = P[flags & 0x03];
774                 }
775                 pixel_ptr += s->stride;
776             }
777         } else {
778             for (y = 0; y < 8; y += 2) {
779                 for (x = 0; x < 8; x++, flags >>= 2) {
780                     pixel_ptr[x            ] =
781                     pixel_ptr[x + s->stride] = P[flags & 0x03];
782                 }
783                 pixel_ptr += s->stride * 2;
784             }
785         }
786     }
787
788     /* report success */
789     return 0;
790 }
791
792 static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s)
793 {
794     int x, y;
795     uint16_t P[4];
796     int flags = 0;
797     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
798
799     /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
800      * either top and bottom or left and right halves */
801     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);
802
803     if (!(AV_RL16(s->stream_ptr) & 0x8000)) {
804
805         /* 4-color encoding for each quadrant */
806         CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 48);
807
808         for (y = 0; y < 16; y++) {
809             // new values for each 4x4 block
810             if (!(y & 3)) {
811                 for (x = 0; x < 4; x++)
812                     P[x] = bytestream_get_le16(&s->stream_ptr);
813                 flags = bytestream_get_le32(&s->stream_ptr);
814             }
815
816             for (x = 0; x < 4; x++, flags >>= 2)
817                 *pixel_ptr++ = P[flags & 0x03];
818
819             pixel_ptr += s->stride - 4;
820             // switch to right half
821             if (y == 7) pixel_ptr -= 8 * s->stride - 4;
822         }
823
824     } else {
825         // vertical split?
826         int vert = !(AV_RL16(s->stream_ptr + 16) & 0x8000);
827         uint64_t flags = 0;
828
829         /* 4-color encoding for either left and right or top and bottom
830          * halves */
831
832         for (y = 0; y < 16; y++) {
833             // load values for each half
834             if (!(y & 7)) {
835                 for (x = 0; x < 4; x++)
836                     P[x] = bytestream_get_le16(&s->stream_ptr);
837                 flags = bytestream_get_le64(&s->stream_ptr);
838             }
839
840             for (x = 0; x < 4; x++, flags >>= 2)
841                 *pixel_ptr++ = P[flags & 0x03];
842
843             if (vert) {
844                 pixel_ptr += s->stride - 4;
845                 // switch to right half
846                 if (y == 7) pixel_ptr -= 8 * s->stride - 4;
847             } else if (y & 1) pixel_ptr += s->line_inc;
848         }
849     }
850
851     /* report success */
852     return 0;
853 }
854
855 static int ipvideo_decode_block_opcode_0xB_16(IpvideoContext *s)
856 {
857     int x, y;
858     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
859
860     /* 64-color encoding (each pixel in block is a different color) */
861     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 128);
862
863     for (y = 0; y < 8; y++) {
864         for (x = 0; x < 8; x++)
865             pixel_ptr[x] = bytestream_get_le16(&s->stream_ptr);
866         pixel_ptr  += s->stride;
867     }
868
869     /* report success */
870     return 0;
871 }
872
873 static int ipvideo_decode_block_opcode_0xC_16(IpvideoContext *s)
874 {
875     int x, y;
876     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
877
878     /* 16-color block encoding: each 2x2 block is a different color */
879     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 32);
880
881     for (y = 0; y < 8; y += 2) {
882         for (x = 0; x < 8; x += 2) {
883             pixel_ptr[x                ] =
884             pixel_ptr[x + 1            ] =
885             pixel_ptr[x +     s->stride] =
886             pixel_ptr[x + 1 + s->stride] = bytestream_get_le16(&s->stream_ptr);
887         }
888         pixel_ptr += s->stride * 2;
889     }
890
891     /* report success */
892     return 0;
893 }
894
895 static int ipvideo_decode_block_opcode_0xD_16(IpvideoContext *s)
896 {
897     int x, y;
898     uint16_t P[2];
899     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
900
901     /* 4-color block encoding: each 4x4 block is a different color */
902     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
903
904     for (y = 0; y < 8; y++) {
905         if (!(y & 3)) {
906             P[0] = bytestream_get_le16(&s->stream_ptr);
907             P[1] = bytestream_get_le16(&s->stream_ptr);
908         }
909         for (x = 0; x < 8; x++)
910             pixel_ptr[x] = P[x >> 2];
911         pixel_ptr += s->stride;
912     }
913
914     /* report success */
915     return 0;
916 }
917
918 static int ipvideo_decode_block_opcode_0xE_16(IpvideoContext *s)
919 {
920     int x, y;
921     uint16_t pix;
922     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
923
924     /* 1-color encoding: the whole block is 1 solid color */
925     CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
926     pix = bytestream_get_le16(&s->stream_ptr);
927
928     for (y = 0; y < 8; y++) {
929         for (x = 0; x < 8; x++)
930             pixel_ptr[x] = pix;
931         pixel_ptr += s->stride;
932     }
933
934     /* report success */
935     return 0;
936 }
937
938 static int (* const ipvideo_decode_block[])(IpvideoContext *s) = {
939     ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1,
940     ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3,
941     ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5,
942     ipvideo_decode_block_opcode_0x6, ipvideo_decode_block_opcode_0x7,
943     ipvideo_decode_block_opcode_0x8, ipvideo_decode_block_opcode_0x9,
944     ipvideo_decode_block_opcode_0xA, ipvideo_decode_block_opcode_0xB,
945     ipvideo_decode_block_opcode_0xC, ipvideo_decode_block_opcode_0xD,
946     ipvideo_decode_block_opcode_0xE, ipvideo_decode_block_opcode_0xF,
947 };
948
949 static int (* const ipvideo_decode_block16[])(IpvideoContext *s) = {
950     ipvideo_decode_block_opcode_0x0,    ipvideo_decode_block_opcode_0x1,
951     ipvideo_decode_block_opcode_0x2,    ipvideo_decode_block_opcode_0x3,
952     ipvideo_decode_block_opcode_0x4,    ipvideo_decode_block_opcode_0x5,
953     ipvideo_decode_block_opcode_0x6_16, ipvideo_decode_block_opcode_0x7_16,
954     ipvideo_decode_block_opcode_0x8_16, ipvideo_decode_block_opcode_0x9_16,
955     ipvideo_decode_block_opcode_0xA_16, ipvideo_decode_block_opcode_0xB_16,
956     ipvideo_decode_block_opcode_0xC_16, ipvideo_decode_block_opcode_0xD_16,
957     ipvideo_decode_block_opcode_0xE_16, ipvideo_decode_block_opcode_0x1,
958 };
959
960 static void ipvideo_decode_opcodes(IpvideoContext *s)
961 {
962     int x, y;
963     unsigned char opcode;
964     int ret;
965     static int frame = 0;
966     GetBitContext gb;
967
968     debug_interplay("------------------ frame %d\n", frame);
969     frame++;
970
971     if (!s->is_16bpp) {
972         /* this is PAL8, so make the palette available */
973         memcpy(s->current_frame.data[1], s->pal, AVPALETTE_SIZE);
974
975         s->stride = s->current_frame.linesize[0];
976         s->stream_ptr = s->buf + 14;  /* data starts 14 bytes in */
977         s->stream_end = s->buf + s->size;
978     } else {
979         s->stride = s->current_frame.linesize[0] >> 1;
980         s->stream_ptr = s->buf + 16;
981         s->stream_end =
982         s->mv_ptr = s->buf + 14 + AV_RL16(s->buf+14);
983         s->mv_end = s->buf + s->size;
984     }
985     s->line_inc = s->stride - 8;
986     s->upper_motion_limit_offset = (s->avctx->height - 8) * s->current_frame.linesize[0]
987                                   + (s->avctx->width - 8) * (1 + s->is_16bpp);
988
989     init_get_bits(&gb, s->decoding_map, s->decoding_map_size * 8);
990     for (y = 0; y < s->avctx->height; y += 8) {
991         for (x = 0; x < s->avctx->width; x += 8) {
992             opcode = get_bits(&gb, 4);
993
994             debug_interplay("  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",
995                             x, y, opcode, s->stream_ptr);
996
997             if (!s->is_16bpp) {
998                 s->pixel_ptr = s->current_frame.data[0] + x
999                               + y*s->current_frame.linesize[0];
1000                 ret = ipvideo_decode_block[opcode](s);
1001             } else {
1002                 s->pixel_ptr = s->current_frame.data[0] + x*2
1003                               + y*s->current_frame.linesize[0];
1004                 ret = ipvideo_decode_block16[opcode](s);
1005             }
1006             if (ret != 0) {
1007                 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode problem on frame %d, @ block (%d, %d)\n",
1008                        frame, x, y);
1009                 return;
1010             }
1011         }
1012     }
1013     if (s->stream_end - s->stream_ptr > 1) {
1014         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode finished with %td bytes left over\n",
1015                s->stream_end - s->stream_ptr);
1016     }
1017 }
1018
1019 static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
1020 {
1021     IpvideoContext *s = avctx->priv_data;
1022
1023     s->avctx = avctx;
1024
1025     s->is_16bpp = avctx->bits_per_coded_sample == 16;
1026     avctx->pix_fmt = s->is_16bpp ? PIX_FMT_RGB555 : PIX_FMT_PAL8;
1027
1028     dsputil_init(&s->dsp, avctx);
1029
1030     /* decoding map contains 4 bits of information per 8x8 block */
1031     s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2);
1032
1033     avcodec_get_frame_defaults(&s->second_last_frame);
1034     avcodec_get_frame_defaults(&s->last_frame);
1035     avcodec_get_frame_defaults(&s->current_frame);
1036     s->current_frame.data[0] = s->last_frame.data[0] =
1037     s->second_last_frame.data[0] = NULL;
1038
1039     return 0;
1040 }
1041
1042 static int ipvideo_decode_frame(AVCodecContext *avctx,
1043                                 void *data, int *data_size,
1044                                 AVPacket *avpkt)
1045 {
1046     const uint8_t *buf = avpkt->data;
1047     int buf_size = avpkt->size;
1048     IpvideoContext *s = avctx->priv_data;
1049
1050     /* compressed buffer needs to be large enough to at least hold an entire
1051      * decoding map */
1052     if (buf_size < s->decoding_map_size)
1053         return buf_size;
1054
1055     s->decoding_map = buf;
1056     s->buf = buf + s->decoding_map_size;
1057     s->size = buf_size - s->decoding_map_size;
1058
1059     s->current_frame.reference = 3;
1060     if (avctx->get_buffer(avctx, &s->current_frame)) {
1061         av_log(avctx, AV_LOG_ERROR, "  Interplay Video: get_buffer() failed\n");
1062         return -1;
1063     }
1064
1065     if (!s->is_16bpp) {
1066         const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
1067         if (pal) {
1068             s->current_frame.palette_has_changed = 1;
1069             memcpy(s->pal, pal, AVPALETTE_SIZE);
1070         }
1071     }
1072
1073     ipvideo_decode_opcodes(s);
1074
1075     *data_size = sizeof(AVFrame);
1076     *(AVFrame*)data = s->current_frame;
1077
1078     /* shuffle frames */
1079     if (s->second_last_frame.data[0])
1080         avctx->release_buffer(avctx, &s->second_last_frame);
1081     s->second_last_frame = s->last_frame;
1082     s->last_frame = s->current_frame;
1083     s->current_frame.data[0] = NULL;  /* catch any access attempts */
1084
1085     /* report that the buffer was completely consumed */
1086     return buf_size;
1087 }
1088
1089 static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
1090 {
1091     IpvideoContext *s = avctx->priv_data;
1092
1093     /* release the last frame */
1094     if (s->last_frame.data[0])
1095         avctx->release_buffer(avctx, &s->last_frame);
1096     if (s->second_last_frame.data[0])
1097         avctx->release_buffer(avctx, &s->second_last_frame);
1098
1099     return 0;
1100 }
1101
1102 AVCodec ff_interplay_video_decoder = {
1103     "interplayvideo",
1104     AVMEDIA_TYPE_VIDEO,
1105     CODEC_ID_INTERPLAY_VIDEO,
1106     sizeof(IpvideoContext),
1107     ipvideo_decode_init,
1108     NULL,
1109     ipvideo_decode_end,
1110     ipvideo_decode_frame,
1111     CODEC_CAP_DR1,
1112     .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
1113 };