0dfeac66bbc24113eec9238fd2631574d71268c4
[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             }
219             s->pixel_ptr += s->line_inc;
220         }
221
222     } else {
223
224         /* need 2 more bytes from the stream */
225         CHECK_STREAM_PTR(2);
226
227         flags = bytestream_get_le16(&s->stream_ptr);
228         for (y = 0; y < 8; y += 2) {
229             for (x = 0; x < 8; x += 2, flags >>= 1) {
230                 s->pixel_ptr[x                ] =
231                 s->pixel_ptr[x + 1            ] =
232                 s->pixel_ptr[x +     s->stride] =
233                 s->pixel_ptr[x + 1 + s->stride] = P[flags & 1];
234             }
235             s->pixel_ptr += s->stride * 2;
236         }
237     }
238
239     /* report success */
240     return 0;
241 }
242
243 static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
244 {
245     int x, y;
246     unsigned char P[2];
247     unsigned int flags = 0;
248
249     /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
250      * either top and bottom or left and right halves */
251     CHECK_STREAM_PTR(2);
252
253     P[0] = *s->stream_ptr++;
254     P[1] = *s->stream_ptr++;
255
256     if (P[0] <= P[1]) {
257
258         CHECK_STREAM_PTR(14);
259         s->stream_ptr -= 2;
260
261         for (y = 0; y < 16; y++) {
262             // new values for each 4x4 block
263             if (!(y & 3)) {
264                 P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
265                 flags = bytestream_get_le16(&s->stream_ptr);
266             }
267
268             for (x = 0; x < 4; x++, flags >>= 1) {
269                 *s->pixel_ptr++ = P[flags & 1];
270             }
271             s->pixel_ptr += s->stride - 4;
272             // switch to right half
273             if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
274         }
275
276     } else {
277
278         /* need 10 more bytes */
279         CHECK_STREAM_PTR(10);
280
281         if (s->stream_ptr[4] <= s->stream_ptr[5]) {
282
283             flags = bytestream_get_le32(&s->stream_ptr);
284
285             /* vertical split; left & right halves are 2-color encoded */
286
287             for (y = 0; y < 16; y++) {
288                 for (x = 0; x < 4; x++, flags >>= 1) {
289                     *s->pixel_ptr++ = P[flags & 1];
290                 }
291                 s->pixel_ptr += s->stride - 4;
292                 // switch to right half
293                 if (y == 7) {
294                     s->pixel_ptr -= 8 * s->stride - 4;
295                     P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
296                     flags = bytestream_get_le32(&s->stream_ptr);
297                 }
298             }
299
300         } else {
301
302             /* horizontal split; top & bottom halves are 2-color encoded */
303
304             for (y = 0; y < 8; y++) {
305                 if (y == 4) {
306                     P[0] = *s->stream_ptr++;
307                     P[1] = *s->stream_ptr++;
308                 }
309                 flags = *s->stream_ptr++ | 0x100;
310
311                 for (; flags != 1; flags >>= 1) {
312
313                     *s->pixel_ptr++ = P[flags & 1];
314                 }
315                 s->pixel_ptr += s->line_inc;
316             }
317         }
318     }
319
320     /* report success */
321     return 0;
322 }
323
324 static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
325 {
326     int x, y;
327     unsigned char P[4];
328
329     /* 4-color encoding */
330     CHECK_STREAM_PTR(4);
331
332     memcpy(P, s->stream_ptr, 4);
333     s->stream_ptr += 4;
334
335     if (P[0] <= P[1]) {
336         if (P[2] <= P[3]) {
337
338             /* 1 of 4 colors for each pixel, need 16 more bytes */
339             CHECK_STREAM_PTR(16);
340
341             for (y = 0; y < 8; y++) {
342                 /* get the next set of 8 2-bit flags */
343                 int flags = bytestream_get_le16(&s->stream_ptr);
344                 for (x = 0; x < 8; x++, flags >>= 2) {
345                     *s->pixel_ptr++ = P[flags & 0x03];
346                 }
347                 s->pixel_ptr += s->line_inc;
348             }
349
350         } else {
351             uint32_t flags;
352
353             /* 1 of 4 colors for each 2x2 block, need 4 more bytes */
354             CHECK_STREAM_PTR(4);
355
356             flags = bytestream_get_le32(&s->stream_ptr);
357
358             for (y = 0; y < 8; y += 2) {
359                 for (x = 0; x < 8; x += 2, flags >>= 2) {
360                     s->pixel_ptr[x                ] =
361                     s->pixel_ptr[x + 1            ] =
362                     s->pixel_ptr[x +     s->stride] =
363                     s->pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];
364                 }
365                 s->pixel_ptr += s->stride * 2;
366             }
367
368         }
369     } else {
370         uint64_t flags;
371
372         /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */
373         CHECK_STREAM_PTR(8);
374
375         flags = bytestream_get_le64(&s->stream_ptr);
376         if (P[2] <= P[3]) {
377             for (y = 0; y < 8; y++) {
378                 for (x = 0; x < 8; x += 2, flags >>= 2) {
379                     s->pixel_ptr[x    ] =
380                     s->pixel_ptr[x + 1] = P[flags & 0x03];
381                 }
382                 s->pixel_ptr += s->stride;
383             }
384         } else {
385             for (y = 0; y < 8; y += 2) {
386                 for (x = 0; x < 8; x++, flags >>= 2) {
387                     s->pixel_ptr[x            ] =
388                     s->pixel_ptr[x + s->stride] = P[flags & 0x03];
389                 }
390                 s->pixel_ptr += s->stride * 2;
391             }
392         }
393     }
394
395     /* report success */
396     return 0;
397 }
398
399 static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
400 {
401     int x, y;
402     unsigned char P[4];
403     int flags = 0;
404
405     /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
406      * either top and bottom or left and right halves */
407     CHECK_STREAM_PTR(24);
408
409     if (s->stream_ptr[0] <= s->stream_ptr[1]) {
410
411         /* 4-color encoding for each quadrant; need 32 bytes */
412         CHECK_STREAM_PTR(32);
413
414         for (y = 0; y < 16; y++) {
415             // new values for each 4x4 block
416             if (!(y & 3)) {
417                 memcpy(P, s->stream_ptr, 4);
418                 s->stream_ptr += 4;
419                 flags = bytestream_get_le32(&s->stream_ptr);
420             }
421
422             for (x = 0; x < 4; x++, flags >>= 2) {
423                 *s->pixel_ptr++ = P[flags & 0x03];
424             }
425
426             s->pixel_ptr += s->stride - 4;
427             // switch to right half
428             if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
429         }
430
431     } else {
432         // vertical split?
433         int vert = s->stream_ptr[12] <= s->stream_ptr[13];
434         uint64_t flags = 0;
435
436         /* 4-color encoding for either left and right or top and bottom
437          * halves */
438
439         for (y = 0; y < 16; y++) {
440             // load values for each half
441             if (!(y & 7)) {
442                 memcpy(P, s->stream_ptr, 4);
443                 s->stream_ptr += 4;
444                 flags = bytestream_get_le64(&s->stream_ptr);
445             }
446
447             for (x = 0; x < 4; x++, flags >>= 2)
448                 *s->pixel_ptr++ = P[flags & 0x03];
449
450             if (vert) {
451                 s->pixel_ptr += s->stride - 4;
452                 // switch to right half
453                 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
454             } else if (y & 1) s->pixel_ptr += s->line_inc;
455         }
456     }
457
458     /* report success */
459     return 0;
460 }
461
462 static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s)
463 {
464     int y;
465
466     /* 64-color encoding (each pixel in block is a different color) */
467     CHECK_STREAM_PTR(64);
468
469     for (y = 0; y < 8; y++) {
470         memcpy(s->pixel_ptr, s->stream_ptr, 8);
471         s->stream_ptr += 8;
472         s->pixel_ptr  += s->stride;
473     }
474
475     /* report success */
476     return 0;
477 }
478
479 static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s)
480 {
481     int x, y;
482
483     /* 16-color block encoding: each 2x2 block is a different color */
484     CHECK_STREAM_PTR(16);
485
486     for (y = 0; y < 8; y += 2) {
487         for (x = 0; x < 8; x += 2) {
488             s->pixel_ptr[x                ] =
489             s->pixel_ptr[x + 1            ] =
490             s->pixel_ptr[x +     s->stride] =
491             s->pixel_ptr[x + 1 + s->stride] = *s->stream_ptr++;
492         }
493         s->pixel_ptr += s->stride * 2;
494     }
495
496     /* report success */
497     return 0;
498 }
499
500 static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s)
501 {
502     int y;
503     unsigned char P;
504
505     /* 4-color block encoding: each 4x4 block is a different color */
506     CHECK_STREAM_PTR(4);
507
508     for (y = 0; y < 16; y++) {
509         if (!(y & 3)) // start of block
510             P = *s->stream_ptr++;
511         memset(s->pixel_ptr, P, 4);
512         s->pixel_ptr += s->stride;
513         // switch to right half
514         if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
515     }
516
517     /* report success */
518     return 0;
519 }
520
521 static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s)
522 {
523     int y;
524     unsigned char pix;
525
526     /* 1-color encoding: the whole block is 1 solid color */
527     CHECK_STREAM_PTR(1);
528     pix = *s->stream_ptr++;
529
530     for (y = 0; y < 8; y++) {
531         memset(s->pixel_ptr, pix, 8);
532         s->pixel_ptr += s->stride;
533     }
534
535     /* report success */
536     return 0;
537 }
538
539 static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s)
540 {
541     int x, y;
542     unsigned char sample[2];
543
544     /* dithered encoding */
545     CHECK_STREAM_PTR(2);
546     sample[0] = *s->stream_ptr++;
547     sample[1] = *s->stream_ptr++;
548
549     for (y = 0; y < 8; y++) {
550         for (x = 0; x < 8; x += 2) {
551             *s->pixel_ptr++ = sample[  y & 1 ];
552             *s->pixel_ptr++ = sample[!(y & 1)];
553         }
554         s->pixel_ptr += s->line_inc;
555     }
556
557     /* report success */
558     return 0;
559 }
560
561 static int (* const ipvideo_decode_block[])(IpvideoContext *s) = {
562     ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1,
563     ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3,
564     ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5,
565     ipvideo_decode_block_opcode_0x6, ipvideo_decode_block_opcode_0x7,
566     ipvideo_decode_block_opcode_0x8, ipvideo_decode_block_opcode_0x9,
567     ipvideo_decode_block_opcode_0xA, ipvideo_decode_block_opcode_0xB,
568     ipvideo_decode_block_opcode_0xC, ipvideo_decode_block_opcode_0xD,
569     ipvideo_decode_block_opcode_0xE, ipvideo_decode_block_opcode_0xF,
570 };
571
572 static void ipvideo_decode_opcodes(IpvideoContext *s)
573 {
574     int x, y;
575     int index = 0;
576     unsigned char opcode;
577     int ret;
578     int code_counts[16] = {0};
579     static int frame = 0;
580
581     debug_interplay("------------------ frame %d\n", frame);
582     frame++;
583
584     /* this is PAL8, so make the palette available */
585     memcpy(s->current_frame.data[1], s->avctx->palctrl->palette, PALETTE_COUNT * 4);
586
587     s->stride = s->current_frame.linesize[0];
588     s->stream_ptr = s->buf + 14;  /* data starts 14 bytes in */
589     s->stream_end = s->buf + s->size;
590     s->line_inc = s->stride - 8;
591     s->upper_motion_limit_offset = (s->avctx->height - 8) * s->stride
592         + s->avctx->width - 8;
593
594     for (y = 0; y < (s->stride * s->avctx->height); y += s->stride * 8) {
595         for (x = y; x < y + s->avctx->width; x += 8) {
596             /* bottom nibble first, then top nibble (which makes it
597              * hard to use a GetBitcontext) */
598             if (index & 1)
599                 opcode = s->decoding_map[index >> 1] >> 4;
600             else
601                 opcode = s->decoding_map[index >> 1] & 0xF;
602             index++;
603
604             debug_interplay("  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",
605                 x - y, y / s->stride, opcode, s->stream_ptr);
606             code_counts[opcode]++;
607
608             s->pixel_ptr = s->current_frame.data[0] + x;
609             ret = ipvideo_decode_block[opcode](s);
610             if (ret != 0) {
611                 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode problem on frame %d, @ block (%d, %d)\n",
612                     frame, x - y, y / s->stride);
613                 return;
614             }
615         }
616     }
617     if (s->stream_end - s->stream_ptr > 1) {
618         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode finished with %td bytes left over\n",
619             s->stream_end - s->stream_ptr);
620     }
621 }
622
623 static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
624 {
625     IpvideoContext *s = avctx->priv_data;
626
627     s->avctx = avctx;
628
629     if (s->avctx->palctrl == NULL) {
630         av_log(avctx, AV_LOG_ERROR, " Interplay video: palette expected.\n");
631         return -1;
632     }
633
634     avctx->pix_fmt = PIX_FMT_PAL8;
635     dsputil_init(&s->dsp, avctx);
636
637     /* decoding map contains 4 bits of information per 8x8 block */
638     s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2);
639
640     s->current_frame.data[0] = s->last_frame.data[0] =
641     s->second_last_frame.data[0] = NULL;
642
643     return 0;
644 }
645
646 static int ipvideo_decode_frame(AVCodecContext *avctx,
647                                 void *data, int *data_size,
648                                 const uint8_t *buf, int buf_size)
649 {
650     IpvideoContext *s = avctx->priv_data;
651     AVPaletteControl *palette_control = avctx->palctrl;
652
653     /* compressed buffer needs to be large enough to at least hold an entire
654      * decoding map */
655     if (buf_size < s->decoding_map_size)
656         return buf_size;
657
658     s->decoding_map = buf;
659     s->buf = buf + s->decoding_map_size;
660     s->size = buf_size - s->decoding_map_size;
661
662     s->current_frame.reference = 3;
663     if (avctx->get_buffer(avctx, &s->current_frame)) {
664         av_log(avctx, AV_LOG_ERROR, "  Interplay Video: get_buffer() failed\n");
665         return -1;
666     }
667
668     ipvideo_decode_opcodes(s);
669
670     if (palette_control->palette_changed) {
671         palette_control->palette_changed = 0;
672         s->current_frame.palette_has_changed = 1;
673     }
674
675     *data_size = sizeof(AVFrame);
676     *(AVFrame*)data = s->current_frame;
677
678     /* shuffle frames */
679     if (s->second_last_frame.data[0])
680         avctx->release_buffer(avctx, &s->second_last_frame);
681     s->second_last_frame = s->last_frame;
682     s->last_frame = s->current_frame;
683     s->current_frame.data[0] = NULL;  /* catch any access attempts */
684
685     /* report that the buffer was completely consumed */
686     return buf_size;
687 }
688
689 static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
690 {
691     IpvideoContext *s = avctx->priv_data;
692
693     /* release the last frame */
694     if (s->last_frame.data[0])
695         avctx->release_buffer(avctx, &s->last_frame);
696     if (s->second_last_frame.data[0])
697         avctx->release_buffer(avctx, &s->second_last_frame);
698
699     return 0;
700 }
701
702 AVCodec interplay_video_decoder = {
703     "interplayvideo",
704     CODEC_TYPE_VIDEO,
705     CODEC_ID_INTERPLAY_VIDEO,
706     sizeof(IpvideoContext),
707     ipvideo_decode_init,
708     NULL,
709     ipvideo_decode_end,
710     ipvideo_decode_frame,
711     CODEC_CAP_DR1,
712     .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
713 };