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