Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * Interplay MVE File Demuxer | |
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 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. | |
33 | */ | |
34 | ||
35 | #include "libavutil/channel_layout.h" | |
36 | #include "libavutil/intreadwrite.h" | |
37 | #include "avformat.h" | |
38 | #include "internal.h" | |
39 | ||
40 | #define CHUNK_PREAMBLE_SIZE 4 | |
41 | #define OPCODE_PREAMBLE_SIZE 4 | |
42 | ||
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 | |
54 | ||
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 | |
77 | ||
78 | #define PALETTE_COUNT 256 | |
79 | ||
80 | typedef struct IPMVEContext { | |
81 | ||
82 | unsigned char *buf; | |
83 | int buf_size; | |
84 | ||
85 | uint64_t frame_pts_inc; | |
86 | ||
87 | unsigned int video_bpp; | |
88 | unsigned int video_width; | |
89 | unsigned int video_height; | |
90 | int64_t video_pts; | |
91 | uint32_t palette[256]; | |
92 | int has_palette; | |
93 | int changed; | |
94 | ||
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; | |
100 | ||
101 | int video_stream_index; | |
102 | int audio_stream_index; | |
103 | ||
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; | |
110 | ||
111 | int64_t next_chunk_offset; | |
112 | ||
113 | } IPMVEContext; | |
114 | ||
115 | static int load_ipmovie_packet(IPMVEContext *s, AVIOContext *pb, | |
116 | AVPacket *pkt) { | |
117 | ||
118 | int chunk_type; | |
119 | ||
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"); | |
124 | return CHUNK_BAD; | |
125 | } | |
126 | ||
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; | |
131 | } | |
132 | ||
133 | avio_seek(pb, s->audio_chunk_offset, SEEK_SET); | |
134 | s->audio_chunk_offset = 0; | |
135 | ||
136 | if (s->audio_chunk_size != av_get_packet(pb, pkt, s->audio_chunk_size)) | |
137 | return CHUNK_EOF; | |
138 | ||
139 | pkt->stream_index = s->audio_stream_index; | |
140 | pkt->pts = s->audio_frame_count; | |
141 | ||
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)); | |
146 | else | |
147 | s->audio_frame_count += | |
148 | (s->audio_chunk_size - 6 - s->audio_channels) / s->audio_channels; | |
149 | ||
150 | av_dlog(NULL, "sending audio frame with pts %"PRId64" (%d audio frames)\n", | |
151 | pkt->pts, s->audio_frame_count); | |
152 | ||
153 | chunk_type = CHUNK_VIDEO; | |
154 | ||
155 | } else if (s->decode_map_chunk_offset) { | |
156 | ||
157 | /* send both the decode map and the video data together */ | |
158 | ||
159 | if (av_new_packet(pkt, s->decode_map_chunk_size + s->video_chunk_size)) | |
160 | return CHUNK_NOMEM; | |
161 | ||
162 | if (s->has_palette) { | |
163 | uint8_t *pal; | |
164 | ||
165 | pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, | |
166 | AVPALETTE_SIZE); | |
167 | if (pal) { | |
168 | memcpy(pal, s->palette, AVPALETTE_SIZE); | |
169 | s->has_palette = 0; | |
170 | } | |
171 | } | |
172 | ||
173 | if (s->changed) { | |
174 | ff_add_param_change(pkt, 0, 0, 0, s->video_width, s->video_height); | |
175 | s->changed = 0; | |
176 | } | |
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; | |
180 | ||
181 | if (avio_read(pb, pkt->data, s->decode_map_chunk_size) != | |
182 | s->decode_map_chunk_size) { | |
183 | av_free_packet(pkt); | |
184 | return CHUNK_EOF; | |
185 | } | |
186 | ||
187 | avio_seek(pb, s->video_chunk_offset, SEEK_SET); | |
188 | s->video_chunk_offset = 0; | |
189 | ||
190 | if (avio_read(pb, pkt->data + s->decode_map_chunk_size, | |
191 | s->video_chunk_size) != s->video_chunk_size) { | |
192 | av_free_packet(pkt); | |
193 | return CHUNK_EOF; | |
194 | } | |
195 | ||
196 | pkt->stream_index = s->video_stream_index; | |
197 | pkt->pts = s->video_pts; | |
198 | ||
199 | av_dlog(NULL, "sending video frame with pts %"PRId64"\n", pkt->pts); | |
200 | ||
201 | s->video_pts += s->frame_pts_inc; | |
202 | ||
203 | chunk_type = CHUNK_VIDEO; | |
204 | ||
205 | } else { | |
206 | ||
207 | avio_seek(pb, s->next_chunk_offset, SEEK_SET); | |
208 | chunk_type = CHUNK_DONE; | |
209 | ||
210 | } | |
211 | ||
212 | return chunk_type; | |
213 | } | |
214 | ||
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, | |
218 | AVPacket *pkt) | |
219 | { | |
220 | unsigned char chunk_preamble[CHUNK_PREAMBLE_SIZE]; | |
221 | int chunk_type; | |
222 | int chunk_size; | |
223 | unsigned char opcode_preamble[OPCODE_PREAMBLE_SIZE]; | |
224 | unsigned char opcode_type; | |
225 | unsigned char opcode_version; | |
226 | int opcode_size; | |
227 | unsigned char scratch[1024]; | |
228 | int i, j; | |
229 | int first_color, last_color; | |
230 | int audio_flags; | |
231 | unsigned char r, g, b; | |
232 | unsigned int width, height; | |
233 | ||
234 | /* see if there are any pending packets */ | |
235 | chunk_type = load_ipmovie_packet(s, pb, pkt); | |
236 | if (chunk_type != CHUNK_DONE) | |
237 | return chunk_type; | |
238 | ||
239 | /* read the next chunk, wherever the file happens to be pointing */ | |
240 | if (avio_feof(pb)) | |
241 | return CHUNK_EOF; | |
242 | if (avio_read(pb, chunk_preamble, CHUNK_PREAMBLE_SIZE) != | |
243 | CHUNK_PREAMBLE_SIZE) | |
244 | return CHUNK_BAD; | |
245 | chunk_size = AV_RL16(&chunk_preamble[0]); | |
246 | chunk_type = AV_RL16(&chunk_preamble[2]); | |
247 | ||
248 | av_dlog(NULL, "chunk type 0x%04X, 0x%04X bytes: ", chunk_type, chunk_size); | |
249 | ||
250 | switch (chunk_type) { | |
251 | ||
252 | case CHUNK_INIT_AUDIO: | |
253 | av_dlog(NULL, "initialize audio\n"); | |
254 | break; | |
255 | ||
256 | case CHUNK_AUDIO_ONLY: | |
257 | av_dlog(NULL, "audio only\n"); | |
258 | break; | |
259 | ||
260 | case CHUNK_INIT_VIDEO: | |
261 | av_dlog(NULL, "initialize video\n"); | |
262 | break; | |
263 | ||
264 | case CHUNK_VIDEO: | |
265 | av_dlog(NULL, "video (and audio)\n"); | |
266 | break; | |
267 | ||
268 | case CHUNK_SHUTDOWN: | |
269 | av_dlog(NULL, "shutdown\n"); | |
270 | break; | |
271 | ||
272 | case CHUNK_END: | |
273 | av_dlog(NULL, "end\n"); | |
274 | break; | |
275 | ||
276 | default: | |
277 | av_dlog(NULL, "invalid chunk\n"); | |
278 | chunk_type = CHUNK_BAD; | |
279 | break; | |
280 | ||
281 | } | |
282 | ||
283 | while ((chunk_size > 0) && (chunk_type != CHUNK_BAD)) { | |
284 | ||
285 | /* read the next chunk, wherever the file happens to be pointing */ | |
286 | if (avio_feof(pb)) { | |
287 | chunk_type = CHUNK_EOF; | |
288 | break; | |
289 | } | |
290 | if (avio_read(pb, opcode_preamble, CHUNK_PREAMBLE_SIZE) != | |
291 | CHUNK_PREAMBLE_SIZE) { | |
292 | chunk_type = CHUNK_BAD; | |
293 | break; | |
294 | } | |
295 | ||
296 | opcode_size = AV_RL16(&opcode_preamble[0]); | |
297 | opcode_type = opcode_preamble[2]; | |
298 | opcode_version = opcode_preamble[3]; | |
299 | ||
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; | |
305 | break; | |
306 | } | |
307 | ||
308 | av_dlog(NULL, " opcode type %02X, version %d, 0x%04X bytes: ", | |
309 | opcode_type, opcode_version, opcode_size); | |
310 | switch (opcode_type) { | |
311 | ||
312 | case OPCODE_END_OF_STREAM: | |
313 | av_dlog(NULL, "end of stream\n"); | |
314 | avio_skip(pb, opcode_size); | |
315 | break; | |
316 | ||
317 | case OPCODE_END_OF_CHUNK: | |
318 | av_dlog(NULL, "end of chunk\n"); | |
319 | avio_skip(pb, opcode_size); | |
320 | break; | |
321 | ||
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; | |
327 | break; | |
328 | } | |
329 | if (avio_read(pb, scratch, opcode_size) != | |
330 | opcode_size) { | |
331 | chunk_type = CHUNK_BAD; | |
332 | break; | |
333 | } | |
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])); | |
338 | break; | |
339 | ||
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; | |
345 | break; | |
346 | } | |
347 | if (avio_read(pb, scratch, opcode_size) != | |
348 | opcode_size) { | |
349 | chunk_type = CHUNK_BAD; | |
350 | break; | |
351 | } | |
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; | |
363 | else | |
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"); | |
370 | break; | |
371 | ||
372 | case OPCODE_START_STOP_AUDIO: | |
373 | av_dlog(NULL, "start/stop audio\n"); | |
374 | avio_skip(pb, opcode_size); | |
375 | break; | |
376 | ||
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 | |
381 | ) { | |
382 | av_dlog(NULL, "bad init_video_buffers opcode\n"); | |
383 | chunk_type = CHUNK_BAD; | |
384 | break; | |
385 | } | |
386 | if (avio_read(pb, scratch, opcode_size) != | |
387 | opcode_size) { | |
388 | chunk_type = CHUNK_BAD; | |
389 | break; | |
390 | } | |
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; | |
395 | s->changed++; | |
396 | } | |
397 | if (height != s->video_height) { | |
398 | s->video_height = height; | |
399 | s->changed++; | |
400 | } | |
401 | if (opcode_version < 2 || !AV_RL16(&scratch[6])) { | |
402 | s->video_bpp = 8; | |
403 | } else { | |
404 | s->video_bpp = 16; | |
405 | } | |
406 | av_dlog(NULL, "video resolution: %d x %d\n", | |
407 | s->video_width, s->video_height); | |
408 | break; | |
409 | ||
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); | |
419 | break; | |
420 | ||
421 | case OPCODE_SEND_BUFFER: | |
422 | av_dlog(NULL, "send buffer\n"); | |
423 | avio_skip(pb, opcode_size); | |
424 | break; | |
425 | ||
426 | case OPCODE_AUDIO_FRAME: | |
427 | av_dlog(NULL, "audio frame\n"); | |
428 | ||
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); | |
433 | break; | |
434 | ||
435 | case OPCODE_SILENCE_FRAME: | |
436 | av_dlog(NULL, "silence frame\n"); | |
437 | avio_skip(pb, opcode_size); | |
438 | break; | |
439 | ||
440 | case OPCODE_INIT_VIDEO_MODE: | |
441 | av_dlog(NULL, "initialize video mode\n"); | |
442 | avio_skip(pb, opcode_size); | |
443 | break; | |
444 | ||
445 | case OPCODE_CREATE_GRADIENT: | |
446 | av_dlog(NULL, "create gradient\n"); | |
447 | avio_skip(pb, opcode_size); | |
448 | break; | |
449 | ||
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; | |
457 | break; | |
458 | } | |
459 | if (avio_read(pb, scratch, opcode_size) != opcode_size) { | |
460 | chunk_type = CHUNK_BAD; | |
461 | break; | |
462 | } | |
463 | ||
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; | |
473 | break; | |
474 | } | |
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; | |
484 | } | |
485 | s->has_palette = 1; | |
486 | break; | |
487 | ||
488 | case OPCODE_SET_PALETTE_COMPRESSED: | |
489 | av_dlog(NULL, "set palette compressed\n"); | |
490 | avio_skip(pb, opcode_size); | |
491 | break; | |
492 | ||
493 | case OPCODE_SET_DECODING_MAP: | |
494 | av_dlog(NULL, "set decoding map\n"); | |
495 | ||
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); | |
500 | break; | |
501 | ||
502 | case OPCODE_VIDEO_DATA: | |
503 | av_dlog(NULL, "set video data\n"); | |
504 | ||
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); | |
509 | break; | |
510 | ||
511 | default: | |
512 | av_dlog(NULL, "*** unknown opcode type\n"); | |
513 | chunk_type = CHUNK_BAD; | |
514 | break; | |
515 | ||
516 | } | |
517 | } | |
518 | ||
519 | /* make a note of where the stream is sitting */ | |
520 | s->next_chunk_offset = avio_tell(pb); | |
521 | ||
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); | |
525 | ||
526 | return chunk_type; | |
527 | } | |
528 | ||
529 | static const char signature[] = "Interplay MVE File\x1A\0\x1A"; | |
530 | ||
531 | static int ipmovie_probe(AVProbeData *p) | |
532 | { | |
533 | const uint8_t *b = p->buf; | |
534 | const uint8_t *b_end = p->buf + p->buf_size - sizeof(signature); | |
535 | do { | |
536 | if (b[0] == signature[0] && memcmp(b, signature, sizeof(signature)) == 0) | |
537 | return AVPROBE_SCORE_MAX; | |
538 | b++; | |
539 | } while (b < b_end); | |
540 | ||
541 | return 0; | |
542 | } | |
543 | ||
544 | static int ipmovie_read_header(AVFormatContext *s) | |
545 | { | |
546 | IPMVEContext *ipmovie = s->priv_data; | |
547 | AVIOContext *pb = s->pb; | |
548 | AVPacket pkt; | |
549 | AVStream *st; | |
550 | unsigned char chunk_preamble[CHUNK_PREAMBLE_SIZE]; | |
551 | int chunk_type, i; | |
552 | uint8_t signature_buffer[sizeof(signature)]; | |
553 | ||
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); | |
558 | if (avio_feof(pb)) | |
559 | return AVERROR_EOF; | |
560 | } | |
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; | |
565 | ||
566 | /* on the first read, this will position the stream at the first chunk */ | |
567 | ipmovie->next_chunk_offset = avio_tell(pb) + 4; | |
568 | ||
569 | for (i = 0; i < 256; i++) | |
570 | ipmovie->palette[i] = 0xFFU << 24; | |
571 | ||
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; | |
575 | ||
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) != | |
579 | CHUNK_PREAMBLE_SIZE) | |
580 | return AVERROR(EIO); | |
581 | chunk_type = AV_RL16(&chunk_preamble[2]); | |
582 | avio_seek(pb, -CHUNK_PREAMBLE_SIZE, SEEK_CUR); | |
583 | ||
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; | |
588 | ||
589 | /* initialize the stream decoders */ | |
590 | st = avformat_new_stream(s, NULL); | |
591 | if (!st) | |
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; | |
601 | ||
602 | if (ipmovie->audio_type) { | |
603 | st = avformat_new_stream(s, NULL); | |
604 | if (!st) | |
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 : | |
613 | AV_CH_LAYOUT_STEREO; | |
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; | |
621 | } | |
622 | ||
623 | return 0; | |
624 | } | |
625 | ||
626 | static int ipmovie_read_packet(AVFormatContext *s, | |
627 | AVPacket *pkt) | |
628 | { | |
629 | IPMVEContext *ipmovie = s->priv_data; | |
630 | AVIOContext *pb = s->pb; | |
631 | int ret; | |
632 | ||
633 | for (;;) { | |
634 | ret = process_ipmovie_chunk(ipmovie, pb, pkt); | |
635 | if (ret == CHUNK_BAD) | |
636 | ret = AVERROR_INVALIDDATA; | |
637 | else if (ret == CHUNK_EOF) | |
638 | ret = AVERROR(EIO); | |
639 | else if (ret == CHUNK_NOMEM) | |
640 | ret = AVERROR(ENOMEM); | |
641 | else if (ret == CHUNK_VIDEO) | |
642 | ret = 0; | |
643 | else if (ret == CHUNK_INIT_VIDEO || ret == CHUNK_INIT_AUDIO) | |
644 | continue; | |
645 | else | |
646 | ret = -1; | |
647 | ||
648 | return ret; | |
649 | } | |
650 | } | |
651 | ||
652 | AVInputFormat ff_ipmovie_demuxer = { | |
653 | .name = "ipmovie", | |
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, | |
659 | }; |