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