2 * Interplay MVE File Demuxer
3 * Copyright (c) 2003 The FFmpeg Project
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * Interplay MVE file demuxer
25 * by Mike Melanson (melanson@pcisys.net)
26 * For more information regarding the Interplay MVE file format, visit:
27 * http://www.pcisys.net/~melanson/codecs/
28 * The aforementioned site also contains a command line utility for parsing
29 * IP MVE files so that you can get a good idea of the typical structure of
30 * such files. This demuxer is not the best example to use if you are trying
31 * to write your own as it uses a rather roundabout approach for splitting
32 * up and sending out the chunks.
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
40 #define CHUNK_PREAMBLE_SIZE 4
41 #define OPCODE_PREAMBLE_SIZE 4
43 #define CHUNK_INIT_AUDIO 0x0000
44 #define CHUNK_AUDIO_ONLY 0x0001
45 #define CHUNK_INIT_VIDEO 0x0002
46 #define CHUNK_VIDEO 0x0003
47 #define CHUNK_SHUTDOWN 0x0004
48 #define CHUNK_END 0x0005
49 /* these last types are used internally */
50 #define CHUNK_DONE 0xFFFC
51 #define CHUNK_NOMEM 0xFFFD
52 #define CHUNK_EOF 0xFFFE
53 #define CHUNK_BAD 0xFFFF
55 #define OPCODE_END_OF_STREAM 0x00
56 #define OPCODE_END_OF_CHUNK 0x01
57 #define OPCODE_CREATE_TIMER 0x02
58 #define OPCODE_INIT_AUDIO_BUFFERS 0x03
59 #define OPCODE_START_STOP_AUDIO 0x04
60 #define OPCODE_INIT_VIDEO_BUFFERS 0x05
61 #define OPCODE_UNKNOWN_06 0x06
62 #define OPCODE_SEND_BUFFER 0x07
63 #define OPCODE_AUDIO_FRAME 0x08
64 #define OPCODE_SILENCE_FRAME 0x09
65 #define OPCODE_INIT_VIDEO_MODE 0x0A
66 #define OPCODE_CREATE_GRADIENT 0x0B
67 #define OPCODE_SET_PALETTE 0x0C
68 #define OPCODE_SET_PALETTE_COMPRESSED 0x0D
69 #define OPCODE_UNKNOWN_0E 0x0E
70 #define OPCODE_SET_DECODING_MAP 0x0F
71 #define OPCODE_UNKNOWN_10 0x10
72 #define OPCODE_VIDEO_DATA 0x11
73 #define OPCODE_UNKNOWN_12 0x12
74 #define OPCODE_UNKNOWN_13 0x13
75 #define OPCODE_UNKNOWN_14 0x14
76 #define OPCODE_UNKNOWN_15 0x15
78 #define PALETTE_COUNT 256
80 typedef struct IPMVEContext
{
85 uint64_t frame_pts_inc
;
87 unsigned int video_bpp
;
88 unsigned int video_width
;
89 unsigned int video_height
;
91 uint32_t palette
[256];
95 unsigned int audio_bits
;
96 unsigned int audio_channels
;
97 unsigned int audio_sample_rate
;
98 enum AVCodecID audio_type
;
99 unsigned int audio_frame_count
;
101 int video_stream_index
;
102 int audio_stream_index
;
104 int64_t audio_chunk_offset
;
105 int audio_chunk_size
;
106 int64_t video_chunk_offset
;
107 int video_chunk_size
;
108 int64_t decode_map_chunk_offset
;
109 int decode_map_chunk_size
;
111 int64_t next_chunk_offset
;
115 static int load_ipmovie_packet(IPMVEContext
*s
, AVIOContext
*pb
,
120 if (s
->audio_chunk_offset
&& s
->audio_channels
&& s
->audio_bits
) {
121 if (s
->audio_type
== AV_CODEC_ID_NONE
) {
122 av_log(NULL
, AV_LOG_ERROR
, "Can not read audio packet before"
123 "audio codec is known\n");
127 /* adjust for PCM audio by skipping chunk header */
128 if (s
->audio_type
!= AV_CODEC_ID_INTERPLAY_DPCM
) {
129 s
->audio_chunk_offset
+= 6;
130 s
->audio_chunk_size
-= 6;
133 avio_seek(pb
, s
->audio_chunk_offset
, SEEK_SET
);
134 s
->audio_chunk_offset
= 0;
136 if (s
->audio_chunk_size
!= av_get_packet(pb
, pkt
, s
->audio_chunk_size
))
139 pkt
->stream_index
= s
->audio_stream_index
;
140 pkt
->pts
= s
->audio_frame_count
;
142 /* audio frame maintenance */
143 if (s
->audio_type
!= AV_CODEC_ID_INTERPLAY_DPCM
)
144 s
->audio_frame_count
+=
145 (s
->audio_chunk_size
/ s
->audio_channels
/ (s
->audio_bits
/ 8));
147 s
->audio_frame_count
+=
148 (s
->audio_chunk_size
- 6 - s
->audio_channels
) / s
->audio_channels
;
150 av_dlog(NULL
, "sending audio frame with pts %"PRId64
" (%d audio frames)\n",
151 pkt
->pts
, s
->audio_frame_count
);
153 chunk_type
= CHUNK_VIDEO
;
155 } else if (s
->decode_map_chunk_offset
) {
157 /* send both the decode map and the video data together */
159 if (av_new_packet(pkt
, s
->decode_map_chunk_size
+ s
->video_chunk_size
))
162 if (s
->has_palette
) {
165 pal
= av_packet_new_side_data(pkt
, AV_PKT_DATA_PALETTE
,
168 memcpy(pal
, s
->palette
, AVPALETTE_SIZE
);
174 ff_add_param_change(pkt
, 0, 0, 0, s
->video_width
, s
->video_height
);
177 pkt
->pos
= s
->decode_map_chunk_offset
;
178 avio_seek(pb
, s
->decode_map_chunk_offset
, SEEK_SET
);
179 s
->decode_map_chunk_offset
= 0;
181 if (avio_read(pb
, pkt
->data
, s
->decode_map_chunk_size
) !=
182 s
->decode_map_chunk_size
) {
187 avio_seek(pb
, s
->video_chunk_offset
, SEEK_SET
);
188 s
->video_chunk_offset
= 0;
190 if (avio_read(pb
, pkt
->data
+ s
->decode_map_chunk_size
,
191 s
->video_chunk_size
) != s
->video_chunk_size
) {
196 pkt
->stream_index
= s
->video_stream_index
;
197 pkt
->pts
= s
->video_pts
;
199 av_dlog(NULL
, "sending video frame with pts %"PRId64
"\n", pkt
->pts
);
201 s
->video_pts
+= s
->frame_pts_inc
;
203 chunk_type
= CHUNK_VIDEO
;
207 avio_seek(pb
, s
->next_chunk_offset
, SEEK_SET
);
208 chunk_type
= CHUNK_DONE
;
215 /* This function loads and processes a single chunk in an IP movie file.
216 * It returns the type of chunk that was processed. */
217 static int process_ipmovie_chunk(IPMVEContext
*s
, AVIOContext
*pb
,
220 unsigned char chunk_preamble
[CHUNK_PREAMBLE_SIZE
];
223 unsigned char opcode_preamble
[OPCODE_PREAMBLE_SIZE
];
224 unsigned char opcode_type
;
225 unsigned char opcode_version
;
227 unsigned char scratch
[1024];
229 int first_color
, last_color
;
231 unsigned char r
, g
, b
;
232 unsigned int width
, height
;
234 /* see if there are any pending packets */
235 chunk_type
= load_ipmovie_packet(s
, pb
, pkt
);
236 if (chunk_type
!= CHUNK_DONE
)
239 /* read the next chunk, wherever the file happens to be pointing */
242 if (avio_read(pb
, chunk_preamble
, CHUNK_PREAMBLE_SIZE
) !=
245 chunk_size
= AV_RL16(&chunk_preamble
[0]);
246 chunk_type
= AV_RL16(&chunk_preamble
[2]);
248 av_dlog(NULL
, "chunk type 0x%04X, 0x%04X bytes: ", chunk_type
, chunk_size
);
250 switch (chunk_type
) {
252 case CHUNK_INIT_AUDIO
:
253 av_dlog(NULL
, "initialize audio\n");
256 case CHUNK_AUDIO_ONLY
:
257 av_dlog(NULL
, "audio only\n");
260 case CHUNK_INIT_VIDEO
:
261 av_dlog(NULL
, "initialize video\n");
265 av_dlog(NULL
, "video (and audio)\n");
269 av_dlog(NULL
, "shutdown\n");
273 av_dlog(NULL
, "end\n");
277 av_dlog(NULL
, "invalid chunk\n");
278 chunk_type
= CHUNK_BAD
;
283 while ((chunk_size
> 0) && (chunk_type
!= CHUNK_BAD
)) {
285 /* read the next chunk, wherever the file happens to be pointing */
287 chunk_type
= CHUNK_EOF
;
290 if (avio_read(pb
, opcode_preamble
, CHUNK_PREAMBLE_SIZE
) !=
291 CHUNK_PREAMBLE_SIZE
) {
292 chunk_type
= CHUNK_BAD
;
296 opcode_size
= AV_RL16(&opcode_preamble
[0]);
297 opcode_type
= opcode_preamble
[2];
298 opcode_version
= opcode_preamble
[3];
300 chunk_size
-= OPCODE_PREAMBLE_SIZE
;
301 chunk_size
-= opcode_size
;
302 if (chunk_size
< 0) {
303 av_dlog(NULL
, "chunk_size countdown just went negative\n");
304 chunk_type
= CHUNK_BAD
;
308 av_dlog(NULL
, " opcode type %02X, version %d, 0x%04X bytes: ",
309 opcode_type
, opcode_version
, opcode_size
);
310 switch (opcode_type
) {
312 case OPCODE_END_OF_STREAM
:
313 av_dlog(NULL
, "end of stream\n");
314 avio_skip(pb
, opcode_size
);
317 case OPCODE_END_OF_CHUNK
:
318 av_dlog(NULL
, "end of chunk\n");
319 avio_skip(pb
, opcode_size
);
322 case OPCODE_CREATE_TIMER
:
323 av_dlog(NULL
, "create timer\n");
324 if ((opcode_version
> 0) || (opcode_size
!= 6)) {
325 av_dlog(NULL
, "bad create_timer opcode\n");
326 chunk_type
= CHUNK_BAD
;
329 if (avio_read(pb
, scratch
, opcode_size
) !=
331 chunk_type
= CHUNK_BAD
;
334 s
->frame_pts_inc
= ((uint64_t)AV_RL32(&scratch
[0])) * AV_RL16(&scratch
[4]);
335 av_dlog(NULL
, " %.2f frames/second (timer div = %d, subdiv = %d)\n",
336 1000000.0 / s
->frame_pts_inc
, AV_RL32(&scratch
[0]),
337 AV_RL16(&scratch
[4]));
340 case OPCODE_INIT_AUDIO_BUFFERS
:
341 av_dlog(NULL
, "initialize audio buffers\n");
342 if (opcode_version
> 1 || opcode_size
> 10 || opcode_size
< 6) {
343 av_dlog(NULL
, "bad init_audio_buffers opcode\n");
344 chunk_type
= CHUNK_BAD
;
347 if (avio_read(pb
, scratch
, opcode_size
) !=
349 chunk_type
= CHUNK_BAD
;
352 s
->audio_sample_rate
= AV_RL16(&scratch
[4]);
353 audio_flags
= AV_RL16(&scratch
[2]);
354 /* bit 0 of the flags: 0 = mono, 1 = stereo */
355 s
->audio_channels
= (audio_flags
& 1) + 1;
356 /* bit 1 of the flags: 0 = 8 bit, 1 = 16 bit */
357 s
->audio_bits
= (((audio_flags
>> 1) & 1) + 1) * 8;
358 /* bit 2 indicates compressed audio in version 1 opcode */
359 if ((opcode_version
== 1) && (audio_flags
& 0x4))
360 s
->audio_type
= AV_CODEC_ID_INTERPLAY_DPCM
;
361 else if (s
->audio_bits
== 16)
362 s
->audio_type
= AV_CODEC_ID_PCM_S16LE
;
364 s
->audio_type
= AV_CODEC_ID_PCM_U8
;
365 av_dlog(NULL
, "audio: %d bits, %d Hz, %s, %s format\n",
366 s
->audio_bits
, s
->audio_sample_rate
,
367 (s
->audio_channels
== 2) ? "stereo" : "mono",
368 (s
->audio_type
== AV_CODEC_ID_INTERPLAY_DPCM
) ?
369 "Interplay audio" : "PCM");
372 case OPCODE_START_STOP_AUDIO
:
373 av_dlog(NULL
, "start/stop audio\n");
374 avio_skip(pb
, opcode_size
);
377 case OPCODE_INIT_VIDEO_BUFFERS
:
378 av_dlog(NULL
, "initialize video buffers\n");
379 if ((opcode_version
> 2) || (opcode_size
> 8) || opcode_size
< 4
380 || opcode_version
== 2 && opcode_size
< 8
382 av_dlog(NULL
, "bad init_video_buffers opcode\n");
383 chunk_type
= CHUNK_BAD
;
386 if (avio_read(pb
, scratch
, opcode_size
) !=
388 chunk_type
= CHUNK_BAD
;
391 width
= AV_RL16(&scratch
[0]) * 8;
392 height
= AV_RL16(&scratch
[2]) * 8;
393 if (width
!= s
->video_width
) {
394 s
->video_width
= width
;
397 if (height
!= s
->video_height
) {
398 s
->video_height
= height
;
401 if (opcode_version
< 2 || !AV_RL16(&scratch
[6])) {
406 av_dlog(NULL
, "video resolution: %d x %d\n",
407 s
->video_width
, s
->video_height
);
410 case OPCODE_UNKNOWN_06
:
411 case OPCODE_UNKNOWN_0E
:
412 case OPCODE_UNKNOWN_10
:
413 case OPCODE_UNKNOWN_12
:
414 case OPCODE_UNKNOWN_13
:
415 case OPCODE_UNKNOWN_14
:
416 case OPCODE_UNKNOWN_15
:
417 av_dlog(NULL
, "unknown (but documented) opcode %02X\n", opcode_type
);
418 avio_skip(pb
, opcode_size
);
421 case OPCODE_SEND_BUFFER
:
422 av_dlog(NULL
, "send buffer\n");
423 avio_skip(pb
, opcode_size
);
426 case OPCODE_AUDIO_FRAME
:
427 av_dlog(NULL
, "audio frame\n");
429 /* log position and move on for now */
430 s
->audio_chunk_offset
= avio_tell(pb
);
431 s
->audio_chunk_size
= opcode_size
;
432 avio_skip(pb
, opcode_size
);
435 case OPCODE_SILENCE_FRAME
:
436 av_dlog(NULL
, "silence frame\n");
437 avio_skip(pb
, opcode_size
);
440 case OPCODE_INIT_VIDEO_MODE
:
441 av_dlog(NULL
, "initialize video mode\n");
442 avio_skip(pb
, opcode_size
);
445 case OPCODE_CREATE_GRADIENT
:
446 av_dlog(NULL
, "create gradient\n");
447 avio_skip(pb
, opcode_size
);
450 case OPCODE_SET_PALETTE
:
451 av_dlog(NULL
, "set palette\n");
452 /* check for the logical maximum palette size
453 * (3 * 256 + 4 bytes) */
454 if (opcode_size
> 0x304 || opcode_size
< 4) {
455 av_dlog(NULL
, "demux_ipmovie: set_palette opcode with invalid size\n");
456 chunk_type
= CHUNK_BAD
;
459 if (avio_read(pb
, scratch
, opcode_size
) != opcode_size
) {
460 chunk_type
= CHUNK_BAD
;
464 /* load the palette into internal data structure */
465 first_color
= AV_RL16(&scratch
[0]);
466 last_color
= first_color
+ AV_RL16(&scratch
[2]) - 1;
467 /* sanity check (since they are 16 bit values) */
468 if ( (first_color
> 0xFF) || (last_color
> 0xFF)
469 || (last_color
- first_color
+ 1)*3 + 4 > opcode_size
) {
470 av_dlog(NULL
, "demux_ipmovie: set_palette indexes out of range (%d -> %d)\n",
471 first_color
, last_color
);
472 chunk_type
= CHUNK_BAD
;
475 j
= 4; /* offset of first palette data */
476 for (i
= first_color
; i
<= last_color
; i
++) {
477 /* the palette is stored as a 6-bit VGA palette, thus each
478 * component is shifted up to a 8-bit range */
479 r
= scratch
[j
++] * 4;
480 g
= scratch
[j
++] * 4;
481 b
= scratch
[j
++] * 4;
482 s
->palette
[i
] = (0xFFU
<< 24) | (r
<< 16) | (g
<< 8) | (b
);
483 s
->palette
[i
] |= s
->palette
[i
] >> 6 & 0x30303;
488 case OPCODE_SET_PALETTE_COMPRESSED
:
489 av_dlog(NULL
, "set palette compressed\n");
490 avio_skip(pb
, opcode_size
);
493 case OPCODE_SET_DECODING_MAP
:
494 av_dlog(NULL
, "set decoding map\n");
496 /* log position and move on for now */
497 s
->decode_map_chunk_offset
= avio_tell(pb
);
498 s
->decode_map_chunk_size
= opcode_size
;
499 avio_skip(pb
, opcode_size
);
502 case OPCODE_VIDEO_DATA
:
503 av_dlog(NULL
, "set video data\n");
505 /* log position and move on for now */
506 s
->video_chunk_offset
= avio_tell(pb
);
507 s
->video_chunk_size
= opcode_size
;
508 avio_skip(pb
, opcode_size
);
512 av_dlog(NULL
, "*** unknown opcode type\n");
513 chunk_type
= CHUNK_BAD
;
519 /* make a note of where the stream is sitting */
520 s
->next_chunk_offset
= avio_tell(pb
);
522 /* dispatch the first of any pending packets */
523 if ((chunk_type
== CHUNK_VIDEO
) || (chunk_type
== CHUNK_AUDIO_ONLY
))
524 chunk_type
= load_ipmovie_packet(s
, pb
, pkt
);
529 static const char signature
[] = "Interplay MVE File\x1A\0\x1A";
531 static int ipmovie_probe(AVProbeData
*p
)
533 const uint8_t *b
= p
->buf
;
534 const uint8_t *b_end
= p
->buf
+ p
->buf_size
- sizeof(signature
);
536 if (b
[0] == signature
[0] && memcmp(b
, signature
, sizeof(signature
)) == 0)
537 return AVPROBE_SCORE_MAX
;
544 static int ipmovie_read_header(AVFormatContext
*s
)
546 IPMVEContext
*ipmovie
= s
->priv_data
;
547 AVIOContext
*pb
= s
->pb
;
550 unsigned char chunk_preamble
[CHUNK_PREAMBLE_SIZE
];
552 uint8_t signature_buffer
[sizeof(signature
)];
554 avio_read(pb
, signature_buffer
, sizeof(signature_buffer
));
555 while (memcmp(signature_buffer
, signature
, sizeof(signature
))) {
556 memmove(signature_buffer
, signature_buffer
+ 1, sizeof(signature_buffer
) - 1);
557 signature_buffer
[sizeof(signature_buffer
) - 1] = avio_r8(pb
);
561 /* initialize private context members */
562 ipmovie
->video_pts
= ipmovie
->audio_frame_count
= 0;
563 ipmovie
->audio_chunk_offset
= ipmovie
->video_chunk_offset
=
564 ipmovie
->decode_map_chunk_offset
= 0;
566 /* on the first read, this will position the stream at the first chunk */
567 ipmovie
->next_chunk_offset
= avio_tell(pb
) + 4;
569 for (i
= 0; i
< 256; i
++)
570 ipmovie
->palette
[i
] = 0xFFU
<< 24;
572 /* process the first chunk which should be CHUNK_INIT_VIDEO */
573 if (process_ipmovie_chunk(ipmovie
, pb
, &pkt
) != CHUNK_INIT_VIDEO
)
574 return AVERROR_INVALIDDATA
;
576 /* peek ahead to the next chunk-- if it is an init audio chunk, process
577 * it; if it is the first video chunk, this is a silent file */
578 if (avio_read(pb
, chunk_preamble
, CHUNK_PREAMBLE_SIZE
) !=
581 chunk_type
= AV_RL16(&chunk_preamble
[2]);
582 avio_seek(pb
, -CHUNK_PREAMBLE_SIZE
, SEEK_CUR
);
584 if (chunk_type
== CHUNK_VIDEO
)
585 ipmovie
->audio_type
= AV_CODEC_ID_NONE
; /* no audio */
586 else if (process_ipmovie_chunk(ipmovie
, pb
, &pkt
) != CHUNK_INIT_AUDIO
)
587 return AVERROR_INVALIDDATA
;
589 /* initialize the stream decoders */
590 st
= avformat_new_stream(s
, NULL
);
592 return AVERROR(ENOMEM
);
593 avpriv_set_pts_info(st
, 63, 1, 1000000);
594 ipmovie
->video_stream_index
= st
->index
;
595 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
596 st
->codec
->codec_id
= AV_CODEC_ID_INTERPLAY_VIDEO
;
597 st
->codec
->codec_tag
= 0; /* no fourcc */
598 st
->codec
->width
= ipmovie
->video_width
;
599 st
->codec
->height
= ipmovie
->video_height
;
600 st
->codec
->bits_per_coded_sample
= ipmovie
->video_bpp
;
602 if (ipmovie
->audio_type
) {
603 st
= avformat_new_stream(s
, NULL
);
605 return AVERROR(ENOMEM
);
606 avpriv_set_pts_info(st
, 32, 1, ipmovie
->audio_sample_rate
);
607 ipmovie
->audio_stream_index
= st
->index
;
608 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
609 st
->codec
->codec_id
= ipmovie
->audio_type
;
610 st
->codec
->codec_tag
= 0; /* no tag */
611 st
->codec
->channels
= ipmovie
->audio_channels
;
612 st
->codec
->channel_layout
= st
->codec
->channels
== 1 ? AV_CH_LAYOUT_MONO
:
614 st
->codec
->sample_rate
= ipmovie
->audio_sample_rate
;
615 st
->codec
->bits_per_coded_sample
= ipmovie
->audio_bits
;
616 st
->codec
->bit_rate
= st
->codec
->channels
* st
->codec
->sample_rate
*
617 st
->codec
->bits_per_coded_sample
;
618 if (st
->codec
->codec_id
== AV_CODEC_ID_INTERPLAY_DPCM
)
619 st
->codec
->bit_rate
/= 2;
620 st
->codec
->block_align
= st
->codec
->channels
* st
->codec
->bits_per_coded_sample
;
626 static int ipmovie_read_packet(AVFormatContext
*s
,
629 IPMVEContext
*ipmovie
= s
->priv_data
;
630 AVIOContext
*pb
= s
->pb
;
634 ret
= process_ipmovie_chunk(ipmovie
, pb
, pkt
);
635 if (ret
== CHUNK_BAD
)
636 ret
= AVERROR_INVALIDDATA
;
637 else if (ret
== CHUNK_EOF
)
639 else if (ret
== CHUNK_NOMEM
)
640 ret
= AVERROR(ENOMEM
);
641 else if (ret
== CHUNK_VIDEO
)
643 else if (ret
== CHUNK_INIT_VIDEO
|| ret
== CHUNK_INIT_AUDIO
)
652 AVInputFormat ff_ipmovie_demuxer
= {
654 .long_name
= NULL_IF_CONFIG_SMALL("Interplay MVE"),
655 .priv_data_size
= sizeof(IPMVEContext
),
656 .read_probe
= ipmovie_probe
,
657 .read_header
= ipmovie_read_header
,
658 .read_packet
= ipmovie_read_packet
,