?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
demux_mkv: support reading all headers based on SeekHead
[mplayer/kovensky.git] / libmpdemux / demux_mkv.c
blobfe925f15ec2a4041a00415fb2c510ff9fb4652fe
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 uint64_t length, l, time, track, pos;
959 int i, il;
960
961 if (index_mode == 0 || index_mode == 2) {
962 ebml_read_skip(s, NULL);
963 return 0;
964 }
965
966 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing cues ] -----------\n");
967 length = ebml_read_length(s, NULL);
968
969 while (length > 0) {
970 time = track = pos = EBML_UINT_INVALID;
971
972 switch (ebml_read_id(s, &il)) {
973 case MATROSKA_ID_CUEPOINT:;
974 uint64_t len;
975
976 len = ebml_read_length(s, &i);
977 l = len + i;
978
979 while (len > 0) {
980 uint64_t l;
981 int il;
982
983 switch (ebml_read_id(s, &il)) {
984 case MATROSKA_ID_CUETIME:
985 time = ebml_read_uint(s, &l);
986 break;
987
988 case MATROSKA_ID_CUETRACKPOSITIONS:;
989 uint64_t le = ebml_read_length(s, &i);
990 l = le + i;
991
992 while (le > 0) {
993 uint64_t l;
994 int il;
995
996 switch (ebml_read_id(s, &il)) {
997 case MATROSKA_ID_CUETRACK:
998 track = ebml_read_uint(s, &l);
999 break;
1000
1001 case MATROSKA_ID_CUECLUSTERPOSITION:
1002 pos = ebml_read_uint(s, &l);
1003 break;
1004
1005 default:
1006 ebml_read_skip(s, &l);
1007 break;
1008 }
1009 le -= l + il;
1010 }
1011 break;
1012
1013 default:
1014 ebml_read_skip(s, &l);
1015 break;
1016 }
1017 len -= l + il;
1018 }
1019 break;
1020
1021 default:
1022 ebml_read_skip(s, &l);
1023 break;
1024 }
1025
1026 length -= l + il;
1027
1028 if (time != EBML_UINT_INVALID && track != EBML_UINT_INVALID
1029 && pos != EBML_UINT_INVALID) {
1030 mkv_d->indexes =
1031 grow_array(mkv_d->indexes, mkv_d->num_indexes,
1032 sizeof(mkv_index_t));
1033 mkv_d->indexes[mkv_d->num_indexes].tnum = track;
1034 mkv_d->indexes[mkv_d->num_indexes].timecode = time;
1035 mkv_d->indexes[mkv_d->num_indexes].filepos =
1036 mkv_d->segment_start + pos;
1037 mp_msg(MSGT_DEMUX, MSGL_DBG2,
1038 "[mkv] |+ found cue point " "for track %" PRIu64
1039 ": timecode %" PRIu64 ", filepos: %" PRIu64 "\n", track,
1040 time, mkv_d->segment_start + pos);
1041 mkv_d->num_indexes++;
1042 }
1043 }
1044
1045 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing cues ] -----------\n");
1046 return 0;
1047 }
1048
1049 static uint64_t read_one_chapter(struct demuxer *demuxer, stream_t *s,
1050 struct matroska_chapter *chapters,
1051 int chapter_num)
1052 {
1053 uint64_t len, l;
1054 uint64_t start = 0, end = 0;
1055 struct matroska_chapter chapter = { };
1056 char *name = 0;
1057 int i;
1058 uint32_t id;
1059 bool badchapter = false;
1060
1061 len = ebml_read_length(s, &i);
1062 uint64_t bytes_read = len + i;
1063
1064 while (len > 0) {
1065 id = ebml_read_id(s, &i);
1066 len -= i;
1067 switch (id) {
1068 case MATROSKA_ID_CHAPTERTIMESTART:
1069 start = ebml_read_uint(s, &l) / 1000000;
1070 len -= l;
1071 break;
1072
1073 case MATROSKA_ID_CHAPTERTIMEEND:
1074 end = ebml_read_uint(s, &l) / 1000000;
1075 len -= l;
1076 break;
1077
1078 case MATROSKA_ID_CHAPTERDISPLAY:;
1079 uint64_t displaylen = ebml_read_length(s, &i);
1080 len -= displaylen + i;
1081 while (displaylen > 0) {
1082 id = ebml_read_id(s, &i);
1083 displaylen -= i;
1084 switch (id) {
1085 case MATROSKA_ID_CHAPSTRING:
1086 name = ebml_read_utf8(s, &l);
1087 break;
1088 default:
1089 ebml_read_skip(s, &l);
1090 break;
1091 }
1092 displaylen -= l;
1093 }
1094 break;
1095
1096 case MATROSKA_ID_CHAPTERSEGMENTUID:
1097 l = ebml_read_length(s, &i);
1098 len -= l + i;
1099 if (l != sizeof(chapter.segment_uid)) {
1100 mp_msg(MSGT_DEMUX, MSGL_INFO,
1101 "[mkv] chapter segment uid invalid length %" PRIu64
1102 "\n", l);
1103 stream_skip(s, l);
1104 } else {
1105 stream_read(s, chapter.segment_uid, l);
1106 chapter.has_segment_uid = true;
1107 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Chapter segment uid ");
1108 for (int i = 0; i < l; i++)
1109 mp_msg(MSGT_DEMUX, MSGL_V, "%02x ",
1110 chapter.segment_uid[i]);
1111 mp_msg(MSGT_DEMUX, MSGL_V, "\n");
1112 }
1113 break;
1114
1115 case MATROSKA_ID_CHAPTERSEGMENTEDITIONUID:
1116 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
1117 "[mkv] Warning: unsupported edition recursion in chapter; "
1118 "will skip on playback!\n");
1119 ebml_read_skip(s, &l);
1120 len -= l;
1121 badchapter = true;
1122 break;
1123
1124 default:
1125 ebml_read_skip(s, &l);
1126 len -= l;
1127 break;
1128 }
1129 }
1130
1131 if (!name)
1132 name = strdup("(unnamed)");
1133
1134 chapter.start = start;
1135 chapter.end = end;
1136 chapter.name = talloc_strdup(chapters, name);
1137 chapters[chapter_num] = chapter;
1138
1139 if (badchapter) {
1140 memset(&chapter.segment_uid, 0, sizeof(chapter.segment_uid));
1141 goto cleanup;
1142 }
1143
1144 mp_msg(MSGT_DEMUX, MSGL_V,
1145 "[mkv] Chapter %u from %02d:%02d:%02d."
1146 "%03d to %02d:%02d:%02d.%03d, %s\n", chapter_num,
1147 (int) (start / 60 / 60 / 1000), (int) ((start / 60 / 1000) % 60),
1148 (int) ((start / 1000) % 60), (int) (start % 1000),
1149 (int) (end / 60 / 60 / 1000), (int) ((end / 60 / 1000) % 60),
1150 (int) ((end / 1000) % 60), (int) (end % 1000), name);
1151
1152 cleanup:
1153 free(name);
1154 return bytes_read;
1155 }
1156
1157 static int demux_mkv_read_chapters(struct demuxer *demuxer)
1158 {
1159 struct MPOpts *opts = demuxer->opts;
1160 stream_t *s = demuxer->stream;
1161 uint64_t length, l;
1162 int i;
1163 uint32_t id;
1164
1165 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing chapters ] ---------\n");
1166 length = ebml_read_length(s, NULL);
1167
1168 struct matroska_chapter *selected_chapters = NULL;
1169 int num_selected_chapters = 0;
1170 bool have_default = false;
1171 bool have_user_specified = false;
1172 int selected_edition = -1;
1173 bool se_is_ordered = false;
1174 int cur_idx = -1;
1175 while (length > 0) {
1176 id = ebml_read_id(s, &i);
1177 length -= i;
1178 switch (id) {
1179 case MATROSKA_ID_EDITIONENTRY:
1180 cur_idx++;
1181 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] New edition %d\n", cur_idx);
1182 uint64_t editionlen = ebml_read_length(s, &i);
1183 length -= editionlen + i;
1184 bool defaultflag = false;
1185 bool ordered = false;
1186 struct matroska_chapter *chapters = NULL;
1187 int num_chapters = 0;
1188 while (editionlen > 0) {
1189 id = ebml_read_id(s, &i);
1190 editionlen -= i;
1191 switch (id) {
1192 case MATROSKA_ID_CHAPTERATOM:
1193 chapters =
1194 talloc_realloc(demuxer, chapters,
1195 struct matroska_chapter,
1196 num_chapters + 1);
1197 l = read_one_chapter(demuxer, s, chapters, num_chapters++);
1198 break;
1199 case MATROSKA_ID_EDITIONFLAGDEFAULT:
1200 defaultflag = ebml_read_uint(s, &l);
1201 mp_msg(MSGT_DEMUX, MSGL_V,
1202 "[mkv] Default edition flag: %d\n", defaultflag);
1203 break;
1204 case MATROSKA_ID_EDITIONFLAGORDERED:
1205 ordered = ebml_read_uint(s, &l);
1206 mp_msg(MSGT_DEMUX, MSGL_V,
1207 "[mkv] Ordered chapter flag: %d\n", ordered);
1208 break;
1209
1210 default:
1211 ebml_read_skip(s, &l);
1212 break;
1213 }
1214 editionlen -= l;
1215 }
1216 if (cur_idx == opts->edition_id) {
1217 have_user_specified = true;
1218 mp_msg(MSGT_DEMUX, MSGL_V,
1219 "[mkv] Found user-selected edition\n");
1220 } else if (!have_user_specified && !have_default && defaultflag) {
1221 have_default = true;
1222 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Default edition: %d\n",
1223 cur_idx);
1224 } else if (selected_edition < 0) {
1225 ;
1226 } else {
1227 talloc_free(chapters);
1228 break;
1229 }
1230 selected_edition = cur_idx;
1231 talloc_free(selected_chapters);
1232 selected_chapters = chapters;
1233 num_selected_chapters = num_chapters;
1234 se_is_ordered = ordered;
1235 break;
1236
1237 default:
1238 ebml_read_skip(s, &l);
1239 length -= l;
1240 break;
1241 }
1242 }
1243 if (cur_idx > 0)
1244 mp_msg(MSGT_DEMUX, MSGL_INFO,
1245 "[mkv] Found %d editions, will play #%d (first is 0).\n",
1246 cur_idx + 1, selected_edition);
1247
1248 for (i = 0; i < num_selected_chapters; i++)
1249 demuxer_add_chapter(demuxer, selected_chapters[i].name,
1250 selected_chapters[i].start,
1251 selected_chapters[i].end);
1252 struct matroska_data *m = &demuxer->matroska_data;
1253 talloc_free(m->ordered_chapters);
1254 if (se_is_ordered) {
1255 m->ordered_chapters = selected_chapters;
1256 m->num_ordered_chapters = num_selected_chapters;
1257 } else {
1258 m->ordered_chapters = NULL;
1259 m->num_ordered_chapters = 0;
1260 talloc_free(selected_chapters);
1261 }
1262
1263 mp_msg(MSGT_DEMUX, MSGL_V,
1264 "[mkv] \\---- [ parsing chapters ] ---------\n");
1265 return 0;
1266 }
1267
1268 static int demux_mkv_read_tags(demuxer_t *demuxer)
1269 {
1270 ebml_read_skip(demuxer->stream, NULL);
1271 return 0;
1272 }
1273
1274 static int demux_mkv_read_attachments(demuxer_t *demuxer)
1275 {
1276 stream_t *s = demuxer->stream;
1277 uint64_t length, l;
1278 int il;
1279
1280 mp_msg(MSGT_DEMUX, MSGL_V,
1281 "[mkv] /---- [ parsing attachments ] ---------\n");
1282 length = ebml_read_length(s, NULL);
1283
1284 while (length > 0) {
1285 switch (ebml_read_id(s, &il)) {
1286 case MATROSKA_ID_ATTACHEDFILE:;
1287 uint64_t len;
1288 int i;
1289 char *name = NULL;
1290 char *mime = NULL;
1291 char *data = NULL;
1292 int data_size = 0;
1293
1294 len = ebml_read_length(s, &i);
1295 l = len + i;
1296
1297 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + an attachment...\n");
1298
1299 while (len > 0) {
1300 uint64_t l;
1301 int il;
1302
1303 switch (ebml_read_id(s, &il)) {
1304 case MATROSKA_ID_FILENAME:
1305 free(name);
1306 name = ebml_read_utf8(s, &l);
1307 if (name == NULL)
1308 goto error;
1309 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + FileName: %s\n",
1310 name);
1311 break;
1312
1313 case MATROSKA_ID_FILEMIMETYPE:
1314 free(mime);
1315 mime = ebml_read_ascii(s, &l);
1316 if (mime == NULL)
1317 goto error;
1318 mp_msg(MSGT_DEMUX, MSGL_V,
1319 "[mkv] | + FileMimeType: %s\n", mime);
1320 break;
1321
1322 case MATROSKA_ID_FILEDATA:;
1323 int x;
1324 uint64_t num = ebml_read_length(s, &x);
1325 l = x + num;
1326 free(data);
1327 data = malloc(num);
1328 if (stream_read(s, data, num) != (int) num) {
1329 error:
1330 free(data);
1331 free(mime);
1332 free(name);
1333 return 0;
1334 }
1335 data_size = num;
1336 mp_msg(MSGT_DEMUX, MSGL_V,
1337 "[mkv] | + FileData, length " "%u\n",
1338 data_size);
1339 break;
1340
1341 default:
1342 ebml_read_skip(s, &l);
1343 break;
1344 }
1345 len -= l + il;
1346 }
1347
1348 demuxer_add_attachment(demuxer, name, mime, data, data_size);
1349 free(data);
1350 free(mime);
1351 free(name);
1352 mp_msg(MSGT_DEMUX, MSGL_V,
1353 "[mkv] Attachment: %s, %s, %u bytes\n", name, mime,
1354 data_size);
1355 break;
1356
1357 default:
1358 ebml_read_skip(s, &l);
1359 break;
1360 }
1361 length -= l + il;
1362 }
1363
1364 mp_msg(MSGT_DEMUX, MSGL_V,
1365 "[mkv] \\---- [ parsing attachments ] ---------\n");
1366 return 0;
1367 }
1368
1369 static int read_header_element(struct demuxer *demuxer, uint32_t id,
1370 off_t at_filepos);
1371
1372 static int demux_mkv_read_seekhead(demuxer_t *demuxer)
1373 {
1374 struct mkv_demuxer *mkv_d = demuxer->priv;
1375 struct stream *s = demuxer->stream;
1376 int res = 0;
1377 struct ebml_seek_head seekhead = {};
1378 struct ebml_parse_ctx parse_ctx = {};
1379
1380 mp_msg(MSGT_DEMUX, MSGL_V,
1381 "[mkv] /---- [ parsing seek head ] ---------\n");
1382 if (ebml_read_element(s, &parse_ctx, &seekhead, &ebml_seek_head_desc) < 0) {
1383 res = 1;
1384 goto out;
1385 }
1386 /* off now holds the position of the next element after the seek head. */
1387 off_t off = stream_tell(s);
1388 for (int i = 0; i < seekhead.n_seek; i++) {
1389 struct ebml_seek *seek = &seekhead.seek[i];
1390 if (seek->n_seek_id != 1 || seek->n_seek_position != 1) {
1391 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Invalid SeekHead entry\n");
1392 continue;
1393 }
1394 uint64_t pos = seek->seek_position + mkv_d->segment_start;
1395 if (pos >= demuxer->movi_end) {
1396 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] SeekHead position beyond "
1397 "end of file - incomplete file?\n");
1398 continue;
1399 }
1400 read_header_element(demuxer, seek->seek_id, pos);
1401 }
1402 if (!stream_seek(s, off)) {
1403 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Couldn't seek back after "
1404 "SeekHead??\n");
1405 res = 1;
1406 }
1407 out:
1408 mp_msg(MSGT_DEMUX, MSGL_V,
1409 "[mkv] \\---- [ parsing seek head ] ---------\n");
1410 talloc_free(parse_ctx.talloc_ctx);
1411 return res;
1412 }
1413
1414 static bool seek_pos_id(struct stream *s, off_t pos, uint32_t id)
1415 {
1416 if (!stream_seek(s, pos)) {
1417 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Failed to seek in file\n");
1418 return false;
1419 }
1420 if (ebml_read_id(s, NULL) != id) {
1421 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Expected element not found\n");
1422 return false;
1423 }
1424 return true;
1425 }
1426
1427 static int read_header_element(struct demuxer *demuxer, uint32_t id,
1428 off_t at_filepos)
1429 {
1430 struct mkv_demuxer *mkv_d = demuxer->priv;
1431 stream_t *s = demuxer->stream;
1432 off_t pos = stream_tell(s) - 4;
1433
1434 switch(id) {
1435 case MATROSKA_ID_INFO:
1436 if (mkv_d->parsed_info)
1437 break;
1438 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1439 return -1;
1440 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ segment information...\n");
1441 mkv_d->parsed_info = true;
1442 return demux_mkv_read_info(demuxer) ? -1 : 1;
1443
1444 case MATROSKA_ID_TRACKS:
1445 if (mkv_d->parsed_tracks)
1446 break;
1447 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1448 return -1;
1449 mkv_d->parsed_tracks = true;
1450 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ segment tracks...\n");
1451 return demux_mkv_read_tracks(demuxer) ? -1 : 1;
1452
1453 case MATROSKA_ID_CUES:
1454 if (is_parsed_header(mkv_d, pos))
1455 break;
1456 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1457 return -1;
1458 return demux_mkv_read_cues(demuxer) ? -1 : 1;
1459
1460 case MATROSKA_ID_TAGS:
1461 if (mkv_d->parsed_tags)
1462 break;
1463 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1464 return -1;
1465 mkv_d->parsed_tags = true;
1466 return demux_mkv_read_tags(demuxer) ? -1 : 1;
1467
1468 case MATROSKA_ID_SEEKHEAD:
1469 if (is_parsed_header(mkv_d, pos))
1470 break;
1471 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1472 return -1;
1473 return demux_mkv_read_seekhead(demuxer) ? -1 : 1;
1474
1475 case MATROSKA_ID_CHAPTERS:
1476 if (mkv_d->parsed_chapters)
1477 break;
1478 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1479 return -1;
1480 mkv_d->parsed_chapters = true;
1481 return demux_mkv_read_chapters(demuxer) ? -1 : 1;
1482
1483 case MATROSKA_ID_ATTACHMENTS:
1484 if (mkv_d->parsed_attachments)
1485 break;
1486 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1487 return -1;
1488 mkv_d->parsed_attachments = true;
1489 return demux_mkv_read_attachments(demuxer) ? -1 : 1;
1490
1491 default:
1492 if (!at_filepos)
1493 ebml_read_skip(s, NULL);
1494 return 0;
1495 }
1496 if (!at_filepos)
1497 ebml_read_skip(s, NULL);
1498 return 1;
1499 }
1500
1501
1502
1503 static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track,
1504 int vid);
1505 static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track,
1506 int aid);
1507 static int demux_mkv_open_sub(demuxer_t *demuxer, mkv_track_t *track,
1508 int sid);
1509
1510 static void display_create_tracks(demuxer_t *demuxer)
1511 {
1512 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1513 int i, vid = 0, aid = 0, sid = 0;
1514
1515 for (i = 0; i < mkv_d->num_tracks; i++) {
1516 char *type = "unknown", str[32];
1517 *str = '\0';
1518 switch (mkv_d->tracks[i]->type) {
1519 case MATROSKA_TRACK_VIDEO:
1520 type = "video";
1521 demux_mkv_open_video(demuxer, mkv_d->tracks[i], vid);
1522 if (mkv_d->tracks[i]->name)
1523 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VID_%d_NAME=%s\n", vid,
1524 mkv_d->tracks[i]->name);
1525 sprintf(str, "-vid %u", vid++);
1526 break;
1527 case MATROSKA_TRACK_AUDIO:
1528 type = "audio";
1529 demux_mkv_open_audio(demuxer, mkv_d->tracks[i], aid);
1530 if (mkv_d->tracks[i]->name)
1531 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_NAME=%s\n", aid,
1532 mkv_d->tracks[i]->name);
1533 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_LANG=%s\n", aid,
1534 mkv_d->tracks[i]->language);
1535 sprintf(str, "-aid %u, -alang %.5s", aid++,
1536 mkv_d->tracks[i]->language);
1537 break;
1538 case MATROSKA_TRACK_SUBTITLE:
1539 type = "subtitles";
1540 demux_mkv_open_sub(demuxer, mkv_d->tracks[i], sid);
1541 if (mkv_d->tracks[i]->name)
1542 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_NAME=%s\n", sid,
1543 mkv_d->tracks[i]->name);
1544 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_LANG=%s\n", sid,
1545 mkv_d->tracks[i]->language);
1546 sprintf(str, "-sid %u, -slang %.5s", sid++,
1547 mkv_d->tracks[i]->language);
1548 break;
1549 }
1550 if (mkv_d->tracks[i]->name)
1551 mp_tmsg(MSGT_DEMUX, MSGL_INFO,
1552 "[mkv] Track ID %u: %s (%s) \"%s\", %s\n",
1553 mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id,
1554 mkv_d->tracks[i]->name, str);
1555 else
1556 mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] Track ID %u: %s (%s), %s\n",
1557 mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id,
1558 str);
1559 }
1560 }
1561
1562 typedef struct {
1563 char *id;
1564 int fourcc;
1565 int extradata;
1566 } videocodec_info_t;
1567
1568 static const videocodec_info_t vinfo[] = {
1569 {MKV_V_MPEG1, mmioFOURCC('m', 'p', 'g', '1'), 0},
1570 {MKV_V_MPEG2, mmioFOURCC('m', 'p', 'g', '2'), 0},
1571 {MKV_V_MPEG4_SP, mmioFOURCC('m', 'p', '4', 'v'), 1},
1572 {MKV_V_MPEG4_ASP, mmioFOURCC('m', 'p', '4', 'v'), 1},
1573 {MKV_V_MPEG4_AP, mmioFOURCC('m', 'p', '4', 'v'), 1},
1574 {MKV_V_MPEG4_AVC, mmioFOURCC('a', 'v', 'c', '1'), 1},
1575 {MKV_V_THEORA, mmioFOURCC('t', 'h', 'e', 'o'), 1},
1576 {NULL, 0, 0}
1577 };
1578
1579 static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track,
1580 int vid)
1581 {
1582 struct MPOpts *opts = demuxer->opts;
1583 BITMAPINFOHEADER *bih;
1584 void *ImageDesc = NULL;
1585 sh_video_t *sh_v;
1586
1587 if (track->ms_compat) { /* MS compatibility mode */
1588 BITMAPINFOHEADER *src;
1589
1590 if (track->private_data == NULL
1591 || track->private_size < sizeof(BITMAPINFOHEADER))
1592 return 1;
1593
1594 src = (BITMAPINFOHEADER *) track->private_data;
1595 bih = calloc(1, track->private_size);
1596 bih->biSize = le2me_32(src->biSize);
1597 bih->biWidth = le2me_32(src->biWidth);
1598 bih->biHeight = le2me_32(src->biHeight);
1599 bih->biPlanes = le2me_16(src->biPlanes);
1600 bih->biBitCount = le2me_16(src->biBitCount);
1601 bih->biCompression = le2me_32(src->biCompression);
1602 bih->biSizeImage = le2me_32(src->biSizeImage);
1603 bih->biXPelsPerMeter = le2me_32(src->biXPelsPerMeter);
1604 bih->biYPelsPerMeter = le2me_32(src->biYPelsPerMeter);
1605 bih->biClrUsed = le2me_32(src->biClrUsed);
1606 bih->biClrImportant = le2me_32(src->biClrImportant);
1607 memcpy((char *) bih + sizeof(BITMAPINFOHEADER),
1608 (char *) src + sizeof(BITMAPINFOHEADER),
1609 track->private_size - sizeof(BITMAPINFOHEADER));
1610
1611 if (track->v_width == 0)
1612 track->v_width = bih->biWidth;
1613 if (track->v_height == 0)
1614 track->v_height = bih->biHeight;
1615 } else {
1616 bih = calloc(1, sizeof(BITMAPINFOHEADER));
1617 bih->biSize = sizeof(BITMAPINFOHEADER);
1618 bih->biWidth = track->v_width;
1619 bih->biHeight = track->v_height;
1620 bih->biBitCount = 24;
1621 bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount / 8;
1622
1623 if (track->private_size >= RVPROPERTIES_SIZE
1624 && (!strcmp(track->codec_id, MKV_V_REALV10)
1625 || !strcmp(track->codec_id, MKV_V_REALV20)
1626 || !strcmp(track->codec_id, MKV_V_REALV30)
1627 || !strcmp(track->codec_id, MKV_V_REALV40))) {
1628 unsigned char *dst, *src;
1629 uint32_t type2;
1630 unsigned int cnt;
1631
1632 src = (uint8_t *) track->private_data + RVPROPERTIES_SIZE;
1633
1634 cnt = track->private_size - RVPROPERTIES_SIZE;
1635 bih = realloc(bih, sizeof(BITMAPINFOHEADER) + 8 + cnt);
1636 bih->biSize = 48 + cnt;
1637 bih->biPlanes = 1;
1638 type2 = AV_RB32(src - 4);
1639 if (type2 == 0x10003000 || type2 == 0x10003001)
1640 bih->biCompression = mmioFOURCC('R', 'V', '1', '3');
1641 else
1642 bih->biCompression =
1643 mmioFOURCC('R', 'V', track->codec_id[9], '0');
1644 dst = (unsigned char *) (bih + 1);
1645 // copy type1 and type2 info from rv properties
1646 memcpy(dst, src - 8, 8);
1647 stream_read(demuxer->stream, dst + 8, cnt);
1648 track->realmedia = 1;
1649
1650 #ifdef CONFIG_QTX_CODECS
1651 } else if (track->private_size >= sizeof(ImageDescription)
1652 && !strcmp(track->codec_id, MKV_V_QUICKTIME)) {
1653 ImageDescriptionPtr idesc;
1654
1655 idesc = (ImageDescriptionPtr) track->private_data;
1656 idesc->idSize = be2me_32(idesc->idSize);
1657 idesc->cType = be2me_32(idesc->cType);
1658 idesc->version = be2me_16(idesc->version);
1659 idesc->revisionLevel = be2me_16(idesc->revisionLevel);
1660 idesc->vendor = be2me_32(idesc->vendor);
1661 idesc->temporalQuality = be2me_32(idesc->temporalQuality);
1662 idesc->spatialQuality = be2me_32(idesc->spatialQuality);
1663 idesc->width = be2me_16(idesc->width);
1664 idesc->height = be2me_16(idesc->height);
1665 idesc->hRes = be2me_32(idesc->hRes);
1666 idesc->vRes = be2me_32(idesc->vRes);
1667 idesc->dataSize = be2me_32(idesc->dataSize);
1668 idesc->frameCount = be2me_16(idesc->frameCount);
1669 idesc->depth = be2me_16(idesc->depth);
1670 idesc->clutID = be2me_16(idesc->clutID);
1671 bih->biPlanes = 1;
1672 bih->biCompression = idesc->cType;
1673 ImageDesc = idesc;
1674 #endif /* CONFIG_QTX_CODECS */
1675
1676 } else {
1677 const videocodec_info_t *vi = vinfo;
1678 while (vi->id && strcmp(vi->id, track->codec_id))
1679 vi++;
1680 bih->biCompression = vi->fourcc;
1681 if (vi->extradata && track->private_data
1682 && (track->private_size > 0)) {
1683 bih->biSize += track->private_size;
1684 bih = realloc(bih, bih->biSize);
1685 memcpy(bih + 1, track->private_data, track->private_size);
1686 }
1687 track->reorder_timecodes = opts->user_correct_pts == 0;
1688 if (!vi->id) {
1689 mp_tmsg(MSGT_DEMUX, MSGL_WARN, "[mkv] Unknown/unsupported "
1690 "CodecID (%s) or missing/bad CodecPrivate\n"
1691 "[mkv] data (track %u).\n",
1692 track->codec_id, track->tnum);
1693 free(bih);
1694 return 1;
1695 }
1696 }
1697 }
1698
1699 sh_v = new_sh_video_vid(demuxer, track->tnum, vid);
1700 sh_v->bih = bih;
1701 sh_v->format = sh_v->bih->biCompression;
1702 if (track->v_frate == 0.0)
1703 track->v_frate = 25.0;
1704 sh_v->fps = track->v_frate;
1705 sh_v->frametime = 1 / track->v_frate;
1706 sh_v->aspect = 0;
1707 if (!track->realmedia) {
1708 sh_v->disp_w = track->v_width;
1709 sh_v->disp_h = track->v_height;
1710 if (track->v_dheight)
1711 sh_v->aspect = (double) track->v_dwidth / track->v_dheight;
1712 } else {
1713 // vd_realvid.c will set aspect to disp_w/disp_h and rederive
1714 // disp_w and disp_h from the RealVideo stream contents returned
1715 // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
1716 // the Matroska file then it has already been set to PixelWidth/Height
1717 // by check_track_information.
1718 sh_v->disp_w = track->v_dwidth;
1719 sh_v->disp_h = track->v_dheight;
1720 }
1721 sh_v->ImageDesc = ImageDesc;
1722 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Aspect: %f\n", sh_v->aspect);
1723
1724 sh_v->ds = demuxer->video;
1725 return 0;
1726 }
1727
1728 static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track,
1729 int aid)
1730 {
1731 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1732 sh_audio_t *sh_a = new_sh_audio_aid(demuxer, track->tnum, aid);
1733 if (!sh_a)
1734 return 1;
1735 mkv_d->audio_tracks[mkv_d->last_aid] = track->tnum;
1736
1737 if (track->language && (strcmp(track->language, "und") != 0))
1738 sh_a->lang = strdup(track->language);
1739 sh_a->default_track = track->default_track;
1740 sh_a->ds = demuxer->audio;
1741 sh_a->wf = malloc(sizeof(WAVEFORMATEX));
1742 if (track->ms_compat && (track->private_size >= sizeof(WAVEFORMATEX))) {
1743 WAVEFORMATEX *wf = (WAVEFORMATEX *) track->private_data;
1744 sh_a->wf = realloc(sh_a->wf, track->private_size);
1745 sh_a->wf->wFormatTag = le2me_16(wf->wFormatTag);
1746 sh_a->wf->nChannels = le2me_16(wf->nChannels);
1747 sh_a->wf->nSamplesPerSec = le2me_32(wf->nSamplesPerSec);
1748 sh_a->wf->nAvgBytesPerSec = le2me_32(wf->nAvgBytesPerSec);
1749 sh_a->wf->nBlockAlign = le2me_16(wf->nBlockAlign);
1750 sh_a->wf->wBitsPerSample = le2me_16(wf->wBitsPerSample);
1751 sh_a->wf->cbSize = track->private_size - sizeof(WAVEFORMATEX);
1752 memcpy(sh_a->wf + 1, wf + 1,
1753 track->private_size - sizeof(WAVEFORMATEX));
1754 if (track->a_sfreq == 0.0)
1755 track->a_sfreq = sh_a->wf->nSamplesPerSec;
1756 if (track->a_channels == 0)
1757 track->a_channels = sh_a->wf->nChannels;
1758 if (track->a_bps == 0)
1759 track->a_bps = sh_a->wf->wBitsPerSample;
1760 track->a_formattag = sh_a->wf->wFormatTag;
1761 } else {
1762 memset(sh_a->wf, 0, sizeof(WAVEFORMATEX));
1763 if (!strcmp(track->codec_id, MKV_A_MP3)
1764 || !strcmp(track->codec_id, MKV_A_MP2))
1765 track->a_formattag = 0x0055;
1766 else if (!strncmp(track->codec_id, MKV_A_AC3, strlen(MKV_A_AC3)))
1767 track->a_formattag = 0x2000;
1768 else if (!strcmp(track->codec_id, MKV_A_DTS))
1769 track->a_formattag = 0x2001;
1770 else if (!strcmp(track->codec_id, MKV_A_PCM)
1771 || !strcmp(track->codec_id, MKV_A_PCM_BE))
1772 track->a_formattag = 0x0001;
1773 else if (!strcmp(track->codec_id, MKV_A_AAC_2MAIN)
1774 || !strncmp(track->codec_id, MKV_A_AAC_2LC,
1775 strlen(MKV_A_AAC_2LC))
1776 || !strcmp(track->codec_id, MKV_A_AAC_2SSR)
1777 || !strcmp(track->codec_id, MKV_A_AAC_4MAIN)
1778 || !strncmp(track->codec_id, MKV_A_AAC_4LC,
1779 strlen(MKV_A_AAC_4LC))
1780 || !strcmp(track->codec_id, MKV_A_AAC_4SSR)
1781 || !strcmp(track->codec_id, MKV_A_AAC_4LTP)
1782 || !strcmp(track->codec_id, MKV_A_AAC))
1783 track->a_formattag = mmioFOURCC('M', 'P', '4', 'A');
1784 else if (!strcmp(track->codec_id, MKV_A_VORBIS)) {
1785 if (track->private_data == NULL)
1786 return 1;
1787 track->a_formattag = mmioFOURCC('v', 'r', 'b', 's');
1788 } else if (!strcmp(track->codec_id, MKV_A_QDMC))
1789 track->a_formattag = mmioFOURCC('Q', 'D', 'M', 'C');
1790 else if (!strcmp(track->codec_id, MKV_A_QDMC2))
1791 track->a_formattag = mmioFOURCC('Q', 'D', 'M', '2');
1792 else if (!strcmp(track->codec_id, MKV_A_WAVPACK))
1793 track->a_formattag = mmioFOURCC('W', 'V', 'P', 'K');
1794 else if (!strcmp(track->codec_id, MKV_A_TRUEHD))
1795 track->a_formattag = mmioFOURCC('T', 'R', 'H', 'D');
1796 else if (!strcmp(track->codec_id, MKV_A_FLAC)) {
1797 if (track->private_data == NULL || track->private_size == 0) {
1798 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
1799 "[mkv] FLAC track does not contain valid headers.\n");
1800 return 1;
1801 }
1802 track->a_formattag = mmioFOURCC('f', 'L', 'a', 'C');
1803 } else if (track->private_size >= RAPROPERTIES4_SIZE) {
1804 if (!strcmp(track->codec_id, MKV_A_REAL28))
1805 track->a_formattag = mmioFOURCC('2', '8', '_', '8');
1806 else if (!strcmp(track->codec_id, MKV_A_REALATRC))
1807 track->a_formattag = mmioFOURCC('a', 't', 'r', 'c');
1808 else if (!strcmp(track->codec_id, MKV_A_REALCOOK))
1809 track->a_formattag = mmioFOURCC('c', 'o', 'o', 'k');
1810 else if (!strcmp(track->codec_id, MKV_A_REALDNET))
1811 track->a_formattag = mmioFOURCC('d', 'n', 'e', 't');
1812 else if (!strcmp(track->codec_id, MKV_A_REALSIPR))
1813 track->a_formattag = mmioFOURCC('s', 'i', 'p', 'r');
1814 } else {
1815 mp_tmsg(MSGT_DEMUX, MSGL_WARN, "[mkv] Unknown/unsupported audio "
1816 "codec ID '%s' for track %u or missing/faulty\n[mkv] "
1817 "private codec data.\n", track->codec_id, track->tnum);
1818 free_sh_audio(demuxer, track->tnum);
1819 return 1;
1820 }
1821 }
1822
1823 sh_a->format = track->a_formattag;
1824 sh_a->wf->wFormatTag = track->a_formattag;
1825 sh_a->channels = track->a_channels;
1826 sh_a->wf->nChannels = track->a_channels;
1827 sh_a->samplerate = (uint32_t) track->a_sfreq;
1828 sh_a->wf->nSamplesPerSec = (uint32_t) track->a_sfreq;
1829 if (track->a_bps == 0) {
1830 sh_a->samplesize = 2;
1831 sh_a->wf->wBitsPerSample = 16;
1832 } else {
1833 sh_a->samplesize = track->a_bps / 8;
1834 sh_a->wf->wBitsPerSample = track->a_bps;
1835 }
1836 if (track->a_formattag == 0x0055) { /* MP3 || MP2 */
1837 sh_a->wf->nAvgBytesPerSec = 16000;
1838 sh_a->wf->nBlockAlign = 1152;
1839 } else if ((track->a_formattag == 0x2000) /* AC3 */
1840 || (track->a_formattag == 0x2001)) { /* DTS */
1841 free(sh_a->wf);
1842 sh_a->wf = NULL;
1843 } else if (track->a_formattag == 0x0001) { /* PCM || PCM_BE */
1844 sh_a->wf->nAvgBytesPerSec = sh_a->channels * sh_a->samplerate * 2;
1845 sh_a->wf->nBlockAlign = sh_a->wf->nAvgBytesPerSec;
1846 if (!strcmp(track->codec_id, MKV_A_PCM_BE))
1847 sh_a->format = mmioFOURCC('t', 'w', 'o', 's');
1848 } else if (!strcmp(track->codec_id, MKV_A_QDMC)
1849 || !strcmp(track->codec_id, MKV_A_QDMC2)) {
1850 sh_a->wf->nAvgBytesPerSec = 16000;
1851 sh_a->wf->nBlockAlign = 1486;
1852 track->fix_i_bps = 1;
1853 track->qt_last_a_pts = 0.0;
1854 if (track->private_data != NULL) {
1855 sh_a->codecdata = malloc(track->private_size);
1856 memcpy(sh_a->codecdata, track->private_data, track->private_size);
1857 sh_a->codecdata_len = track->private_size;
1858 }
1859 } else if (track->a_formattag == mmioFOURCC('M', 'P', '4', 'A')) {
1860 int profile, srate_idx;
1861
1862 sh_a->wf->nAvgBytesPerSec = 16000;
1863 sh_a->wf->nBlockAlign = 1024;
1864
1865 if (!strcmp(track->codec_id, MKV_A_AAC)
1866 && (NULL != track->private_data)) {
1867 sh_a->codecdata = malloc(track->private_size);
1868 memcpy(sh_a->codecdata, track->private_data, track->private_size);
1869 sh_a->codecdata_len = track->private_size;
1870 return 0;
1871 }
1872
1873 /* Recreate the 'private data' */
1874 /* which faad2 uses in its initialization */
1875 srate_idx = aac_get_sample_rate_index(sh_a->samplerate);
1876 if (!strncmp(&track->codec_id[12], "MAIN", 4))
1877 profile = 0;
1878 else if (!strncmp(&track->codec_id[12], "LC", 2))
1879 profile = 1;
1880 else if (!strncmp(&track->codec_id[12], "SSR", 3))
1881 profile = 2;
1882 else
1883 profile = 3;
1884 sh_a->codecdata = malloc(5);
1885 sh_a->codecdata[0] = ((profile + 1) << 3) | ((srate_idx & 0xE) >> 1);
1886 sh_a->codecdata[1] =
1887 ((srate_idx & 0x1) << 7) | (track->a_channels << 3);
1888
1889 if (strstr(track->codec_id, "SBR") != NULL) {
1890 /* HE-AAC (aka SBR AAC) */
1891 sh_a->codecdata_len = 5;
1892
1893 sh_a->samplerate *= 2;
1894 sh_a->wf->nSamplesPerSec *= 2;
1895 srate_idx = aac_get_sample_rate_index(sh_a->samplerate);
1896 sh_a->codecdata[2] = AAC_SYNC_EXTENSION_TYPE >> 3;
1897 sh_a->codecdata[3] = ((AAC_SYNC_EXTENSION_TYPE & 0x07) << 5) | 5;
1898 sh_a->codecdata[4] = (1 << 7) | (srate_idx << 3);
1899 track->default_duration = 1024.0 / (sh_a->samplerate / 2);
1900 } else {
1901 sh_a->codecdata_len = 2;
1902 track->default_duration = 1024.0 / sh_a->samplerate;
1903 }
1904 } else if (track->a_formattag == mmioFOURCC('v', 'r', 'b', 's')) { /* VORBIS */
1905 sh_a->wf->cbSize = track->private_size;
1906 sh_a->wf = realloc(sh_a->wf, sizeof(WAVEFORMATEX) + sh_a->wf->cbSize);
1907 memcpy((unsigned char *) (sh_a->wf + 1), track->private_data,
1908 sh_a->wf->cbSize);
1909 } else if (track->private_size >= RAPROPERTIES4_SIZE
1910 && !strncmp(track->codec_id, MKV_A_REALATRC, 7)) {
1911 /* Common initialization for all RealAudio codecs */
1912 unsigned char *src = track->private_data;
1913 int codecdata_length, version;
1914 int flavor;
1915
1916 sh_a->wf->nAvgBytesPerSec = 0; /* FIXME !? */
1917
1918 version = AV_RB16(src + 4);
1919 flavor = AV_RB16(src + 22);
1920 track->coded_framesize = AV_RB32(src + 24);
1921 track->sub_packet_h = AV_RB16(src + 40);
1922 sh_a->wf->nBlockAlign = track->audiopk_size = AV_RB16(src + 42);
1923 track->sub_packet_size = AV_RB16(src + 44);
1924 if (version == 4) {
1925 src += RAPROPERTIES4_SIZE;
1926 src += src[0] + 1;
1927 src += src[0] + 1;
1928 } else
1929 src += RAPROPERTIES5_SIZE;
1930
1931 src += 3;
1932 if (version == 5)
1933 src++;
1934 codecdata_length = AV_RB32(src);
1935 src += 4;
1936 sh_a->wf->cbSize = codecdata_length;
1937 sh_a->wf = realloc(sh_a->wf, sizeof(WAVEFORMATEX) + sh_a->wf->cbSize);
1938 memcpy(((char *) (sh_a->wf + 1)), src, codecdata_length);
1939
1940 switch (track->a_formattag) {
1941 case mmioFOURCC('a', 't', 'r', 'c'):
1942 sh_a->wf->nAvgBytesPerSec = atrc_fl2bps[flavor];
1943 sh_a->wf->nBlockAlign = track->sub_packet_size;
1944 track->audio_buf =
1945 malloc(track->sub_packet_h * track->audiopk_size);
1946 track->audio_timestamp =
1947 malloc(track->sub_packet_h * sizeof(double));
1948 break;
1949 case mmioFOURCC('c', 'o', 'o', 'k'):
1950 sh_a->wf->nAvgBytesPerSec = cook_fl2bps[flavor];
1951 sh_a->wf->nBlockAlign = track->sub_packet_size;
1952 track->audio_buf =
1953 malloc(track->sub_packet_h * track->audiopk_size);
1954 track->audio_timestamp =
1955 malloc(track->sub_packet_h * sizeof(double));
1956 break;
1957 case mmioFOURCC('s', 'i', 'p', 'r'):
1958 sh_a->wf->nAvgBytesPerSec = sipr_fl2bps[flavor];
1959 sh_a->wf->nBlockAlign = track->coded_framesize;
1960 track->audio_buf =
1961 malloc(track->sub_packet_h * track->audiopk_size);
1962 track->audio_timestamp =
1963 malloc(track->sub_packet_h * sizeof(double));
1964 break;
1965 case mmioFOURCC('2', '8', '_', '8'):
1966 sh_a->wf->nAvgBytesPerSec = 3600;
1967 sh_a->wf->nBlockAlign = track->coded_framesize;
1968 track->audio_buf =
1969 malloc(track->sub_packet_h * track->audiopk_size);
1970 track->audio_timestamp =
1971 malloc(track->sub_packet_h * sizeof(double));
1972 break;
1973 }
1974
1975 track->realmedia = 1;
1976 } else if (!strcmp(track->codec_id, MKV_A_FLAC)
1977 || (track->a_formattag == 0xf1ac)) {
1978 unsigned char *ptr;
1979 int size;
1980 free(sh_a->wf);
1981 sh_a->wf = NULL;
1982
1983 if (track->a_formattag == mmioFOURCC('f', 'L', 'a', 'C')) {
1984 ptr = track->private_data;
1985 size = track->private_size;
1986 } else {
1987 sh_a->format = mmioFOURCC('f', 'L', 'a', 'C');
1988 ptr = track->private_data + sizeof(WAVEFORMATEX);
1989 size = track->private_size - sizeof(WAVEFORMATEX);
1990 }
1991 if (size < 4 || ptr[0] != 'f' || ptr[1] != 'L' || ptr[2] != 'a'
1992 || ptr[3] != 'C') {
1993 sh_a->codecdata = malloc(4);
1994 sh_a->codecdata_len = 4;
1995 memcpy(sh_a->codecdata, "fLaC", 4);
1996 } else {
1997 sh_a->codecdata = malloc(size);
1998 sh_a->codecdata_len = size;
1999 memcpy(sh_a->codecdata, ptr, size);
2000 }
2001 } else if (track->a_formattag == mmioFOURCC('W', 'V', 'P', 'K') || track->a_formattag == mmioFOURCC('T', 'R', 'H', 'D')) { /* do nothing, still works */
2002 } else if (!track->ms_compat
2003 || (track->private_size < sizeof(WAVEFORMATEX))) {
2004 free_sh_audio(demuxer, track->tnum);
2005 return 1;
2006 }
2007
2008 return 0;
2009 }
2010
2011 static int demux_mkv_open_sub(demuxer_t *demuxer, mkv_track_t *track,
2012 int sid)
2013 {
2014 if (track->subtitle_type != MATROSKA_SUBTYPE_UNKNOWN) {
2015 int size, m;
2016 uint8_t *buffer;
2017 sh_sub_t *sh = new_sh_sub_sid(demuxer, track->tnum, sid);
2018 track->sh_sub = sh;
2019 sh->type = 't';
2020 if (track->subtitle_type == MATROSKA_SUBTYPE_VOBSUB)
2021 sh->type = 'v';
2022 if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
2023 sh->type = 'a';
2024 size = track->private_size;
2025 m = demux_mkv_decode(track, track->private_data, &buffer, &size, 2);
2026 if (buffer && m) {
2027 free(track->private_data);
2028 track->private_data = buffer;
2029 track->private_size = size;
2030 }
2031 sh->extradata = malloc(track->private_size);
2032 memcpy(sh->extradata, track->private_data, track->private_size);
2033 sh->extradata_len = track->private_size;
2034 if (track->language && (strcmp(track->language, "und") != 0))
2035 sh->lang = strdup(track->language);
2036 sh->default_track = track->default_track;
2037 } else {
2038 mp_tmsg(MSGT_DEMUX, MSGL_ERR,
2039 "[mkv] Subtitle type '%s' is not supported.\n",
2040 track->codec_id);
2041 return 1;
2042 }
2043
2044 return 0;
2045 }
2046
2047 static int demux_mkv_open(demuxer_t *demuxer)
2048 {
2049 stream_t *s = demuxer->stream;
2050 mkv_demuxer_t *mkv_d;
2051 mkv_track_t *track;
2052 int i, cont = 0;
2053
2054 stream_seek(s, s->start_pos);
2055 if (ebml_read_id(s, NULL) != EBML_ID_EBML)
2056 return 0;
2057 struct ebml_ebml ebml_master = {};
2058 struct ebml_parse_ctx parse_ctx = { .no_error_messages = true };
2059 if (ebml_read_element(s, &parse_ctx, &ebml_master, &ebml_ebml_desc) < 0)
2060 return 0;
2061 if (ebml_master.doc_type.len != 8 || strncmp(ebml_master.doc_type.start,
2062 "matroska", 8)) {
2063 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] no head found\n");
2064 talloc_free(parse_ctx.talloc_ctx);
2065 return 0;
2066 }
2067 if (ebml_master.doc_type_read_version > 2) {
2068 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] This looks like a Matroska file, "
2069 "but we don't support format version %"PRIu64"\n",
2070 ebml_master.doc_type_read_version);
2071 talloc_free(parse_ctx.talloc_ctx);
2072 return 0;
2073 }
2074 if ((ebml_master.n_ebml_read_version
2075 && ebml_master.ebml_read_version != EBML_VERSION)
2076 || (ebml_master.n_ebml_max_size_length
2077 && ebml_master.ebml_max_size_length > 8)
2078 || (ebml_master.n_ebml_max_id_length
2079 && ebml_master.ebml_max_id_length != 4)) {
2080 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] This looks like a Matroska file, "
2081 "but the header has bad parameters\n");
2082 talloc_free(parse_ctx.talloc_ctx);
2083 return 0;
2084 }
2085 talloc_free(parse_ctx.talloc_ctx);
2086
2087 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Found the head...\n");
2088
2089 if (ebml_read_id(s, NULL) != MATROSKA_ID_SEGMENT) {
2090 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] but no segment :(\n");
2091 return 0;
2092 }
2093 ebml_read_length(s, NULL); /* return bytes number until EOF */
2094
2095 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] + a segment...\n");
2096
2097 mkv_d = talloc_zero(demuxer, struct mkv_demuxer);
2098 demuxer->priv = mkv_d;
2099 mkv_d->tc_scale = 1000000;
2100 mkv_d->segment_start = stream_tell(s);
2101
2102 while (!cont) {
2103 uint32_t id = ebml_read_id(s, NULL);
2104 switch (id) {
2105 case MATROSKA_ID_CLUSTER:
2106 mp_msg(MSGT_DEMUX, MSGL_V,
2107 "[mkv] |+ found cluster, headers are "
2108 "parsed completely :)\n");
2109 stream_seek(s, stream_tell(s) - 4);
2110 cont = 1;
2111 break;
2112
2113 default:
2114 cont = read_header_element(demuxer, id, 0) < 1;
2115 break;
2116 case EBML_ID_VOID:
2117 ebml_read_skip(s, NULL);
2118 break;
2119 }
2120 }
2121
2122 display_create_tracks(demuxer);
2123
2124 /* select video track */
2125 track = NULL;
2126 if (demuxer->video->id == -1) { /* automatically select a video track */
2127 /* search for a video track that has the 'default' flag set */
2128 for (i = 0; i < mkv_d->num_tracks; i++)
2129 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO
2130 && mkv_d->tracks[i]->default_track) {
2131 track = mkv_d->tracks[i];
2132 break;
2133 }
2134
2135 if (track == NULL)
2136 /* no track has the 'default' flag set */
2137 /* let's take the first video track */
2138 for (i = 0; i < mkv_d->num_tracks; i++)
2139 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO) {
2140 track = mkv_d->tracks[i];
2141 break;
2142 }
2143 } else if (demuxer->video->id != -2) /* -2 = no video at all */
2144 track =
2145 demux_mkv_find_track_by_num(mkv_d, demuxer->video->id,
2146 MATROSKA_TRACK_VIDEO);
2147
2148 if (track && demuxer->v_streams[track->tnum]) {
2149 mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] Will play video track %u.\n",
2150 track->tnum);
2151 demuxer->video->id = track->tnum;
2152 demuxer->video->sh = demuxer->v_streams[track->tnum];
2153 } else {
2154 mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] No video track found/wanted.\n");
2155 demuxer->video->id = -2;
2156 }
2157
2158 /* select audio track */
2159 track = NULL;
2160 if (track == NULL)
2161 /* search for an audio track that has the 'default' flag set */
2162 for (i = 0; i < mkv_d->num_tracks; i++)
2163 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO
2164 && mkv_d->tracks[i]->default_track) {
2165 track = mkv_d->tracks[i];
2166 break;
2167 }
2168
2169 if (track == NULL)
2170 /* no track has the 'default' flag set */
2171 /* let's take the first audio track */
2172 for (i = 0; i < mkv_d->num_tracks; i++)
2173 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO) {
2174 track = mkv_d->tracks[i];
2175 break;
2176 }
2177
2178 if (track && demuxer->a_streams[track->tnum]) {
2179 demuxer->audio->id = track->tnum;
2180 demuxer->audio->sh = demuxer->a_streams[track->tnum];
2181 } else {
2182 mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] No audio track found/wanted.\n");
2183 demuxer->audio->id = -2;
2184 }
2185
2186
2187 if (demuxer->audio->id != -2)
2188 for (i = 0; i < mkv_d->num_tracks; i++) {
2189 if (mkv_d->tracks[i]->type != MATROSKA_TRACK_AUDIO)
2190 continue;
2191 if (demuxer->a_streams[track->tnum]) {
2192 mkv_d->last_aid++;
2193 if (mkv_d->last_aid == MAX_A_STREAMS)
2194 break;
2195 }
2196 }
2197
2198 if (s->end_pos == 0 || (mkv_d->indexes == NULL && index_mode < 0))
2199 demuxer->seekable = 0;
2200 else {
2201 demuxer->movi_start = s->start_pos;
2202 demuxer->movi_end = s->end_pos;
2203 demuxer->seekable = 1;
2204 }
2205
2206 demuxer->accurate_seek = true;
2207
2208 return DEMUXER_TYPE_MATROSKA;
2209 }
2210
2211 static void demux_close_mkv(demuxer_t *demuxer)
2212 {
2213 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2214
2215 if (mkv_d) {
2216 int i;
2217 free_cached_dps(demuxer);
2218 if (mkv_d->tracks) {
2219 for (i = 0; i < mkv_d->num_tracks; i++)
2220 demux_mkv_free_trackentry(mkv_d->tracks[i]);
2221 free(mkv_d->tracks);
2222 }
2223 free(mkv_d->indexes);
2224 free(mkv_d->cluster_positions);
2225 }
2226 }
2227
2228 static int demux_mkv_read_block_lacing(uint8_t *buffer, uint64_t *size,
2229 uint8_t *laces,
2230 uint32_t **all_lace_sizes)
2231 {
2232 uint32_t total = 0, *lace_size;
2233 uint8_t flags;
2234 int i;
2235
2236 *all_lace_sizes = NULL;
2237 lace_size = NULL;
2238 /* lacing flags */
2239 flags = *buffer++;
2240 (*size)--;
2241
2242 switch ((flags & 0x06) >> 1) {
2243 case 0: /* no lacing */
2244 *laces = 1;
2245 lace_size = calloc(*laces, sizeof(uint32_t));
2246 lace_size[0] = *size;
2247 break;
2248
2249 case 1: /* xiph lacing */
2250 case 2: /* fixed-size lacing */
2251 case 3: /* EBML lacing */
2252 *laces = *buffer++;
2253 (*size)--;
2254 (*laces)++;
2255 lace_size = calloc(*laces, sizeof(uint32_t));
2256
2257 switch ((flags & 0x06) >> 1) {
2258 case 1: /* xiph lacing */
2259 for (i = 0; i < *laces - 1; i++) {
2260 lace_size[i] = 0;
2261 do {
2262 lace_size[i] += *buffer;
2263 (*size)--;
2264 } while (*buffer++ == 0xFF);
2265 total += lace_size[i];
2266 }
2267 lace_size[i] = *size - total;
2268 break;
2269
2270 case 2: /* fixed-size lacing */
2271 for (i = 0; i < *laces; i++)
2272 lace_size[i] = *size / *laces;
2273 break;
2274
2275 case 3:; /* EBML lacing */
2276 int l;
2277 uint64_t num = ebml_read_vlen_uint(buffer, &l);
2278 if (num == EBML_UINT_INVALID) {
2279 free(lace_size);
2280 return 1;
2281 }
2282 buffer += l;
2283 *size -= l;
2284
2285 total = lace_size[0] = num;
2286 for (i = 1; i < *laces - 1; i++) {
2287 int64_t snum;
2288 snum = ebml_read_vlen_int(buffer, &l);
2289 if (snum == EBML_INT_INVALID) {
2290 free(lace_size);
2291 return 1;
2292 }
2293 buffer += l;
2294 *size -= l;
2295 lace_size[i] = lace_size[i - 1] + snum;
2296 total += lace_size[i];
2297 }
2298 lace_size[i] = *size - total;
2299 break;
2300 }
2301 break;
2302 }
2303 *all_lace_sizes = lace_size;
2304 return 0;
2305 }
2306
2307 static void handle_subtitles(demuxer_t *demuxer, mkv_track_t *track,
2308 char *block, int64_t size,
2309 uint64_t block_duration, uint64_t timecode)
2310 {
2311 demux_packet_t *dp;
2312
2313 if (block_duration == 0) {
2314 mp_msg(MSGT_DEMUX, MSGL_WARN,
2315 "[mkv] Warning: No BlockDuration for subtitle track found.\n");
2316 return;
2317 }
2318
2319 sub_utf8 = 1;
2320 dp = new_demux_packet(size);
2321 memcpy(dp->buffer, block, size);
2322 dp->pts = timecode / 1000.0;
2323 dp->endpts = (timecode + block_duration) / 1000.0;
2324 ds_add_packet(demuxer->sub, dp);
2325 }
2326
2327 double real_fix_timestamp(unsigned char *buf, unsigned int timestamp,
2328 unsigned int format, int64_t *kf_base, int *kf_pts,
2329 double *pts);
2330
2331 static void handle_realvideo(demuxer_t *demuxer, mkv_track_t *track,
2332 uint8_t *buffer, uint32_t size, int block_bref)
2333 {
2334 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2335 demux_packet_t *dp;
2336 uint32_t timestamp = mkv_d->last_pts * 1000;
2337
2338 dp = new_demux_packet(size);
2339 memcpy(dp->buffer, buffer, size);
2340
2341 if (mkv_d->v_skip_to_keyframe) {
2342 dp->pts = mkv_d->last_pts;
2343 track->rv_kf_base = 0;
2344 track->rv_kf_pts = timestamp;
2345 } else
2346 dp->pts =
2347 real_fix_timestamp(dp->buffer, timestamp,
2348 ((sh_video_t *) demuxer->video->sh)->bih->
2349 biCompression, &track->rv_kf_base,
2350 &track->rv_kf_pts, NULL);
2351 dp->pos = demuxer->filepos;
2352 dp->flags = block_bref ? 0 : 0x10;
2353
2354 ds_add_packet(demuxer->video, dp);
2355 }
2356
2357 static void handle_realaudio(demuxer_t *demuxer, mkv_track_t *track,
2358 uint8_t *buffer, uint32_t size, int block_bref)
2359 {
2360 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2361 int sps = track->sub_packet_size;
2362 int sph = track->sub_packet_h;
2363 int cfs = track->coded_framesize;
2364 int w = track->audiopk_size;
2365 int spc = track->sub_packet_cnt;
2366 demux_packet_t *dp;
2367 int x;
2368
2369 if ((track->a_formattag == mmioFOURCC('2', '8', '_', '8'))
2370 || (track->a_formattag == mmioFOURCC('c', 'o', 'o', 'k'))
2371 || (track->a_formattag == mmioFOURCC('a', 't', 'r', 'c'))
2372 || (track->a_formattag == mmioFOURCC('s', 'i', 'p', 'r'))) {
2373 // if(!block_bref)
2374 // spc = track->sub_packet_cnt = 0;
2375 switch (track->a_formattag) {
2376 case mmioFOURCC('2', '8', '_', '8'):
2377 for (x = 0; x < sph / 2; x++)
2378 memcpy(track->audio_buf + x * 2 * w + spc * cfs,
2379 buffer + cfs * x, cfs);
2380 break;
2381 case mmioFOURCC('c', 'o', 'o', 'k'):
2382 case mmioFOURCC('a', 't', 'r', 'c'):
2383 for (x = 0; x < w / sps; x++)
2384 memcpy(track->audio_buf +
2385 sps * (sph * x + ((sph + 1) / 2) * (spc & 1) +
2386 (spc >> 1)), buffer + sps * x, sps);
2387 break;
2388 case mmioFOURCC('s', 'i', 'p', 'r'):
2389 memcpy(track->audio_buf + spc * w, buffer, w);
2390 if (spc == sph - 1) {
2391 int n;
2392 int bs = sph * w * 2 / 96; // nibbles per subpacket
2393 // Perform reordering
2394 for (n = 0; n < 38; n++) {
2395 int j;
2396 int i = bs * sipr_swaps[n][0];
2397 int o = bs * sipr_swaps[n][1];
2398 // swap nibbles of block 'i' with 'o' TODO: optimize
2399 for (j = 0; j < bs; j++) {
2400 int x = (i & 1) ?
2401 (track->audio_buf[i >> 1] >> 4) :
2402 (track->audio_buf[i >> 1] & 0x0F);
2403 int y = (o & 1) ?
2404 (track->audio_buf[o >> 1] >> 4) :
2405 (track->audio_buf[o >> 1] & 0x0F);
2406 if (o & 1)
2407 track->audio_buf[o >> 1] =
2408 (track->audio_buf[o >> 1] & 0x0F) | (x << 4);
2409 else
2410 track->audio_buf[o >> 1] =
2411 (track->audio_buf[o >> 1] & 0xF0) | x;
2412 if (i & 1)
2413 track->audio_buf[i >> 1] =
2414 (track->audio_buf[i >> 1] & 0x0F) | (y << 4);
2415 else
2416 track->audio_buf[i >> 1] =
2417 (track->audio_buf[i >> 1] & 0xF0) | y;
2418 ++i;
2419 ++o;
2420 }
2421 }
2422 }
2423 break;
2424 }
2425 track->audio_timestamp[track->sub_packet_cnt] =
2426 (track->ra_pts == mkv_d->last_pts) ? 0 : (mkv_d->last_pts);
2427 track->ra_pts = mkv_d->last_pts;
2428 if (track->sub_packet_cnt == 0)
2429 track->audio_filepos = demuxer->filepos;
2430 if (++(track->sub_packet_cnt) == sph) {
2431 int apk_usize =
2432 ((WAVEFORMATEX *) ((sh_audio_t *) demuxer->audio->sh)->wf)->
2433 nBlockAlign;
2434 track->sub_packet_cnt = 0;
2435 // Release all the audio packets
2436 for (x = 0; x < sph * w / apk_usize; x++) {
2437 dp = new_demux_packet(apk_usize);
2438 memcpy(dp->buffer, track->audio_buf + x * apk_usize,
2439 apk_usize);
2440 /* Put timestamp only on packets that correspond to original
2441 * audio packets in file */
2442 dp->pts = (x * apk_usize % w) ? 0 :
2443 track->audio_timestamp[x * apk_usize / w];
2444 dp->pos = track->audio_filepos; // all equal
2445 dp->flags = x ? 0 : 0x10; // Mark first packet as keyframe
2446 ds_add_packet(demuxer->audio, dp);
2447 }
2448 }
2449 } else { // Not a codec that require reordering
2450 dp = new_demux_packet(size);
2451 memcpy(dp->buffer, buffer, size);
2452 if (track->ra_pts == mkv_d->last_pts && !mkv_d->a_skip_to_keyframe)
2453 dp->pts = 0;
2454 else
2455 dp->pts = mkv_d->last_pts;
2456 track->ra_pts = mkv_d->last_pts;
2457
2458 dp->pos = demuxer->filepos;
2459 dp->flags = block_bref ? 0 : 0x10;
2460 ds_add_packet(demuxer->audio, dp);
2461 }
2462 }
2463
2464 /** Reorder timecodes and add cached demux packets to the queues.
2465 *
2466 * Timecode reordering is needed if a video track contains B frames that
2467 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2468 * MPlayer doesn't like timestamps in display order. This function adjusts
2469 * the timestamp of cached frames (which are exactly one I/P frame followed
2470 * by one or more B frames) so that they are in coding order again.
2471 *
2472 * Example: The track with 25 FPS contains four frames with the timecodes
2473 * I at 0ms, P at 120ms, B at 40ms and B at 80ms. As soon as the next I
2474 * or P frame arrives these timecodes can be changed to I at 0ms, P at 40ms,
2475 * B at 80ms and B at 120ms.
2476 *
2477 * This works for simple H.264 B-frame pyramids, but not for arbitrary orders.
2478 *
2479 * \param demuxer The Matroska demuxer struct for this instance.
2480 * \param track The track structure whose cache should be handled.
2481 */
2482 static void flush_cached_dps(demuxer_t *demuxer, mkv_track_t *track)
2483 {
2484 int i, ok;
2485
2486 if (track->num_cached_dps == 0)
2487 return;
2488
2489 do {
2490 ok = 1;
2491 for (i = 1; i < track->num_cached_dps; i++)
2492 if (track->cached_dps[i - 1]->pts > track->cached_dps[i]->pts) {
2493 double tmp_pts = track->cached_dps[i - 1]->pts;
2494 track->cached_dps[i - 1]->pts = track->cached_dps[i]->pts;
2495 track->cached_dps[i]->pts = tmp_pts;
2496 ok = 0;
2497 }
2498 } while (!ok);
2499
2500 for (i = 0; i < track->num_cached_dps; i++)
2501 ds_add_packet(demuxer->video, track->cached_dps[i]);
2502 track->num_cached_dps = 0;
2503 }
2504
2505 /** Cache video frames if timecodes have to be reordered.
2506 *
2507 * Timecode reordering is needed if a video track contains B frames that
2508 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2509 * This function takes in a Matroska block read from the file, allocates a
2510 * demux packet for it, fills in its values, allocates space for storing
2511 * pointers to the cached demux packets and adds the packet to it. If
2512 * the packet contains an I or a P frame then ::flush_cached_dps is called
2513 * in order to send the old cached frames downstream.
2514 *
2515 * \param demuxer The Matroska demuxer struct for this instance.
2516 * \param track The packet is meant for this track.
2517 * \param buffer The actual frame contents.
2518 * \param size The frame size in bytes.
2519 * \param block_bref A relative timecode (backward reference). If it is \c 0
2520 * then the frame is an I frame.
2521 * \param block_fref A relative timecode (forward reference). If it is \c 0
2522 * then the frame is either an I frame or a P frame depending on the value
2523 * of \a block_bref. Otherwise it's a B frame.
2524 */
2525 static void handle_video_bframes(demuxer_t *demuxer, mkv_track_t *track,
2526 uint8_t *buffer, uint32_t size,
2527 int block_bref, int block_fref)
2528 {
2529 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2530 demux_packet_t *dp;
2531
2532 dp = new_demux_packet(size);
2533 memcpy(dp->buffer, buffer, size);
2534 dp->pos = demuxer->filepos;
2535 dp->pts = mkv_d->last_pts;
2536 if ((track->num_cached_dps > 0) && (dp->pts < track->max_pts))
2537 block_fref = 1;
2538 if (block_fref == 0) /* I or P frame */
2539 flush_cached_dps(demuxer, track);
2540 if (block_bref != 0) /* I frame, don't cache it */
2541 dp->flags = 0x10;
2542 if ((track->num_cached_dps + 1) > track->num_allocated_dps) {
2543 track->cached_dps = (demux_packet_t **)
2544 realloc(track->cached_dps,
2545 (track->num_cached_dps + 10) * sizeof(demux_packet_t *));
2546 track->num_allocated_dps += 10;
2547 }
2548 track->cached_dps[track->num_cached_dps] = dp;
2549 track->num_cached_dps++;
2550 if (dp->pts > track->max_pts)
2551 track->max_pts = dp->pts;
2552 }
2553
2554 static int handle_block(demuxer_t *demuxer, uint8_t *block, uint64_t length,
2555 uint64_t block_duration, int64_t block_bref,
2556 int64_t block_fref, uint8_t simpleblock)
2557 {
2558 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2559 mkv_track_t *track = NULL;
2560 demux_stream_t *ds = NULL;
2561 uint64_t old_length;
2562 int64_t tc;
2563 uint32_t *lace_size;
2564 uint8_t laces, flags;
2565 int i, num, tmp, use_this_block = 1;
2566 double current_pts;
2567 int16_t time;
2568
2569 /* first byte(s): track num */
2570 num = ebml_read_vlen_uint(block, &tmp);
2571 block += tmp;
2572 /* time (relative to cluster time) */
2573 time = block[0] << 8 | block[1];
2574 block += 2;
2575 length -= tmp + 2;
2576 old_length = length;
2577 flags = block[0];
2578 if (demux_mkv_read_block_lacing(block, &length, &laces, &lace_size))
2579 return 0;
2580 block += old_length - length;
2581
2582 tc = (time * mkv_d->tc_scale + mkv_d->cluster_tc) / 1000000.0 + 0.5;
2583 if (tc < 0)
2584 tc = 0;
2585 current_pts = tc / 1000.0;
2586
2587 for (i = 0; i < mkv_d->num_tracks; i++)
2588 if (mkv_d->tracks[i]->tnum == num) {
2589 track = mkv_d->tracks[i];
2590 break;
2591 }
2592 if (track == NULL) {
2593 free(lace_size);
2594 return 1;
2595 }
2596 if (num == demuxer->audio->id) {
2597 ds = demuxer->audio;
2598
2599 if (mkv_d->a_skip_to_keyframe) {
2600 if (simpleblock) {
2601 if (!(flags & 0x80)) /*current frame isn't a keyframe */
2602 use_this_block = 0;
2603 } else if (block_bref != 0)
2604 use_this_block = 0;
2605 } else if (mkv_d->v_skip_to_keyframe)
2606 use_this_block = 0;
2607
2608 if (track->fix_i_bps && use_this_block) {
2609 sh_audio_t *sh = (sh_audio_t *) ds->sh;
2610
2611 if (block_duration != 0) {
2612 sh->i_bps = length * 1000 / block_duration;
2613 track->fix_i_bps = 0;
2614 } else if (track->qt_last_a_pts == 0.0)
2615 track->qt_last_a_pts = current_pts;
2616 else if (track->qt_last_a_pts != current_pts) {
2617 sh->i_bps = length / (current_pts - track->qt_last_a_pts);
2618 track->fix_i_bps = 0;
2619 }
2620 }
2621 } else if (tc < mkv_d->skip_to_timecode)
2622 use_this_block = 0;
2623 else if (num == demuxer->video->id) {
2624 ds = demuxer->video;
2625 if (mkv_d->v_skip_to_keyframe) {
2626 if (simpleblock) {
2627 if (!(flags & 0x80)) /*current frame isn't a keyframe */
2628 use_this_block = 0;
2629 } else if (block_bref != 0 || block_fref != 0)
2630 use_this_block = 0;
2631 }
2632 } else if (num == demuxer->sub->id) {
2633 ds = demuxer->sub;
2634 if (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB) {
2635 if (!mkv_d->v_skip_to_keyframe)
2636 handle_subtitles(demuxer, track, block, length, block_duration,
2637 tc);
2638 use_this_block = 0;
2639 }
2640 } else
2641 use_this_block = 0;
2642
2643 if (use_this_block) {
2644 mkv_d->last_pts = current_pts;
2645 mkv_d->last_filepos = demuxer->filepos;
2646
2647 for (i = 0; i < laces; i++) {
2648 if (ds == demuxer->video && track->realmedia)
2649 handle_realvideo(demuxer, track, block, lace_size[i],
2650 block_bref);
2651 else if (ds == demuxer->audio && track->realmedia)
2652 handle_realaudio(demuxer, track, block, lace_size[i],
2653 block_bref);
2654 else if (ds == demuxer->video && track->reorder_timecodes)
2655 handle_video_bframes(demuxer, track, block, lace_size[i],
2656 block_bref, block_fref);
2657 else {
2658 int modified, size = lace_size[i];
2659 demux_packet_t *dp;
2660 uint8_t *buffer;
2661 modified = demux_mkv_decode(track, block, &buffer, &size, 1);
2662 if (buffer) {
2663 dp = new_demux_packet(size);
2664 memcpy(dp->buffer, buffer, size);
2665 if (modified)
2666 free(buffer);
2667 dp->flags = (block_bref == 0
2668 && block_fref == 0) ? 0x10 : 0;
2669 /* If default_duration is 0, assume no pts value is known
2670 * for packets after the first one (rather than all pts
2671 * values being the same) */
2672 if (i == 0 || track->default_duration)
2673 dp->pts =
2674 mkv_d->last_pts + i * track->default_duration;
2675 ds_add_packet(ds, dp);
2676 }
2677 }
2678 block += lace_size[i];
2679 }
2680
2681 if (ds == demuxer->video) {
2682 mkv_d->v_skip_to_keyframe = 0;
2683 mkv_d->skip_to_timecode = 0;
2684 } else if (ds == demuxer->audio)
2685 mkv_d->a_skip_to_keyframe = 0;
2686
2687 free(lace_size);
2688 return 1;
2689 }
2690
2691 free(lace_size);
2692 return 0;
2693 }
2694
2695 static int demux_mkv_fill_buffer(demuxer_t *demuxer, demux_stream_t *ds)
2696 {
2697 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2698 stream_t *s = demuxer->stream;
2699 uint64_t l;
2700 int il, tmp;
2701
2702 while (1) {
2703 while (mkv_d->cluster_size > 0) {
2704 uint64_t block_duration = 0, block_length = 0;
2705 int64_t block_bref = 0, block_fref = 0;
2706 uint8_t *block = NULL;
2707
2708 while (mkv_d->blockgroup_size > 0) {
2709 switch (ebml_read_id(s, &il)) {
2710 case MATROSKA_ID_BLOCKDURATION:
2711 block_duration = ebml_read_uint(s, &l);
2712 if (block_duration == EBML_UINT_INVALID) {
2713 free(block);
2714 return 0;
2715 }
2716 block_duration =
2717 block_duration * mkv_d->tc_scale / 1000000.0 + 0.5;
2718 break;
2719
2720 case MATROSKA_ID_BLOCK:
2721 block_length = ebml_read_length(s, &tmp);
2722 free(block);
2723 if (block_length > SIZE_MAX - AV_LZO_INPUT_PADDING)
2724 return 0;
2725 block = malloc(block_length + AV_LZO_INPUT_PADDING);
2726 demuxer->filepos = stream_tell(s);
2727 if (stream_read(s, block, block_length) !=
2728 (int) block_length) {
2729 free(block);
2730 return 0;
2731 }
2732 l = tmp + block_length;
2733 break;
2734
2735 case MATROSKA_ID_REFERENCEBLOCK:;
2736 int64_t num = ebml_read_int(s, &l);
2737 if (num == EBML_INT_INVALID) {
2738 free(block);
2739 return 0;
2740 }
2741 if (num <= 0)
2742 block_bref = num;
2743 else
2744 block_fref = num;
2745 break;
2746
2747 case EBML_ID_INVALID:
2748 free(block);
2749 return 0;
2750
2751 default:
2752 ebml_read_skip(s, &l);
2753 break;
2754 }
2755 mkv_d->blockgroup_size -= l + il;
2756 mkv_d->cluster_size -= l + il;
2757 }
2758
2759 if (block) {
2760 int res = handle_block(demuxer, block, block_length,
2761 block_duration, block_bref, block_fref,
2762 0);
2763 free(block);
2764 if (res < 0)
2765 return 0;
2766 if (res)
2767 return 1;
2768 }
2769
2770 if (mkv_d->cluster_size > 0) {
2771 switch (ebml_read_id(s, &il)) {
2772 case MATROSKA_ID_TIMECODE:;
2773 uint64_t num = ebml_read_uint(s, &l);
2774 if (num == EBML_UINT_INVALID)
2775 return 0;
2776 mkv_d->cluster_tc = num * mkv_d->tc_scale;
2777 add_cluster_position(mkv_d, mkv_d->cluster_start,
2778 mkv_d->cluster_tc);
2779 break;
2780
2781 case MATROSKA_ID_BLOCKGROUP:
2782 mkv_d->blockgroup_size = ebml_read_length(s, &tmp);
2783 l = tmp;
2784 break;
2785
2786 case MATROSKA_ID_SIMPLEBLOCK:;
2787 int res;
2788 block_length = ebml_read_length(s, &tmp);
2789 block = malloc(block_length);
2790 demuxer->filepos = stream_tell(s);
2791 if (stream_read(s, block, block_length) !=
2792 (int) block_length) {
2793 free(block);
2794 return 0;
2795 }
2796 l = tmp + block_length;
2797 res = handle_block(demuxer, block, block_length,
2798 block_duration, block_bref,
2799 block_fref, 1);
2800 free(block);
2801 mkv_d->cluster_size -= l + il;
2802 if (res < 0)
2803 return 0;
2804 else if (res)
2805 return 1;
2806 else
2807 mkv_d->cluster_size += l + il;
2808 break;
2809
2810 case EBML_ID_INVALID:
2811 return 0;
2812
2813 default:
2814 ebml_read_skip(s, &l);
2815 break;
2816 }
2817 mkv_d->cluster_size -= l + il;
2818 }
2819 }
2820
2821 if (ebml_read_id(s, &il) != MATROSKA_ID_CLUSTER)
2822 return 0;
2823 mkv_d->cluster_start = stream_tell(s) - il;
2824 mkv_d->cluster_size = ebml_read_length(s, NULL);
2825 }
2826
2827 return 0;
2828 }
2829
2830 static void demux_mkv_seek(demuxer_t *demuxer, float rel_seek_secs,
2831 float audio_delay, int flags)
2832 {
2833 if (!(flags & (SEEK_BACKWARD | SEEK_FORWARD))) {
2834 if (flags & SEEK_ABSOLUTE || rel_seek_secs < 0)
2835 flags |= SEEK_BACKWARD;
2836 else
2837 flags |= SEEK_FORWARD;
2838 }
2839 // Adjust the target a little bit to catch cases where the target position
2840 // specifies a keyframe with high, but not perfect, precision.
2841 rel_seek_secs += flags & SEEK_FORWARD ? -0.005 : 0.005;
2842
2843 free_cached_dps(demuxer);
2844 if (!(flags & SEEK_FACTOR)) { /* time in secs */
2845 mkv_index_t *index = NULL;
2846 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2847 stream_t *s = demuxer->stream;
2848 int64_t target_timecode = 0, diff, min_diff = 0xFFFFFFFFFFFFFFFLL;
2849 int i;
2850
2851 if (!(flags & SEEK_ABSOLUTE)) /* relative seek */
2852 target_timecode = (int64_t) (mkv_d->last_pts * 1000.0);
2853 target_timecode += (int64_t) (rel_seek_secs * 1000.0);
2854 if (target_timecode < 0)
2855 target_timecode = 0;
2856
2857 if (mkv_d->indexes == NULL) { /* no index was found */
2858 int64_t target_tc_ns = (int64_t) (rel_seek_secs * 1e9);
2859 if (target_tc_ns < 0)
2860 target_tc_ns = 0;
2861 uint64_t max_filepos = 0;
2862 int64_t max_tc = -1;
2863 int n = mkv_d->num_cluster_pos;
2864 if (n > 0) {
2865 max_filepos = mkv_d->cluster_positions[n - 1].filepos;
2866 max_tc = mkv_d->cluster_positions[n - 1].timecode;
2867 }
2868
2869 if (target_tc_ns > max_tc) {
2870 if ((off_t) max_filepos > stream_tell(s))
2871 stream_seek(s, max_filepos);
2872 else
2873 stream_seek(s, stream_tell(s) + mkv_d->cluster_size);
2874 /* parse all the clusters upto target_filepos */
2875 while (!s->eof) {
2876 uint64_t start = stream_tell(s);
2877 uint32_t type = ebml_read_id(s, NULL);
2878 uint64_t len = ebml_read_length(s, NULL);
2879 uint64_t end = stream_tell(s) + len;
2880 if (type == MATROSKA_ID_CLUSTER) {
2881 while (!s->eof && stream_tell(s) < end) {
2882 if (ebml_read_id(s, NULL)
2883 == MATROSKA_ID_TIMECODE) {
2884 uint64_t tc = ebml_read_uint(s, NULL);
2885 tc *= mkv_d->tc_scale;
2886 add_cluster_position(mkv_d, start, tc);
2887 if (tc >= target_tc_ns)
2888 goto enough_index;
2889 break;
2890 }
2891 }
2892 }
2893 stream_seek(s, end);
2894 }
2895 enough_index:
2896 if (s->eof)
2897 stream_reset(s);
2898 }
2899 if (!mkv_d->num_cluster_pos) {
2900 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] no target for seek found\n");
2901 return;
2902 }
2903 uint64_t cluster_pos = mkv_d->cluster_positions[0].filepos;
2904 /* Let's find the nearest cluster */
2905 for (i = 0; i < mkv_d->num_cluster_pos; i++) {
2906 diff = mkv_d->cluster_positions[i].timecode - target_tc_ns;
2907 if (flags & SEEK_BACKWARD && diff < 0 && -diff < min_diff) {
2908 cluster_pos = mkv_d->cluster_positions[i].filepos;
2909 min_diff = -diff;
2910 } else if (flags & SEEK_FORWARD
2911 && (diff < 0 ? -1 * diff : diff) < min_diff) {
2912 cluster_pos = mkv_d->cluster_positions[i].filepos;
2913 min_diff = diff < 0 ? -1 * diff : diff;
2914 }
2915 }
2916 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
2917 stream_seek(s, cluster_pos);
2918 } else {
2919 int seek_id = (demuxer->video->id < 0) ?
2920 demuxer->audio->id : demuxer->video->id;
2921
2922 /* let's find the entry in the indexes with the smallest */
2923 /* difference to the wanted timecode. */
2924 for (i = 0; i < mkv_d->num_indexes; i++)
2925 if (mkv_d->indexes[i].tnum == seek_id) {
2926 diff =
2927 target_timecode -
2928 (int64_t) (mkv_d->indexes[i].timecode *
2929 mkv_d->tc_scale / 1000000.0 + 0.5);
2930
2931 if (flags & SEEK_BACKWARD) {
2932 // Seek backward: find the last index position
2933 // before target time
2934 if (diff < 0 || diff >= min_diff)
2935 continue;
2936 } else {
2937 // Seek forward: find the first index position
2938 // after target time. If no such index exists, find last
2939 // position between current position and target time.
2940 if (diff <= 0) {
2941 if (min_diff <= 0 && diff <= min_diff)
2942 continue;
2943 } else if (diff >=
2944 FFMIN(target_timecode - mkv_d->last_pts,
2945 min_diff))
2946 continue;
2947 }
2948 min_diff = diff;
2949 index = mkv_d->indexes + i;
2950 }
2951
2952 if (index) { /* We've found an entry. */
2953 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
2954 stream_seek(s, index->filepos);
2955 }
2956 }
2957
2958 if (demuxer->video->id >= 0)
2959 mkv_d->v_skip_to_keyframe = 1;
2960 if (flags & SEEK_FORWARD)
2961 mkv_d->skip_to_timecode = target_timecode;
2962 else
2963 mkv_d->skip_to_timecode = index ? index->timecode : 0;
2964 mkv_d->a_skip_to_keyframe = 1;
2965
2966 demux_mkv_fill_buffer(demuxer, NULL);
2967 } else if ((demuxer->movi_end <= 0) || !(flags & SEEK_ABSOLUTE))
2968 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
2969 else {
2970 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2971 stream_t *s = demuxer->stream;
2972 uint64_t target_filepos;
2973 mkv_index_t *index = NULL;
2974 int i;
2975
2976 if (mkv_d->indexes == NULL) { /* not implemented without index */
2977 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
2978 return;
2979 }
2980
2981 target_filepos = (uint64_t) (demuxer->movi_end * rel_seek_secs);
2982 for (i = 0; i < mkv_d->num_indexes; i++)
2983 if (mkv_d->indexes[i].tnum == demuxer->video->id)
2984 if ((index == NULL)
2985 || ((mkv_d->indexes[i].filepos >= target_filepos)
2986 && ((index->filepos < target_filepos)
2987 || (mkv_d->indexes[i].filepos < index->filepos))))
2988 index = &mkv_d->indexes[i];
2989
2990 if (!index)
2991 return;
2992
2993 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
2994 stream_seek(s, index->filepos);
2995
2996 if (demuxer->video->id >= 0)
2997 mkv_d->v_skip_to_keyframe = 1;
2998 mkv_d->skip_to_timecode = index->timecode;
2999 mkv_d->a_skip_to_keyframe = 1;
3000
3001 demux_mkv_fill_buffer(demuxer, NULL);
3002 }
3003 }
3004
3005 static int demux_mkv_control(demuxer_t *demuxer, int cmd, void *arg)
3006 {
3007 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
3008
3009 switch (cmd) {
3010 case DEMUXER_CTRL_CORRECT_PTS:
3011 return DEMUXER_CTRL_OK;
3012 case DEMUXER_CTRL_GET_TIME_LENGTH:
3013 if (mkv_d->duration == 0)
3014 return DEMUXER_CTRL_DONTKNOW;
3015
3016 *((double *) arg) = (double) mkv_d->duration;
3017 return DEMUXER_CTRL_OK;
3018
3019 case DEMUXER_CTRL_GET_PERCENT_POS:
3020 if (mkv_d->duration == 0) {
3021 return DEMUXER_CTRL_DONTKNOW;
3022 }
3023
3024 *((int *) arg) = (int) (100 * mkv_d->last_pts / mkv_d->duration);
3025 return DEMUXER_CTRL_OK;
3026
3027 case DEMUXER_CTRL_SWITCH_AUDIO:
3028 if (demuxer->audio && demuxer->audio->sh) {
3029 sh_audio_t *sh = demuxer->a_streams[demuxer->audio->id];
3030 int aid = *(int *) arg;
3031 if (aid < 0)
3032 aid = (sh->aid + 1) % mkv_d->last_aid;
3033 if (aid != sh->aid) {
3034 mkv_track_t *track =
3035 demux_mkv_find_track_by_num(mkv_d, aid,
3036 MATROSKA_TRACK_AUDIO);
3037 if (track) {
3038 demuxer->audio->id = track->tnum;
3039 sh = demuxer->a_streams[demuxer->audio->id];
3040 ds_free_packs(demuxer->audio);
3041 }
3042 }
3043 *(int *) arg = sh->aid;
3044 } else
3045 *(int *) arg = -2;
3046 return DEMUXER_CTRL_OK;
3047
3048 default:
3049 return DEMUXER_CTRL_NOTIMPL;
3050 }
3051 }
3052
3053 const demuxer_desc_t demuxer_desc_matroska = {
3054 "Matroska demuxer",
3055 "mkv",
3056 "Matroska",
3057 "Aurelien Jacobs",
3058 "",
3059 DEMUXER_TYPE_MATROSKA,
3060 1, // safe autodetect
3061 demux_mkv_open,
3062 demux_mkv_fill_buffer,
3063 NULL,
3064 demux_close_mkv,
3065 demux_mkv_seek,
3066 demux_mkv_control
3067 };
Sources used to build Kovensky's MPlayer