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