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