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