?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Support for multiple editions in Matroska
[mplayer.git] / libmpdemux / demux_mkv.c
blobc07224ae67109117e4b53f5291fbcebfd05743b5
1 /*
2 * Matroska demuxer
3 * Copyright (C) 2004 Aurelien Jacobs <aurel@gnuage.org>
4 * Based on the one written by Ronald Bultje for gstreamer
5 * and on demux_mkv.cpp from Moritz Bunkus.
6 *
7 * This file is part of MPlayer.
8 *
9 * MPlayer is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * MPlayer is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 */
23
24 #include "config.h"
25
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <ctype.h>
29 #include <inttypes.h>
30 #include <stdbool.h>
31
32 #include "talloc.h"
33 #include "options.h"
34 #include "stream/stream.h"
35 #include "demuxer.h"
36 #include "stheader.h"
37 #include "ebml.h"
38 #include "matroska.h"
39
40 #include "mp_msg.h"
41 #include "help_mp.h"
42
43 #include "vobsub.h"
44 #include "subreader.h"
45 #include "libvo/sub.h"
46
47 #include "ass_mp.h"
48
49 #include "libavutil/common.h"
50
51 #ifdef CONFIG_QTX_CODECS
52 #include "loader/qtx/qtxsdk/components.h"
53 #endif
54
55 #if CONFIG_ZLIB
56 #include <zlib.h>
57 #endif
58
59 #include "libavutil/lzo.h"
60 #include "ffmpeg_files/intreadwrite.h"
61 #include "libavutil/avstring.h"
62
63 static const unsigned char sipr_swaps[38][2]={
64 {0,63},{1,22},{2,44},{3,90},{5,81},{7,31},{8,86},{9,58},{10,36},{12,68},
65 {13,39},{14,73},{15,53},{16,69},{17,57},{19,88},{20,34},{21,71},{24,46},
66 {25,94},{26,54},{28,75},{29,50},{32,70},{33,92},{35,74},{38,85},{40,56},
67 {42,87},{43,65},{45,59},{48,79},{49,93},{51,89},{55,95},{61,76},{67,83},
68 {77,80} };
69
70 // Map flavour to bytes per second
71 #define SIPR_FLAVORS 4
72 #define ATRC_FLAVORS 8
73 #define COOK_FLAVORS 34
74 static const int sipr_fl2bps[SIPR_FLAVORS] = {813, 1062, 625, 2000};
75 static const int atrc_fl2bps[ATRC_FLAVORS] = {8269, 11714, 13092, 16538, 18260, 22050, 33075, 44100};
76 static const int cook_fl2bps[COOK_FLAVORS] = {
77 1000, 1378, 2024, 2584, 4005, 5513, 8010, 4005, 750, 2498,
78 4048, 5513, 8010, 11973, 8010, 2584, 4005, 2067, 2584, 2584,
79 4005, 4005, 5513, 5513, 8010, 12059, 1550, 8010, 12059, 5513,
80 12016, 16408, 22911, 33506};
81
82 typedef struct
83 {
84 uint32_t order, type, scope;
85 uint32_t comp_algo;
86 uint8_t *comp_settings;
87 int comp_settings_len;
88 } mkv_content_encoding_t;
89
90 typedef struct mkv_track
91 {
92 int tnum;
93 char *name;
94
95 char *codec_id;
96 int ms_compat;
97 char *language;
98
99 int type;
100
101 uint32_t v_width, v_height, v_dwidth, v_dheight;
102 double v_frate;
103
104 uint32_t a_formattag;
105 uint32_t a_channels, a_bps;
106 float a_sfreq;
107
108 double default_duration;
109
110 int default_track;
111
112 unsigned char *private_data;
113 unsigned int private_size;
114
115 /* stuff for realmedia */
116 int realmedia;
117 int64_t rv_kf_base;
118 int rv_kf_pts;
119 double rv_pts; /* previous video timestamp */
120 double ra_pts; /* previous audio timestamp */
121
122 /** realaudio descrambling */
123 int sub_packet_size; ///< sub packet size, per stream
124 int sub_packet_h; ///< number of coded frames per block
125 int coded_framesize; ///< coded frame size, per stream
126 int audiopk_size; ///< audio packet size
127 unsigned char *audio_buf; ///< place to store reordered audio data
128 double *audio_timestamp; ///< timestamp for each audio packet
129 int sub_packet_cnt; ///< number of subpacket already received
130 int audio_filepos; ///< file position of first audio packet in block
131
132 /* stuff for quicktime */
133 int fix_i_bps;
134 double qt_last_a_pts;
135
136 int subtitle_type;
137
138 /* The timecodes of video frames might have to be reordered if they're
139 in display order (the timecodes, not the frames themselves!). In this
140 case demux packets have to be cached with the help of these variables. */
141 int reorder_timecodes;
142 demux_packet_t **cached_dps;
143 int num_cached_dps, num_allocated_dps;
144 double max_pts;
145
146 /* generic content encoding support */
147 mkv_content_encoding_t *encodings;
148 int num_encodings;
149
150 /* For VobSubs and SSA/ASS */
151 sh_sub_t *sh_sub;
152 } mkv_track_t;
153
154 typedef struct mkv_index
155 {
156 int tnum;
157 uint64_t timecode, filepos;
158 } mkv_index_t;
159
160 typedef struct mkv_demuxer
161 {
162 off_t segment_start;
163
164 double duration, last_pts;
165 uint64_t last_filepos;
166
167 mkv_track_t **tracks;
168 int num_tracks;
169
170 uint64_t tc_scale, cluster_tc;
171
172 uint64_t cluster_size;
173 uint64_t blockgroup_size;
174
175 mkv_index_t *indexes;
176 int num_indexes;
177
178 off_t *parsed_cues;
179 int parsed_cues_num;
180 off_t *parsed_seekhead;
181 int parsed_seekhead_num;
182
183 uint64_t *cluster_positions;
184 int num_cluster_pos;
185
186 int64_t skip_to_timecode;
187 int v_skip_to_keyframe, a_skip_to_keyframe;
188
189 int last_aid;
190 int audio_tracks[MAX_A_STREAMS];
191 } mkv_demuxer_t;
192
193 #define REALHEADER_SIZE 16
194 #define RVPROPERTIES_SIZE 34
195 #define RAPROPERTIES4_SIZE 56
196 #define RAPROPERTIES5_SIZE 70
197
198 /**
199 * \brief ensures there is space for at least one additional element
200 * \param array array to grow
201 * \param nelem current number of elements in array
202 * \param elsize size of one array element
203 */
204 static void *grow_array(void *array, int nelem, size_t elsize) {
205 if (!(nelem & 31))
206 array = realloc(array, (nelem + 32) * elsize);
207 return array;
208 }
209
210 static mkv_track_t *
211 demux_mkv_find_track_by_num (mkv_demuxer_t *d, int n, int type)
212 {
213 int i, id;
214
215 for (i=0, id=0; i < d->num_tracks; i++)
216 if (d->tracks[i] != NULL && d->tracks[i]->type == type)
217 if (id++ == n)
218 return d->tracks[i];
219
220 return NULL;
221 }
222
223 static void
224 add_cluster_position (mkv_demuxer_t *mkv_d, uint64_t position)
225 {
226 int i = mkv_d->num_cluster_pos;
227
228 while (i--)
229 if (mkv_d->cluster_positions[i] == position)
230 return;
231
232 mkv_d->cluster_positions = grow_array(mkv_d->cluster_positions,
233 mkv_d->num_cluster_pos,
234 sizeof(uint64_t));
235 mkv_d->cluster_positions[mkv_d->num_cluster_pos++] = position;
236 }
237
238
239 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
240 static int
241 aac_get_sample_rate_index (uint32_t sample_rate)
242 {
243 static const int srates[] = {92017, 75132, 55426, 46009, 37566, 27713, 23004, 18783, 13856, 11502, 9391, 0};
244 int i = 0;
245 while (sample_rate < srates[i]) i++;
246 return i;
247 }
248
249 /** \brief Free cached demux packets
250 *
251 * Reordering the timecodes requires caching of demux packets. This function
252 * frees all these cached packets and the memory for the cached pointers
253 * itself.
254 *
255 * \param demuxer The demuxer for which the cache is to be freed.
256 */
257 static void
258 free_cached_dps (demuxer_t *demuxer)
259 {
260 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
261 mkv_track_t *track;
262 int i, k;
263
264 for (k = 0; k < mkv_d->num_tracks; k++)
265 {
266 track = mkv_d->tracks[k];
267 for (i = 0; i < track->num_cached_dps; i++)
268 free_demux_packet (track->cached_dps[i]);
269 free(track->cached_dps);
270 track->cached_dps = NULL;
271 track->num_cached_dps = 0;
272 track->num_allocated_dps = 0;
273 track->max_pts = 0;
274 }
275 }
276
277 static int
278 demux_mkv_decode (mkv_track_t *track, uint8_t *src, uint8_t **dest,
279 uint32_t *size, uint32_t type)
280 {
281 int i, result;
282 int modified = 0;
283
284 *dest = src;
285 if (track->num_encodings <= 0)
286 return 0;
287
288 for (i=0; i<track->num_encodings; i++)
289 {
290 if (!(track->encodings[i].scope & type))
291 continue;
292
293 #if CONFIG_ZLIB
294 if (track->encodings[i].comp_algo == 0)
295 {
296 /* zlib encoded track */
297 z_stream zstream;
298
299 zstream.zalloc = (alloc_func) 0;
300 zstream.zfree = (free_func) 0;
301 zstream.opaque = (voidpf) 0;
302 if (inflateInit (&zstream) != Z_OK)
303 {
304 mp_tmsg (MSGT_DEMUX, MSGL_WARN,
305 "[mkv] zlib initialization failed.\n");
306 return modified;
307 }
308 zstream.next_in = (Bytef *) src;
309 zstream.avail_in = *size;
310
311 modified = 1;
312 *dest = NULL;
313 zstream.avail_out = *size;
314 do {
315 *size += 4000;
316 *dest = realloc (*dest, *size);
317 zstream.next_out = (Bytef *) (*dest + zstream.total_out);
318 result = inflate (&zstream, Z_NO_FLUSH);
319 if (result != Z_OK && result != Z_STREAM_END)
320 {
321 mp_tmsg (MSGT_DEMUX, MSGL_WARN,
322 "[mkv] zlib decompression failed.\n");
323 free(*dest);
324 *dest = NULL;
325 inflateEnd (&zstream);
326 return modified;
327 }
328 zstream.avail_out += 4000;
329 } while (zstream.avail_out == 4000 &&
330 zstream.avail_in != 0 && result != Z_STREAM_END);
331
332 *size = zstream.total_out;
333 inflateEnd (&zstream);
334 }
335 #endif
336 if (track->encodings[i].comp_algo == 2)
337 {
338 /* lzo encoded track */
339 int dstlen = *size * 3;
340
341 *dest = NULL;
342 while (1)
343 {
344 int srclen = *size;
345 if (dstlen > SIZE_MAX - AV_LZO_OUTPUT_PADDING) goto lzo_fail;
346 *dest = realloc (*dest, dstlen + AV_LZO_OUTPUT_PADDING);
347 result = av_lzo1x_decode (*dest, &dstlen, src, &srclen);
348 if (result == 0)
349 break;
350 if (!(result & AV_LZO_OUTPUT_FULL))
351 {
352 lzo_fail:
353 mp_tmsg (MSGT_DEMUX, MSGL_WARN,
354 "[mkv] lzo decompression failed.\n");
355 free(*dest);
356 *dest = NULL;
357 return modified;
358 }
359 mp_msg (MSGT_DEMUX, MSGL_DBG2,
360 "[mkv] lzo decompression buffer too small.\n");
361 dstlen *= 2;
362 }
363 *size = dstlen;
364 }
365 }
366
367 return modified;
368 }
369
370
371 static int demux_mkv_read_info(demuxer_t *demuxer)
372 {
373 mkv_demuxer_t *mkv_d = demuxer->priv;
374 stream_t *s = demuxer->stream;
375 uint64_t length, l;
376 int i;
377 uint64_t tc_scale = 1000000;
378 long double duration = 0.;
379
380 length = ebml_read_length(s, NULL);
381 while (length > 0) {
382 uint32_t id = ebml_read_id(s, &i);
383 length -= i;
384 switch (id) {
385 case MATROSKA_ID_TIMECODESCALE:
386 tc_scale = ebml_read_uint(s, &l);
387 length -= l;
388 if (tc_scale == EBML_UINT_INVALID)
389 return 1;
390 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + timecode scale: %"PRIu64"\n",
391 tc_scale);
392 break;
393
394 case MATROSKA_ID_DURATION:
395 duration = ebml_read_float(s, &l);
396 length -= l;
397 if (duration == EBML_FLOAT_INVALID)
398 return 1;
399 break;
400
401 case MATROSKA_ID_SEGMENTUID:;
402 l = ebml_read_length(s, &i);
403 length -= i;
404 if (l != sizeof(demuxer->matroska_data.segment_uid)) {
405 mp_msg(MSGT_DEMUX, MSGL_INFO,
406 "[mkv] segment uid invalid length %"PRIu64"\n", l);
407 stream_skip(s, l);
408 } else {
409 stream_read(s, demuxer->matroska_data.segment_uid, l);
410 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + segment uid");
411 for (int i = 0; i < l; i++)
412 mp_msg(MSGT_DEMUX, MSGL_V, " %02x",
413 demuxer->matroska_data.segment_uid[i]);
414 mp_msg(MSGT_DEMUX, MSGL_V, "\n");
415 }
416 length -= l;
417 break;
418
419 default:
420 ebml_read_skip(s, &l);
421 length -= l;
422 break;
423 }
424 }
425 mkv_d->tc_scale = tc_scale;
426 mkv_d->duration = duration * tc_scale / 1000000000.0;
427 if (duration)
428 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + duration: %.3fs\n",
429 mkv_d->duration);
430
431 return 0;
432 }
433
434 /**
435 * \brief free array of kv_content_encoding_t
436 * \param encodings pointer to array
437 * \param numencodings number of encodings in array
438 */
439 static void
440 demux_mkv_free_encodings(mkv_content_encoding_t *encodings, int numencodings)
441 {
442 while (numencodings-- > 0)
443 free(encodings[numencodings].comp_settings);
444 free(encodings);
445 }
446
447 static int
448 demux_mkv_read_trackencodings (demuxer_t *demuxer, mkv_track_t *track)
449 {
450 stream_t *s = demuxer->stream;
451 mkv_content_encoding_t *ce, e;
452 uint64_t len, length, l;
453 int il, n;
454
455 ce = malloc (sizeof (*ce));
456 n = 0;
457
458 len = length = ebml_read_length (s, &il);
459 len += il;
460 while (length > 0)
461 {
462 switch (ebml_read_id (s, &il))
463 {
464 case MATROSKA_ID_CONTENTENCODING:
465 {
466 uint64_t len;
467 int i;
468
469 memset (&e, 0, sizeof (e));
470 e.scope = 1;
471
472 len = ebml_read_length (s, &i);
473 l = len + i;
474
475 while (len > 0)
476 {
477 uint64_t num, l;
478 int il;
479
480 switch (ebml_read_id (s, &il))
481 {
482 case MATROSKA_ID_CONTENTENCODINGORDER:
483 num = ebml_read_uint (s, &l);
484 if (num == EBML_UINT_INVALID)
485 goto err_out;
486 e.order = num;
487 break;
488
489 case MATROSKA_ID_CONTENTENCODINGSCOPE:
490 num = ebml_read_uint (s, &l);
491 if (num == EBML_UINT_INVALID)
492 goto err_out;
493 e.scope = num;
494 break;
495
496 case MATROSKA_ID_CONTENTENCODINGTYPE:
497 num = ebml_read_uint (s, &l);
498 if (num == EBML_UINT_INVALID)
499 goto err_out;
500 e.type = num;
501 break;
502
503 case MATROSKA_ID_CONTENTCOMPRESSION:
504 {
505 uint64_t le;
506
507 le = ebml_read_length (s, &i);
508 l = le + i;
509
510 while (le > 0)
511 {
512 uint64_t l;
513 int il;
514
515 switch (ebml_read_id (s, &il))
516 {
517 case MATROSKA_ID_CONTENTCOMPALGO:
518 num = ebml_read_uint (s, &l);
519 if (num == EBML_UINT_INVALID)
520 goto err_out;
521 e.comp_algo = num;
522 break;
523
524 case MATROSKA_ID_CONTENTCOMPSETTINGS:
525 l = ebml_read_length (s, &i);
526 e.comp_settings = malloc (l);
527 stream_read (s, e.comp_settings, l);
528 e.comp_settings_len = l;
529 l += i;
530 break;
531
532 default:
533 ebml_read_skip (s, &l);
534 break;
535 }
536 le -= l + il;
537 }
538
539 if (e.type == 1)
540 {
541 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
542 "[mkv] Track number %u has been encrypted and decryption has not yet been\n[mkv] implemented. Skipping track.\n", track->tnum);
543 }
544 else if (e.type != 0)
545 {
546 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
547 "[mkv] Unknown content encoding type for track %u. Skipping track.\n", track->tnum);
548 }
549
550 if (e.comp_algo != 0 && e.comp_algo != 2)
551 {
552 mp_tmsg (MSGT_DEMUX, MSGL_WARN,
553 "[mkv] Track %u has been compressed with an unknown/unsupported compression\n[mkv] algorithm (%u). Skipping track.\n",
554 track->tnum, e.comp_algo);
555 }
556 #if !CONFIG_ZLIB
557 else if (e.comp_algo == 0)
558 {
559 mp_tmsg (MSGT_DEMUX, MSGL_WARN,
560 "[mkv] Track %u was compressed with zlib but mplayer has not been compiled\n[mkv] with support for zlib compression. Skipping track.\n",
561 track->tnum);
562 }
563 #endif
564
565 break;
566 }
567
568 default:
569 ebml_read_skip (s, &l);
570 break;
571 }
572 len -= l + il;
573 }
574 for (i=0; i<n; i++)
575 if (e.order <= ce[i].order)
576 break;
577 ce = realloc (ce, (n+1) *sizeof (*ce));
578 memmove (ce+i+1, ce+i, (n-i) * sizeof (*ce));
579 memcpy (ce+i, &e, sizeof (e));
580 n++;
581 break;
582 }
583
584 default:
585 ebml_read_skip (s, &l);
586 break;
587 }
588
589 length -= l + il;
590 }
591
592 track->encodings = ce;
593 track->num_encodings = n;
594 return len;
595
596 err_out:
597 demux_mkv_free_encodings(ce, n);
598 return 0;
599 }
600
601 static int
602 demux_mkv_read_trackaudio (demuxer_t *demuxer, mkv_track_t *track)
603 {
604 stream_t *s = demuxer->stream;
605 uint64_t len, length, l;
606 int il;
607
608 track->a_sfreq = 8000.0;
609 track->a_channels = 1;
610
611 len = length = ebml_read_length (s, &il);
612 len += il;
613 while (length > 0)
614 {
615 switch (ebml_read_id (s, &il))
616 {
617 case MATROSKA_ID_AUDIOSAMPLINGFREQ:
618 {
619 long double num = ebml_read_float (s, &l);
620 if (num == EBML_FLOAT_INVALID)
621 return 0;
622 track->a_sfreq = num;
623 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Sampling frequency: %f\n",
624 track->a_sfreq);
625 break;
626 }
627
628 case MATROSKA_ID_AUDIOBITDEPTH:
629 {
630 uint64_t num = ebml_read_uint (s, &l);
631 if (num == EBML_UINT_INVALID)
632 return 0;
633 track->a_bps = num;
634 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Bit depth: %u\n",
635 track->a_bps);
636 break;
637 }
638
639 case MATROSKA_ID_AUDIOCHANNELS:
640 {
641 uint64_t num = ebml_read_uint (s, &l);
642 if (num == EBML_UINT_INVALID)
643 return 0;
644 track->a_channels = num;
645 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Channels: %u\n",
646 track->a_channels);
647 break;
648 }
649
650 default:
651 ebml_read_skip (s, &l);
652 break;
653 }
654 length -= l + il;
655 }
656 return len;
657 }
658
659 static int
660 demux_mkv_read_trackvideo (demuxer_t *demuxer, mkv_track_t *track)
661 {
662 stream_t *s = demuxer->stream;
663 uint64_t len, length, l;
664 int il;
665
666 len = length = ebml_read_length (s, &il);
667 len += il;
668 while (length > 0)
669 {
670 switch (ebml_read_id (s, &il))
671 {
672 case MATROSKA_ID_VIDEOFRAMERATE:
673 {
674 long double num = ebml_read_float (s, &l);
675 if (num == EBML_FLOAT_INVALID)
676 return 0;
677 track->v_frate = num;
678 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Frame rate: %f\n",
679 track->v_frate);
680 if (track->v_frate > 0)
681 track->default_duration = 1 / track->v_frate;
682 break;
683 }
684
685 case MATROSKA_ID_VIDEODISPLAYWIDTH:
686 {
687 uint64_t num = ebml_read_uint (s, &l);
688 if (num == EBML_UINT_INVALID)
689 return 0;
690 track->v_dwidth = num;
691 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Display width: %u\n",
692 track->v_dwidth);
693 break;
694 }
695
696 case MATROSKA_ID_VIDEODISPLAYHEIGHT:
697 {
698 uint64_t num = ebml_read_uint (s, &l);
699 if (num == EBML_UINT_INVALID)
700 return 0;
701 track->v_dheight = num;
702 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Display height: %u\n",
703 track->v_dheight);
704 break;
705 }
706
707 case MATROSKA_ID_VIDEOPIXELWIDTH:
708 {
709 uint64_t num = ebml_read_uint (s, &l);
710 if (num == EBML_UINT_INVALID)
711 return 0;
712 track->v_width = num;
713 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Pixel width: %u\n",
714 track->v_width);
715 break;
716 }
717
718 case MATROSKA_ID_VIDEOPIXELHEIGHT:
719 {
720 uint64_t num = ebml_read_uint (s, &l);
721 if (num == EBML_UINT_INVALID)
722 return 0;
723 track->v_height = num;
724 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Pixel height: %u\n",
725 track->v_height);
726 break;
727 }
728
729 default:
730 ebml_read_skip (s, &l);
731 break;
732 }
733 length -= l + il;
734 }
735 return len;
736 }
737
738 /**
739 * \brief free any data associated with given track
740 * \param track track of which to free data
741 */
742 static void
743 demux_mkv_free_trackentry(mkv_track_t *track) {
744 free (track->name);
745 free (track->codec_id);
746 free (track->language);
747 free (track->private_data);
748 free (track->audio_buf);
749 free (track->audio_timestamp);
750 demux_mkv_free_encodings(track->encodings, track->num_encodings);
751 free(track);
752 }
753
754 static int
755 demux_mkv_read_trackentry (demuxer_t *demuxer)
756 {
757 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
758 stream_t *s = demuxer->stream;
759 mkv_track_t *track;
760 uint64_t len, length, l;
761 int il;
762
763 track = calloc (1, sizeof (*track));
764 /* set default values */
765 track->default_track = 1;
766 track->name = 0;
767 track->language = strdup("eng");
768
769 len = length = ebml_read_length (s, &il);
770 len += il;
771 while (length > 0)
772 {
773 switch (ebml_read_id (s, &il))
774 {
775 case MATROSKA_ID_TRACKNUMBER:
776 {
777 uint64_t num = ebml_read_uint (s, &l);
778 if (num == EBML_UINT_INVALID)
779 goto err_out;
780 track->tnum = num;
781 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Track number: %u\n",
782 track->tnum);
783 break;
784 }
785
786 case MATROSKA_ID_TRACKNAME:
787 {
788 track->name = ebml_read_utf8 (s, &l);
789 if (track->name == NULL)
790 goto err_out;
791 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Name: %s\n",
792 track->name);
793 break;
794 }
795
796 case MATROSKA_ID_TRACKTYPE:
797 {
798 uint64_t num = ebml_read_uint (s, &l);
799 if (num == EBML_UINT_INVALID)
800 return 0;
801 track->type = num;
802 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Track type: ");
803 switch (track->type)
804 {
805 case MATROSKA_TRACK_AUDIO:
806 mp_msg (MSGT_DEMUX, MSGL_V, "Audio\n");
807 break;
808 case MATROSKA_TRACK_VIDEO:
809 mp_msg (MSGT_DEMUX, MSGL_V, "Video\n");
810 break;
811 case MATROSKA_TRACK_SUBTITLE:
812 mp_msg (MSGT_DEMUX, MSGL_V, "Subtitle\n");
813 break;
814 default:
815 mp_msg (MSGT_DEMUX, MSGL_V, "unknown\n");
816 break;
817 }
818 break;
819 }
820
821 case MATROSKA_ID_TRACKAUDIO:
822 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Audio track\n");
823 l = demux_mkv_read_trackaudio (demuxer, track);
824 if (l == 0)
825 goto err_out;
826 break;
827
828 case MATROSKA_ID_TRACKVIDEO:
829 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Video track\n");
830 l = demux_mkv_read_trackvideo (demuxer, track);
831 if (l == 0)
832 goto err_out;
833 break;
834
835 case MATROSKA_ID_CODECID:
836 track->codec_id = ebml_read_ascii (s, &l);
837 if (track->codec_id == NULL)
838 goto err_out;
839 if (!strcmp (track->codec_id, MKV_V_MSCOMP) ||
840 !strcmp (track->codec_id, MKV_A_ACM))
841 track->ms_compat = 1;
842 else if (!strcmp (track->codec_id, MKV_S_VOBSUB))
843 track->subtitle_type = MATROSKA_SUBTYPE_VOBSUB;
844 else if (!strcmp (track->codec_id, MKV_S_TEXTSSA)
845 || !strcmp (track->codec_id, MKV_S_TEXTASS)
846 || !strcmp (track->codec_id, MKV_S_SSA)
847 || !strcmp (track->codec_id, MKV_S_ASS))
848 {
849 track->subtitle_type = MATROSKA_SUBTYPE_SSA;
850 }
851 else if (!strcmp (track->codec_id, MKV_S_TEXTASCII))
852 track->subtitle_type = MATROSKA_SUBTYPE_TEXT;
853 if (!strcmp (track->codec_id, MKV_S_TEXTUTF8))
854 {
855 track->subtitle_type = MATROSKA_SUBTYPE_TEXT;
856 }
857 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Codec ID: %s\n",
858 track->codec_id);
859 break;
860
861 case MATROSKA_ID_CODECPRIVATE:
862 {
863 int x;
864 uint64_t num = ebml_read_length (s, &x);
865 // audit: cheap guard against overflows later..
866 if (num > SIZE_MAX - 1000) return 0;
867 l = x + num;
868 track->private_data = malloc (num + AV_LZO_INPUT_PADDING);
869 if (stream_read(s, track->private_data, num) != (int) num)
870 goto err_out;
871 track->private_size = num;
872 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + CodecPrivate, length "
873 "%u\n", track->private_size);
874 break;
875 }
876
877 case MATROSKA_ID_TRACKLANGUAGE:
878 free(track->language);
879 track->language = ebml_read_utf8 (s, &l);
880 if (track->language == NULL)
881 goto err_out;
882 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Language: %s\n",
883 track->language);
884 break;
885
886 case MATROSKA_ID_TRACKFLAGDEFAULT:
887 {
888 uint64_t num = ebml_read_uint (s, &l);
889 if (num == EBML_UINT_INVALID)
890 goto err_out;
891 track->default_track = num;
892 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Default flag: %u\n",
893 track->default_track);
894 break;
895 }
896
897 case MATROSKA_ID_TRACKDEFAULTDURATION:
898 {
899 uint64_t num = ebml_read_uint (s, &l);
900 if (num == EBML_UINT_INVALID)
901 goto err_out;
902 if (num == 0)
903 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Default duration: 0");
904 else
905 {
906 track->v_frate = 1000000000.0 / num;
907 track->default_duration = num / 1000000000.0;
908 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + Default duration: "
909 "%.3fms ( = %.3f fps)\n",num/1000000.0,track->v_frate);
910 }
911 break;
912 }
913
914 case MATROSKA_ID_TRACKENCODINGS:
915 l = demux_mkv_read_trackencodings (demuxer, track);
916 if (l == 0)
917 goto err_out;
918 break;
919
920 default:
921 ebml_read_skip (s, &l);
922 break;
923 }
924 length -= l + il;
925 }
926
927 mkv_d->tracks[mkv_d->num_tracks++] = track;
928 return len;
929
930 err_out:
931 demux_mkv_free_trackentry(track);
932 return 0;
933 }
934
935 static int
936 demux_mkv_read_tracks (demuxer_t *demuxer)
937 {
938 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
939 stream_t *s = demuxer->stream;
940 uint64_t length, l;
941 int il;
942
943 mkv_d->tracks = malloc (sizeof (*mkv_d->tracks));
944 mkv_d->num_tracks = 0;
945
946 length = ebml_read_length (s, NULL);
947 while (length > 0)
948 {
949 switch (ebml_read_id (s, &il))
950 {
951 case MATROSKA_ID_TRACKENTRY:
952 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + a track...\n");
953 mkv_d->tracks = realloc (mkv_d->tracks,
954 (mkv_d->num_tracks+1)
955 *sizeof (*mkv_d->tracks));
956 l = demux_mkv_read_trackentry (demuxer);
957 if (l == 0)
958 return 1;
959 break;
960
961 default:
962 ebml_read_skip (s, &l);
963 break;
964 }
965 length -= l + il;
966 }
967 return 0;
968 }
969
970 static int
971 demux_mkv_read_cues (demuxer_t *demuxer)
972 {
973 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
974 stream_t *s = demuxer->stream;
975 uint64_t length, l, time, track, pos;
976 off_t off;
977 int i, il;
978
979 if (index_mode == 0) {
980 ebml_read_skip (s, NULL);
981 return 0;
982 }
983 off = stream_tell (s);
984 for (i=0; i<mkv_d->parsed_cues_num; i++)
985 if (mkv_d->parsed_cues[i] == off)
986 {
987 ebml_read_skip (s, NULL);
988 return 0;
989 }
990 mkv_d->parsed_cues = realloc (mkv_d->parsed_cues,
991 (mkv_d->parsed_cues_num+1)
992 * sizeof (off_t));
993 mkv_d->parsed_cues[mkv_d->parsed_cues_num++] = off;
994
995 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing cues ] -----------\n");
996 length = ebml_read_length (s, NULL);
997
998 while (length > 0)
999 {
1000 time = track = pos = EBML_UINT_INVALID;
1001
1002 switch (ebml_read_id (s, &il))
1003 {
1004 case MATROSKA_ID_POINTENTRY:
1005 {
1006 uint64_t len;
1007
1008 len = ebml_read_length (s, &i);
1009 l = len + i;
1010
1011 while (len > 0)
1012 {
1013 uint64_t l;
1014 int il;
1015
1016 switch (ebml_read_id (s, &il))
1017 {
1018 case MATROSKA_ID_CUETIME:
1019 time = ebml_read_uint (s, &l);
1020 break;
1021
1022 case MATROSKA_ID_CUETRACKPOSITION:
1023 {
1024 uint64_t le;
1025
1026 le = ebml_read_length (s, &i);
1027 l = le + i;
1028
1029 while (le > 0)
1030 {
1031 uint64_t l;
1032 int il;
1033
1034 switch (ebml_read_id (s, &il))
1035 {
1036 case MATROSKA_ID_CUETRACK:
1037 track = ebml_read_uint (s, &l);
1038 break;
1039
1040 case MATROSKA_ID_CUECLUSTERPOSITION:
1041 pos = ebml_read_uint (s, &l);
1042 break;
1043
1044 default:
1045 ebml_read_skip (s, &l);
1046 break;
1047 }
1048 le -= l + il;
1049 }
1050 break;
1051 }
1052
1053 default:
1054 ebml_read_skip (s, &l);
1055 break;
1056 }
1057 len -= l + il;
1058 }
1059 break;
1060 }
1061
1062 default:
1063 ebml_read_skip (s, &l);
1064 break;
1065 }
1066
1067 length -= l + il;
1068
1069 if (time != EBML_UINT_INVALID && track != EBML_UINT_INVALID
1070 && pos != EBML_UINT_INVALID)
1071 {
1072 mkv_d->indexes = grow_array(mkv_d->indexes, mkv_d->num_indexes,
1073 sizeof(mkv_index_t));
1074 mkv_d->indexes[mkv_d->num_indexes].tnum = track;
1075 mkv_d->indexes[mkv_d->num_indexes].timecode = time;
1076 mkv_d->indexes[mkv_d->num_indexes].filepos =mkv_d->segment_start+pos;
1077 mp_msg (MSGT_DEMUX, MSGL_DBG2, "[mkv] |+ found cue point "
1078 "for track %"PRIu64": timecode %"PRIu64", filepos: %"PRIu64"\n",
1079 track, time, mkv_d->segment_start + pos);
1080 mkv_d->num_indexes++;
1081 }
1082 }
1083
1084 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing cues ] -----------\n");
1085 return 0;
1086 }
1087
1088 static uint64_t read_one_chapter(struct demuxer *demuxer, stream_t *s,
1089 struct matroska_chapter *chapters,
1090 int chapter_num)
1091 {
1092 uint64_t len, l;
1093 uint64_t start = 0, end = 0;
1094 struct matroska_chapter chapter = {};
1095 char *name = 0;
1096 int i;
1097 uint32_t id;
1098 bool badchapter = false;
1099
1100 len = ebml_read_length(s, &i);
1101 uint64_t bytes_read = len + i;
1102
1103 while (len > 0) {
1104 id = ebml_read_id(s, &i);
1105 len -= i;
1106 switch (id) {
1107 case MATROSKA_ID_CHAPTERTIMESTART:
1108 start = ebml_read_uint(s, &l) / 1000000;
1109 len -= l;
1110 break;
1111
1112 case MATROSKA_ID_CHAPTERTIMEEND:
1113 end = ebml_read_uint(s, &l) / 1000000;
1114 len -= l;
1115 break;
1116
1117 case MATROSKA_ID_CHAPTERDISPLAY:;
1118 uint64_t displaylen = ebml_read_length(s, &i);
1119 len -= displaylen + i;
1120 while (displaylen > 0) {
1121 id = ebml_read_id(s, &i);
1122 displaylen -= i;
1123 switch (id) {
1124 case MATROSKA_ID_CHAPSTRING:
1125 name = ebml_read_utf8(s, &l);
1126 break;
1127 default:
1128 ebml_read_skip(s, &l);
1129 break;
1130 }
1131 displaylen -= l;
1132 }
1133 break;
1134
1135 case MATROSKA_ID_CHAPTERSEGMENTUID:
1136 l = ebml_read_length(s, &i);
1137 len -= l + i;
1138 if (l != sizeof(chapter.segment_uid)) {
1139 mp_msg(MSGT_DEMUX, MSGL_INFO,
1140 "[mkv] chapter segment uid invalid length %"PRIu64"\n",
1141 l);
1142 stream_skip(s, l);
1143 } else {
1144 stream_read(s, chapter.segment_uid, l);
1145 chapter.has_segment_uid = true;
1146 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Chapter segment uid ");
1147 for (int i = 0; i < l; i++)
1148 mp_msg(MSGT_DEMUX, MSGL_V, "%02x ", chapter.segment_uid[i]);
1149 mp_msg(MSGT_DEMUX, MSGL_V, "\n");
1150 }
1151 break;
1152
1153 case MATROSKA_ID_CHAPTERSEGMENTEDITIONUID:
1154 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
1155 "[mkv] Warning: unsupported edition recursion in chapter; "
1156 "will skip on playback!\n");
1157 ebml_read_skip(s, &l);
1158 len -= l;
1159 badchapter = true;
1160 break;
1161
1162 default:
1163 ebml_read_skip(s, &l);
1164 len -= l;
1165 break;
1166 }
1167 }
1168
1169 if (!name)
1170 name = strdup("(unnamed)");
1171
1172 chapter.start = start;
1173 chapter.end = end;
1174 chapter.name = talloc_strdup(chapters, name);
1175 chapters[chapter_num] = chapter;
1176
1177 if (badchapter) {
1178 memset(&chapter.segment_uid, 0, sizeof(chapter.segment_uid));
1179 goto cleanup;
1180 }
1181
1182 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Chapter %u from %02d:%02d:%02d."
1183 "%03d to %02d:%02d:%02d.%03d, %s\n",
1184 chapter_num,
1185 (int) (start / 60 / 60 / 1000),
1186 (int) ((start / 60 / 1000) % 60),
1187 (int) ((start / 1000) % 60),
1188 (int) (start % 1000),
1189 (int) (end / 60 / 60 / 1000),
1190 (int) ((end / 60 / 1000) % 60),
1191 (int) ((end / 1000) % 60),
1192 (int) (end % 1000), name);
1193
1194 cleanup:
1195 free(name);
1196 return bytes_read;
1197 }
1198
1199 static int demux_mkv_read_chapters(struct demuxer *demuxer)
1200 {
1201 struct MPOpts *opts = demuxer->opts;
1202 stream_t *s = demuxer->stream;
1203 uint64_t length, l;
1204 int i;
1205 uint32_t id;
1206
1207 if (demuxer->chapters) {
1208 ebml_read_skip(s, NULL);
1209 return 0;
1210 }
1211
1212 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing chapters ] ---------\n");
1213 length = ebml_read_length(s, NULL);
1214
1215 struct matroska_chapter *selected_chapters = NULL;
1216 int num_selected_chapters = 0;
1217 bool have_default = false;
1218 bool have_user_specified = false;
1219 int selected_edition = -1;
1220 bool se_is_ordered = false;
1221 int cur_idx = -1;
1222 while (length > 0) {
1223 id = ebml_read_id(s, &i);
1224 length -= i;
1225 switch (id) {
1226 case MATROSKA_ID_EDITIONENTRY:
1227 cur_idx++;
1228 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] New edition %d\n", cur_idx);
1229 uint64_t editionlen = ebml_read_length(s, &i);
1230 length -= editionlen + i;
1231 bool defaultflag = false;
1232 bool ordered = false;
1233 struct matroska_chapter *chapters = NULL;
1234 int num_chapters = 0;
1235 while (editionlen > 0) {
1236 id = ebml_read_id(s, &i);
1237 editionlen -= i;
1238 switch (id) {
1239 case MATROSKA_ID_CHAPTERATOM:
1240 chapters = talloc_realloc(demuxer, chapters,
1241 struct matroska_chapter,
1242 num_chapters + 1);
1243 l = read_one_chapter(demuxer, s, chapters, num_chapters++);
1244 break;
1245 case MATROSKA_ID_EDITIONFLAGDEFAULT:
1246 defaultflag = ebml_read_uint(s, &l);
1247 mp_msg(MSGT_DEMUX, MSGL_V,
1248 "[mkv] Default edition flag: %d\n", defaultflag);
1249 break;
1250 case MATROSKA_ID_EDITIONFLAGORDERED:
1251 ordered = ebml_read_uint(s, &l);
1252 mp_msg(MSGT_DEMUX, MSGL_V,
1253 "[mkv] Ordered chapter flag: %d\n", ordered);
1254 break;
1255
1256 default:
1257 ebml_read_skip(s, &l);
1258 break;
1259 }
1260 editionlen -= l;
1261 }
1262 if (cur_idx == opts->edition_id) {
1263 have_user_specified = true;
1264 mp_msg(MSGT_DEMUX, MSGL_V,
1265 "[mkv] Found user-selected edition\n");
1266 } else if (!have_user_specified && !have_default && defaultflag) {
1267 have_default = true;
1268 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Default edition: %d\n",
1269 cur_idx);
1270 } else if (selected_edition < 0) {
1271 ;
1272 } else {
1273 talloc_free(chapters);
1274 break;
1275 }
1276 selected_edition = cur_idx;
1277 talloc_free(selected_chapters);
1278 selected_chapters = chapters;
1279 num_selected_chapters = num_chapters;
1280 se_is_ordered = ordered;
1281 break;
1282
1283 default:
1284 ebml_read_skip(s, &l);
1285 length -= l;
1286 break;
1287 }
1288 }
1289 if (cur_idx > 0)
1290 mp_msg(MSGT_DEMUX, MSGL_INFO,
1291 "[mkv] Found %d editions, will play #%d (first is 0).\n",
1292 cur_idx + 1, selected_edition);
1293
1294 for (i = 0; i < num_selected_chapters; i++)
1295 demuxer_add_chapter(demuxer, selected_chapters[i].name,
1296 selected_chapters[i].start,
1297 selected_chapters[i].end);
1298 struct matroska_data *m = &demuxer->matroska_data;
1299 talloc_free(m->ordered_chapters);
1300 if (se_is_ordered) {
1301 m->ordered_chapters = selected_chapters;
1302 m->num_ordered_chapters = num_selected_chapters;
1303 } else {
1304 m->ordered_chapters = NULL;
1305 m->num_ordered_chapters = 0;
1306 talloc_free(selected_chapters);
1307 }
1308
1309 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing chapters ] ---------\n");
1310 return 0;
1311 }
1312
1313 static int
1314 demux_mkv_read_tags (demuxer_t *demuxer)
1315 {
1316 ebml_read_skip (demuxer->stream, NULL);
1317 return 0;
1318 }
1319
1320 static int
1321 demux_mkv_read_attachments (demuxer_t *demuxer)
1322 {
1323 stream_t *s = demuxer->stream;
1324 uint64_t length, l;
1325 int il;
1326
1327 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing attachments ] ---------\n");
1328 length = ebml_read_length (s, NULL);
1329
1330 while (length > 0)
1331 {
1332 switch (ebml_read_id (s, &il))
1333 {
1334 case MATROSKA_ID_ATTACHEDFILE:
1335 {
1336 uint64_t len;
1337 int i;
1338 char* name = NULL;
1339 char* mime = NULL;
1340 char* data = NULL;
1341 int data_size = 0;
1342
1343 len = ebml_read_length (s, &i);
1344 l = len + i;
1345
1346 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + an attachment...\n");
1347
1348 while (len > 0)
1349 {
1350 uint64_t l;
1351 int il;
1352
1353 switch (ebml_read_id (s, &il))
1354 {
1355 case MATROSKA_ID_FILENAME:
1356 free(name);
1357 name = ebml_read_utf8 (s, &l);
1358 if (name == NULL)
1359 goto error;
1360 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + FileName: %s\n",
1361 name);
1362 break;
1363
1364 case MATROSKA_ID_FILEMIMETYPE:
1365 free(mime);
1366 mime = ebml_read_ascii (s, &l);
1367 if (mime == NULL)
1368 goto error;
1369 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + FileMimeType: %s\n",
1370 mime);
1371 break;
1372
1373 case MATROSKA_ID_FILEDATA:
1374 {
1375 int x;
1376 uint64_t num = ebml_read_length (s, &x);
1377 l = x + num;
1378 free(data);
1379 data = malloc (num);
1380 if (stream_read(s, data, num) != (int) num)
1381 {
1382 error:
1383 free(data);
1384 free(mime);
1385 free(name);
1386 return 0;
1387 }
1388 data_size = num;
1389 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] | + FileData, length "
1390 "%u\n", data_size);
1391 break;
1392 }
1393
1394 default:
1395 ebml_read_skip (s, &l);
1396 break;
1397 }
1398 len -= l + il;
1399 }
1400
1401 demuxer_add_attachment(demuxer, name, mime, data, data_size);
1402 free(data);
1403 free(mime);
1404 free(name);
1405 mp_msg(MSGT_DEMUX, MSGL_V,
1406 "[mkv] Attachment: %s, %s, %u bytes\n",
1407 name, mime, data_size);
1408 break;
1409 }
1410
1411 default:
1412 ebml_read_skip (s, &l);
1413 break;
1414 }
1415 length -= l + il;
1416 }
1417
1418 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing attachments ] ---------\n");
1419 return 0;
1420 }
1421
1422 static int
1423 demux_mkv_read_seekhead (demuxer_t *demuxer)
1424 {
1425 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1426 stream_t *s = demuxer->stream;
1427 uint64_t length, l, seek_pos, saved_pos, num;
1428 uint32_t seek_id;
1429 int i, il, res = 0;
1430 off_t off;
1431
1432 off = stream_tell (s);
1433 for (i=0; i<mkv_d->parsed_seekhead_num; i++)
1434 if (mkv_d->parsed_seekhead[i] == off)
1435 {
1436 ebml_read_skip (s, NULL);
1437 return 0;
1438 }
1439 mkv_d->parsed_seekhead = realloc (mkv_d->parsed_seekhead,
1440 (mkv_d->parsed_seekhead_num+1)
1441 * sizeof (off_t));
1442 mkv_d->parsed_seekhead[mkv_d->parsed_seekhead_num++] = off;
1443
1444 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing seek head ] ---------\n");
1445 length = ebml_read_length (s, NULL);
1446 /* off now holds the position of the next element after the seek head. */
1447 off = stream_tell (s) + length;
1448 while (length > 0 && !res)
1449 {
1450
1451 seek_id = 0;
1452 seek_pos = EBML_UINT_INVALID;
1453
1454 switch (ebml_read_id (s, &il))
1455 {
1456 case MATROSKA_ID_SEEKENTRY:
1457 {
1458 uint64_t len;
1459
1460 len = ebml_read_length (s, &i);
1461 l = len + i;
1462
1463 while (len > 0)
1464 {
1465 uint64_t l;
1466 int il;
1467
1468 switch (ebml_read_id (s, &il))
1469 {
1470 case MATROSKA_ID_SEEKID:
1471 num = ebml_read_uint (s, &l);
1472 if (num != EBML_UINT_INVALID)
1473 seek_id = num;
1474 break;
1475
1476 case MATROSKA_ID_SEEKPOSITION:
1477 seek_pos = ebml_read_uint (s, &l);
1478 break;
1479
1480 default:
1481 ebml_read_skip (s, &l);
1482 break;
1483 }
1484 len -= l + il;
1485 }
1486
1487 break;
1488 }
1489
1490 default:
1491 ebml_read_skip (s, &l);
1492 break;
1493 }
1494 length -= l + il;
1495
1496 if (seek_id == 0 || seek_id == MATROSKA_ID_CLUSTER
1497 || seek_pos == EBML_UINT_INVALID ||
1498 ((mkv_d->segment_start + seek_pos) >= (uint64_t)demuxer->movi_end))
1499 continue;
1500
1501 saved_pos = stream_tell (s);
1502 if (!stream_seek (s, mkv_d->segment_start + seek_pos))
1503 res = 1;
1504 else
1505 {
1506 if (ebml_read_id (s, &il) != seek_id)
1507 res = 1;
1508 else
1509 switch (seek_id)
1510 {
1511 case MATROSKA_ID_CUES:
1512 if (demux_mkv_read_cues (demuxer))
1513 res = 1;
1514 break;
1515
1516 case MATROSKA_ID_TAGS:
1517 if (demux_mkv_read_tags (demuxer))
1518 res = 1;
1519 break;
1520
1521 case MATROSKA_ID_SEEKHEAD:
1522 if (demux_mkv_read_seekhead (demuxer))
1523 res = 1;
1524 break;
1525
1526 case MATROSKA_ID_CHAPTERS:
1527 if (demux_mkv_read_chapters (demuxer))
1528 res = 1;
1529 break;
1530 }
1531 }
1532
1533 stream_seek (s, saved_pos);
1534 }
1535 if (res)
1536 {
1537 /* If there was an error then try to skip this seek head. */
1538 if (stream_seek (s, off))
1539 res = 0;
1540 }
1541 else
1542 if (length > 0)
1543 stream_seek (s, stream_tell (s) + length);
1544 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing seek head ] ---------\n");
1545 return res;
1546 }
1547
1548 static int
1549 demux_mkv_open_video (demuxer_t *demuxer, mkv_track_t *track, int vid);
1550 static int
1551 demux_mkv_open_audio (demuxer_t *demuxer, mkv_track_t *track, int aid);
1552 static int
1553 demux_mkv_open_sub (demuxer_t *demuxer, mkv_track_t *track, int sid);
1554
1555 static void
1556 display_create_tracks (demuxer_t *demuxer)
1557 {
1558 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *)demuxer->priv;
1559 int i, vid=0, aid=0, sid=0;
1560
1561 for (i=0; i<mkv_d->num_tracks; i++)
1562 {
1563 char *type = "unknown", str[32];
1564 *str = '\0';
1565 switch (mkv_d->tracks[i]->type)
1566 {
1567 case MATROSKA_TRACK_VIDEO:
1568 type = "video";
1569 demux_mkv_open_video(demuxer, mkv_d->tracks[i], vid);
1570 if (mkv_d->tracks[i]->name)
1571 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VID_%d_NAME=%s\n", vid, mkv_d->tracks[i]->name);
1572 sprintf (str, "-vid %u", vid++);
1573 break;
1574 case MATROSKA_TRACK_AUDIO:
1575 type = "audio";
1576 demux_mkv_open_audio(demuxer, mkv_d->tracks[i], aid);
1577 if (mkv_d->tracks[i]->name)
1578 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_NAME=%s\n", aid, mkv_d->tracks[i]->name);
1579 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_LANG=%s\n", aid, mkv_d->tracks[i]->language);
1580 sprintf (str, "-aid %u, -alang %.5s",aid++,mkv_d->tracks[i]->language);
1581 break;
1582 case MATROSKA_TRACK_SUBTITLE:
1583 type = "subtitles";
1584 demux_mkv_open_sub(demuxer, mkv_d->tracks[i], sid);
1585 if (mkv_d->tracks[i]->name)
1586 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_NAME=%s\n", sid, mkv_d->tracks[i]->name);
1587 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_LANG=%s\n", sid, mkv_d->tracks[i]->language);
1588 sprintf (str, "-sid %u, -slang %.5s",sid++,mkv_d->tracks[i]->language);
1589 break;
1590 }
1591 if (mkv_d->tracks[i]->name)
1592 mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] Track ID %u: %s (%s) \"%s\", %s\n",
1593 mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id, mkv_d->tracks[i]->name, str);
1594 else
1595 mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] Track ID %u: %s (%s), %s\n",
1596 mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id, str);
1597 }
1598 }
1599
1600 typedef struct {
1601 char *id;
1602 int fourcc;
1603 int extradata;
1604 } videocodec_info_t;
1605
1606 static const videocodec_info_t vinfo[] = {
1607 { MKV_V_MPEG1, mmioFOURCC('m', 'p', 'g', '1'), 0 },
1608 { MKV_V_MPEG2, mmioFOURCC('m', 'p', 'g', '2'), 0 },
1609 { MKV_V_MPEG4_SP, mmioFOURCC('m', 'p', '4', 'v'), 1 },
1610 { MKV_V_MPEG4_ASP, mmioFOURCC('m', 'p', '4', 'v'), 1 },
1611 { MKV_V_MPEG4_AP, mmioFOURCC('m', 'p', '4', 'v'), 1 },
1612 { MKV_V_MPEG4_AVC, mmioFOURCC('a', 'v', 'c', '1'), 1 },
1613 { MKV_V_THEORA, mmioFOURCC('t', 'h', 'e', 'o'), 1 },
1614 { NULL, 0, 0 }
1615 };
1616
1617 static int
1618 demux_mkv_open_video (demuxer_t *demuxer, mkv_track_t *track, int vid)
1619 {
1620 struct MPOpts *opts = demuxer->opts;
1621 BITMAPINFOHEADER *bih;
1622 void *ImageDesc = NULL;
1623 sh_video_t *sh_v;
1624
1625 if (track->ms_compat) /* MS compatibility mode */
1626 {
1627 BITMAPINFOHEADER *src;
1628
1629 if (track->private_data == NULL
1630 || track->private_size < sizeof (BITMAPINFOHEADER))
1631 return 1;
1632
1633 src = (BITMAPINFOHEADER *) track->private_data;
1634 bih = calloc (1, track->private_size);
1635 bih->biSize = le2me_32 (src->biSize);
1636 bih->biWidth = le2me_32 (src->biWidth);
1637 bih->biHeight = le2me_32 (src->biHeight);
1638 bih->biPlanes = le2me_16 (src->biPlanes);
1639 bih->biBitCount = le2me_16 (src->biBitCount);
1640 bih->biCompression = le2me_32 (src->biCompression);
1641 bih->biSizeImage = le2me_32 (src->biSizeImage);
1642 bih->biXPelsPerMeter = le2me_32 (src->biXPelsPerMeter);
1643 bih->biYPelsPerMeter = le2me_32 (src->biYPelsPerMeter);
1644 bih->biClrUsed = le2me_32 (src->biClrUsed);
1645 bih->biClrImportant = le2me_32 (src->biClrImportant);
1646 memcpy((char *) bih + sizeof (BITMAPINFOHEADER),
1647 (char *) src + sizeof (BITMAPINFOHEADER),
1648 track->private_size - sizeof (BITMAPINFOHEADER));
1649
1650 if (track->v_width == 0)
1651 track->v_width = bih->biWidth;
1652 if (track->v_height == 0)
1653 track->v_height = bih->biHeight;
1654 }
1655 else
1656 {
1657 bih = calloc (1, sizeof (BITMAPINFOHEADER));
1658 bih->biSize = sizeof (BITMAPINFOHEADER);
1659 bih->biWidth = track->v_width;
1660 bih->biHeight = track->v_height;
1661 bih->biBitCount = 24;
1662 bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount/8;
1663
1664 if (track->private_size >= RVPROPERTIES_SIZE
1665 && (!strcmp (track->codec_id, MKV_V_REALV10)
1666 || !strcmp (track->codec_id, MKV_V_REALV20)
1667 || !strcmp (track->codec_id, MKV_V_REALV30)
1668 || !strcmp (track->codec_id, MKV_V_REALV40)))
1669 {
1670 unsigned char *dst, *src;
1671 uint32_t type2;
1672 unsigned int cnt;
1673
1674 src = (uint8_t *)track->private_data + RVPROPERTIES_SIZE;
1675
1676 cnt = track->private_size - RVPROPERTIES_SIZE;
1677 bih = realloc(bih, sizeof (BITMAPINFOHEADER)+8+cnt);
1678 bih->biSize = 48+cnt;
1679 bih->biPlanes = 1;
1680 type2 = AV_RB32(src - 4);
1681 if (type2 == 0x10003000 || type2 == 0x10003001)
1682 bih->biCompression=mmioFOURCC('R','V','1','3');
1683 else
1684 bih->biCompression=mmioFOURCC('R','V',track->codec_id[9],'0');
1685 dst = (unsigned char *) (bih + 1);
1686 // copy type1 and type2 info from rv properties
1687 memcpy(dst, src - 8, 8);
1688 stream_read(demuxer->stream, dst+8, cnt);
1689 track->realmedia = 1;
1690
1691 #ifdef CONFIG_QTX_CODECS
1692 }
1693 else if (track->private_size >= sizeof (ImageDescription)
1694 && !strcmp(track->codec_id, MKV_V_QUICKTIME))
1695 {
1696 ImageDescriptionPtr idesc;
1697
1698 idesc = (ImageDescriptionPtr) track->private_data;
1699 idesc->idSize = be2me_32 (idesc->idSize);
1700 idesc->cType = be2me_32 (idesc->cType);
1701 idesc->version = be2me_16 (idesc->version);
1702 idesc->revisionLevel = be2me_16 (idesc->revisionLevel);
1703 idesc->vendor = be2me_32 (idesc->vendor);
1704 idesc->temporalQuality = be2me_32 (idesc->temporalQuality);
1705 idesc->spatialQuality = be2me_32 (idesc->spatialQuality);
1706 idesc->width = be2me_16 (idesc->width);
1707 idesc->height = be2me_16 (idesc->height);
1708 idesc->hRes = be2me_32 (idesc->hRes);
1709 idesc->vRes = be2me_32 (idesc->vRes);
1710 idesc->dataSize = be2me_32 (idesc->dataSize);
1711 idesc->frameCount = be2me_16 (idesc->frameCount);
1712 idesc->depth = be2me_16 (idesc->depth);
1713 idesc->clutID = be2me_16 (idesc->clutID);
1714 bih->biPlanes = 1;
1715 bih->biCompression = idesc->cType;
1716 ImageDesc = idesc;
1717 #endif /* CONFIG_QTX_CODECS */
1718
1719 }
1720 else
1721 {
1722 const videocodec_info_t *vi = vinfo;
1723 while (vi->id && strcmp(vi->id, track->codec_id)) vi++;
1724 bih->biCompression = vi->fourcc;
1725 if (vi->extradata && track->private_data && (track->private_size > 0))
1726 {
1727 bih->biSize += track->private_size;
1728 bih = realloc (bih, bih->biSize);
1729 memcpy (bih + 1, track->private_data, track->private_size);
1730 }
1731 track->reorder_timecodes = opts->user_correct_pts == 0;
1732 if (!vi->id) {
1733 mp_tmsg (MSGT_DEMUX,MSGL_WARN, "[mkv] Unknown/unsupported CodecID (%s) or missing/bad CodecPrivate\n[mkv] data (track %u).\n",
1734 track->codec_id, track->tnum);
1735 free(bih);
1736 return 1;
1737 }
1738 }
1739 }
1740
1741 sh_v = new_sh_video_vid (demuxer, track->tnum, vid);
1742 sh_v->bih = bih;
1743 sh_v->format = sh_v->bih->biCompression;
1744 if (track->v_frate == 0.0)
1745 track->v_frate = 25.0;
1746 sh_v->fps = track->v_frate;
1747 sh_v->frametime = 1 / track->v_frate;
1748 sh_v->aspect = 0;
1749 if (!track->realmedia)
1750 {
1751 sh_v->disp_w = track->v_width;
1752 sh_v->disp_h = track->v_height;
1753 if (track->v_dheight)
1754 sh_v->aspect = (double)track->v_dwidth / track->v_dheight;
1755 }
1756 else
1757 {
1758 // vd_realvid.c will set aspect to disp_w/disp_h and rederive
1759 // disp_w and disp_h from the RealVideo stream contents returned
1760 // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
1761 // the Matroska file then it has already been set to PixelWidth/Height
1762 // by check_track_information.
1763 sh_v->disp_w = track->v_dwidth;
1764 sh_v->disp_h = track->v_dheight;
1765 }
1766 sh_v->ImageDesc = ImageDesc;
1767 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] Aspect: %f\n", sh_v->aspect);
1768
1769 sh_v->ds = demuxer->video;
1770 return 0;
1771 }
1772
1773 static int
1774 demux_mkv_open_audio (demuxer_t *demuxer, mkv_track_t *track, int aid)
1775 {
1776 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1777 sh_audio_t *sh_a = new_sh_audio_aid(demuxer, track->tnum, aid);
1778 if(!sh_a) return 1;
1779 mkv_d->audio_tracks[mkv_d->last_aid] = track->tnum;
1780
1781 if (track->language && (strcmp(track->language, "und") != 0))
1782 sh_a->lang = strdup(track->language);
1783 sh_a->default_track = track->default_track;
1784 sh_a->ds = demuxer->audio;
1785 sh_a->wf = malloc (sizeof (WAVEFORMATEX));
1786 if (track->ms_compat && (track->private_size >= sizeof(WAVEFORMATEX)))
1787 {
1788 WAVEFORMATEX *wf = (WAVEFORMATEX *)track->private_data;
1789 sh_a->wf = realloc(sh_a->wf, track->private_size);
1790 sh_a->wf->wFormatTag = le2me_16 (wf->wFormatTag);
1791 sh_a->wf->nChannels = le2me_16 (wf->nChannels);
1792 sh_a->wf->nSamplesPerSec = le2me_32 (wf->nSamplesPerSec);
1793 sh_a->wf->nAvgBytesPerSec = le2me_32 (wf->nAvgBytesPerSec);
1794 sh_a->wf->nBlockAlign = le2me_16 (wf->nBlockAlign);
1795 sh_a->wf->wBitsPerSample = le2me_16 (wf->wBitsPerSample);
1796 sh_a->wf->cbSize = track->private_size - sizeof(WAVEFORMATEX);
1797 memcpy(sh_a->wf + 1, wf + 1, track->private_size - sizeof(WAVEFORMATEX));
1798 if (track->a_sfreq == 0.0)
1799 track->a_sfreq = sh_a->wf->nSamplesPerSec;
1800 if (track->a_channels == 0)
1801 track->a_channels = sh_a->wf->nChannels;
1802 if (track->a_bps == 0)
1803 track->a_bps = sh_a->wf->wBitsPerSample;
1804 track->a_formattag = sh_a->wf->wFormatTag;
1805 }
1806 else
1807 {
1808 memset(sh_a->wf, 0, sizeof (WAVEFORMATEX));
1809 if (!strcmp(track->codec_id, MKV_A_MP3) ||
1810 !strcmp(track->codec_id, MKV_A_MP2))
1811 track->a_formattag = 0x0055;
1812 else if (!strncmp(track->codec_id, MKV_A_AC3, strlen(MKV_A_AC3)))
1813 track->a_formattag = 0x2000;
1814 else if (!strcmp(track->codec_id, MKV_A_DTS))
1815 track->a_formattag = 0x2001;
1816 else if (!strcmp(track->codec_id, MKV_A_PCM) ||
1817 !strcmp(track->codec_id, MKV_A_PCM_BE))
1818 track->a_formattag = 0x0001;
1819 else if (!strcmp(track->codec_id, MKV_A_AAC_2MAIN) ||
1820 !strncmp(track->codec_id, MKV_A_AAC_2LC,
1821 strlen(MKV_A_AAC_2LC)) ||
1822 !strcmp(track->codec_id, MKV_A_AAC_2SSR) ||
1823 !strcmp(track->codec_id, MKV_A_AAC_4MAIN) ||
1824 !strncmp(track->codec_id, MKV_A_AAC_4LC,
1825 strlen(MKV_A_AAC_4LC)) ||
1826 !strcmp(track->codec_id, MKV_A_AAC_4SSR) ||
1827 !strcmp(track->codec_id, MKV_A_AAC_4LTP) ||
1828 !strcmp(track->codec_id, MKV_A_AAC))
1829 track->a_formattag = mmioFOURCC('M', 'P', '4', 'A');
1830 else if (!strcmp(track->codec_id, MKV_A_VORBIS))
1831 {
1832 if (track->private_data == NULL)
1833 return 1;
1834 track->a_formattag = mmioFOURCC('v', 'r', 'b', 's');
1835 }
1836 else if (!strcmp(track->codec_id, MKV_A_QDMC))
1837 track->a_formattag = mmioFOURCC('Q', 'D', 'M', 'C');
1838 else if (!strcmp(track->codec_id, MKV_A_QDMC2))
1839 track->a_formattag = mmioFOURCC('Q', 'D', 'M', '2');
1840 else if (!strcmp(track->codec_id, MKV_A_WAVPACK))
1841 track->a_formattag = mmioFOURCC('W', 'V', 'P', 'K');
1842 else if (!strcmp(track->codec_id, MKV_A_TRUEHD))
1843 track->a_formattag = mmioFOURCC('T', 'R', 'H', 'D');
1844 else if (!strcmp(track->codec_id, MKV_A_FLAC))
1845 {
1846 if (track->private_data == NULL || track->private_size == 0)
1847 {
1848 mp_tmsg (MSGT_DEMUX, MSGL_WARN,
1849 "[mkv] FLAC track does not contain valid headers.\n");
1850 return 1;
1851 }
1852 track->a_formattag = mmioFOURCC ('f', 'L', 'a', 'C');
1853 }
1854 else if (track->private_size >= RAPROPERTIES4_SIZE)
1855 {
1856 if (!strcmp(track->codec_id, MKV_A_REAL28))
1857 track->a_formattag = mmioFOURCC('2', '8', '_', '8');
1858 else if (!strcmp(track->codec_id, MKV_A_REALATRC))
1859 track->a_formattag = mmioFOURCC('a', 't', 'r', 'c');
1860 else if (!strcmp(track->codec_id, MKV_A_REALCOOK))
1861 track->a_formattag = mmioFOURCC('c', 'o', 'o', 'k');
1862 else if (!strcmp(track->codec_id, MKV_A_REALDNET))
1863 track->a_formattag = mmioFOURCC('d', 'n', 'e', 't');
1864 else if (!strcmp(track->codec_id, MKV_A_REALSIPR))
1865 track->a_formattag = mmioFOURCC('s', 'i', 'p', 'r');
1866 }
1867 else
1868 {
1869 mp_tmsg (MSGT_DEMUX, MSGL_WARN, "[mkv] Unknown/unsupported audio codec ID '%s' for track %u or missing/faulty\n[mkv] private codec data.\n",
1870 track->codec_id, track->tnum);
1871 free_sh_audio(demuxer, track->tnum);
1872 return 1;
1873 }
1874 }
1875
1876 sh_a->format = track->a_formattag;
1877 sh_a->wf->wFormatTag = track->a_formattag;
1878 sh_a->channels = track->a_channels;
1879 sh_a->wf->nChannels = track->a_channels;
1880 sh_a->samplerate = (uint32_t) track->a_sfreq;
1881 sh_a->wf->nSamplesPerSec = (uint32_t) track->a_sfreq;
1882 if (track->a_bps == 0)
1883 {
1884 sh_a->samplesize = 2;
1885 sh_a->wf->wBitsPerSample = 16;
1886 }
1887 else
1888 {
1889 sh_a->samplesize = track->a_bps / 8;
1890 sh_a->wf->wBitsPerSample = track->a_bps;
1891 }
1892 if (track->a_formattag == 0x0055) /* MP3 || MP2 */
1893 {
1894 sh_a->wf->nAvgBytesPerSec = 16000;
1895 sh_a->wf->nBlockAlign = 1152;
1896 }
1897 else if ((track->a_formattag == 0x2000) || /* AC3 */
1898 (track->a_formattag == 0x2001)) /* DTS */
1899 {
1900 free(sh_a->wf);
1901 sh_a->wf = NULL;
1902 }
1903 else if (track->a_formattag == 0x0001) /* PCM || PCM_BE */
1904 {
1905 sh_a->wf->nAvgBytesPerSec = sh_a->channels * sh_a->samplerate*2;
1906 sh_a->wf->nBlockAlign = sh_a->wf->nAvgBytesPerSec;
1907 if (!strcmp(track->codec_id, MKV_A_PCM_BE))
1908 sh_a->format = mmioFOURCC('t', 'w', 'o', 's');
1909 }
1910 else if (!strcmp(track->codec_id, MKV_A_QDMC) ||
1911 !strcmp(track->codec_id, MKV_A_QDMC2))
1912 {
1913 sh_a->wf->nAvgBytesPerSec = 16000;
1914 sh_a->wf->nBlockAlign = 1486;
1915 track->fix_i_bps = 1;
1916 track->qt_last_a_pts = 0.0;
1917 if (track->private_data != NULL)
1918 {
1919 sh_a->codecdata=malloc(track->private_size);
1920 memcpy (sh_a->codecdata, track->private_data,
1921 track->private_size);
1922 sh_a->codecdata_len = track->private_size;
1923 }
1924 }
1925 else if (track->a_formattag == mmioFOURCC('M', 'P', '4', 'A'))
1926 {
1927 int profile, srate_idx;
1928
1929 sh_a->wf->nAvgBytesPerSec = 16000;
1930 sh_a->wf->nBlockAlign = 1024;
1931
1932 if (!strcmp (track->codec_id, MKV_A_AAC) &&
1933 (NULL != track->private_data))
1934 {
1935 sh_a->codecdata=malloc(track->private_size);
1936 memcpy (sh_a->codecdata, track->private_data,
1937 track->private_size);
1938 sh_a->codecdata_len = track->private_size;
1939 return 0;
1940 }
1941
1942 /* Recreate the 'private data' */
1943 /* which faad2 uses in its initialization */
1944 srate_idx = aac_get_sample_rate_index (sh_a->samplerate);
1945 if (!strncmp (&track->codec_id[12], "MAIN", 4))
1946 profile = 0;
1947 else if (!strncmp (&track->codec_id[12], "LC", 2))
1948 profile = 1;
1949 else if (!strncmp (&track->codec_id[12], "SSR", 3))
1950 profile = 2;
1951 else
1952 profile = 3;
1953 sh_a->codecdata = malloc (5);
1954 sh_a->codecdata[0] = ((profile+1) << 3) | ((srate_idx&0xE) >> 1);
1955 sh_a->codecdata[1] = ((srate_idx&0x1)<<7)|(track->a_channels<<3);
1956
1957 if (strstr(track->codec_id, "SBR") != NULL)
1958 {
1959 /* HE-AAC (aka SBR AAC) */
1960 sh_a->codecdata_len = 5;
1961
1962 sh_a->samplerate *= 2;
1963 sh_a->wf->nSamplesPerSec *= 2;
1964 srate_idx = aac_get_sample_rate_index(sh_a->samplerate);
1965 sh_a->codecdata[2] = AAC_SYNC_EXTENSION_TYPE >> 3;
1966 sh_a->codecdata[3] = ((AAC_SYNC_EXTENSION_TYPE&0x07)<<5) | 5;
1967 sh_a->codecdata[4] = (1 << 7) | (srate_idx << 3);
1968 track->default_duration = 1024.0 / (sh_a->samplerate / 2);
1969 }
1970 else
1971 {
1972 sh_a->codecdata_len = 2;
1973 track->default_duration = 1024.0 / sh_a->samplerate;
1974 }
1975 }
1976 else if (track->a_formattag == mmioFOURCC('v', 'r', 'b', 's')) /* VORBIS */
1977 {
1978 sh_a->wf->cbSize = track->private_size;
1979 sh_a->wf = realloc(sh_a->wf, sizeof(WAVEFORMATEX) + sh_a->wf->cbSize);
1980 memcpy((unsigned char *) (sh_a->wf+1), track->private_data, sh_a->wf->cbSize);
1981 }
1982 else if (track->private_size >= RAPROPERTIES4_SIZE
1983 && !strncmp (track->codec_id, MKV_A_REALATRC, 7))
1984 {
1985 /* Common initialization for all RealAudio codecs */
1986 unsigned char *src = track->private_data;
1987 int codecdata_length, version;
1988 int flavor;
1989
1990 sh_a->wf->nAvgBytesPerSec = 0; /* FIXME !? */
1991
1992 version = AV_RB16(src + 4);
1993 flavor = AV_RB16(src + 22);
1994 track->coded_framesize = AV_RB32(src + 24);
1995 track->sub_packet_h = AV_RB16(src + 40);
1996 sh_a->wf->nBlockAlign =
1997 track->audiopk_size = AV_RB16(src + 42);
1998 track->sub_packet_size = AV_RB16(src + 44);
1999 if (version == 4)
2000 {
2001 src += RAPROPERTIES4_SIZE;
2002 src += src[0] + 1;
2003 src += src[0] + 1;
2004 }
2005 else
2006 src += RAPROPERTIES5_SIZE;
2007
2008 src += 3;
2009 if (version == 5)
2010 src++;
2011 codecdata_length = AV_RB32(src);
2012 src += 4;
2013 sh_a->wf->cbSize = codecdata_length;
2014 sh_a->wf = realloc (sh_a->wf,
2015 sizeof (WAVEFORMATEX) +
2016 sh_a->wf->cbSize);
2017 memcpy(((char *)(sh_a->wf + 1)), src, codecdata_length);
2018
2019 switch (track->a_formattag) {
2020 case mmioFOURCC('a', 't', 'r', 'c'):
2021 sh_a->wf->nAvgBytesPerSec = atrc_fl2bps[flavor];
2022 sh_a->wf->nBlockAlign = track->sub_packet_size;
2023 track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
2024 track->audio_timestamp = malloc(track->sub_packet_h * sizeof(double));
2025 break;
2026 case mmioFOURCC('c', 'o', 'o', 'k'):
2027 sh_a->wf->nAvgBytesPerSec = cook_fl2bps[flavor];
2028 sh_a->wf->nBlockAlign = track->sub_packet_size;
2029 track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
2030 track->audio_timestamp = malloc(track->sub_packet_h * sizeof(double));
2031 break;
2032 case mmioFOURCC('s', 'i', 'p', 'r'):
2033 sh_a->wf->nAvgBytesPerSec = sipr_fl2bps[flavor];
2034 sh_a->wf->nBlockAlign = track->coded_framesize;
2035 track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
2036 track->audio_timestamp = malloc(track->sub_packet_h * sizeof(double));
2037 break;
2038 case mmioFOURCC('2', '8', '_', '8'):
2039 sh_a->wf->nAvgBytesPerSec = 3600;
2040 sh_a->wf->nBlockAlign = track->coded_framesize;
2041 track->audio_buf = malloc(track->sub_packet_h * track->audiopk_size);
2042 track->audio_timestamp = malloc(track->sub_packet_h * sizeof(double));
2043 break;
2044 }
2045
2046 track->realmedia = 1;
2047 }
2048 else if (!strcmp(track->codec_id, MKV_A_FLAC) ||
2049 (track->a_formattag == 0xf1ac))
2050 {
2051 unsigned char *ptr;
2052 int size;
2053 free(sh_a->wf);
2054 sh_a->wf = NULL;
2055
2056 if (track->a_formattag == mmioFOURCC('f', 'L', 'a', 'C'))
2057 {
2058 ptr = track->private_data;
2059 size = track->private_size;
2060 }
2061 else
2062 {
2063 sh_a->format = mmioFOURCC('f', 'L', 'a', 'C');
2064 ptr = track->private_data
2065 + sizeof (WAVEFORMATEX);
2066 size = track->private_size - sizeof (WAVEFORMATEX);
2067 }
2068 if (size < 4 || ptr[0] != 'f' || ptr[1] != 'L' ||
2069 ptr[2] != 'a' || ptr[3] != 'C')
2070 {
2071 sh_a->codecdata = malloc(4);
2072 sh_a->codecdata_len = 4;
2073 memcpy(sh_a->codecdata, "fLaC", 4);
2074 }
2075 else
2076 {
2077 sh_a->codecdata = malloc(size);
2078 sh_a->codecdata_len = size;
2079 memcpy(sh_a->codecdata, ptr, size);
2080 }
2081 }
2082 else if (track->a_formattag == mmioFOURCC('W', 'V', 'P', 'K') ||
2083 track->a_formattag == mmioFOURCC('T', 'R', 'H', 'D'))
2084 { /* do nothing, still works */ }
2085 else if (!track->ms_compat || (track->private_size < sizeof(WAVEFORMATEX)))
2086 {
2087 free_sh_audio(demuxer, track->tnum);
2088 return 1;
2089 }
2090
2091 return 0;
2092 }
2093
2094 static int
2095 demux_mkv_open_sub (demuxer_t *demuxer, mkv_track_t *track, int sid)
2096 {
2097 if (track->subtitle_type != MATROSKA_SUBTYPE_UNKNOWN)
2098 {
2099 int size, m;
2100 uint8_t *buffer;
2101 sh_sub_t *sh = new_sh_sub_sid(demuxer, track->tnum, sid);
2102 track->sh_sub = sh;
2103 sh->type = 't';
2104 if (track->subtitle_type == MATROSKA_SUBTYPE_VOBSUB)
2105 sh->type = 'v';
2106 if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
2107 sh->type = 'a';
2108 size = track->private_size;
2109 m = demux_mkv_decode (track,track->private_data,&buffer,&size,2);
2110 if (buffer && m)
2111 {
2112 free (track->private_data);
2113 track->private_data = buffer;
2114 track->private_size = size;
2115 }
2116 sh->extradata=malloc(track->private_size);
2117 memcpy (sh->extradata, track->private_data,
2118 track->private_size);
2119 sh->extradata_len = track->private_size;
2120 if (track->language && (strcmp(track->language, "und") != 0))
2121 sh->lang = strdup(track->language);
2122 sh->default_track = track->default_track;
2123 }
2124 else
2125 {
2126 mp_tmsg (MSGT_DEMUX, MSGL_ERR, "[mkv] Subtitle type '%s' is not supported.\n",
2127 track->codec_id);
2128 return 1;
2129 }
2130
2131 return 0;
2132 }
2133
2134 static int
2135 demux_mkv_open (demuxer_t *demuxer)
2136 {
2137 stream_t *s = demuxer->stream;
2138 mkv_demuxer_t *mkv_d;
2139 mkv_track_t *track;
2140 int i, version, cont = 0;
2141 char *str;
2142
2143 stream_seek(s, s->start_pos);
2144 str = ebml_read_header (s, &version);
2145 if (str == NULL || strcmp (str, "matroska") || version > 2)
2146 {
2147 mp_msg (MSGT_DEMUX, MSGL_DBG2, "[mkv] no head found\n");
2148 return 0;
2149 }
2150 free (str);
2151
2152 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] Found the head...\n");
2153
2154 if (ebml_read_id (s, NULL) != MATROSKA_ID_SEGMENT)
2155 {
2156 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] but no segment :(\n");
2157 return 0;
2158 }
2159 ebml_read_length (s, NULL); /* return bytes number until EOF */
2160
2161 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] + a segment...\n");
2162
2163 mkv_d = calloc (1, sizeof (mkv_demuxer_t));
2164 demuxer->priv = mkv_d;
2165 mkv_d->tc_scale = 1000000;
2166 mkv_d->segment_start = stream_tell (s);
2167 mkv_d->parsed_cues = malloc (sizeof (off_t));
2168 mkv_d->parsed_seekhead = malloc (sizeof (off_t));
2169
2170 while (!cont)
2171 {
2172 switch (ebml_read_id (s, NULL))
2173 {
2174 case MATROSKA_ID_INFO:
2175 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] |+ segment information...\n");
2176 cont = demux_mkv_read_info (demuxer);
2177 break;
2178
2179 case MATROSKA_ID_TRACKS:
2180 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] |+ segment tracks...\n");
2181 cont = demux_mkv_read_tracks (demuxer);
2182 break;
2183
2184 case MATROSKA_ID_CUES:
2185 cont = demux_mkv_read_cues (demuxer);
2186 break;
2187
2188 case MATROSKA_ID_TAGS:
2189 cont = demux_mkv_read_tags (demuxer);
2190 break;
2191
2192 case MATROSKA_ID_SEEKHEAD:
2193 cont = demux_mkv_read_seekhead (demuxer);
2194 break;
2195
2196 case MATROSKA_ID_CHAPTERS:
2197 cont = demux_mkv_read_chapters (demuxer);
2198 break;
2199
2200 case MATROSKA_ID_ATTACHMENTS:
2201 cont = demux_mkv_read_attachments (demuxer);
2202 break;
2203
2204 case MATROSKA_ID_CLUSTER:
2205 {
2206 int p, l;
2207 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] |+ found cluster, headers are "
2208 "parsed completely :)\n");
2209 /* get the first cluster timecode */
2210 p = stream_tell(s);
2211 l = ebml_read_length (s, NULL);
2212 while (ebml_read_id (s, NULL) != MATROSKA_ID_CLUSTERTIMECODE)
2213 {
2214 ebml_read_skip (s, NULL);
2215 if (stream_tell (s) >= p + l)
2216 break;
2217 }
2218 if (stream_tell (s) < p + l)
2219 {
2220 uint64_t num = ebml_read_uint (s, NULL);
2221 if (num == EBML_UINT_INVALID)
2222 return 0;
2223 }
2224 stream_seek (s, p - 4);
2225 cont = 1;
2226 break;
2227 }
2228
2229 default:
2230 cont = 1;
2231 case EBML_ID_VOID:
2232 ebml_read_skip (s, NULL);
2233 break;
2234 }
2235 }
2236
2237 display_create_tracks (demuxer);
2238
2239 /* select video track */
2240 track = NULL;
2241 if (demuxer->video->id == -1) /* automatically select a video track */
2242 {
2243 /* search for a video track that has the 'default' flag set */
2244 for (i=0; i<mkv_d->num_tracks; i++)
2245 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO
2246 && mkv_d->tracks[i]->default_track)
2247 {
2248 track = mkv_d->tracks[i];
2249 break;
2250 }
2251
2252 if (track == NULL)
2253 /* no track has the 'default' flag set */
2254 /* let's take the first video track */
2255 for (i=0; i<mkv_d->num_tracks; i++)
2256 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO)
2257 {
2258 track = mkv_d->tracks[i];
2259 break;
2260 }
2261 }
2262 else if (demuxer->video->id != -2) /* -2 = no video at all */
2263 track = demux_mkv_find_track_by_num (mkv_d, demuxer->video->id,
2264 MATROSKA_TRACK_VIDEO);
2265
2266 if (track && demuxer->v_streams[track->tnum])
2267 {
2268 mp_tmsg (MSGT_DEMUX, MSGL_INFO,
2269 "[mkv] Will play video track %u.\n", track->tnum);
2270 demuxer->video->id = track->tnum;
2271 demuxer->video->sh = demuxer->v_streams[track->tnum];
2272 }
2273 else
2274 {
2275 mp_tmsg (MSGT_DEMUX, MSGL_INFO, "[mkv] No video track found/wanted.\n");
2276 demuxer->video->id = -2;
2277 }
2278
2279 /* select audio track */
2280 track = NULL;
2281 if (track == NULL)
2282 /* search for an audio track that has the 'default' flag set */
2283 for (i=0; i < mkv_d->num_tracks; i++)
2284 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO
2285 && mkv_d->tracks[i]->default_track)
2286 {
2287 track = mkv_d->tracks[i];
2288 break;
2289 }
2290
2291 if (track == NULL)
2292 /* no track has the 'default' flag set */
2293 /* let's take the first audio track */
2294 for (i=0; i < mkv_d->num_tracks; i++)
2295 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO)
2296 {
2297 track = mkv_d->tracks[i];
2298 break;
2299 }
2300
2301 if (track && demuxer->a_streams[track->tnum])
2302 {
2303 demuxer->audio->id = track->tnum;
2304 demuxer->audio->sh = demuxer->a_streams[track->tnum];
2305 }
2306 else
2307 {
2308 mp_tmsg (MSGT_DEMUX, MSGL_INFO, "[mkv] No audio track found/wanted.\n");
2309 demuxer->audio->id = -2;
2310 }
2311
2312
2313 if(demuxer->audio->id != -2)
2314 for (i=0; i < mkv_d->num_tracks; i++)
2315 {
2316 if(mkv_d->tracks[i]->type != MATROSKA_TRACK_AUDIO)
2317 continue;
2318 if(demuxer->a_streams[track->tnum])
2319 {
2320 mkv_d->last_aid++;
2321 if(mkv_d->last_aid == MAX_A_STREAMS)
2322 break;
2323 }
2324 }
2325
2326 if (s->end_pos == 0 || (mkv_d->indexes == NULL && index_mode < 0))
2327 demuxer->seekable = 0;
2328 else
2329 {
2330 demuxer->movi_start = s->start_pos;
2331 demuxer->movi_end = s->end_pos;
2332 demuxer->seekable = 1;
2333 }
2334
2335 demuxer->accurate_seek = true;
2336
2337 return DEMUXER_TYPE_MATROSKA;
2338 }
2339
2340 static void
2341 demux_close_mkv (demuxer_t *demuxer)
2342 {
2343 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2344
2345 if (mkv_d)
2346 {
2347 int i;
2348 free_cached_dps (demuxer);
2349 if (mkv_d->tracks)
2350 {
2351 for (i=0; i<mkv_d->num_tracks; i++)
2352 demux_mkv_free_trackentry(mkv_d->tracks[i]);
2353 free (mkv_d->tracks);
2354 }
2355 free (mkv_d->indexes);
2356 free (mkv_d->cluster_positions);
2357 free (mkv_d->parsed_cues);
2358 free (mkv_d->parsed_seekhead);
2359 free (mkv_d);
2360 }
2361 }
2362
2363 static int
2364 demux_mkv_read_block_lacing (uint8_t *buffer, uint64_t *size,
2365 uint8_t *laces, uint32_t **all_lace_sizes)
2366 {
2367 uint32_t total = 0, *lace_size;
2368 uint8_t flags;
2369 int i;
2370
2371 *all_lace_sizes = NULL;
2372 lace_size = NULL;
2373 /* lacing flags */
2374 flags = *buffer++;
2375 (*size)--;
2376
2377 switch ((flags & 0x06) >> 1)
2378 {
2379 case 0: /* no lacing */
2380 *laces = 1;
2381 lace_size = calloc(*laces, sizeof(uint32_t));
2382 lace_size[0] = *size;
2383 break;
2384
2385 case 1: /* xiph lacing */
2386 case 2: /* fixed-size lacing */
2387 case 3: /* EBML lacing */
2388 *laces = *buffer++;
2389 (*size)--;
2390 (*laces)++;
2391 lace_size = calloc(*laces, sizeof(uint32_t));
2392
2393 switch ((flags & 0x06) >> 1)
2394 {
2395 case 1: /* xiph lacing */
2396 for (i=0; i < *laces-1; i++)
2397 {
2398 lace_size[i] = 0;
2399 do
2400 {
2401 lace_size[i] += *buffer;
2402 (*size)--;
2403 } while (*buffer++ == 0xFF);
2404 total += lace_size[i];
2405 }
2406 lace_size[i] = *size - total;
2407 break;
2408
2409 case 2: /* fixed-size lacing */
2410 for (i=0; i < *laces; i++)
2411 lace_size[i] = *size / *laces;
2412 break;
2413
2414 case 3: /* EBML lacing */
2415 {
2416 int l;
2417 uint64_t num = ebml_read_vlen_uint (buffer, &l);
2418 if (num == EBML_UINT_INVALID) {
2419 free(lace_size);
2420 return 1;
2421 }
2422 buffer += l;
2423 *size -= l;
2424
2425 total = lace_size[0] = num;
2426 for (i=1; i < *laces-1; i++)
2427 {
2428 int64_t snum;
2429 snum = ebml_read_vlen_int (buffer, &l);
2430 if (snum == EBML_INT_INVALID) {
2431 free(lace_size);
2432 return 1;
2433 }
2434 buffer += l;
2435 *size -= l;
2436 lace_size[i] = lace_size[i-1] + snum;
2437 total += lace_size[i];
2438 }
2439 lace_size[i] = *size - total;
2440 break;
2441 }
2442 }
2443 break;
2444 }
2445 *all_lace_sizes = lace_size;
2446 return 0;
2447 }
2448
2449 static void
2450 handle_subtitles(demuxer_t *demuxer, mkv_track_t *track, char *block,
2451 int64_t size, uint64_t block_duration, uint64_t timecode)
2452 {
2453 demux_packet_t *dp;
2454
2455 if (block_duration == 0)
2456 {
2457 mp_msg (MSGT_DEMUX, MSGL_WARN,
2458 "[mkv] Warning: No BlockDuration for subtitle track found.\n");
2459 return;
2460 }
2461
2462 sub_utf8 = 1;
2463 dp = new_demux_packet(size);
2464 memcpy(dp->buffer, block, size);
2465 dp->pts = timecode / 1000.0;
2466 dp->endpts = (timecode + block_duration) / 1000.0;
2467 ds_add_packet(demuxer->sub, dp);
2468 }
2469
2470 double real_fix_timestamp(unsigned char *buf, unsigned int timestamp, unsigned int format, int64_t *kf_base, int *kf_pts, double *pts);
2471
2472 static void
2473 handle_realvideo (demuxer_t *demuxer, mkv_track_t *track, uint8_t *buffer,
2474 uint32_t size, int block_bref)
2475 {
2476 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2477 demux_packet_t *dp;
2478 uint32_t timestamp = mkv_d->last_pts * 1000;
2479
2480 dp = new_demux_packet (size);
2481 memcpy (dp->buffer, buffer, size);
2482
2483 if (mkv_d->v_skip_to_keyframe)
2484 {
2485 dp->pts = mkv_d->last_pts;
2486 track->rv_kf_base = 0;
2487 track->rv_kf_pts = timestamp;
2488 }
2489 else
2490 dp->pts = real_fix_timestamp (dp->buffer, timestamp,
2491 ((sh_video_t*)demuxer->video->sh)->bih->biCompression,
2492 &track->rv_kf_base, &track->rv_kf_pts, NULL);
2493 dp->pos = demuxer->filepos;
2494 dp->flags = block_bref ? 0 : 0x10;
2495
2496 ds_add_packet(demuxer->video, dp);
2497 }
2498
2499 static void
2500 handle_realaudio (demuxer_t *demuxer, mkv_track_t *track, uint8_t *buffer,
2501 uint32_t size, int block_bref)
2502 {
2503 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2504 int sps = track->sub_packet_size;
2505 int sph = track->sub_packet_h;
2506 int cfs = track->coded_framesize;
2507 int w = track->audiopk_size;
2508 int spc = track->sub_packet_cnt;
2509 demux_packet_t *dp;
2510 int x;
2511
2512 if ((track->a_formattag == mmioFOURCC('2', '8', '_', '8')) ||
2513 (track->a_formattag == mmioFOURCC('c', 'o', 'o', 'k')) ||
2514 (track->a_formattag == mmioFOURCC('a', 't', 'r', 'c')) ||
2515 (track->a_formattag == mmioFOURCC('s', 'i', 'p', 'r')))
2516 {
2517 // if(!block_bref)
2518 // spc = track->sub_packet_cnt = 0;
2519 switch (track->a_formattag) {
2520 case mmioFOURCC('2', '8', '_', '8'):
2521 for (x = 0; x < sph / 2; x++)
2522 memcpy(track->audio_buf + x * 2 * w + spc * cfs, buffer + cfs * x, cfs);
2523 break;
2524 case mmioFOURCC('c', 'o', 'o', 'k'):
2525 case mmioFOURCC('a', 't', 'r', 'c'):
2526 for (x = 0; x < w / sps; x++)
2527 memcpy(track->audio_buf + sps * (sph * x + ((sph + 1) / 2) * (spc & 1) + (spc >> 1)), buffer + sps * x, sps);
2528 break;
2529 case mmioFOURCC('s', 'i', 'p', 'r'):
2530 memcpy(track->audio_buf + spc * w, buffer, w);
2531 if (spc == sph - 1)
2532 {
2533 int n;
2534 int bs = sph * w * 2 / 96; // nibbles per subpacket
2535 // Perform reordering
2536 for(n=0; n < 38; n++)
2537 {
2538 int j;
2539 int i = bs * sipr_swaps[n][0];
2540 int o = bs * sipr_swaps[n][1];
2541 // swap nibbles of block 'i' with 'o' TODO: optimize
2542 for(j = 0;j < bs; j++)
2543 {
2544 int x = (i & 1) ? (track->audio_buf[i >> 1] >> 4) : (track->audio_buf[i >> 1] & 0x0F);
2545 int y = (o & 1) ? (track->audio_buf[o >> 1] >> 4) : (track->audio_buf[o >> 1] & 0x0F);
2546 if(o & 1)
2547 track->audio_buf[o >> 1] = (track->audio_buf[o >> 1] & 0x0F) | (x << 4);
2548 else
2549 track->audio_buf[o >> 1] = (track->audio_buf[o >> 1] & 0xF0) | x;
2550 if(i & 1)
2551 track->audio_buf[i >> 1] = (track->audio_buf[i >> 1] & 0x0F) | (y << 4);
2552 else
2553 track->audio_buf[i >> 1] = (track->audio_buf[i >> 1] & 0xF0) | y;
2554 ++i; ++o;
2555 }
2556 }
2557 }
2558 break;
2559 }
2560 track->audio_timestamp[track->sub_packet_cnt] = (track->ra_pts == mkv_d->last_pts) ? 0 : (mkv_d->last_pts);
2561 track->ra_pts = mkv_d->last_pts;
2562 if (track->sub_packet_cnt == 0)
2563 track->audio_filepos = demuxer->filepos;
2564 if (++(track->sub_packet_cnt) == sph)
2565 {
2566 int apk_usize = ((WAVEFORMATEX*)((sh_audio_t*)demuxer->audio->sh)->wf)->nBlockAlign;
2567 track->sub_packet_cnt = 0;
2568 // Release all the audio packets
2569 for (x = 0; x < sph*w/apk_usize; x++)
2570 {
2571 dp = new_demux_packet(apk_usize);
2572 memcpy(dp->buffer, track->audio_buf + x * apk_usize, apk_usize);
2573 /* Put timestamp only on packets that correspond to original audio packets in file */
2574 dp->pts = (x * apk_usize % w) ? 0 : track->audio_timestamp[x * apk_usize / w];
2575 dp->pos = track->audio_filepos; // all equal
2576 dp->flags = x ? 0 : 0x10; // Mark first packet as keyframe
2577 ds_add_packet(demuxer->audio, dp);
2578 }
2579 }
2580 } else { // Not a codec that require reordering
2581 dp = new_demux_packet (size);
2582 memcpy(dp->buffer, buffer, size);
2583 if (track->ra_pts == mkv_d->last_pts && !mkv_d->a_skip_to_keyframe)
2584 dp->pts = 0;
2585 else
2586 dp->pts = mkv_d->last_pts;
2587 track->ra_pts = mkv_d->last_pts;
2588
2589 dp->pos = demuxer->filepos;
2590 dp->flags = block_bref ? 0 : 0x10;
2591 ds_add_packet (demuxer->audio, dp);
2592 }
2593 }
2594
2595 /** Reorder timecodes and add cached demux packets to the queues.
2596 *
2597 * Timecode reordering is needed if a video track contains B frames that
2598 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2599 * MPlayer doesn't like timestamps in display order. This function adjusts
2600 * the timestamp of cached frames (which are exactly one I/P frame followed
2601 * by one or more B frames) so that they are in coding order again.
2602 *
2603 * Example: The track with 25 FPS contains four frames with the timecodes
2604 * I at 0ms, P at 120ms, B at 40ms and B at 80ms. As soon as the next I
2605 * or P frame arrives these timecodes can be changed to I at 0ms, P at 40ms,
2606 * B at 80ms and B at 120ms.
2607 *
2608 * This works for simple H.264 B-frame pyramids, but not for arbitrary orders.
2609 *
2610 * \param demuxer The Matroska demuxer struct for this instance.
2611 * \param track The track structure whose cache should be handled.
2612 */
2613 static void
2614 flush_cached_dps (demuxer_t *demuxer, mkv_track_t *track)
2615 {
2616 int i, ok;
2617
2618 if (track->num_cached_dps == 0)
2619 return;
2620
2621 do {
2622 ok = 1;
2623 for (i = 1; i < track->num_cached_dps; i++)
2624 if (track->cached_dps[i - 1]->pts > track->cached_dps[i]->pts) {
2625 double tmp_pts = track->cached_dps[i - 1]->pts;
2626 track->cached_dps[i - 1]->pts = track->cached_dps[i]->pts;
2627 track->cached_dps[i]->pts = tmp_pts;
2628 ok = 0;
2629 }
2630 } while (!ok);
2631
2632 for (i = 0; i < track->num_cached_dps; i++)
2633 ds_add_packet (demuxer->video, track->cached_dps[i]);
2634 track->num_cached_dps = 0;
2635 }
2636
2637 /** Cache video frames if timecodes have to be reordered.
2638 *
2639 * Timecode reordering is needed if a video track contains B frames that
2640 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2641 * This function takes in a Matroska block read from the file, allocates a
2642 * demux packet for it, fills in its values, allocates space for storing
2643 * pointers to the cached demux packets and adds the packet to it. If
2644 * the packet contains an I or a P frame then ::flush_cached_dps is called
2645 * in order to send the old cached frames downstream.
2646 *
2647 * \param demuxer The Matroska demuxer struct for this instance.
2648 * \param track The packet is meant for this track.
2649 * \param buffer The actual frame contents.
2650 * \param size The frame size in bytes.
2651 * \param block_bref A relative timecode (backward reference). If it is \c 0
2652 * then the frame is an I frame.
2653 * \param block_fref A relative timecode (forward reference). If it is \c 0
2654 * then the frame is either an I frame or a P frame depending on the value
2655 * of \a block_bref. Otherwise it's a B frame.
2656 */
2657 static void
2658 handle_video_bframes (demuxer_t *demuxer, mkv_track_t *track, uint8_t *buffer,
2659 uint32_t size, int block_bref, int block_fref)
2660 {
2661 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2662 demux_packet_t *dp;
2663
2664 dp = new_demux_packet (size);
2665 memcpy(dp->buffer, buffer, size);
2666 dp->pos = demuxer->filepos;
2667 dp->pts = mkv_d->last_pts;
2668 if ((track->num_cached_dps > 0) && (dp->pts < track->max_pts))
2669 block_fref = 1;
2670 if (block_fref == 0) /* I or P frame */
2671 flush_cached_dps (demuxer, track);
2672 if (block_bref != 0) /* I frame, don't cache it */
2673 dp->flags = 0x10;
2674 if ((track->num_cached_dps + 1) > track->num_allocated_dps)
2675 {
2676 track->cached_dps = (demux_packet_t **)
2677 realloc(track->cached_dps, (track->num_cached_dps + 10) *
2678 sizeof(demux_packet_t *));
2679 track->num_allocated_dps += 10;
2680 }
2681 track->cached_dps[track->num_cached_dps] = dp;
2682 track->num_cached_dps++;
2683 if (dp->pts > track->max_pts)
2684 track->max_pts = dp->pts;
2685 }
2686
2687 static int
2688 handle_block (demuxer_t *demuxer, uint8_t *block, uint64_t length,
2689 uint64_t block_duration, int64_t block_bref, int64_t block_fref, uint8_t simpleblock)
2690 {
2691 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2692 mkv_track_t *track = NULL;
2693 demux_stream_t *ds = NULL;
2694 uint64_t old_length;
2695 int64_t tc;
2696 uint32_t *lace_size;
2697 uint8_t laces, flags;
2698 int i, num, tmp, use_this_block = 1;
2699 double current_pts;
2700 int16_t time;
2701
2702 /* first byte(s): track num */
2703 num = ebml_read_vlen_uint (block, &tmp);
2704 block += tmp;
2705 /* time (relative to cluster time) */
2706 time = block[0] << 8 | block[1];
2707 block += 2;
2708 length -= tmp + 2;
2709 old_length = length;
2710 flags = block[0];
2711 if (demux_mkv_read_block_lacing (block, &length, &laces, &lace_size))
2712 return 0;
2713 block += old_length - length;
2714
2715 tc = (time*mkv_d->tc_scale+mkv_d->cluster_tc) / 1000000.0 + 0.5;
2716 if (tc < 0)
2717 tc = 0;
2718 current_pts = tc / 1000.0;
2719
2720 for (i=0; i<mkv_d->num_tracks; i++)
2721 if (mkv_d->tracks[i]->tnum == num) {
2722 track = mkv_d->tracks[i];
2723 break;
2724 }
2725 if (track == NULL)
2726 {
2727 free(lace_size);
2728 return 1;
2729 }
2730 if (num == demuxer->audio->id)
2731 {
2732 ds = demuxer->audio;
2733
2734 if (mkv_d->a_skip_to_keyframe)
2735 {
2736 if (simpleblock)
2737 {
2738 if (!(flags&0x80)) /*current frame isn't a keyframe*/
2739 use_this_block = 0;
2740 }
2741 else if (block_bref != 0)
2742 use_this_block = 0;
2743 }
2744 else if (mkv_d->v_skip_to_keyframe)
2745 use_this_block = 0;
2746
2747 if (track->fix_i_bps && use_this_block)
2748 {
2749 sh_audio_t *sh = (sh_audio_t *) ds->sh;
2750
2751 if (block_duration != 0)
2752 {
2753 sh->i_bps = length * 1000 / block_duration;
2754 track->fix_i_bps = 0;
2755 }
2756 else if (track->qt_last_a_pts == 0.0)
2757 track->qt_last_a_pts = current_pts;
2758 else if(track->qt_last_a_pts != current_pts)
2759 {
2760 sh->i_bps = length / (current_pts - track->qt_last_a_pts);
2761 track->fix_i_bps = 0;
2762 }
2763 }
2764 }
2765 else if (tc < mkv_d->skip_to_timecode)
2766 use_this_block = 0;
2767 else if (num == demuxer->video->id)
2768 {
2769 ds = demuxer->video;
2770 if (mkv_d->v_skip_to_keyframe)
2771 {
2772 if (simpleblock)
2773 {
2774 if (!(flags&0x80)) /*current frame isn't a keyframe*/
2775 use_this_block = 0;
2776 }
2777 else if (block_bref != 0 || block_fref != 0)
2778 use_this_block = 0;
2779 }
2780 }
2781 else if (num == demuxer->sub->id)
2782 {
2783 ds = demuxer->sub;
2784 if (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB)
2785 {
2786 if (!mkv_d->v_skip_to_keyframe)
2787 handle_subtitles (demuxer, track, block, length,
2788 block_duration, tc);
2789 use_this_block = 0;
2790 }
2791 }
2792 else
2793 use_this_block = 0;
2794
2795 if (use_this_block)
2796 {
2797 mkv_d->last_pts = current_pts;
2798 mkv_d->last_filepos = demuxer->filepos;
2799
2800 for (i=0; i < laces; i++)
2801 {
2802 if (ds == demuxer->video && track->realmedia)
2803 handle_realvideo (demuxer, track, block, lace_size[i], block_bref);
2804 else if (ds == demuxer->audio && track->realmedia)
2805 handle_realaudio (demuxer, track, block, lace_size[i], block_bref);
2806 else if (ds == demuxer->video && track->reorder_timecodes)
2807 handle_video_bframes (demuxer, track, block, lace_size[i],
2808 block_bref, block_fref);
2809 else
2810 {
2811 int modified, size = lace_size[i];
2812 demux_packet_t *dp;
2813 uint8_t *buffer;
2814 modified = demux_mkv_decode (track, block, &buffer, &size, 1);
2815 if (buffer)
2816 {
2817 dp = new_demux_packet (size);
2818 memcpy (dp->buffer, buffer, size);
2819 if (modified)
2820 free (buffer);
2821 dp->flags = (block_bref == 0 && block_fref == 0) ? 0x10 : 0;
2822 /* If default_duration is 0, assume no pts value is known
2823 * for packets after the first one (rather than all pts
2824 * values being the same) */
2825 if (i == 0 || track->default_duration)
2826 dp->pts = mkv_d->last_pts + i * track->default_duration;
2827 ds_add_packet (ds, dp);
2828 }
2829 }
2830 block += lace_size[i];
2831 }
2832
2833 if (ds == demuxer->video)
2834 {
2835 mkv_d->v_skip_to_keyframe = 0;
2836 mkv_d->skip_to_timecode = 0;
2837 }
2838 else if (ds == demuxer->audio)
2839 mkv_d->a_skip_to_keyframe = 0;
2840
2841 free(lace_size);
2842 return 1;
2843 }
2844
2845 free(lace_size);
2846 return 0;
2847 }
2848
2849 static int
2850 demux_mkv_fill_buffer (demuxer_t *demuxer, demux_stream_t *ds)
2851 {
2852 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2853 stream_t *s = demuxer->stream;
2854 uint64_t l;
2855 int il, tmp;
2856
2857 while (1)
2858 {
2859 while (mkv_d->cluster_size > 0)
2860 {
2861 uint64_t block_duration = 0, block_length = 0;
2862 int64_t block_bref = 0, block_fref = 0;
2863 uint8_t *block = NULL;
2864
2865 while (mkv_d->blockgroup_size > 0)
2866 {
2867 switch (ebml_read_id (s, &il))
2868 {
2869 case MATROSKA_ID_BLOCKDURATION:
2870 {
2871 block_duration = ebml_read_uint (s, &l);
2872 if (block_duration == EBML_UINT_INVALID) {
2873 free(block);
2874 return 0;
2875 }
2876 block_duration = block_duration * mkv_d->tc_scale / 1000000.0 + 0.5;
2877 break;
2878 }
2879
2880 case MATROSKA_ID_BLOCK:
2881 block_length = ebml_read_length (s, &tmp);
2882 free(block);
2883 if (block_length > SIZE_MAX - AV_LZO_INPUT_PADDING) return 0;
2884 block = malloc (block_length + AV_LZO_INPUT_PADDING);
2885 demuxer->filepos = stream_tell (s);
2886 if (stream_read (s,block,block_length) != (int) block_length)
2887 {
2888 free(block);
2889 return 0;
2890 }
2891 l = tmp + block_length;
2892 break;
2893
2894 case MATROSKA_ID_REFERENCEBLOCK:
2895 {
2896 int64_t num = ebml_read_int (s, &l);
2897 if (num == EBML_INT_INVALID) {
2898 free(block);
2899 return 0;
2900 }
2901 if (num <= 0)
2902 block_bref = num;
2903 else
2904 block_fref = num;
2905 break;
2906 }
2907
2908 case EBML_ID_INVALID:
2909 free(block);
2910 return 0;
2911
2912 default:
2913 ebml_read_skip (s, &l);
2914 break;
2915 }
2916 mkv_d->blockgroup_size -= l + il;
2917 mkv_d->cluster_size -= l + il;
2918 }
2919
2920 if (block)
2921 {
2922 int res = handle_block (demuxer, block, block_length,
2923 block_duration, block_bref, block_fref, 0);
2924 free (block);
2925 if (res < 0)
2926 return 0;
2927 if (res)
2928 return 1;
2929 }
2930
2931 if (mkv_d->cluster_size > 0)
2932 {
2933 switch (ebml_read_id (s, &il))
2934 {
2935 case MATROSKA_ID_CLUSTERTIMECODE:
2936 {
2937 uint64_t num = ebml_read_uint (s, &l);
2938 if (num == EBML_UINT_INVALID)
2939 return 0;
2940 mkv_d->cluster_tc = num * mkv_d->tc_scale;
2941 break;
2942 }
2943
2944 case MATROSKA_ID_BLOCKGROUP:
2945 mkv_d->blockgroup_size = ebml_read_length (s, &tmp);
2946 l = tmp;
2947 break;
2948
2949 case MATROSKA_ID_SIMPLEBLOCK:
2950 {
2951 int res;
2952 block_length = ebml_read_length (s, &tmp);
2953 block = malloc (block_length);
2954 demuxer->filepos = stream_tell (s);
2955 if (stream_read (s,block,block_length) != (int) block_length)
2956 {
2957 free(block);
2958 return 0;
2959 }
2960 l = tmp + block_length;
2961 res = handle_block (demuxer, block, block_length,
2962 block_duration, block_bref, block_fref, 1);
2963 free (block);
2964 mkv_d->cluster_size -= l + il;
2965 if (res < 0)
2966 return 0;
2967 else if (res)
2968 return 1;
2969 else mkv_d->cluster_size += l + il;
2970 break;
2971 }
2972 case EBML_ID_INVALID:
2973 return 0;
2974
2975 default:
2976 ebml_read_skip (s, &l);
2977 break;
2978 }
2979 mkv_d->cluster_size -= l + il;
2980 }
2981 }
2982
2983 if (ebml_read_id (s, &il) != MATROSKA_ID_CLUSTER)
2984 return 0;
2985 add_cluster_position(mkv_d, stream_tell(s)-il);
2986 mkv_d->cluster_size = ebml_read_length (s, NULL);
2987 }
2988
2989 return 0;
2990 }
2991
2992 static void
2993 demux_mkv_seek (demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags)
2994 {
2995 if (!(flags & (SEEK_BACKWARD | SEEK_FORWARD))) {
2996 if (flags & SEEK_ABSOLUTE || rel_seek_secs < 0)
2997 flags |= SEEK_BACKWARD;
2998 else
2999 flags |= SEEK_FORWARD;
3000 }
3001 // Adjust the target a little bit to catch cases where the target position
3002 // specifies a keyframe with high, but not perfect, precision.
3003 rel_seek_secs += flags & SEEK_FORWARD ? -0.005 : 0.005;
3004
3005 free_cached_dps (demuxer);
3006 if (!(flags & SEEK_FACTOR)) /* time in secs */
3007 {
3008 mkv_index_t *index = NULL;
3009 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3010 stream_t *s = demuxer->stream;
3011 int64_t target_timecode = 0, diff, min_diff=0xFFFFFFFFFFFFFFFLL;
3012 int i;
3013
3014 if (!(flags & SEEK_ABSOLUTE)) /* relative seek */
3015 target_timecode = (int64_t) (mkv_d->last_pts * 1000.0);
3016 target_timecode += (int64_t)(rel_seek_secs * 1000.0);
3017 if (target_timecode < 0)
3018 target_timecode = 0;
3019
3020 if (mkv_d->indexes == NULL) /* no index was found */
3021 {
3022 uint64_t target_filepos, cluster_pos, max_pos;
3023
3024 target_filepos = (uint64_t) (target_timecode * mkv_d->last_filepos
3025 / (mkv_d->last_pts * 1000.0));
3026
3027 max_pos = mkv_d->num_cluster_pos ? mkv_d->cluster_positions[mkv_d->num_cluster_pos-1] : 0;
3028 if (target_filepos > max_pos)
3029 {
3030 if ((off_t) max_pos > stream_tell (s))
3031 stream_seek (s, max_pos);
3032 else
3033 stream_seek (s, stream_tell (s) + mkv_d->cluster_size);
3034 /* parse all the clusters upto target_filepos */
3035 while (!s->eof && stream_tell(s) < (off_t) target_filepos)
3036 {
3037 switch (ebml_read_id (s, &i))
3038 {
3039 case MATROSKA_ID_CLUSTER:
3040 add_cluster_position(mkv_d, (uint64_t) stream_tell(s)-i);
3041 break;
3042
3043 case MATROSKA_ID_CUES:
3044 demux_mkv_read_cues (demuxer);
3045 break;
3046 }
3047 ebml_read_skip (s, NULL);
3048 }
3049 if (s->eof)
3050 stream_reset(s);
3051 }
3052
3053 if (mkv_d->indexes == NULL)
3054 {
3055 cluster_pos = mkv_d->cluster_positions[0];
3056 /* Let's find the nearest cluster */
3057 for (i=0; i < mkv_d->num_cluster_pos; i++)
3058 {
3059 diff = mkv_d->cluster_positions[i] - target_filepos;
3060 if (flags & SEEK_BACKWARD && diff < 0 && -diff < min_diff)
3061 {
3062 cluster_pos = mkv_d->cluster_positions[i];
3063 min_diff = -diff;
3064 }
3065 else if (flags & SEEK_FORWARD
3066 && (diff < 0 ? -1 * diff : diff) < min_diff)
3067 {
3068 cluster_pos = mkv_d->cluster_positions[i];
3069 min_diff = diff < 0 ? -1 * diff : diff;
3070 }
3071 }
3072 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
3073 stream_seek (s, cluster_pos);
3074 }
3075 }
3076 else
3077 {
3078 int seek_id = (demuxer->video->id < 0) ? demuxer->audio->id : demuxer->video->id;
3079
3080 /* let's find the entry in the indexes with the smallest */
3081 /* difference to the wanted timecode. */
3082 for (i=0; i < mkv_d->num_indexes; i++)
3083 if (mkv_d->indexes[i].tnum == seek_id)
3084 {
3085 diff = target_timecode -
3086 (int64_t)(mkv_d->indexes[i].timecode * mkv_d->tc_scale
3087 / 1000000.0 + 0.5);
3088
3089 if (flags & SEEK_BACKWARD) {
3090 // Seek backward: find the last index position
3091 // before target time
3092 if (diff < 0 || diff >= min_diff)
3093 continue;
3094 }
3095 else {
3096 // Seek forward: find the first index position
3097 // after target time. If no such index exists, find last
3098 // position between current position and target time.
3099 if (diff <= 0) {
3100 if (min_diff <= 0 && diff <= min_diff)
3101 continue;
3102 }
3103 else if (diff >= FFMIN(target_timecode - mkv_d->last_pts,
3104 min_diff))
3105 continue;
3106 }
3107 min_diff = diff;
3108 index = mkv_d->indexes + i;
3109 }
3110
3111 if (index) /* We've found an entry. */
3112 {
3113 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
3114 stream_seek (s, index->filepos);
3115 }
3116 }
3117
3118 if (demuxer->video->id >= 0)
3119 mkv_d->v_skip_to_keyframe = 1;
3120 if (flags & SEEK_FORWARD)
3121 mkv_d->skip_to_timecode = target_timecode;
3122 else
3123 mkv_d->skip_to_timecode = index ? index->timecode : 0;
3124 mkv_d->a_skip_to_keyframe = 1;
3125
3126 demux_mkv_fill_buffer(demuxer, NULL);
3127 }
3128 else if ((demuxer->movi_end <= 0) || !(flags & SEEK_ABSOLUTE))
3129 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
3130 else
3131 {
3132 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3133 stream_t *s = demuxer->stream;
3134 uint64_t target_filepos;
3135 mkv_index_t *index = NULL;
3136 int i;
3137
3138 if (mkv_d->indexes == NULL) /* no index was found */
3139 { /* I'm lazy... */
3140 mp_msg (MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
3141 return;
3142 }
3143
3144 target_filepos = (uint64_t)(demuxer->movi_end * rel_seek_secs);
3145 for (i=0; i < mkv_d->num_indexes; i++)
3146 if (mkv_d->indexes[i].tnum == demuxer->video->id)
3147 if ((index == NULL) ||
3148 ((mkv_d->indexes[i].filepos >= target_filepos) &&
3149 ((index->filepos < target_filepos) ||
3150 (mkv_d->indexes[i].filepos < index->filepos))))
3151 index = &mkv_d->indexes[i];
3152
3153 if (!index)
3154 return;
3155
3156 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
3157 stream_seek (s, index->filepos);
3158
3159 if (demuxer->video->id >= 0)
3160 mkv_d->v_skip_to_keyframe = 1;
3161 mkv_d->skip_to_timecode = index->timecode;
3162 mkv_d->a_skip_to_keyframe = 1;
3163
3164 demux_mkv_fill_buffer(demuxer, NULL);
3165 }
3166 }
3167
3168 static int
3169 demux_mkv_control (demuxer_t *demuxer, int cmd, void *arg)
3170 {
3171 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3172
3173 switch (cmd)
3174 {
3175 case DEMUXER_CTRL_CORRECT_PTS:
3176 return DEMUXER_CTRL_OK;
3177 case DEMUXER_CTRL_GET_TIME_LENGTH:
3178 if (mkv_d->duration == 0)
3179 return DEMUXER_CTRL_DONTKNOW;
3180
3181 *((double *)arg) = (double)mkv_d->duration;
3182 return DEMUXER_CTRL_OK;
3183
3184 case DEMUXER_CTRL_GET_PERCENT_POS:
3185 if (mkv_d->duration == 0)
3186 {
3187 return DEMUXER_CTRL_DONTKNOW;
3188 }
3189
3190 *((int *) arg) = (int) (100 * mkv_d->last_pts / mkv_d->duration);
3191 return DEMUXER_CTRL_OK;
3192
3193 case DEMUXER_CTRL_SWITCH_AUDIO:
3194 if (demuxer->audio && demuxer->audio->sh) {
3195 sh_audio_t *sh = demuxer->a_streams[demuxer->audio->id];
3196 int aid = *(int*)arg;
3197 if (aid < 0)
3198 aid = (sh->aid + 1) % mkv_d->last_aid;
3199 if (aid != sh->aid) {
3200 mkv_track_t *track = demux_mkv_find_track_by_num (mkv_d, aid, MATROSKA_TRACK_AUDIO);
3201 if (track) {
3202 demuxer->audio->id = track->tnum;
3203 sh = demuxer->a_streams[demuxer->audio->id];
3204 ds_free_packs(demuxer->audio);
3205 }
3206 }
3207 *(int*)arg = sh->aid;
3208 } else
3209 *(int*)arg = -2;
3210 return DEMUXER_CTRL_OK;
3211
3212 default:
3213 return DEMUXER_CTRL_NOTIMPL;
3214 }
3215 }
3216
3217 const demuxer_desc_t demuxer_desc_matroska = {
3218 "Matroska demuxer",
3219 "mkv",
3220 "Matroska",
3221 "Aurelien Jacobs",
3222 "",
3223 DEMUXER_TYPE_MATROSKA,
3224 1, // safe autodetect
3225 demux_mkv_open,
3226 demux_mkv_fill_buffer,
3227 NULL,
3228 demux_close_mkv,
3229 demux_mkv_seek,
3230 demux_mkv_control
3231 };
MPlayer development branch