Remove unused code_counts array from interplavideo.c.
[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 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.
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 #include <unistd.h>
41
42 #include "avcodec.h"
43 #include "bytestream.h"
44 #include "dsputil.h"
45
46 #define PALETTE_COUNT 256
47
48 /* debugging support */
49 #define DEBUG_INTERPLAY 0
50 #if DEBUG_INTERPLAY
51 #define debug_interplay(x,...) av_log(NULL, AV_LOG_DEBUG, x, __VA_ARGS__)
52 #else
53 static inline void debug_interplay(const char *format, ...) { }
54 #endif
55
56 typedef struct IpvideoContext {
57
58     AVCodecContext *avctx;
59     DSPContext dsp;
60     AVFrame second_last_frame;
61     AVFrame last_frame;
62     AVFrame current_frame;
63     const unsigned char *decoding_map;
64     int decoding_map_size;
65
66     const unsigned char *buf;
67     int size;
68
69     const unsigned char *stream_ptr;
70     const unsigned char *stream_end;
71     unsigned char *pixel_ptr;
72     int line_inc;
73     int stride;
74     int upper_motion_limit_offset;
75
76 } IpvideoContext;
77
78 #define CHECK_STREAM_PTR(n) \
79   if (s->stream_end - s->stream_ptr < n) { \
80     av_log(s->avctx, AV_LOG_ERROR, "Interplay video warning: stream_ptr out of bounds (%p >= %p)\n", \
81       s->stream_ptr + n, s->stream_end); \
82     return -1; \
83   }
84
85 static int copy_from(IpvideoContext *s, AVFrame *src, int delta_x, int delta_y)
86 {
87     int current_offset = s->pixel_ptr - s->current_frame.data[0];
88     int motion_offset = current_offset + delta_y * s->stride + delta_x;
89     if (motion_offset < 0) {
90         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset);
91         return -1;
92     } else if (motion_offset > s->upper_motion_limit_offset) {
93         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n",
94             motion_offset, s->upper_motion_limit_offset);
95         return -1;
96     }
97     s->dsp.put_pixels_tab[1][0](s->pixel_ptr, src->data[0] + motion_offset, s->stride, 8);
98     return 0;
99 }
100
101 static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s)
102 {
103     return copy_from(s, &s->last_frame, 0, 0);
104 }
105
106 static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s)
107 {
108     return copy_from(s, &s->second_last_frame, 0, 0);
109 }
110
111 static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s)
112 {
113     unsigned char B;
114     int x, y;
115
116     /* copy block from 2 frames ago using a motion vector; need 1 more byte */
117     CHECK_STREAM_PTR(1);
118     B = *s->stream_ptr++;
119
120     if (B < 56) {
121         x = 8 + (B % 7);
122         y = B / 7;
123     } else {
124         x = -14 + ((B - 56) % 29);
125         y =   8 + ((B - 56) / 29);
126     }
127
128     debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
129     return copy_from(s, &s->second_last_frame, x, y);
130 }
131
132 static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s)
133 {
134     unsigned char B;
135     int x, y;
136
137     /* copy 8x8 block from current frame from an up/left block */
138
139     /* need 1 more byte for motion */
140     CHECK_STREAM_PTR(1);
141     B = *s->stream_ptr++;
142
143     if (B < 56) {
144         x = -(8 + (B % 7));
145         y = -(B / 7);
146     } else {
147         x = -(-14 + ((B - 56) % 29));
148         y = -(  8 + ((B - 56) / 29));
149     }
150
151     debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
152     return copy_from(s, &s->current_frame, x, y);
153 }
154
155 static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s)
156 {
157     int x, y;
158     unsigned char B, BL, BH;
159
160     /* copy a block from the previous frame; need 1 more byte */
161     CHECK_STREAM_PTR(1);
162
163     B = *s->stream_ptr++;
164     BL = B & 0x0F;
165     BH = (B >> 4) & 0x0F;
166     x = -8 + BL;
167     y = -8 + BH;
168
169     debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
170     return copy_from(s, &s->last_frame, x, y);
171 }
172
173 static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s)
174 {
175     signed char x, y;
176
177     /* copy a block from the previous frame using an expanded range;
178      * need 2 more bytes */
179     CHECK_STREAM_PTR(2);
180
181     x = *s->stream_ptr++;
182     y = *s->stream_ptr++;
183
184     debug_interplay ("    motion bytes = %d, %d\n", x, y);
185     return copy_from(s, &s->last_frame, x, y);
186 }
187
188 static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s)
189 {
190     /* mystery opcode? skip multiple blocks? */
191     av_log(s->avctx, AV_LOG_ERROR, "  Interplay video: Help! Mystery opcode 0x6 seen\n");
192
193     /* report success */
194     return 0;
195 }
196
197 static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)
198 {
199     int x, y;
200     unsigned char P[2];
201     unsigned int flags;
202
203     /* 2-color encoding */
204     CHECK_STREAM_PTR(2);
205
206     P[0] = *s->stream_ptr++;
207     P[1] = *s->stream_ptr++;
208
209     if (P[0] <= P[1]) {
210
211         /* need 8 more bytes from the stream */
212         CHECK_STREAM_PTR(8);
213
214         for (y = 0; y < 8; y++) {
215             flags = *s->stream_ptr++ | 0x100;
216             for (; flags != 1; flags >>= 1)
217                 *s->pixel_ptr++ = P[flags & 1];
218             s->pixel_ptr += s->line_inc;
219         }
220
221     } else {
222
223         /* need 2 more bytes from the stream */
224         CHECK_STREAM_PTR(2);
225
226         flags = bytestream_get_le16(&s->stream_ptr);
227         for (y = 0; y < 8; y += 2) {
228             for (x = 0; x < 8; x += 2, flags >>= 1) {
229                 s->pixel_ptr[x                ] =
230                 s->pixel_ptr[x + 1            ] =
231                 s->pixel_ptr[x +     s->stride] =
232                 s->pixel_ptr[x + 1 + s->stride] = P[flags & 1];
233             }
234             s->pixel_ptr += s->stride * 2;
235         }
236     }
237
238     /* report success */
239     return 0;
240 }
241
242 static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
243 {
244     int x, y;
245     unsigned char P[2];
246     unsigned int flags = 0;
247
248     /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
249      * either top and bottom or left and right halves */
250     CHECK_STREAM_PTR(2);
251
252     P[0] = *s->stream_ptr++;
253     P[1] = *s->stream_ptr++;
254
255     if (P[0] <= P[1]) {
256
257         CHECK_STREAM_PTR(14);
258         s->stream_ptr -= 2;
259
260         for (y = 0; y < 16; y++) {
261             // new values for each 4x4 block
262             if (!(y & 3)) {
263                 P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
264                 flags = bytestream_get_le16(&s->stream_ptr);
265             }
266
267             for (x = 0; x < 4; x++, flags >>= 1)
268                 *s->pixel_ptr++ = P[flags & 1];
269             s->pixel_ptr += s->stride - 4;
270             // switch to right half
271             if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
272         }
273
274     } else {
275
276         /* need 10 more bytes */
277         CHECK_STREAM_PTR(10);
278
279         if (s->stream_ptr[4] <= s->stream_ptr[5]) {
280
281             flags = bytestream_get_le32(&s->stream_ptr);
282
283             /* vertical split; left & right halves are 2-color encoded */
284
285             for (y = 0; y < 16; y++) {
286                 for (x = 0; x < 4; x++, flags >>= 1)
287                     *s->pixel_ptr++ = P[flags & 1];
288                 s->pixel_ptr += s->stride - 4;
289                 // switch to right half
290                 if (y == 7) {
291                     s->pixel_ptr -= 8 * s->stride - 4;
292                     P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
293                     flags = bytestream_get_le32(&s->stream_ptr);
294                 }
295             }
296
297         } else {
298
299             /* horizontal split; top & bottom halves are 2-color encoded */
300
301             for (y = 0; y < 8; y++) {
302                 if (y == 4) {
303                     P[0] = *s->stream_ptr++;
304                     P[1] = *s->stream_ptr++;
305                 }
306                 flags = *s->stream_ptr++ | 0x100;
307
308                 for (; flags != 1; flags >>= 1)
309                     *s->pixel_ptr++ = P[flags & 1];
310                 s->pixel_ptr += s->line_inc;
311             }
312         }
313     }
314
315     /* report success */
316     return 0;
317 }
318
319 static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
320 {
321     int x, y;
322     unsigned char P[4];
323
324     /* 4-color encoding */
325     CHECK_STREAM_PTR(4);
326
327     memcpy(P, s->stream_ptr, 4);
328     s->stream_ptr += 4;
329
330     if (P[0] <= P[1]) {
331         if (P[2] <= P[3]) {
332
333             /* 1 of 4 colors for each pixel, need 16 more bytes */
334             CHECK_STREAM_PTR(16);
335
336             for (y = 0; y < 8; y++) {
337                 /* get the next set of 8 2-bit flags */
338                 int flags = bytestream_get_le16(&s->stream_ptr);
339                 for (x = 0; x < 8; x++, flags >>= 2)
340                     *s->pixel_ptr++ = P[flags & 0x03];
341                 s->pixel_ptr += s->line_inc;
342             }
343
344         } else {
345             uint32_t flags;
346
347             /* 1 of 4 colors for each 2x2 block, need 4 more bytes */
348             CHECK_STREAM_PTR(4);
349
350             flags = bytestream_get_le32(&s->stream_ptr);
351
352             for (y = 0; y < 8; y += 2) {
353                 for (x = 0; x < 8; x += 2, flags >>= 2) {
354                     s->pixel_ptr[x                ] =
355                     s->pixel_ptr[x + 1            ] =
356                     s->pixel_ptr[x +     s->stride] =
357                     s->pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];
358                 }
359                 s->pixel_ptr += s->stride * 2;
360             }
361
362         }
363     } else {
364         uint64_t flags;
365
366         /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */
367         CHECK_STREAM_PTR(8);
368
369         flags = bytestream_get_le64(&s->stream_ptr);
370         if (P[2] <= P[3]) {
371             for (y = 0; y < 8; y++) {
372                 for (x = 0; x < 8; x += 2, flags >>= 2) {
373                     s->pixel_ptr[x    ] =
374                     s->pixel_ptr[x + 1] = P[flags & 0x03];
375                 }
376                 s->pixel_ptr += s->stride;
377             }
378         } else {
379             for (y = 0; y < 8; y += 2) {
380                 for (x = 0; x < 8; x++, flags >>= 2) {
381                     s->pixel_ptr[x            ] =
382                     s->pixel_ptr[x + s->stride] = P[flags & 0x03];
383                 }
384                 s->pixel_ptr += s->stride * 2;
385             }
386         }
387     }
388
389     /* report success */
390     return 0;
391 }
392
393 static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
394 {
395     int x, y;
396     unsigned char P[4];
397     int flags = 0;
398
399     /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
400      * either top and bottom or left and right halves */
401     CHECK_STREAM_PTR(24);
402
403     if (s->stream_ptr[0] <= s->stream_ptr[1]) {
404
405         /* 4-color encoding for each quadrant; need 32 bytes */
406         CHECK_STREAM_PTR(32);
407
408         for (y = 0; y < 16; y++) {
409             // new values for each 4x4 block
410             if (!(y & 3)) {
411                 memcpy(P, s->stream_ptr, 4);
412                 s->stream_ptr += 4;
413                 flags = bytestream_get_le32(&s->stream_ptr);
414             }
415
416             for (x = 0; x < 4; x++, flags >>= 2)
417                 *s->pixel_ptr++ = P[flags & 0x03];
418
419             s->pixel_ptr += s->stride - 4;
420             // switch to right half
421             if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
422         }
423
424     } else {
425         // vertical split?
426         int vert = s->stream_ptr[12] <= s->stream_ptr[13];
427         uint64_t flags = 0;
428
429         /* 4-color encoding for either left and right or top and bottom
430          * halves */
431
432         for (y = 0; y < 16; y++) {
433             // load values for each half
434             if (!(y & 7)) {
435                 memcpy(P, s->stream_ptr, 4);
436                 s->stream_ptr += 4;
437                 flags = bytestream_get_le64(&s->stream_ptr);
438             }
439
440             for (x = 0; x < 4; x++, flags >>= 2)
441                 *s->pixel_ptr++ = P[flags & 0x03];
442
443             if (vert) {
444                 s->pixel_ptr += s->stride - 4;
445                 // switch to right half
446                 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
447             } else if (y & 1) s->pixel_ptr += s->line_inc;
448         }
449     }
450
451     /* report success */
452     return 0;
453 }
454
455 static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s)
456 {
457     int y;
458
459     /* 64-color encoding (each pixel in block is a different color) */
460     CHECK_STREAM_PTR(64);
461
462     for (y = 0; y < 8; y++) {
463         memcpy(s->pixel_ptr, s->stream_ptr, 8);
464         s->stream_ptr += 8;
465         s->pixel_ptr  += s->stride;
466     }
467
468     /* report success */
469     return 0;
470 }
471
472 static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s)
473 {
474     int x, y;
475
476     /* 16-color block encoding: each 2x2 block is a different color */
477     CHECK_STREAM_PTR(16);
478
479     for (y = 0; y < 8; y += 2) {
480         for (x = 0; x < 8; x += 2) {
481             s->pixel_ptr[x                ] =
482             s->pixel_ptr[x + 1            ] =
483             s->pixel_ptr[x +     s->stride] =
484             s->pixel_ptr[x + 1 + s->stride] = *s->stream_ptr++;
485         }
486         s->pixel_ptr += s->stride * 2;
487     }
488
489     /* report success */
490     return 0;
491 }
492
493 static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s)
494 {
495     int y;
496     unsigned char P[2];
497
498     /* 4-color block encoding: each 4x4 block is a different color */
499     CHECK_STREAM_PTR(4);
500
501     for (y = 0; y < 8; y++) {
502         if (!(y & 3)) {
503             P[0] = *s->stream_ptr++;
504             P[1] = *s->stream_ptr++;
505         }
506         memset(s->pixel_ptr,     P[0], 4);
507         memset(s->pixel_ptr + 4, P[1], 4);
508         s->pixel_ptr += s->stride;
509     }
510
511     /* report success */
512     return 0;
513 }
514
515 static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s)
516 {
517     int y;
518     unsigned char pix;
519
520     /* 1-color encoding: the whole block is 1 solid color */
521     CHECK_STREAM_PTR(1);
522     pix = *s->stream_ptr++;
523
524     for (y = 0; y < 8; y++) {
525         memset(s->pixel_ptr, pix, 8);
526         s->pixel_ptr += s->stride;
527     }
528
529     /* report success */
530     return 0;
531 }
532
533 static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s)
534 {
535     int x, y;
536     unsigned char sample[2];
537
538     /* dithered encoding */
539     CHECK_STREAM_PTR(2);
540     sample[0] = *s->stream_ptr++;
541     sample[1] = *s->stream_ptr++;
542
543     for (y = 0; y < 8; y++) {
544         for (x = 0; x < 8; x += 2) {
545             *s->pixel_ptr++ = sample[  y & 1 ];
546             *s->pixel_ptr++ = sample[!(y & 1)];
547         }
548         s->pixel_ptr += s->line_inc;
549     }
550
551     /* report success */
552     return 0;
553 }
554
555 static int (* const ipvideo_decode_block[])(IpvideoContext *s) = {
556     ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1,
557     ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3,
558     ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5,
559     ipvideo_decode_block_opcode_0x6, ipvideo_decode_block_opcode_0x7,
560     ipvideo_decode_block_opcode_0x8, ipvideo_decode_block_opcode_0x9,
561     ipvideo_decode_block_opcode_0xA, ipvideo_decode_block_opcode_0xB,
562     ipvideo_decode_block_opcode_0xC, ipvideo_decode_block_opcode_0xD,
563     ipvideo_decode_block_opcode_0xE, ipvideo_decode_block_opcode_0xF,
564 };
565
566 static void ipvideo_decode_opcodes(IpvideoContext *s)
567 {
568     int x, y;
569     int index = 0;
570     unsigned char opcode;
571     int ret;
572     static int frame = 0;
573
574     debug_interplay("------------------ frame %d\n", frame);
575     frame++;
576
577     /* this is PAL8, so make the palette available */
578     memcpy(s->current_frame.data[1], s->avctx->palctrl->palette, PALETTE_COUNT * 4);
579
580     s->stride = s->current_frame.linesize[0];
581     s->stream_ptr = s->buf + 14;  /* data starts 14 bytes in */
582     s->stream_end = s->buf + s->size;
583     s->line_inc = s->stride - 8;
584     s->upper_motion_limit_offset = (s->avctx->height - 8) * s->stride
585         + s->avctx->width - 8;
586
587     for (y = 0; y < (s->stride * s->avctx->height); y += s->stride * 8) {
588         for (x = y; x < y + s->avctx->width; x += 8) {
589             /* bottom nibble first, then top nibble (which makes it
590              * hard to use a GetBitcontext) */
591             if (index & 1)
592                 opcode = s->decoding_map[index >> 1] >> 4;
593             else
594                 opcode = s->decoding_map[index >> 1] & 0xF;
595             index++;
596
597             debug_interplay("  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",
598                 x - y, y / s->stride, opcode, s->stream_ptr);
599
600             s->pixel_ptr = s->current_frame.data[0] + x;
601             ret = ipvideo_decode_block[opcode](s);
602             if (ret != 0) {
603                 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode problem on frame %d, @ block (%d, %d)\n",
604                     frame, x - y, y / s->stride);
605                 return;
606             }
607         }
608     }
609     if (s->stream_end - s->stream_ptr > 1) {
610         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode finished with %td bytes left over\n",
611             s->stream_end - s->stream_ptr);
612     }
613 }
614
615 static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
616 {
617     IpvideoContext *s = avctx->priv_data;
618
619     s->avctx = avctx;
620
621     if (s->avctx->palctrl == NULL) {
622         av_log(avctx, AV_LOG_ERROR, " Interplay video: palette expected.\n");
623         return -1;
624     }
625
626     avctx->pix_fmt = PIX_FMT_PAL8;
627     dsputil_init(&s->dsp, avctx);
628
629     /* decoding map contains 4 bits of information per 8x8 block */
630     s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2);
631
632     s->current_frame.data[0] = s->last_frame.data[0] =
633     s->second_last_frame.data[0] = NULL;
634
635     return 0;
636 }
637
638 static int ipvideo_decode_frame(AVCodecContext *avctx,
639                                 void *data, int *data_size,
640                                 AVPacket *avpkt)
641 {
642     const uint8_t *buf = avpkt->data;
643     int buf_size = avpkt->size;
644     IpvideoContext *s = avctx->priv_data;
645     AVPaletteControl *palette_control = avctx->palctrl;
646
647     /* compressed buffer needs to be large enough to at least hold an entire
648      * decoding map */
649     if (buf_size < s->decoding_map_size)
650         return buf_size;
651
652     s->decoding_map = buf;
653     s->buf = buf + s->decoding_map_size;
654     s->size = buf_size - s->decoding_map_size;
655
656     s->current_frame.reference = 3;
657     if (avctx->get_buffer(avctx, &s->current_frame)) {
658         av_log(avctx, AV_LOG_ERROR, "  Interplay Video: get_buffer() failed\n");
659         return -1;
660     }
661
662     ipvideo_decode_opcodes(s);
663
664     if (palette_control->palette_changed) {
665         palette_control->palette_changed = 0;
666         s->current_frame.palette_has_changed = 1;
667     }
668
669     *data_size = sizeof(AVFrame);
670     *(AVFrame*)data = s->current_frame;
671
672     /* shuffle frames */
673     if (s->second_last_frame.data[0])
674         avctx->release_buffer(avctx, &s->second_last_frame);
675     s->second_last_frame = s->last_frame;
676     s->last_frame = s->current_frame;
677     s->current_frame.data[0] = NULL;  /* catch any access attempts */
678
679     /* report that the buffer was completely consumed */
680     return buf_size;
681 }
682
683 static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
684 {
685     IpvideoContext *s = avctx->priv_data;
686
687     /* release the last frame */
688     if (s->last_frame.data[0])
689         avctx->release_buffer(avctx, &s->last_frame);
690     if (s->second_last_frame.data[0])
691         avctx->release_buffer(avctx, &s->second_last_frame);
692
693     return 0;
694 }
695
696 AVCodec interplay_video_decoder = {
697     "interplayvideo",
698     CODEC_TYPE_VIDEO,
699     CODEC_ID_INTERPLAY_VIDEO,
700     sizeof(IpvideoContext),
701     ipvideo_decode_init,
702     NULL,
703     ipvideo_decode_end,
704     ipvideo_decode_frame,
705     CODEC_CAP_DR1,
706     .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
707 };