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