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