Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
[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     int code_counts[16] = {0};
573     static int frame = 0;
574
575     debug_interplay("------------------ frame %d\n", frame);
576     frame++;
577
578     /* this is PAL8, so make the palette available */
579     memcpy(s->current_frame.data[1], s->avctx->palctrl->palette, PALETTE_COUNT * 4);
580
581     s->stride = s->current_frame.linesize[0];
582     s->stream_ptr = s->buf + 14;  /* data starts 14 bytes in */
583     s->stream_end = s->buf + s->size;
584     s->line_inc = s->stride - 8;
585     s->upper_motion_limit_offset = (s->avctx->height - 8) * s->stride
586         + s->avctx->width - 8;
587
588     for (y = 0; y < (s->stride * s->avctx->height); y += s->stride * 8) {
589         for (x = y; x < y + s->avctx->width; x += 8) {
590             /* bottom nibble first, then top nibble (which makes it
591              * hard to use a GetBitcontext) */
592             if (index & 1)
593                 opcode = s->decoding_map[index >> 1] >> 4;
594             else
595                 opcode = s->decoding_map[index >> 1] & 0xF;
596             index++;
597
598             debug_interplay("  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",
599                 x - y, y / s->stride, opcode, s->stream_ptr);
600             code_counts[opcode]++;
601
602             s->pixel_ptr = s->current_frame.data[0] + x;
603             ret = ipvideo_decode_block[opcode](s);
604             if (ret != 0) {
605                 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode problem on frame %d, @ block (%d, %d)\n",
606                     frame, x - y, y / s->stride);
607                 return;
608             }
609         }
610     }
611     if (s->stream_end - s->stream_ptr > 1) {
612         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode finished with %td bytes left over\n",
613             s->stream_end - s->stream_ptr);
614     }
615 }
616
617 static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
618 {
619     IpvideoContext *s = avctx->priv_data;
620
621     s->avctx = avctx;
622
623     if (s->avctx->palctrl == NULL) {
624         av_log(avctx, AV_LOG_ERROR, " Interplay video: palette expected.\n");
625         return -1;
626     }
627
628     avctx->pix_fmt = PIX_FMT_PAL8;
629     dsputil_init(&s->dsp, avctx);
630
631     /* decoding map contains 4 bits of information per 8x8 block */
632     s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2);
633
634     s->current_frame.data[0] = s->last_frame.data[0] =
635     s->second_last_frame.data[0] = NULL;
636
637     return 0;
638 }
639
640 static int ipvideo_decode_frame(AVCodecContext *avctx,
641                                 void *data, int *data_size,
642                                 AVPacket *avpkt)
643 {
644     const uint8_t *buf = avpkt->data;
645     int buf_size = avpkt->size;
646     IpvideoContext *s = avctx->priv_data;
647     AVPaletteControl *palette_control = avctx->palctrl;
648
649     /* compressed buffer needs to be large enough to at least hold an entire
650      * decoding map */
651     if (buf_size < s->decoding_map_size)
652         return buf_size;
653
654     s->decoding_map = buf;
655     s->buf = buf + s->decoding_map_size;
656     s->size = buf_size - s->decoding_map_size;
657
658     s->current_frame.reference = 3;
659     if (avctx->get_buffer(avctx, &s->current_frame)) {
660         av_log(avctx, AV_LOG_ERROR, "  Interplay Video: get_buffer() failed\n");
661         return -1;
662     }
663
664     ipvideo_decode_opcodes(s);
665
666     if (palette_control->palette_changed) {
667         palette_control->palette_changed = 0;
668         s->current_frame.palette_has_changed = 1;
669     }
670
671     *data_size = sizeof(AVFrame);
672     *(AVFrame*)data = s->current_frame;
673
674     /* shuffle frames */
675     if (s->second_last_frame.data[0])
676         avctx->release_buffer(avctx, &s->second_last_frame);
677     s->second_last_frame = s->last_frame;
678     s->last_frame = s->current_frame;
679     s->current_frame.data[0] = NULL;  /* catch any access attempts */
680
681     /* report that the buffer was completely consumed */
682     return buf_size;
683 }
684
685 static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
686 {
687     IpvideoContext *s = avctx->priv_data;
688
689     /* release the last frame */
690     if (s->last_frame.data[0])
691         avctx->release_buffer(avctx, &s->last_frame);
692     if (s->second_last_frame.data[0])
693         avctx->release_buffer(avctx, &s->second_last_frame);
694
695     return 0;
696 }
697
698 AVCodec interplay_video_decoder = {
699     "interplayvideo",
700     CODEC_TYPE_VIDEO,
701     CODEC_ID_INTERPLAY_VIDEO,
702     sizeof(IpvideoContext),
703     ipvideo_decode_init,
704     NULL,
705     ipvideo_decode_end,
706     ipvideo_decode_frame,
707     CODEC_CAP_DR1,
708     .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
709 };