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