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