?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
options: more mplayer.c options moved to option struct
[mplayer/greg.git] / libmpdemux / demux_mkv.c
blobb0601b7da693e2196bd74b0e561d3a0673744685
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 "bstr.h"
35 #include "stream/stream.h"
36 #include "demuxer.h"
37 #include "stheader.h"
38 #include "ebml.h"
39 #include "matroska.h"
40 #include "demux_real.h"
41
42 #include "mp_msg.h"
43
44 #include "vobsub.h"
45 #include "subreader.h"
46 #include "libvo/sub.h"
47
48 #include "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 "ffmpeg_files/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
72 // Map flavour to bytes per second
73 #define SIPR_FLAVORS 4
74 #define ATRC_FLAVORS 8
75 #define COOK_FLAVORS 34
76 static const int sipr_fl2bps[SIPR_FLAVORS] = { 813, 1062, 625, 2000 };
77 static const int atrc_fl2bps[ATRC_FLAVORS] = {
78 8269, 11714, 13092, 16538, 18260, 22050, 33075, 44100 };
79 static const int cook_fl2bps[COOK_FLAVORS] = {
80 1000, 1378, 2024, 2584, 4005, 5513, 8010, 4005, 750, 2498,
81 4048, 5513, 8010, 11973, 8010, 2584, 4005, 2067, 2584, 2584,
82 4005, 4005, 5513, 5513, 8010, 12059, 1550, 8010, 12059, 5513,
83 12016, 16408, 22911, 33506
84 };
85
86 typedef struct mkv_content_encoding {
87 uint64_t order, type, scope;
88 uint64_t comp_algo;
89 uint8_t *comp_settings;
90 int comp_settings_len;
91 } mkv_content_encoding_t;
92
93 typedef struct mkv_track {
94 int tnum;
95 char *name;
96 int id; // -aid / -sid / -vid option value
97
98 char *codec_id;
99 int ms_compat;
100 char *language;
101
102 int type;
103
104 uint32_t v_width, v_height, v_dwidth, v_dheight;
105 double v_frate;
106
107 uint32_t a_formattag;
108 uint32_t a_channels, a_bps;
109 float a_sfreq;
110
111 double default_duration;
112
113 int default_track;
114
115 unsigned char *private_data;
116 unsigned int private_size;
117
118 /* stuff for realmedia */
119 int realmedia;
120 int64_t rv_kf_base;
121 int rv_kf_pts;
122 double rv_pts; /* previous video timestamp */
123 double ra_pts; /* previous audio timestamp */
124
125 /** realaudio descrambling */
126 int sub_packet_size; ///< sub packet size, per stream
127 int sub_packet_h; ///< number of coded frames per block
128 int coded_framesize; ///< coded frame size, per stream
129 int audiopk_size; ///< audio packet size
130 unsigned char *audio_buf; ///< place to store reordered audio data
131 double *audio_timestamp; ///< timestamp for each audio packet
132 int sub_packet_cnt; ///< number of subpacket already received
133 int audio_filepos; ///< file position of first audio packet in block
134
135 /* stuff for quicktime */
136 int fix_i_bps;
137 double qt_last_a_pts;
138
139 int subtitle_type;
140
141 /* The timecodes of video frames might have to be reordered if they're
142 in display order (the timecodes, not the frames themselves!). In this
143 case demux packets have to be cached with the help of these variables. */
144 int reorder_timecodes;
145 demux_packet_t **cached_dps;
146 int num_cached_dps, num_allocated_dps;
147 double max_pts;
148
149 /* generic content encoding support */
150 mkv_content_encoding_t *encodings;
151 int num_encodings;
152
153 /* For VobSubs and SSA/ASS */
154 sh_sub_t *sh_sub;
155 } mkv_track_t;
156
157 typedef struct mkv_index {
158 int tnum;
159 uint64_t timecode, filepos;
160 } mkv_index_t;
161
162 typedef struct mkv_demuxer {
163 off_t segment_start;
164
165 double 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_start;
174 uint64_t cluster_size;
175 uint64_t blockgroup_size;
176
177 mkv_index_t *indexes;
178 int num_indexes;
179
180 off_t *parsed_pos;
181 int num_parsed_pos;
182 bool parsed_info;
183 bool parsed_tracks;
184 bool parsed_tags;
185 bool parsed_chapters;
186 bool parsed_attachments;
187
188 struct cluster_pos {
189 uint64_t filepos;
190 uint64_t timecode;
191 } *cluster_positions;
192 int num_cluster_pos;
193
194 int64_t skip_to_timecode;
195 int v_skip_to_keyframe, a_skip_to_keyframe;
196
197 int num_audio_tracks;
198 } mkv_demuxer_t;
199
200 #define REALHEADER_SIZE 16
201 #define RVPROPERTIES_SIZE 34
202 #define RAPROPERTIES4_SIZE 56
203 #define RAPROPERTIES5_SIZE 70
204
205 /**
206 * \brief ensures there is space for at least one additional element
207 * \param array array to grow
208 * \param nelem current number of elements in array
209 * \param elsize size of one array element
210 */
211 static void *grow_array(void *array, int nelem, size_t elsize)
212 {
213 if (!(nelem & 31))
214 array = realloc(array, (nelem + 32) * elsize);
215 return array;
216 }
217
218 static bool is_parsed_header(struct mkv_demuxer *mkv_d, off_t pos)
219 {
220 int low = 0;
221 int high = mkv_d->num_parsed_pos;
222 while (high > low + 1) {
223 int mid = high + low >> 1;
224 if (mkv_d->parsed_pos[mid] > pos)
225 high = mid;
226 else
227 low = mid;
228 }
229 if (mkv_d->num_parsed_pos && mkv_d->parsed_pos[low] == pos)
230 return true;
231 if (!(mkv_d->num_parsed_pos & 31))
232 mkv_d->parsed_pos = talloc_realloc(mkv_d, mkv_d->parsed_pos, off_t,
233 mkv_d->num_parsed_pos + 32);
234 mkv_d->num_parsed_pos++;
235 for (int i = mkv_d->num_parsed_pos - 1; i > low; i--)
236 mkv_d->parsed_pos[i] = mkv_d->parsed_pos[i - 1];
237 mkv_d->parsed_pos[low] = pos;
238 return false;
239 }
240
241 static mkv_track_t *find_track_by_num(struct mkv_demuxer *d, int n, int type)
242 {
243 for (int i = 0; i < d->num_tracks; i++)
244 if (d->tracks[i] != NULL && d->tracks[i]->type == type)
245 if (d->tracks[i]->id == n)
246 return d->tracks[i];
247
248 return NULL;
249 }
250
251 static void add_cluster_position(mkv_demuxer_t *mkv_d, uint64_t filepos,
252 uint64_t timecode)
253 {
254 if (mkv_d->indexes)
255 return;
256
257 int n = mkv_d->num_cluster_pos;
258 if (n > 0 && mkv_d->cluster_positions[n-1].filepos >= filepos)
259 return;
260
261 mkv_d->cluster_positions =
262 grow_array(mkv_d->cluster_positions, mkv_d->num_cluster_pos,
263 sizeof(*mkv_d->cluster_positions));
264 mkv_d->cluster_positions[mkv_d->num_cluster_pos++] = (struct cluster_pos){
265 .filepos = filepos,
266 .timecode = timecode,
267 };
268 }
269
270
271 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
272 static int aac_get_sample_rate_index(uint32_t sample_rate)
273 {
274 static const int srates[] = {
275 92017, 75132, 55426, 46009, 37566, 27713,
276 23004, 18783, 13856, 11502, 9391, 0
277 };
278 int i = 0;
279 while (sample_rate < srates[i])
280 i++;
281 return i;
282 }
283
284 /** \brief Free cached demux packets
285 *
286 * Reordering the timecodes requires caching of demux packets. This function
287 * frees all these cached packets and the memory for the cached pointers
288 * itself.
289 *
290 * \param demuxer The demuxer for which the cache is to be freed.
291 */
292 static void free_cached_dps(demuxer_t *demuxer)
293 {
294 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
295 mkv_track_t *track;
296 int i, k;
297
298 for (k = 0; k < mkv_d->num_tracks; k++) {
299 track = mkv_d->tracks[k];
300 for (i = 0; i < track->num_cached_dps; i++)
301 free_demux_packet(track->cached_dps[i]);
302 free(track->cached_dps);
303 track->cached_dps = NULL;
304 track->num_cached_dps = 0;
305 track->num_allocated_dps = 0;
306 track->max_pts = 0;
307 }
308 }
309
310 static void demux_mkv_decode(mkv_track_t *track, uint8_t *src,
311 uint8_t **dest, uint32_t *size, uint32_t type)
312 {
313 uint8_t *orig_src = src;
314
315 *dest = src;
316
317 for (int i = 0; i < track->num_encodings; i++) {
318 struct mkv_content_encoding *enc = track->encodings + i;
319 if (!(enc->scope & type))
320 continue;
321
322 if (src != *dest && src != orig_src)
323 talloc_free(src);
324 src = *dest; // output from last iteration is new source
325
326 if (enc->comp_algo == 0) {
327 #if CONFIG_ZLIB
328 /* zlib encoded track */
329
330 if (*size == 0)
331 continue;
332
333 z_stream zstream;
334
335 zstream.zalloc = (alloc_func) 0;
336 zstream.zfree = (free_func) 0;
337 zstream.opaque = (voidpf) 0;
338 if (inflateInit(&zstream) != Z_OK) {
339 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
340 "[mkv] zlib initialization failed.\n");
341 goto error;
342 }
343 zstream.next_in = (Bytef *) src;
344 zstream.avail_in = *size;
345
346 *dest = NULL;
347 zstream.avail_out = *size;
348 int result;
349 do {
350 *size += 4000;
351 *dest = talloc_realloc_size(NULL, *dest, *size);
352 zstream.next_out = (Bytef *) (*dest + zstream.total_out);
353 result = inflate(&zstream, Z_NO_FLUSH);
354 if (result != Z_OK && result != Z_STREAM_END) {
355 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
356 "[mkv] zlib decompression failed.\n");
357 talloc_free(*dest);
358 *dest = NULL;
359 inflateEnd(&zstream);
360 goto error;
361 }
362 zstream.avail_out += 4000;
363 } while (zstream.avail_out == 4000 && zstream.avail_in != 0
364 && result != Z_STREAM_END);
365
366 *size = zstream.total_out;
367 inflateEnd(&zstream);
368 #endif
369 } else if (enc->comp_algo == 2) {
370 /* lzo encoded track */
371 int out_avail;
372 int dstlen = *size * 3;
373
374 *dest = NULL;
375 while (1) {
376 int srclen = *size;
377 *dest = talloc_realloc_size(NULL, *dest,
378 dstlen + AV_LZO_OUTPUT_PADDING);
379 out_avail = dstlen;
380 int result = av_lzo1x_decode(*dest, &out_avail, src, &srclen);
381 if (result == 0)
382 break;
383 if (!(result & AV_LZO_OUTPUT_FULL)) {
384 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
385 "[mkv] lzo decompression failed.\n");
386 talloc_free(*dest);
387 *dest = NULL;
388 goto error;
389 }
390 mp_msg(MSGT_DEMUX, MSGL_DBG2,
391 "[mkv] lzo decompression buffer too small.\n");
392 dstlen *= 2;
393 }
394 *size = dstlen - out_avail;
395 } else if (enc->comp_algo == 3) {
396 *dest = talloc_size(NULL, *size + enc->comp_settings_len);
397 memcpy(*dest, enc->comp_settings, enc->comp_settings_len);
398 memcpy(*dest + enc->comp_settings_len, src, *size);
399 *size += enc->comp_settings_len;
400 }
401 }
402
403 error:
404 if (src != *dest && src != orig_src)
405 talloc_free(src);
406 }
407
408
409 static int demux_mkv_read_info(demuxer_t *demuxer)
410 {
411 mkv_demuxer_t *mkv_d = demuxer->priv;
412 stream_t *s = demuxer->stream;
413
414 mkv_d->tc_scale = 1000000;
415 mkv_d->duration = 0;
416
417 struct ebml_info info = {};
418 struct ebml_parse_ctx parse_ctx = {};
419 if (ebml_read_element(s, &parse_ctx, &info, &ebml_info_desc) < 0)
420 return 1;
421 if (info.n_timecode_scale) {
422 mkv_d->tc_scale = info.timecode_scale;
423 mp_msg(MSGT_DEMUX, MSGL_V,
424 "[mkv] | + timecode scale: %" PRIu64 "\n", mkv_d->tc_scale);
425 }
426 if (info.n_duration) {
427 mkv_d->duration = info.duration * mkv_d->tc_scale / 1e9;
428 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + duration: %.3fs\n",
429 mkv_d->duration);
430 }
431 if (info.n_segment_uid) {
432 int len = info.segment_uid.len;
433 if (len != sizeof(demuxer->matroska_data.segment_uid)) {
434 mp_msg(MSGT_DEMUX, MSGL_INFO,
435 "[mkv] segment uid invalid length %d\n", len);
436 } else {
437 memcpy(demuxer->matroska_data.segment_uid, info.segment_uid.start,
438 len);
439 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + segment uid");
440 for (int i = 0; i < len; i++)
441 mp_msg(MSGT_DEMUX, MSGL_V, " %02x",
442 demuxer->matroska_data.segment_uid[i]);
443 mp_msg(MSGT_DEMUX, MSGL_V, "\n");
444 }
445 }
446 talloc_free(parse_ctx.talloc_ctx);
447 return 0;
448 }
449
450 static void parse_trackencodings(struct demuxer *demuxer,
451 struct mkv_track *track,
452 struct ebml_content_encodings *encodings)
453 {
454 // initial allocation to be a non-NULL context before realloc
455 mkv_content_encoding_t *ce = talloc_size(track, 1);
456
457 for (int n_enc = 0; n_enc < encodings->n_content_encoding; n_enc++) {
458 struct ebml_content_encoding *enc = encodings->content_encoding + n_enc;
459 struct mkv_content_encoding e = {};
460 e.order = enc->content_encoding_order;
461 if (enc->n_content_encoding_scope)
462 e.scope = enc->content_encoding_scope;
463 else
464 e.scope = 1;
465 e.type = enc->content_encoding_type;
466
467 if (enc->n_content_compression) {
468 struct ebml_content_compression *z = &enc->content_compression;
469 e.comp_algo = z->content_comp_algo;
470 if (z->n_content_comp_settings) {
471 int sz = z->content_comp_settings.len;
472 e.comp_settings = talloc_size(ce, sz);
473 memcpy(e.comp_settings, z->content_comp_settings.start, sz);
474 e.comp_settings_len = sz;
475 }
476 }
477
478 if (e.type == 1) {
479 mp_tmsg(MSGT_DEMUX, MSGL_WARN, "[mkv] Track "
480 "number %u has been encrypted and "
481 "decryption has not yet been\n"
482 "[mkv] implemented. Skipping track.\n",
483 track->tnum);
484 } else if (e.type != 0) {
485 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
486 "[mkv] Unknown content encoding type for "
487 "track %u. Skipping track.\n",
488 track->tnum);
489 } else if (e.comp_algo != 0 && e.comp_algo != 2 && e.comp_algo != 3) {
490 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
491 "[mkv] Track %u has been compressed with "
492 "an unknown/unsupported compression\n"
493 "[mkv] algorithm (%" PRIu64 "). Skipping track.\n",
494 track->tnum, e.comp_algo);
495 }
496 #if !CONFIG_ZLIB
497 else if (e.comp_algo == 0) {
498 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
499 "[mkv] Track %u was compressed with zlib "
500 "but mplayer has not been compiled\n"
501 "[mkv] with support for zlib compression. "
502 "Skipping track.\n",
503 track->tnum);
504 }
505 #endif
506 int i;
507 for (i = 0; i < n_enc; i++)
508 if (e.order >= ce[i].order)
509 break;
510 ce = talloc_realloc_size(track, ce, (n_enc + 1) * sizeof(*ce));
511 memmove(ce + i + 1, ce + i, (n_enc - i) * sizeof(*ce));
512 memcpy(ce + i, &e, sizeof(e));
513 }
514
515 track->encodings = ce;
516 track->num_encodings = encodings->n_content_encoding;
517 }
518
519 static void parse_trackaudio(struct demuxer *demuxer, struct mkv_track *track,
520 struct ebml_audio *audio)
521 {
522 if (audio->n_sampling_frequency) {
523 track->a_sfreq = audio->sampling_frequency;
524 mp_msg(MSGT_DEMUX, MSGL_V,
525 "[mkv] | + Sampling frequency: %f\n", track->a_sfreq);
526 } else
527 track->a_sfreq = 8000;
528 if (audio->n_bit_depth) {
529 track->a_bps = audio->bit_depth;
530 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Bit depth: %u\n",
531 track->a_bps);
532 }
533 if (audio->n_channels) {
534 track->a_channels = audio->channels;
535 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Channels: %u\n",
536 track->a_channels);
537 } else
538 track->a_channels = 1;
539 }
540
541 static void parse_trackvideo(struct demuxer *demuxer, struct mkv_track *track,
542 struct ebml_video *video)
543 {
544 if (video->n_frame_rate) {
545 track->v_frate = video->frame_rate;
546 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Frame rate: %f\n",
547 track->v_frate);
548 if (track->v_frate > 0)
549 track->default_duration = 1 / track->v_frate;
550 }
551 if (video->n_display_width) {
552 track->v_dwidth = video->display_width;
553 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Display width: %u\n",
554 track->v_dwidth);
555 }
556 if (video->n_display_height) {
557 track->v_dheight = video->display_height;
558 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Display height: %u\n",
559 track->v_dheight);
560 }
561 if (video->n_pixel_width) {
562 track->v_width = video->pixel_width;
563 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Pixel width: %u\n",
564 track->v_width);
565 }
566 if (video->n_pixel_height) {
567 track->v_height = video->pixel_height;
568 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Pixel height: %u\n",
569 track->v_height);
570 }
571 }
572
573 /**
574 * \brief free any data associated with given track
575 * \param track track of which to free data
576 */
577 static void demux_mkv_free_trackentry(mkv_track_t *track)
578 {
579 free(track->audio_buf);
580 free(track->audio_timestamp);
581 talloc_free(track);
582 }
583
584 static void parse_trackentry(struct demuxer *demuxer,
585 struct ebml_track_entry *entry)
586 {
587 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
588 struct mkv_track *track = talloc_zero_size(NULL, sizeof(*track));
589
590 track->tnum = entry->track_number;
591 if (track->tnum)
592 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Track number: %u\n",
593 track->tnum);
594 else
595 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Missing track number!\n");
596
597 if (entry->n_name) {
598 track->name = talloc_strndup(track, entry->name.start,
599 entry->name.len);
600 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Name: %s\n",
601 track->name);
602 }
603
604 track->type = entry->track_type;
605 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Track type: ");
606 switch (track->type) {
607 case MATROSKA_TRACK_AUDIO:
608 mp_msg(MSGT_DEMUX, MSGL_V, "Audio\n");
609 break;
610 case MATROSKA_TRACK_VIDEO:
611 mp_msg(MSGT_DEMUX, MSGL_V, "Video\n");
612 break;
613 case MATROSKA_TRACK_SUBTITLE:
614 mp_msg(MSGT_DEMUX, MSGL_V, "Subtitle\n");
615 break;
616 default:
617 mp_msg(MSGT_DEMUX, MSGL_V, "unknown\n");
618 break;
619 }
620
621 if (entry->n_audio) {
622 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Audio track\n");
623 parse_trackaudio(demuxer, track, &entry->audio);
624 }
625
626 if (entry->n_video) {
627 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Video track\n");
628 parse_trackvideo(demuxer, track, &entry->video);
629 }
630
631 if (entry->n_codec_id) {
632 track->codec_id = talloc_strndup(track, entry->codec_id.start,
633 entry->codec_id.len);
634 if (!strcmp(track->codec_id, MKV_V_MSCOMP)
635 || !strcmp(track->codec_id, MKV_A_ACM))
636 track->ms_compat = 1;
637 else if (!strcmp(track->codec_id, MKV_S_VOBSUB))
638 track->subtitle_type = MATROSKA_SUBTYPE_VOBSUB;
639 else if (!strcmp(track->codec_id, MKV_S_TEXTSSA)
640 || !strcmp(track->codec_id, MKV_S_TEXTASS)
641 || !strcmp(track->codec_id, MKV_S_SSA)
642 || !strcmp(track->codec_id, MKV_S_ASS)) {
643 track->subtitle_type = MATROSKA_SUBTYPE_SSA;
644 } else if (!strcmp(track->codec_id, MKV_S_TEXTASCII))
645 track->subtitle_type = MATROSKA_SUBTYPE_TEXT;
646 if (!strcmp(track->codec_id, MKV_S_TEXTUTF8)) {
647 track->subtitle_type = MATROSKA_SUBTYPE_TEXT;
648 }
649 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Codec ID: %s\n",
650 track->codec_id);
651 } else
652 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Missing codec ID!\n");
653
654 if (entry->n_codec_private) {
655 int len = entry->codec_private.len;
656 track->private_data = talloc_size(track, len + AV_LZO_INPUT_PADDING);
657 memcpy(track->private_data, entry->codec_private.start, len);
658 track->private_size = len;
659 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + CodecPrivate, length %u\n",
660 track->private_size);
661 }
662
663 if (entry->n_language) {
664 track->language = talloc_strndup(track, entry->language.start,
665 entry->language.len);
666 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Language: %s\n",
667 track->language);
668 } else
669 track->language = talloc_strdup(track, "eng");
670
671 if (entry->n_flag_default) {
672 track->default_track = entry->flag_default;
673 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Default flag: %u\n",
674 track->default_track);
675 } else
676 track->default_track = 1;
677
678 if (entry->n_default_duration) {
679 track->default_duration = entry->default_duration / 1e9;
680 if (entry->default_duration == 0)
681 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + Default duration: 0");
682 else {
683 if (!track->v_frate)
684 track->v_frate = 1e9 / entry->default_duration;
685 mp_msg(MSGT_DEMUX, MSGL_V,
686 "[mkv] | + Default duration: %.3fms ( = %.3f fps)\n",
687 entry->default_duration / 1000000.0, track->v_frate);
688 }
689 }
690
691 if (entry->n_content_encodings)
692 parse_trackencodings(demuxer, track, &entry->content_encodings);
693
694 mkv_d->tracks[mkv_d->num_tracks++] = track;
695 }
696
697 static int demux_mkv_read_tracks(demuxer_t *demuxer)
698 {
699 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
700 stream_t *s = demuxer->stream;
701
702 struct ebml_tracks tracks = {};
703 struct ebml_parse_ctx parse_ctx = {};
704 if (ebml_read_element(s, &parse_ctx, &tracks, &ebml_tracks_desc) < 0)
705 return 1;
706
707 mkv_d->tracks = talloc_size(mkv_d,
708 tracks.n_track_entry * sizeof(*mkv_d->tracks));
709 for (int i = 0; i < tracks.n_track_entry; i++) {
710 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] | + a track...\n");
711 parse_trackentry(demuxer, &tracks.track_entry[i]);
712 }
713 talloc_free(parse_ctx.talloc_ctx);
714 return 0;
715 }
716
717 static int demux_mkv_read_cues(demuxer_t *demuxer)
718 {
719 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
720 stream_t *s = demuxer->stream;
721
722 if (index_mode == 0 || index_mode == 2) {
723 ebml_read_skip(s, NULL);
724 return 0;
725 }
726
727 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing cues ] -----------\n");
728 struct ebml_cues cues = {};
729 struct ebml_parse_ctx parse_ctx = {};
730 if (ebml_read_element(s, &parse_ctx, &cues, &ebml_cues_desc) < 0)
731 goto out;
732 for (int i = 0; i < cues.n_cue_point; i++) {
733 struct ebml_cue_point *cuepoint = &cues.cue_point[i];
734 if (cuepoint->n_cue_time != 1 || !cuepoint->n_cue_track_positions) {
735 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Malformed CuePoint element\n");
736 continue;
737 }
738 uint64_t time = cuepoint->cue_time;
739 for (int i = 0; i < cuepoint->n_cue_track_positions; i++) {
740 struct ebml_cue_track_positions *trackpos =
741 &cuepoint->cue_track_positions[i];
742 uint64_t track = trackpos->cue_track;
743 uint64_t pos = trackpos->cue_cluster_position;
744 mkv_d->indexes =
745 grow_array(mkv_d->indexes, mkv_d->num_indexes,
746 sizeof(mkv_index_t));
747 mkv_d->indexes[mkv_d->num_indexes].tnum = track;
748 mkv_d->indexes[mkv_d->num_indexes].timecode = time;
749 mkv_d->indexes[mkv_d->num_indexes].filepos =
750 mkv_d->segment_start + pos;
751 mp_msg(MSGT_DEMUX, MSGL_DBG2,
752 "[mkv] |+ found cue point for track %" PRIu64
753 ": timecode %" PRIu64 ", filepos: %" PRIu64 "\n", track,
754 time, mkv_d->segment_start + pos);
755 mkv_d->num_indexes++;
756 }
757 }
758
759 out:
760 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] \\---- [ parsing cues ] -----------\n");
761 talloc_free(parse_ctx.talloc_ctx);
762 return 0;
763 }
764
765 static int demux_mkv_read_chapters(struct demuxer *demuxer)
766 {
767 struct MPOpts *opts = demuxer->opts;
768 stream_t *s = demuxer->stream;
769
770 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] /---- [ parsing chapters ] ---------\n");
771 struct ebml_chapters file_chapters = {};
772 struct ebml_parse_ctx parse_ctx = {};
773 if (ebml_read_element(s, &parse_ctx, &file_chapters,
774 &ebml_chapters_desc) < 0)
775 goto out;
776
777 int selected_edition = 0;
778 int num_editions = file_chapters.n_edition_entry;
779 struct ebml_edition_entry *editions = file_chapters.edition_entry;
780 if (opts->edition_id >= 0 && opts->edition_id < num_editions) {
781 selected_edition = opts->edition_id;
782 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] User-specified edition: %d\n",
783 selected_edition);
784 } else
785 for (int i = 0; i < num_editions; i++)
786 if (editions[i].edition_flag_default) {
787 selected_edition = i;
788 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Default edition: %d\n", i);
789 break;
790 }
791 struct matroska_chapter *m_chapters = NULL;
792 if (editions[selected_edition].edition_flag_ordered) {
793 int count = editions[selected_edition].n_chapter_atom;
794 m_chapters = talloc_array_ptrtype(demuxer, m_chapters, count);
795 demuxer->matroska_data.ordered_chapters = m_chapters;
796 demuxer->matroska_data.num_ordered_chapters = count;
797 }
798
799 for (int idx = 0; idx < num_editions; idx++) {
800 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] New edition %d\n", idx);
801 int warn_level = idx == selected_edition ? MSGL_WARN : MSGL_V;
802 if (editions[idx].n_edition_flag_default)
803 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Default edition flag: %"PRIu64
804 "\n", editions[idx].edition_flag_default);
805 if (editions[idx].n_edition_flag_ordered)
806 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Ordered chapter flag: %"PRIu64
807 "\n", editions[idx].edition_flag_ordered);
808 for (int i = 0; i < editions[idx].n_chapter_atom; i++) {
809 struct ebml_chapter_atom *ca = editions[idx].chapter_atom + i;
810 struct matroska_chapter chapter = { };
811 struct bstr name = { "(unnamed)", 9 };
812
813 if (!ca->n_chapter_time_start)
814 mp_msg(MSGT_DEMUX, warn_level,
815 "[mkv] Chapter lacks start time\n");
816 chapter.start = ca->chapter_time_start / 1000000;
817 chapter.end = ca->chapter_time_end / 1000000;
818
819 if (ca->n_chapter_display) {
820 if (ca->n_chapter_display > 1)
821 mp_msg(MSGT_DEMUX, warn_level, "[mkv] Multiple chapter "
822 "names not supported, picking first\n");
823 if (!ca->chapter_display[0].n_chap_string)
824 mp_msg(MSGT_DEMUX, warn_level, "[mkv] Malformed chapter "
825 "name entry\n");
826 else
827 name = ca->chapter_display[0].chap_string;
828 }
829
830 if (ca->n_chapter_segment_uid) {
831 chapter.has_segment_uid = true;
832 int len = ca->chapter_segment_uid.len;
833 if (len != sizeof(chapter.segment_uid))
834 mp_msg(MSGT_DEMUX, warn_level,
835 "[mkv] Chapter segment uid bad length %d\n", len);
836 else if (ca->n_chapter_segment_edition_uid) {
837 mp_tmsg(MSGT_DEMUX, warn_level, "[mkv] Warning: "
838 "unsupported edition recursion in chapter; "
839 "will skip on playback!\n");
840 } else {
841 memcpy(chapter.segment_uid, ca->chapter_segment_uid.start,
842 len);
843 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Chapter segment uid ");
844 for (int i = 0; i < len; i++)
845 mp_msg(MSGT_DEMUX, MSGL_V, "%02x ",
846 chapter.segment_uid[i]);
847 mp_msg(MSGT_DEMUX, MSGL_V, "\n");
848 }
849 }
850
851 mp_msg(MSGT_DEMUX, MSGL_V,
852 "[mkv] Chapter %u from %02d:%02d:%02d.%03d "
853 "to %02d:%02d:%02d.%03d, %.*s\n", i,
854 (int) (chapter.start / 60 / 60 / 1000),
855 (int) ((chapter.start / 60 / 1000) % 60),
856 (int) ((chapter.start / 1000) % 60),
857 (int) (chapter.start % 1000),
858 (int) (chapter.end / 60 / 60 / 1000),
859 (int) ((chapter.end / 60 / 1000) % 60),
860 (int) ((chapter.end / 1000) % 60),
861 (int) (chapter.end % 1000),
862 BSTR_P(name));
863
864 if (idx == selected_edition){
865 demuxer_add_chapter(demuxer, name, chapter.start, chapter.end);
866 if (editions[idx].edition_flag_ordered) {
867 chapter.name = talloc_strndup(m_chapters, name.start,
868 name.len);
869 m_chapters[i] = chapter;
870 }
871 }
872 }
873 }
874 if (num_editions > 1)
875 mp_msg(MSGT_DEMUX, MSGL_INFO,
876 "[mkv] Found %d editions, will play #%d (first is 0).\n",
877 num_editions, selected_edition);
878
879 out:
880 talloc_free(parse_ctx.talloc_ctx);
881 mp_msg(MSGT_DEMUX, MSGL_V,
882 "[mkv] \\---- [ parsing chapters ] ---------\n");
883 return 0;
884 }
885
886 static int demux_mkv_read_tags(demuxer_t *demuxer)
887 {
888 stream_t *s = demuxer->stream;
889
890 struct ebml_parse_ctx parse_ctx = {};
891 struct ebml_tags tags = {};
892 if (ebml_read_element(s, &parse_ctx, &tags, &ebml_tags_desc) < 0)
893 return 1;
894
895 for (int i = 0; i < tags.n_tag; i++) {
896 struct ebml_tag tag = tags.tag[i];
897 if (tag.targets.target_track_uid || tag.targets.target_edition_uid ||
898 tag.targets.target_chapter_uid || tag.targets.target_attachment_uid)
899 continue;
900
901 for (int j; j < tag.n_simple_tag; j++)
902 demux_info_add_bstr(demuxer, tag.simple_tag[j].tag_name, tag.simple_tag[j].tag_string);
903 }
904
905 return 0;
906 }
907
908 static int demux_mkv_read_attachments(demuxer_t *demuxer)
909 {
910 stream_t *s = demuxer->stream;
911
912 mp_msg(MSGT_DEMUX, MSGL_V,
913 "[mkv] /---- [ parsing attachments ] ---------\n");
914
915 struct ebml_attachments attachments = {};
916 struct ebml_parse_ctx parse_ctx = {};
917 if (ebml_read_element(s, &parse_ctx, &attachments,
918 &ebml_attachments_desc) < 0)
919 goto out;
920
921 for (int i = 0; i < attachments.n_attached_file; i++) {
922 struct ebml_attached_file *attachment = &attachments.attached_file[i];
923 if (!attachment->n_file_name || !attachment->n_file_mime_type
924 || !attachment->n_file_data) {
925 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Malformed attachment\n");
926 continue;
927 }
928 struct bstr name = attachment->file_name;
929 struct bstr mime = attachment->file_mime_type;
930 demuxer_add_attachment(demuxer, name, mime, attachment->file_data);
931 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Attachment: %.*s, %.*s, %zu bytes\n",
932 BSTR_P(name), BSTR_P(mime), attachment->file_data.len);
933 }
934
935 out:
936 talloc_free(parse_ctx.talloc_ctx);
937 mp_msg(MSGT_DEMUX, MSGL_V,
938 "[mkv] \\---- [ parsing attachments ] ---------\n");
939 return 0;
940 }
941
942 static int read_header_element(struct demuxer *demuxer, uint32_t id,
943 off_t at_filepos);
944
945 static int demux_mkv_read_seekhead(demuxer_t *demuxer)
946 {
947 struct mkv_demuxer *mkv_d = demuxer->priv;
948 struct stream *s = demuxer->stream;
949 int res = 0;
950 struct ebml_seek_head seekhead = {};
951 struct ebml_parse_ctx parse_ctx = {};
952
953 mp_msg(MSGT_DEMUX, MSGL_V,
954 "[mkv] /---- [ parsing seek head ] ---------\n");
955 if (ebml_read_element(s, &parse_ctx, &seekhead, &ebml_seek_head_desc) < 0) {
956 res = 1;
957 goto out;
958 }
959 /* off now holds the position of the next element after the seek head. */
960 off_t off = stream_tell(s);
961 for (int i = 0; i < seekhead.n_seek; i++) {
962 struct ebml_seek *seek = &seekhead.seek[i];
963 if (seek->n_seek_id != 1 || seek->n_seek_position != 1) {
964 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Invalid SeekHead entry\n");
965 continue;
966 }
967 uint64_t pos = seek->seek_position + mkv_d->segment_start;
968 if (pos >= demuxer->movi_end) {
969 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] SeekHead position beyond "
970 "end of file - incomplete file?\n");
971 continue;
972 }
973 read_header_element(demuxer, seek->seek_id, pos);
974 }
975 if (!stream_seek(s, off)) {
976 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Couldn't seek back after "
977 "SeekHead??\n");
978 res = 1;
979 }
980 out:
981 mp_msg(MSGT_DEMUX, MSGL_V,
982 "[mkv] \\---- [ parsing seek head ] ---------\n");
983 talloc_free(parse_ctx.talloc_ctx);
984 return res;
985 }
986
987 static bool seek_pos_id(struct stream *s, off_t pos, uint32_t id)
988 {
989 if (!stream_seek(s, pos)) {
990 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Failed to seek in file\n");
991 return false;
992 }
993 if (ebml_read_id(s, NULL) != id) {
994 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] Expected element not found\n");
995 return false;
996 }
997 return true;
998 }
999
1000 static int read_header_element(struct demuxer *demuxer, uint32_t id,
1001 off_t at_filepos)
1002 {
1003 struct mkv_demuxer *mkv_d = demuxer->priv;
1004 stream_t *s = demuxer->stream;
1005 off_t pos = stream_tell(s) - 4;
1006
1007 switch(id) {
1008 case MATROSKA_ID_INFO:
1009 if (mkv_d->parsed_info)
1010 break;
1011 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1012 return -1;
1013 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ segment information...\n");
1014 mkv_d->parsed_info = true;
1015 return demux_mkv_read_info(demuxer) ? -1 : 1;
1016
1017 case MATROSKA_ID_TRACKS:
1018 if (mkv_d->parsed_tracks)
1019 break;
1020 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1021 return -1;
1022 mkv_d->parsed_tracks = true;
1023 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] |+ segment tracks...\n");
1024 return demux_mkv_read_tracks(demuxer) ? -1 : 1;
1025
1026 case MATROSKA_ID_CUES:
1027 if (is_parsed_header(mkv_d, pos))
1028 break;
1029 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1030 return -1;
1031 return demux_mkv_read_cues(demuxer) ? -1 : 1;
1032
1033 case MATROSKA_ID_TAGS:
1034 if (mkv_d->parsed_tags)
1035 break;
1036 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1037 return -1;
1038 mkv_d->parsed_tags = true;
1039 return demux_mkv_read_tags(demuxer) ? -1 : 1;
1040
1041 case MATROSKA_ID_SEEKHEAD:
1042 if (is_parsed_header(mkv_d, pos))
1043 break;
1044 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1045 return -1;
1046 return demux_mkv_read_seekhead(demuxer) ? -1 : 1;
1047
1048 case MATROSKA_ID_CHAPTERS:
1049 if (mkv_d->parsed_chapters)
1050 break;
1051 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1052 return -1;
1053 mkv_d->parsed_chapters = true;
1054 return demux_mkv_read_chapters(demuxer) ? -1 : 1;
1055
1056 case MATROSKA_ID_ATTACHMENTS:
1057 if (mkv_d->parsed_attachments)
1058 break;
1059 if (at_filepos && !seek_pos_id(s, at_filepos, id))
1060 return -1;
1061 mkv_d->parsed_attachments = true;
1062 return demux_mkv_read_attachments(demuxer) ? -1 : 1;
1063
1064 default:
1065 if (!at_filepos)
1066 ebml_read_skip(s, NULL);
1067 return 0;
1068 }
1069 if (!at_filepos)
1070 ebml_read_skip(s, NULL);
1071 return 1;
1072 }
1073
1074
1075
1076 static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track,
1077 int vid);
1078 static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track,
1079 int aid);
1080 static int demux_mkv_open_sub(demuxer_t *demuxer, mkv_track_t *track,
1081 int sid);
1082
1083 static void display_create_tracks(demuxer_t *demuxer)
1084 {
1085 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1086 int i, vid = 0, aid = 0, sid = 0;
1087
1088 for (i = 0; i < mkv_d->num_tracks; i++) {
1089 char *type = "unknown", str[32];
1090 *str = '\0';
1091 switch (mkv_d->tracks[i]->type) {
1092 case MATROSKA_TRACK_VIDEO:
1093 type = "video";
1094 mkv_d->tracks[i]->id = -1;
1095 if (vid == MAX_V_STREAMS)
1096 break;
1097 mkv_d->tracks[i]->id = vid;
1098 demux_mkv_open_video(demuxer, mkv_d->tracks[i], vid);
1099 if (mkv_d->tracks[i]->name)
1100 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VID_%d_NAME=%s\n", vid,
1101 mkv_d->tracks[i]->name);
1102 sprintf(str, "-vid %u", vid++);
1103 break;
1104 case MATROSKA_TRACK_AUDIO:
1105 type = "audio";
1106 mkv_d->tracks[i]->id = -1;
1107 if (aid == MAX_A_STREAMS)
1108 break;
1109 mkv_d->tracks[i]->id = aid;
1110 demux_mkv_open_audio(demuxer, mkv_d->tracks[i], aid);
1111 if (mkv_d->tracks[i]->name)
1112 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_NAME=%s\n", aid,
1113 mkv_d->tracks[i]->name);
1114 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_LANG=%s\n", aid,
1115 mkv_d->tracks[i]->language);
1116 sprintf(str, "-aid %u, -alang %.5s", aid++,
1117 mkv_d->tracks[i]->language);
1118 break;
1119 case MATROSKA_TRACK_SUBTITLE:
1120 type = "subtitles";
1121 mkv_d->tracks[i]->id = -1;
1122 if (sid == MAX_S_STREAMS)
1123 break;
1124 mkv_d->tracks[i]->id = sid;
1125 demux_mkv_open_sub(demuxer, mkv_d->tracks[i], sid);
1126 if (mkv_d->tracks[i]->name)
1127 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_NAME=%s\n", sid,
1128 mkv_d->tracks[i]->name);
1129 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_LANG=%s\n", sid,
1130 mkv_d->tracks[i]->language);
1131 sprintf(str, "-sid %u, -slang %.5s", sid++,
1132 mkv_d->tracks[i]->language);
1133 break;
1134 }
1135 if (mkv_d->tracks[i]->name)
1136 mp_tmsg(MSGT_DEMUX, MSGL_INFO,
1137 "[mkv] Track ID %u: %s (%s) \"%s\", %s\n",
1138 mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id,
1139 mkv_d->tracks[i]->name, str);
1140 else
1141 mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] Track ID %u: %s (%s), %s\n",
1142 mkv_d->tracks[i]->tnum, type, mkv_d->tracks[i]->codec_id,
1143 str);
1144 }
1145 mkv_d->num_audio_tracks = aid;
1146 }
1147
1148 typedef struct {
1149 char *id;
1150 int fourcc;
1151 int extradata;
1152 } videocodec_info_t;
1153
1154 static const videocodec_info_t vinfo[] = {
1155 {MKV_V_MJPEG, mmioFOURCC('m', 'j', 'p', 'g'), 1},
1156 {MKV_V_MPEG1, mmioFOURCC('m', 'p', 'g', '1'), 0},
1157 {MKV_V_MPEG2, mmioFOURCC('m', 'p', 'g', '2'), 0},
1158 {MKV_V_MPEG4_SP, mmioFOURCC('m', 'p', '4', 'v'), 1},
1159 {MKV_V_MPEG4_ASP, mmioFOURCC('m', 'p', '4', 'v'), 1},
1160 {MKV_V_MPEG4_AP, mmioFOURCC('m', 'p', '4', 'v'), 1},
1161 {MKV_V_MPEG4_AVC, mmioFOURCC('a', 'v', 'c', '1'), 1},
1162 {MKV_V_THEORA, mmioFOURCC('t', 'h', 'e', 'o'), 1},
1163 {MKV_V_VP8, mmioFOURCC('V', 'P', '8', '0'), 0},
1164 {NULL, 0, 0}
1165 };
1166
1167 static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track,
1168 int vid)
1169 {
1170 struct MPOpts *opts = demuxer->opts;
1171 BITMAPINFOHEADER *bih;
1172 void *ImageDesc = NULL;
1173 sh_video_t *sh_v;
1174
1175 if (track->ms_compat) { /* MS compatibility mode */
1176 BITMAPINFOHEADER *src;
1177
1178 if (track->private_data == NULL
1179 || track->private_size < sizeof(*bih))
1180 return 1;
1181
1182 src = (BITMAPINFOHEADER *) track->private_data;
1183 bih = calloc(1, track->private_size);
1184 bih->biSize = le2me_32(src->biSize);
1185 bih->biWidth = le2me_32(src->biWidth);
1186 bih->biHeight = le2me_32(src->biHeight);
1187 bih->biPlanes = le2me_16(src->biPlanes);
1188 bih->biBitCount = le2me_16(src->biBitCount);
1189 bih->biCompression = le2me_32(src->biCompression);
1190 bih->biSizeImage = le2me_32(src->biSizeImage);
1191 bih->biXPelsPerMeter = le2me_32(src->biXPelsPerMeter);
1192 bih->biYPelsPerMeter = le2me_32(src->biYPelsPerMeter);
1193 bih->biClrUsed = le2me_32(src->biClrUsed);
1194 bih->biClrImportant = le2me_32(src->biClrImportant);
1195 memcpy(bih + 1,
1196 src + 1,
1197 track->private_size - sizeof(*bih));
1198
1199 if (track->v_width == 0)
1200 track->v_width = bih->biWidth;
1201 if (track->v_height == 0)
1202 track->v_height = bih->biHeight;
1203 } else {
1204 bih = calloc(1, sizeof(*bih));
1205 bih->biSize = sizeof(*bih);
1206 bih->biWidth = track->v_width;
1207 bih->biHeight = track->v_height;
1208 bih->biBitCount = 24;
1209 bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount / 8;
1210
1211 if (track->private_size >= RVPROPERTIES_SIZE
1212 && (!strcmp(track->codec_id, MKV_V_REALV10)
1213 || !strcmp(track->codec_id, MKV_V_REALV20)
1214 || !strcmp(track->codec_id, MKV_V_REALV30)
1215 || !strcmp(track->codec_id, MKV_V_REALV40))) {
1216 unsigned char *dst, *src;
1217 uint32_t type2;
1218 unsigned int cnt;
1219
1220 src = (uint8_t *) track->private_data + RVPROPERTIES_SIZE;
1221
1222 cnt = track->private_size - RVPROPERTIES_SIZE;
1223 bih = realloc(bih, sizeof(*bih) + 8 + cnt);
1224 bih->biSize = 48 + cnt;
1225 bih->biPlanes = 1;
1226 type2 = AV_RB32(src - 4);
1227 if (type2 == 0x10003000 || type2 == 0x10003001)
1228 bih->biCompression = mmioFOURCC('R', 'V', '1', '3');
1229 else
1230 bih->biCompression =
1231 mmioFOURCC('R', 'V', track->codec_id[9], '0');
1232 dst = (unsigned char *) (bih + 1);
1233 // copy type1 and type2 info from rv properties
1234 memcpy(dst, src - 8, 8 + cnt);
1235 track->realmedia = 1;
1236
1237 #ifdef CONFIG_QTX_CODECS
1238 } else if (track->private_size >= sizeof(ImageDescription)
1239 && !strcmp(track->codec_id, MKV_V_QUICKTIME)) {
1240 ImageDescriptionPtr idesc;
1241
1242 idesc = (ImageDescriptionPtr) track->private_data;
1243 idesc->idSize = be2me_32(idesc->idSize);
1244 idesc->cType = be2me_32(idesc->cType);
1245 idesc->version = be2me_16(idesc->version);
1246 idesc->revisionLevel = be2me_16(idesc->revisionLevel);
1247 idesc->vendor = be2me_32(idesc->vendor);
1248 idesc->temporalQuality = be2me_32(idesc->temporalQuality);
1249 idesc->spatialQuality = be2me_32(idesc->spatialQuality);
1250 idesc->width = be2me_16(idesc->width);
1251 idesc->height = be2me_16(idesc->height);
1252 idesc->hRes = be2me_32(idesc->hRes);
1253 idesc->vRes = be2me_32(idesc->vRes);
1254 idesc->dataSize = be2me_32(idesc->dataSize);
1255 idesc->frameCount = be2me_16(idesc->frameCount);
1256 idesc->depth = be2me_16(idesc->depth);
1257 idesc->clutID = be2me_16(idesc->clutID);
1258 bih->biPlanes = 1;
1259 bih->biCompression = idesc->cType;
1260 ImageDesc = idesc;
1261 #endif /* CONFIG_QTX_CODECS */
1262
1263 } else {
1264 const videocodec_info_t *vi = vinfo;
1265 while (vi->id && strcmp(vi->id, track->codec_id))
1266 vi++;
1267 bih->biCompression = vi->fourcc;
1268 if (vi->extradata && track->private_data
1269 && (track->private_size > 0)) {
1270 bih->biSize += track->private_size;
1271 bih = realloc(bih, bih->biSize);
1272 memcpy(bih + 1, track->private_data, track->private_size);
1273 }
1274 track->reorder_timecodes = opts->user_correct_pts == 0;
1275 if (!vi->id) {
1276 mp_tmsg(MSGT_DEMUX, MSGL_WARN, "[mkv] Unknown/unsupported "
1277 "CodecID (%s) or missing/bad CodecPrivate\n"
1278 "[mkv] data (track %u).\n",
1279 track->codec_id, track->tnum);
1280 free(bih);
1281 return 1;
1282 }
1283 }
1284 }
1285
1286 sh_v = new_sh_video(demuxer, vid);
1287 sh_v->bih = bih;
1288 sh_v->format = sh_v->bih->biCompression;
1289 if (track->v_frate == 0.0)
1290 track->v_frate = 25.0;
1291 sh_v->fps = track->v_frate;
1292 sh_v->frametime = 1 / track->v_frate;
1293 sh_v->aspect = 0;
1294 if (!track->realmedia) {
1295 sh_v->disp_w = track->v_width;
1296 sh_v->disp_h = track->v_height;
1297 if (track->v_dheight)
1298 sh_v->aspect = (double) track->v_dwidth / track->v_dheight;
1299 } else {
1300 // vd_realvid.c will set aspect to disp_w/disp_h and rederive
1301 // disp_w and disp_h from the RealVideo stream contents returned
1302 // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
1303 // the Matroska file then it has already been set to PixelWidth/Height
1304 // by check_track_information.
1305 sh_v->disp_w = track->v_dwidth;
1306 sh_v->disp_h = track->v_dheight;
1307 }
1308 sh_v->ImageDesc = ImageDesc;
1309 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Aspect: %f\n", sh_v->aspect);
1310
1311 sh_v->ds = demuxer->video;
1312 return 0;
1313 }
1314
1315 static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track,
1316 int aid)
1317 {
1318 sh_audio_t *sh_a = new_sh_audio(demuxer, aid);
1319 if (!sh_a)
1320 return 1;
1321
1322 if (track->language && (strcmp(track->language, "und") != 0))
1323 sh_a->lang = strdup(track->language);
1324 sh_a->default_track = track->default_track;
1325 sh_a->ds = demuxer->audio;
1326 sh_a->wf = malloc(sizeof(*sh_a->wf));
1327 if (track->ms_compat && (track->private_size >= sizeof(*sh_a->wf))) {
1328 WAVEFORMATEX *wf = (WAVEFORMATEX *) track->private_data;
1329 sh_a->wf = realloc(sh_a->wf, track->private_size);
1330 sh_a->wf->wFormatTag = le2me_16(wf->wFormatTag);
1331 sh_a->wf->nChannels = le2me_16(wf->nChannels);
1332 sh_a->wf->nSamplesPerSec = le2me_32(wf->nSamplesPerSec);
1333 sh_a->wf->nAvgBytesPerSec = le2me_32(wf->nAvgBytesPerSec);
1334 sh_a->wf->nBlockAlign = le2me_16(wf->nBlockAlign);
1335 sh_a->wf->wBitsPerSample = le2me_16(wf->wBitsPerSample);
1336 sh_a->wf->cbSize = track->private_size - sizeof(*sh_a->wf);
1337 memcpy(sh_a->wf + 1, wf + 1,
1338 track->private_size - sizeof(*sh_a->wf));
1339 if (track->a_sfreq == 0.0)
1340 track->a_sfreq = sh_a->wf->nSamplesPerSec;
1341 if (track->a_channels == 0)
1342 track->a_channels = sh_a->wf->nChannels;
1343 if (track->a_bps == 0)
1344 track->a_bps = sh_a->wf->wBitsPerSample;
1345 track->a_formattag = sh_a->wf->wFormatTag;
1346 } else {
1347 memset(sh_a->wf, 0, sizeof(*sh_a->wf));
1348 if (!strcmp(track->codec_id, MKV_A_MP3)
1349 || !strcmp(track->codec_id, MKV_A_MP2))
1350 track->a_formattag = 0x0055;
1351 else if (!strncmp(track->codec_id, MKV_A_AC3, strlen(MKV_A_AC3)))
1352 track->a_formattag = 0x2000;
1353 else if (!strcmp(track->codec_id, MKV_A_DTS))
1354 track->a_formattag = 0x2001;
1355 else if (!strcmp(track->codec_id, MKV_A_PCM)
1356 || !strcmp(track->codec_id, MKV_A_PCM_BE))
1357 track->a_formattag = 0x0001;
1358 else if (!strcmp(track->codec_id, MKV_A_AAC_2MAIN)
1359 || !strncmp(track->codec_id, MKV_A_AAC_2LC,
1360 strlen(MKV_A_AAC_2LC))
1361 || !strcmp(track->codec_id, MKV_A_AAC_2SSR)
1362 || !strcmp(track->codec_id, MKV_A_AAC_4MAIN)
1363 || !strncmp(track->codec_id, MKV_A_AAC_4LC,
1364 strlen(MKV_A_AAC_4LC))
1365 || !strcmp(track->codec_id, MKV_A_AAC_4SSR)
1366 || !strcmp(track->codec_id, MKV_A_AAC_4LTP)
1367 || !strcmp(track->codec_id, MKV_A_AAC))
1368 track->a_formattag = mmioFOURCC('M', 'P', '4', 'A');
1369 else if (!strcmp(track->codec_id, MKV_A_VORBIS)) {
1370 if (track->private_data == NULL)
1371 return 1;
1372 track->a_formattag = mmioFOURCC('v', 'r', 'b', 's');
1373 } else if (!strcmp(track->codec_id, MKV_A_QDMC))
1374 track->a_formattag = mmioFOURCC('Q', 'D', 'M', 'C');
1375 else if (!strcmp(track->codec_id, MKV_A_QDMC2))
1376 track->a_formattag = mmioFOURCC('Q', 'D', 'M', '2');
1377 else if (!strcmp(track->codec_id, MKV_A_WAVPACK))
1378 track->a_formattag = mmioFOURCC('W', 'V', 'P', 'K');
1379 else if (!strcmp(track->codec_id, MKV_A_TRUEHD))
1380 track->a_formattag = mmioFOURCC('T', 'R', 'H', 'D');
1381 else if (!strcmp(track->codec_id, MKV_A_FLAC)) {
1382 if (track->private_data == NULL || track->private_size == 0) {
1383 mp_tmsg(MSGT_DEMUX, MSGL_WARN,
1384 "[mkv] FLAC track does not contain valid headers.\n");
1385 return 1;
1386 }
1387 track->a_formattag = mmioFOURCC('f', 'L', 'a', 'C');
1388 } else if (track->private_size >= RAPROPERTIES4_SIZE) {
1389 if (!strcmp(track->codec_id, MKV_A_REAL28))
1390 track->a_formattag = mmioFOURCC('2', '8', '_', '8');
1391 else if (!strcmp(track->codec_id, MKV_A_REALATRC))
1392 track->a_formattag = mmioFOURCC('a', 't', 'r', 'c');
1393 else if (!strcmp(track->codec_id, MKV_A_REALCOOK))
1394 track->a_formattag = mmioFOURCC('c', 'o', 'o', 'k');
1395 else if (!strcmp(track->codec_id, MKV_A_REALDNET))
1396 track->a_formattag = mmioFOURCC('d', 'n', 'e', 't');
1397 else if (!strcmp(track->codec_id, MKV_A_REALSIPR))
1398 track->a_formattag = mmioFOURCC('s', 'i', 'p', 'r');
1399 } else {
1400 mp_tmsg(MSGT_DEMUX, MSGL_WARN, "[mkv] Unknown/unsupported audio "
1401 "codec ID '%s' for track %u or missing/faulty\n[mkv] "
1402 "private codec data.\n", track->codec_id, track->tnum);
1403 free_sh_audio(demuxer, track->id);
1404 return 1;
1405 }
1406 }
1407
1408 sh_a->format = track->a_formattag;
1409 sh_a->wf->wFormatTag = track->a_formattag;
1410 sh_a->channels = track->a_channels;
1411 sh_a->wf->nChannels = track->a_channels;
1412 sh_a->samplerate = (uint32_t) track->a_sfreq;
1413 sh_a->wf->nSamplesPerSec = (uint32_t) track->a_sfreq;
1414 if (track->a_bps == 0) {
1415 sh_a->samplesize = 2;
1416 sh_a->wf->wBitsPerSample = 16;
1417 } else {
1418 sh_a->samplesize = track->a_bps / 8;
1419 sh_a->wf->wBitsPerSample = track->a_bps;
1420 }
1421 if (track->a_formattag == 0x0055) { /* MP3 || MP2 */
1422 sh_a->wf->nAvgBytesPerSec = 16000;
1423 sh_a->wf->nBlockAlign = 1152;
1424 } else if ((track->a_formattag == 0x2000) /* AC3 */
1425 || (track->a_formattag == 0x2001)) { /* DTS */
1426 free(sh_a->wf);
1427 sh_a->wf = NULL;
1428 } else if (track->a_formattag == 0x0001) { /* PCM || PCM_BE */
1429 sh_a->wf->nAvgBytesPerSec = sh_a->channels * sh_a->samplerate * 2;
1430 sh_a->wf->nBlockAlign = sh_a->wf->nAvgBytesPerSec;
1431 if (!strcmp(track->codec_id, MKV_A_PCM_BE))
1432 sh_a->format = mmioFOURCC('t', 'w', 'o', 's');
1433 } else if (!strcmp(track->codec_id, MKV_A_QDMC)
1434 || !strcmp(track->codec_id, MKV_A_QDMC2)) {
1435 sh_a->wf->nAvgBytesPerSec = 16000;
1436 sh_a->wf->nBlockAlign = 1486;
1437 track->fix_i_bps = 1;
1438 track->qt_last_a_pts = 0.0;
1439 if (track->private_data != NULL) {
1440 sh_a->codecdata = malloc(track->private_size);
1441 memcpy(sh_a->codecdata, track->private_data, track->private_size);
1442 sh_a->codecdata_len = track->private_size;
1443 }
1444 } else if (track->a_formattag == mmioFOURCC('M', 'P', '4', 'A')) {
1445 int profile, srate_idx;
1446
1447 sh_a->wf->nAvgBytesPerSec = 16000;
1448 sh_a->wf->nBlockAlign = 1024;
1449
1450 if (!strcmp(track->codec_id, MKV_A_AAC)
1451 && (NULL != track->private_data)) {
1452 sh_a->codecdata = malloc(track->private_size);
1453 memcpy(sh_a->codecdata, track->private_data, track->private_size);
1454 sh_a->codecdata_len = track->private_size;
1455 return 0;
1456 }
1457
1458 /* Recreate the 'private data' */
1459 /* which faad2 uses in its initialization */
1460 srate_idx = aac_get_sample_rate_index(sh_a->samplerate);
1461 if (!strncmp(&track->codec_id[12], "MAIN", 4))
1462 profile = 0;
1463 else if (!strncmp(&track->codec_id[12], "LC", 2))
1464 profile = 1;
1465 else if (!strncmp(&track->codec_id[12], "SSR", 3))
1466 profile = 2;
1467 else
1468 profile = 3;
1469 sh_a->codecdata = malloc(5);
1470 sh_a->codecdata[0] = ((profile + 1) << 3) | ((srate_idx & 0xE) >> 1);
1471 sh_a->codecdata[1] =
1472 ((srate_idx & 0x1) << 7) | (track->a_channels << 3);
1473
1474 if (strstr(track->codec_id, "SBR") != NULL) {
1475 /* HE-AAC (aka SBR AAC) */
1476 sh_a->codecdata_len = 5;
1477
1478 sh_a->samplerate *= 2;
1479 sh_a->wf->nSamplesPerSec *= 2;
1480 srate_idx = aac_get_sample_rate_index(sh_a->samplerate);
1481 sh_a->codecdata[2] = AAC_SYNC_EXTENSION_TYPE >> 3;
1482 sh_a->codecdata[3] = ((AAC_SYNC_EXTENSION_TYPE & 0x07) << 5) | 5;
1483 sh_a->codecdata[4] = (1 << 7) | (srate_idx << 3);
1484 track->default_duration = 1024.0 / (sh_a->samplerate / 2);
1485 } else {
1486 sh_a->codecdata_len = 2;
1487 track->default_duration = 1024.0 / sh_a->samplerate;
1488 }
1489 } else if (track->a_formattag == mmioFOURCC('v', 'r', 'b', 's')) { /* VORBIS */
1490 sh_a->wf->cbSize = track->private_size;
1491 sh_a->wf = realloc(sh_a->wf, sizeof(*sh_a->wf) + sh_a->wf->cbSize);
1492 memcpy((unsigned char *) (sh_a->wf + 1), track->private_data,
1493 sh_a->wf->cbSize);
1494 } else if (track->private_size >= RAPROPERTIES4_SIZE
1495 && !strncmp(track->codec_id, MKV_A_REALATRC, 7)) {
1496 /* Common initialization for all RealAudio codecs */
1497 unsigned char *src = track->private_data;
1498 int codecdata_length, version;
1499 int flavor;
1500
1501 sh_a->wf->nAvgBytesPerSec = 0; /* FIXME !? */
1502
1503 version = AV_RB16(src + 4);
1504 flavor = AV_RB16(src + 22);
1505 track->coded_framesize = AV_RB32(src + 24);
1506 track->sub_packet_h = AV_RB16(src + 40);
1507 sh_a->wf->nBlockAlign = track->audiopk_size = AV_RB16(src + 42);
1508 track->sub_packet_size = AV_RB16(src + 44);
1509 if (version == 4) {
1510 src += RAPROPERTIES4_SIZE;
1511 src += src[0] + 1;
1512 src += src[0] + 1;
1513 } else
1514 src += RAPROPERTIES5_SIZE;
1515
1516 src += 3;
1517 if (version == 5)
1518 src++;
1519 codecdata_length = AV_RB32(src);
1520 src += 4;
1521 sh_a->wf->cbSize = codecdata_length;
1522 sh_a->wf = realloc(sh_a->wf, sizeof(*sh_a->wf) + sh_a->wf->cbSize);
1523 memcpy(((char *) (sh_a->wf + 1)), src, codecdata_length);
1524
1525 switch (track->a_formattag) {
1526 case mmioFOURCC('a', 't', 'r', 'c'):
1527 sh_a->wf->nAvgBytesPerSec = atrc_fl2bps[flavor];
1528 sh_a->wf->nBlockAlign = track->sub_packet_size;
1529 track->audio_buf =
1530 malloc(track->sub_packet_h * track->audiopk_size);
1531 track->audio_timestamp =
1532 malloc(track->sub_packet_h * sizeof(double));
1533 break;
1534 case mmioFOURCC('c', 'o', 'o', 'k'):
1535 sh_a->wf->nAvgBytesPerSec = cook_fl2bps[flavor];
1536 sh_a->wf->nBlockAlign = track->sub_packet_size;
1537 track->audio_buf =
1538 malloc(track->sub_packet_h * track->audiopk_size);
1539 track->audio_timestamp =
1540 malloc(track->sub_packet_h * sizeof(double));
1541 break;
1542 case mmioFOURCC('s', 'i', 'p', 'r'):
1543 sh_a->wf->nAvgBytesPerSec = sipr_fl2bps[flavor];
1544 sh_a->wf->nBlockAlign = track->coded_framesize;
1545 track->audio_buf =
1546 malloc(track->sub_packet_h * track->audiopk_size);
1547 track->audio_timestamp =
1548 malloc(track->sub_packet_h * sizeof(double));
1549 break;
1550 case mmioFOURCC('2', '8', '_', '8'):
1551 sh_a->wf->nAvgBytesPerSec = 3600;
1552 sh_a->wf->nBlockAlign = track->coded_framesize;
1553 track->audio_buf =
1554 malloc(track->sub_packet_h * track->audiopk_size);
1555 track->audio_timestamp =
1556 malloc(track->sub_packet_h * sizeof(double));
1557 break;
1558 }
1559
1560 track->realmedia = 1;
1561 } else if (!strcmp(track->codec_id, MKV_A_FLAC)
1562 || (track->a_formattag == 0xf1ac)) {
1563 unsigned char *ptr;
1564 int size;
1565 free(sh_a->wf);
1566 sh_a->wf = NULL;
1567
1568 if (track->a_formattag == mmioFOURCC('f', 'L', 'a', 'C')) {
1569 ptr = track->private_data;
1570 size = track->private_size;
1571 } else {
1572 sh_a->format = mmioFOURCC('f', 'L', 'a', 'C');
1573 ptr = track->private_data + sizeof(*sh_a->wf);
1574 size = track->private_size - sizeof(*sh_a->wf);
1575 }
1576 if (size < 4 || ptr[0] != 'f' || ptr[1] != 'L' || ptr[2] != 'a'
1577 || ptr[3] != 'C') {
1578 sh_a->codecdata = malloc(4);
1579 sh_a->codecdata_len = 4;
1580 memcpy(sh_a->codecdata, "fLaC", 4);
1581 } else {
1582 sh_a->codecdata = malloc(size);
1583 sh_a->codecdata_len = size;
1584 memcpy(sh_a->codecdata, ptr, size);
1585 }
1586 } else if (track->a_formattag == mmioFOURCC('W', 'V', 'P', 'K') || track->a_formattag == mmioFOURCC('T', 'R', 'H', 'D')) { /* do nothing, still works */
1587 } else if (!track->ms_compat
1588 || (track->private_size < sizeof(*sh_a->wf))) {
1589 free_sh_audio(demuxer, track->id);
1590 return 1;
1591 }
1592
1593 return 0;
1594 }
1595
1596 static int demux_mkv_open_sub(demuxer_t *demuxer, mkv_track_t *track,
1597 int sid)
1598 {
1599 if (track->subtitle_type != MATROSKA_SUBTYPE_UNKNOWN) {
1600 int size;
1601 uint8_t *buffer;
1602 sh_sub_t *sh = new_sh_sub(demuxer, sid);
1603 track->sh_sub = sh;
1604 sh->type = 't';
1605 if (track->subtitle_type == MATROSKA_SUBTYPE_VOBSUB)
1606 sh->type = 'v';
1607 if (track->subtitle_type == MATROSKA_SUBTYPE_SSA)
1608 sh->type = 'a';
1609 size = track->private_size;
1610 demux_mkv_decode(track, track->private_data, &buffer, &size, 2);
1611 if (buffer && buffer != track->private_data) {
1612 talloc_free(track->private_data);
1613 talloc_steal(track, buffer);
1614 track->private_data = buffer;
1615 track->private_size = size;
1616 }
1617 sh->extradata = malloc(track->private_size);
1618 memcpy(sh->extradata, track->private_data, track->private_size);
1619 sh->extradata_len = track->private_size;
1620 if (track->language && (strcmp(track->language, "und") != 0))
1621 sh->lang = strdup(track->language);
1622 sh->default_track = track->default_track;
1623 } else {
1624 mp_tmsg(MSGT_DEMUX, MSGL_ERR,
1625 "[mkv] Subtitle type '%s' is not supported.\n",
1626 track->codec_id);
1627 return 1;
1628 }
1629
1630 return 0;
1631 }
1632
1633 static int demux_mkv_open(demuxer_t *demuxer)
1634 {
1635 stream_t *s = demuxer->stream;
1636 mkv_demuxer_t *mkv_d;
1637 mkv_track_t *track;
1638 int i, cont = 0;
1639
1640 stream_seek(s, s->start_pos);
1641 if (ebml_read_id(s, NULL) != EBML_ID_EBML)
1642 return 0;
1643 struct ebml_ebml ebml_master = {};
1644 struct ebml_parse_ctx parse_ctx = { .no_error_messages = true };
1645 if (ebml_read_element(s, &parse_ctx, &ebml_master, &ebml_ebml_desc) < 0)
1646 return 0;
1647 if (ebml_master.doc_type.start == NULL) {
1648 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] File has EBML header but no doctype."
1649 " Assuming \"matroska\".\n");
1650 } else if (bstrcmp(ebml_master.doc_type, BSTR("matroska")) != 0
1651 && bstrcmp(ebml_master.doc_type, BSTR("webm")) != 0) {
1652 mp_msg(MSGT_DEMUX, MSGL_DBG2, "[mkv] no head found\n");
1653 talloc_free(parse_ctx.talloc_ctx);
1654 return 0;
1655 }
1656 if (ebml_master.doc_type_read_version > 2) {
1657 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] This looks like a Matroska file, "
1658 "but we don't support format version %"PRIu64"\n",
1659 ebml_master.doc_type_read_version);
1660 talloc_free(parse_ctx.talloc_ctx);
1661 return 0;
1662 }
1663 if ((ebml_master.n_ebml_read_version
1664 && ebml_master.ebml_read_version != EBML_VERSION)
1665 || (ebml_master.n_ebml_max_size_length
1666 && ebml_master.ebml_max_size_length > 8)
1667 || (ebml_master.n_ebml_max_id_length
1668 && ebml_master.ebml_max_id_length != 4)) {
1669 mp_msg(MSGT_DEMUX, MSGL_WARN, "[mkv] This looks like a Matroska file, "
1670 "but the header has bad parameters\n");
1671 talloc_free(parse_ctx.talloc_ctx);
1672 return 0;
1673 }
1674 talloc_free(parse_ctx.talloc_ctx);
1675
1676 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] Found the head...\n");
1677
1678 if (ebml_read_id(s, NULL) != MATROSKA_ID_SEGMENT) {
1679 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] but no segment :(\n");
1680 return 0;
1681 }
1682 ebml_read_length(s, NULL); /* return bytes number until EOF */
1683
1684 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] + a segment...\n");
1685
1686 mkv_d = talloc_zero(demuxer, struct mkv_demuxer);
1687 demuxer->priv = mkv_d;
1688 mkv_d->tc_scale = 1000000;
1689 mkv_d->segment_start = stream_tell(s);
1690
1691 while (!cont) {
1692 uint32_t id = ebml_read_id(s, NULL);
1693 switch (id) {
1694 case MATROSKA_ID_CLUSTER:
1695 mp_msg(MSGT_DEMUX, MSGL_V,
1696 "[mkv] |+ found cluster, headers are "
1697 "parsed completely :)\n");
1698 stream_seek(s, stream_tell(s) - 4);
1699 cont = 1;
1700 break;
1701
1702 default:
1703 cont = read_header_element(demuxer, id, 0) < 1;
1704 break;
1705 case EBML_ID_VOID:
1706 ebml_read_skip(s, NULL);
1707 break;
1708 }
1709 }
1710
1711 display_create_tracks(demuxer);
1712
1713 /* select video track */
1714 track = NULL;
1715 if (demuxer->video->id == -1) { /* automatically select a video track */
1716 /* search for a video track that has the 'default' flag set */
1717 for (i = 0; i < mkv_d->num_tracks; i++)
1718 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO
1719 && mkv_d->tracks[i]->default_track) {
1720 track = mkv_d->tracks[i];
1721 break;
1722 }
1723
1724 if (track == NULL)
1725 /* no track has the 'default' flag set */
1726 /* let's take the first video track */
1727 for (i = 0; i < mkv_d->num_tracks; i++)
1728 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_VIDEO
1729 && mkv_d->tracks[i]->id >= 0) {
1730 track = mkv_d->tracks[i];
1731 break;
1732 }
1733 } else if (demuxer->video->id != -2) /* -2 = no video at all */
1734 track = find_track_by_num(mkv_d, demuxer->video->id,
1735 MATROSKA_TRACK_VIDEO);
1736
1737 if (track && demuxer->v_streams[track->id]) {
1738 mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] Will play video track %u.\n",
1739 track->tnum);
1740 demuxer->video->id = track->id;
1741 demuxer->video->sh = demuxer->v_streams[track->id];
1742 } else {
1743 mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] No video track found/wanted.\n");
1744 demuxer->video->id = -2;
1745 }
1746
1747 /* select audio track */
1748 track = NULL;
1749 if (track == NULL)
1750 /* search for an audio track that has the 'default' flag set */
1751 for (i = 0; i < mkv_d->num_tracks; i++)
1752 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO
1753 && mkv_d->tracks[i]->default_track) {
1754 track = mkv_d->tracks[i];
1755 break;
1756 }
1757
1758 if (track == NULL)
1759 /* no track has the 'default' flag set */
1760 /* let's take the first audio track */
1761 for (i = 0; i < mkv_d->num_tracks; i++)
1762 if (mkv_d->tracks[i]->type == MATROSKA_TRACK_AUDIO
1763 && mkv_d->tracks[i]->id >= 0) {
1764 track = mkv_d->tracks[i];
1765 break;
1766 }
1767
1768 if (track && demuxer->a_streams[track->id]) {
1769 demuxer->audio->id = track->id;
1770 demuxer->audio->sh = demuxer->a_streams[track->id];
1771 } else {
1772 mp_tmsg(MSGT_DEMUX, MSGL_INFO, "[mkv] No audio track found/wanted.\n");
1773 demuxer->audio->id = -2;
1774 }
1775
1776 if (s->end_pos == 0)
1777 demuxer->seekable = 0;
1778 else {
1779 demuxer->movi_start = s->start_pos;
1780 demuxer->movi_end = s->end_pos;
1781 demuxer->seekable = 1;
1782 }
1783
1784 demuxer->accurate_seek = true;
1785
1786 return DEMUXER_TYPE_MATROSKA;
1787 }
1788
1789 static void demux_close_mkv(demuxer_t *demuxer)
1790 {
1791 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1792
1793 if (mkv_d) {
1794 int i;
1795 free_cached_dps(demuxer);
1796 if (mkv_d->tracks) {
1797 for (i = 0; i < mkv_d->num_tracks; i++)
1798 demux_mkv_free_trackentry(mkv_d->tracks[i]);
1799 }
1800 free(mkv_d->indexes);
1801 free(mkv_d->cluster_positions);
1802 }
1803 }
1804
1805 static int demux_mkv_read_block_lacing(uint8_t *buffer, uint64_t *size,
1806 uint8_t *laces,
1807 uint32_t **all_lace_sizes)
1808 {
1809 uint32_t total = 0;
1810 uint32_t *lace_size = NULL;
1811 uint8_t flags;
1812 int i;
1813
1814 *all_lace_sizes = NULL;
1815 /* lacing flags */
1816 if (*size < 1)
1817 goto error;
1818 flags = *buffer++;
1819 (*size)--;
1820
1821 switch ((flags & 0x06) >> 1) {
1822 case 0: /* no lacing */
1823 *laces = 1;
1824 lace_size = calloc(*laces, sizeof(uint32_t));
1825 lace_size[0] = *size;
1826 break;
1827
1828 case 1: /* xiph lacing */
1829 case 2: /* fixed-size lacing */
1830 case 3: /* EBML lacing */
1831 if (*size < 1)
1832 goto error;
1833 *laces = *buffer++;
1834 (*size)--;
1835 (*laces)++;
1836 lace_size = calloc(*laces, sizeof(uint32_t));
1837
1838 switch ((flags & 0x06) >> 1) {
1839 case 1: /* xiph lacing */
1840 for (i = 0; i < *laces - 1; i++) {
1841 lace_size[i] = 0;
1842 do {
1843 if (!*size)
1844 goto error;
1845 lace_size[i] += *buffer;
1846 (*size)--;
1847 } while (*buffer++ == 0xFF);
1848 if (lace_size[i] > *size - total || total > *size)
1849 goto error;
1850 total += lace_size[i];
1851 }
1852 lace_size[i] = *size - total;
1853 break;
1854
1855 case 2: /* fixed-size lacing */
1856 for (i = 0; i < *laces; i++)
1857 lace_size[i] = *size / *laces;
1858 break;
1859
1860 case 3:; /* EBML lacing */
1861 int l;
1862 uint64_t num = ebml_read_vlen_uint(buffer, &l);
1863 if (num == EBML_UINT_INVALID)
1864 goto error;
1865 buffer += l;
1866 if (*size < l)
1867 goto error;
1868 *size -= l;
1869 if (num > *size)
1870 goto error;
1871
1872 total = lace_size[0] = num;
1873 for (i = 1; i < *laces - 1; i++) {
1874 int64_t snum = ebml_read_vlen_int(buffer, &l);
1875 if (snum == EBML_INT_INVALID)
1876 goto error;
1877 buffer += l;
1878 if (*size < l)
1879 goto error;
1880 *size -= l;
1881 lace_size[i] = lace_size[i - 1] + snum;
1882 if (lace_size[i] > *size - total || total > *size)
1883 goto error;
1884 total += lace_size[i];
1885 }
1886 lace_size[i] = *size - total;
1887 break;
1888 }
1889 break;
1890 }
1891 *all_lace_sizes = lace_size;
1892 return 0;
1893
1894 error:
1895 free(lace_size);
1896 mp_msg(MSGT_DEMUX, MSGL_ERR, "[mkv] Bad input [lacing]\n");
1897 return 1;
1898 }
1899
1900 static void handle_subtitles(demuxer_t *demuxer, mkv_track_t *track,
1901 char *block, int64_t size,
1902 uint64_t block_duration, uint64_t timecode)
1903 {
1904 demux_packet_t *dp;
1905
1906 if (block_duration == 0) {
1907 mp_msg(MSGT_DEMUX, MSGL_WARN,
1908 "[mkv] Warning: No BlockDuration for subtitle track found.\n");
1909 return;
1910 }
1911
1912 sub_utf8 = 1;
1913 dp = new_demux_packet(size);
1914 memcpy(dp->buffer, block, size);
1915 dp->pts = timecode / 1000.0;
1916 dp->endpts = (timecode + block_duration) / 1000.0;
1917 ds_add_packet(demuxer->sub, dp);
1918 }
1919
1920 static void handle_realvideo(demuxer_t *demuxer, mkv_track_t *track,
1921 uint8_t *buffer, uint32_t size, int block_bref)
1922 {
1923 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1924 demux_packet_t *dp;
1925 uint32_t timestamp = mkv_d->last_pts * 1000;
1926
1927 dp = new_demux_packet(size);
1928 memcpy(dp->buffer, buffer, size);
1929
1930 if (mkv_d->v_skip_to_keyframe) {
1931 dp->pts = mkv_d->last_pts;
1932 track->rv_kf_base = 0;
1933 track->rv_kf_pts = timestamp;
1934 } else
1935 dp->pts =
1936 real_fix_timestamp(dp->buffer, timestamp,
1937 ((sh_video_t *) demuxer->video->sh)->bih->
1938 biCompression, &track->rv_kf_base,
1939 &track->rv_kf_pts, NULL);
1940 dp->pos = demuxer->filepos;
1941 dp->flags = block_bref ? 0 : 0x10;
1942
1943 ds_add_packet(demuxer->video, dp);
1944 }
1945
1946 static void handle_realaudio(demuxer_t *demuxer, mkv_track_t *track,
1947 uint8_t *buffer, uint32_t size, int block_bref)
1948 {
1949 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
1950 int sps = track->sub_packet_size;
1951 int sph = track->sub_packet_h;
1952 int cfs = track->coded_framesize;
1953 int w = track->audiopk_size;
1954 int spc = track->sub_packet_cnt;
1955 demux_packet_t *dp;
1956 int x;
1957
1958 if ((track->a_formattag == mmioFOURCC('2', '8', '_', '8'))
1959 || (track->a_formattag == mmioFOURCC('c', 'o', 'o', 'k'))
1960 || (track->a_formattag == mmioFOURCC('a', 't', 'r', 'c'))
1961 || (track->a_formattag == mmioFOURCC('s', 'i', 'p', 'r'))) {
1962 // if(!block_bref)
1963 // spc = track->sub_packet_cnt = 0;
1964 switch (track->a_formattag) {
1965 case mmioFOURCC('2', '8', '_', '8'):
1966 for (x = 0; x < sph / 2; x++)
1967 memcpy(track->audio_buf + x * 2 * w + spc * cfs,
1968 buffer + cfs * x, cfs);
1969 break;
1970 case mmioFOURCC('c', 'o', 'o', 'k'):
1971 case mmioFOURCC('a', 't', 'r', 'c'):
1972 for (x = 0; x < w / sps; x++)
1973 memcpy(track->audio_buf +
1974 sps * (sph * x + ((sph + 1) / 2) * (spc & 1) +
1975 (spc >> 1)), buffer + sps * x, sps);
1976 break;
1977 case mmioFOURCC('s', 'i', 'p', 'r'):
1978 memcpy(track->audio_buf + spc * w, buffer, w);
1979 if (spc == sph - 1) {
1980 int n;
1981 int bs = sph * w * 2 / 96; // nibbles per subpacket
1982 // Perform reordering
1983 for (n = 0; n < 38; n++) {
1984 int j;
1985 int i = bs * sipr_swaps[n][0];
1986 int o = bs * sipr_swaps[n][1];
1987 // swap nibbles of block 'i' with 'o' TODO: optimize
1988 for (j = 0; j < bs; j++) {
1989 int x = (i & 1) ?
1990 (track->audio_buf[i >> 1] >> 4) :
1991 (track->audio_buf[i >> 1] & 0x0F);
1992 int y = (o & 1) ?
1993 (track->audio_buf[o >> 1] >> 4) :
1994 (track->audio_buf[o >> 1] & 0x0F);
1995 if (o & 1)
1996 track->audio_buf[o >> 1] =
1997 (track->audio_buf[o >> 1] & 0x0F) | (x << 4);
1998 else
1999 track->audio_buf[o >> 1] =
2000 (track->audio_buf[o >> 1] & 0xF0) | x;
2001 if (i & 1)
2002 track->audio_buf[i >> 1] =
2003 (track->audio_buf[i >> 1] & 0x0F) | (y << 4);
2004 else
2005 track->audio_buf[i >> 1] =
2006 (track->audio_buf[i >> 1] & 0xF0) | y;
2007 ++i;
2008 ++o;
2009 }
2010 }
2011 }
2012 break;
2013 }
2014 track->audio_timestamp[track->sub_packet_cnt] =
2015 (track->ra_pts == mkv_d->last_pts) ? 0 : (mkv_d->last_pts);
2016 track->ra_pts = mkv_d->last_pts;
2017 if (track->sub_packet_cnt == 0)
2018 track->audio_filepos = demuxer->filepos;
2019 if (++(track->sub_packet_cnt) == sph) {
2020 int apk_usize =
2021 ((sh_audio_t *) demuxer->audio->sh)->wf->nBlockAlign;
2022 track->sub_packet_cnt = 0;
2023 // Release all the audio packets
2024 for (x = 0; x < sph * w / apk_usize; x++) {
2025 dp = new_demux_packet(apk_usize);
2026 memcpy(dp->buffer, track->audio_buf + x * apk_usize,
2027 apk_usize);
2028 /* Put timestamp only on packets that correspond to original
2029 * audio packets in file */
2030 dp->pts = (x * apk_usize % w) ? 0 :
2031 track->audio_timestamp[x * apk_usize / w];
2032 dp->pos = track->audio_filepos; // all equal
2033 dp->flags = x ? 0 : 0x10; // Mark first packet as keyframe
2034 ds_add_packet(demuxer->audio, dp);
2035 }
2036 }
2037 } else { // Not a codec that require reordering
2038 dp = new_demux_packet(size);
2039 memcpy(dp->buffer, buffer, size);
2040 if (track->ra_pts == mkv_d->last_pts && !mkv_d->a_skip_to_keyframe)
2041 dp->pts = 0;
2042 else
2043 dp->pts = mkv_d->last_pts;
2044 track->ra_pts = mkv_d->last_pts;
2045
2046 dp->pos = demuxer->filepos;
2047 dp->flags = block_bref ? 0 : 0x10;
2048 ds_add_packet(demuxer->audio, dp);
2049 }
2050 }
2051
2052 /** Reorder timecodes and add cached demux packets to the queues.
2053 *
2054 * Timecode reordering is needed if a video track contains B frames that
2055 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2056 * MPlayer doesn't like timestamps in display order. This function adjusts
2057 * the timestamp of cached frames (which are exactly one I/P frame followed
2058 * by one or more B frames) so that they are in coding order again.
2059 *
2060 * Example: The track with 25 FPS contains four frames with the timecodes
2061 * I at 0ms, P at 120ms, B at 40ms and B at 80ms. As soon as the next I
2062 * or P frame arrives these timecodes can be changed to I at 0ms, P at 40ms,
2063 * B at 80ms and B at 120ms.
2064 *
2065 * This works for simple H.264 B-frame pyramids, but not for arbitrary orders.
2066 *
2067 * \param demuxer The Matroska demuxer struct for this instance.
2068 * \param track The track structure whose cache should be handled.
2069 */
2070 static void flush_cached_dps(demuxer_t *demuxer, mkv_track_t *track)
2071 {
2072 int i, ok;
2073
2074 if (track->num_cached_dps == 0)
2075 return;
2076
2077 do {
2078 ok = 1;
2079 for (i = 1; i < track->num_cached_dps; i++)
2080 if (track->cached_dps[i - 1]->pts > track->cached_dps[i]->pts) {
2081 double tmp_pts = track->cached_dps[i - 1]->pts;
2082 track->cached_dps[i - 1]->pts = track->cached_dps[i]->pts;
2083 track->cached_dps[i]->pts = tmp_pts;
2084 ok = 0;
2085 }
2086 } while (!ok);
2087
2088 for (i = 0; i < track->num_cached_dps; i++)
2089 ds_add_packet(demuxer->video, track->cached_dps[i]);
2090 track->num_cached_dps = 0;
2091 }
2092
2093 /** Cache video frames if timecodes have to be reordered.
2094 *
2095 * Timecode reordering is needed if a video track contains B frames that
2096 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2097 * This function takes in a Matroska block read from the file, allocates a
2098 * demux packet for it, fills in its values, allocates space for storing
2099 * pointers to the cached demux packets and adds the packet to it. If
2100 * the packet contains an I or a P frame then ::flush_cached_dps is called
2101 * in order to send the old cached frames downstream.
2102 *
2103 * \param demuxer The Matroska demuxer struct for this instance.
2104 * \param track The packet is meant for this track.
2105 * \param buffer The actual frame contents.
2106 * \param size The frame size in bytes.
2107 * \param block_bref A relative timecode (backward reference). If it is \c 0
2108 * then the frame is an I frame.
2109 * \param block_fref A relative timecode (forward reference). If it is \c 0
2110 * then the frame is either an I frame or a P frame depending on the value
2111 * of \a block_bref. Otherwise it's a B frame.
2112 */
2113 static void handle_video_bframes(demuxer_t *demuxer, mkv_track_t *track,
2114 uint8_t *buffer, uint32_t size,
2115 int block_bref, int block_fref)
2116 {
2117 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2118 demux_packet_t *dp;
2119
2120 dp = new_demux_packet(size);
2121 memcpy(dp->buffer, buffer, size);
2122 dp->pos = demuxer->filepos;
2123 dp->pts = mkv_d->last_pts;
2124 if ((track->num_cached_dps > 0) && (dp->pts < track->max_pts))
2125 block_fref = 1;
2126 if (block_fref == 0) /* I or P frame */
2127 flush_cached_dps(demuxer, track);
2128 if (block_bref != 0) /* I frame, don't cache it */
2129 dp->flags = 0x10;
2130 if ((track->num_cached_dps + 1) > track->num_allocated_dps) {
2131 track->cached_dps = (demux_packet_t **)
2132 realloc(track->cached_dps,
2133 (track->num_cached_dps + 10) * sizeof(demux_packet_t *));
2134 track->num_allocated_dps += 10;
2135 }
2136 track->cached_dps[track->num_cached_dps] = dp;
2137 track->num_cached_dps++;
2138 if (dp->pts > track->max_pts)
2139 track->max_pts = dp->pts;
2140 }
2141
2142 static int handle_block(demuxer_t *demuxer, uint8_t *block, uint64_t length,
2143 uint64_t block_duration, int64_t block_bref,
2144 int64_t block_fref, uint8_t simpleblock)
2145 {
2146 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2147 mkv_track_t *track = NULL;
2148 demux_stream_t *ds = NULL;
2149 uint64_t old_length;
2150 int64_t tc;
2151 uint32_t *lace_size;
2152 uint8_t laces, flags;
2153 int i, num, tmp, use_this_block = 1;
2154 double current_pts;
2155 int16_t time;
2156
2157 /* first byte(s): track num */
2158 num = ebml_read_vlen_uint(block, &tmp);
2159 block += tmp;
2160 /* time (relative to cluster time) */
2161 time = block[0] << 8 | block[1];
2162 block += 2;
2163 length -= tmp + 2;
2164 old_length = length;
2165 flags = block[0];
2166 if (demux_mkv_read_block_lacing(block, &length, &laces, &lace_size))
2167 return 0;
2168 block += old_length - length;
2169
2170 tc = (time * mkv_d->tc_scale + mkv_d->cluster_tc) / 1000000.0 + 0.5;
2171 if (tc < 0)
2172 tc = 0;
2173 current_pts = tc / 1000.0;
2174
2175 for (i = 0; i < mkv_d->num_tracks; i++)
2176 if (mkv_d->tracks[i]->tnum == num) {
2177 track = mkv_d->tracks[i];
2178 break;
2179 }
2180 if (track == NULL) {
2181 free(lace_size);
2182 return 1;
2183 }
2184 if (track->type == MATROSKA_TRACK_AUDIO
2185 && track->id == demuxer->audio->id) {
2186 ds = demuxer->audio;
2187
2188 if (mkv_d->a_skip_to_keyframe) {
2189 if (simpleblock) {
2190 if (!(flags & 0x80)) /*current frame isn't a keyframe */
2191 use_this_block = 0;
2192 } else if (block_bref != 0)
2193 use_this_block = 0;
2194 } else if (mkv_d->v_skip_to_keyframe)
2195 use_this_block = 0;
2196
2197 if (track->fix_i_bps && use_this_block) {
2198 sh_audio_t *sh = (sh_audio_t *) ds->sh;
2199
2200 if (block_duration != 0) {
2201 sh->i_bps = length * 1000 / block_duration;
2202 track->fix_i_bps = 0;
2203 } else if (track->qt_last_a_pts == 0.0)
2204 track->qt_last_a_pts = current_pts;
2205 else if (track->qt_last_a_pts != current_pts) {
2206 sh->i_bps = length / (current_pts - track->qt_last_a_pts);
2207 track->fix_i_bps = 0;
2208 }
2209 }
2210 } else if (tc < mkv_d->skip_to_timecode)
2211 use_this_block = 0;
2212 else if (track->type == MATROSKA_TRACK_VIDEO
2213 && track->id == demuxer->video->id) {
2214 ds = demuxer->video;
2215 if (mkv_d->v_skip_to_keyframe) {
2216 if (simpleblock) {
2217 if (!(flags & 0x80)) /*current frame isn't a keyframe */
2218 use_this_block = 0;
2219 } else if (block_bref != 0 || block_fref != 0)
2220 use_this_block = 0;
2221 }
2222 } else if (track->type == MATROSKA_TRACK_SUBTITLE
2223 && track->id == demuxer->sub->id) {
2224 ds = demuxer->sub;
2225 if (track->subtitle_type != MATROSKA_SUBTYPE_VOBSUB) {
2226 uint8_t *buffer;
2227 int size = length;
2228 demux_mkv_decode(track, block, &buffer, &size, 1);
2229 handle_subtitles(demuxer, track, buffer, size, block_duration, tc);
2230 if (buffer != block)
2231 talloc_free(buffer);
2232 use_this_block = 0;
2233 }
2234 } else
2235 use_this_block = 0;
2236
2237 if (use_this_block) {
2238 mkv_d->last_pts = current_pts;
2239 mkv_d->last_filepos = demuxer->filepos;
2240
2241 for (i = 0; i < laces; i++) {
2242 if (ds == demuxer->video && track->realmedia)
2243 handle_realvideo(demuxer, track, block, lace_size[i],
2244 block_bref);
2245 else if (ds == demuxer->audio && track->realmedia)
2246 handle_realaudio(demuxer, track, block, lace_size[i],
2247 block_bref);
2248 else if (ds == demuxer->video && track->reorder_timecodes)
2249 handle_video_bframes(demuxer, track, block, lace_size[i],
2250 block_bref, block_fref);
2251 else {
2252 int size = lace_size[i];
2253 demux_packet_t *dp;
2254 uint8_t *buffer;
2255 demux_mkv_decode(track, block, &buffer, &size, 1);
2256 if (buffer) {
2257 dp = new_demux_packet(size);
2258 memcpy(dp->buffer, buffer, size);
2259 if (buffer != block)
2260 talloc_free(buffer);
2261 dp->flags = (block_bref == 0
2262 && block_fref == 0) ? 0x10 : 0;
2263 /* If default_duration is 0, assume no pts value is known
2264 * for packets after the first one (rather than all pts
2265 * values being the same) */
2266 if (i == 0 || track->default_duration)
2267 dp->pts =
2268 mkv_d->last_pts + i * track->default_duration;
2269 ds_add_packet(ds, dp);
2270 }
2271 }
2272 block += lace_size[i];
2273 }
2274
2275 if (ds == demuxer->video) {
2276 mkv_d->v_skip_to_keyframe = 0;
2277 mkv_d->skip_to_timecode = 0;
2278 } else if (ds == demuxer->audio)
2279 mkv_d->a_skip_to_keyframe = 0;
2280
2281 free(lace_size);
2282 return 1;
2283 }
2284
2285 free(lace_size);
2286 return 0;
2287 }
2288
2289 static int demux_mkv_fill_buffer(demuxer_t *demuxer, demux_stream_t *ds)
2290 {
2291 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2292 stream_t *s = demuxer->stream;
2293 uint64_t l;
2294 int il, tmp;
2295
2296 while (1) {
2297 while (mkv_d->cluster_size > 0) {
2298 uint64_t block_duration = 0, block_length = 0;
2299 int64_t block_bref = 0, block_fref = 0;
2300 uint8_t *block = NULL;
2301
2302 while (mkv_d->blockgroup_size > 0) {
2303 switch (ebml_read_id(s, &il)) {
2304 case MATROSKA_ID_BLOCKDURATION:
2305 block_duration = ebml_read_uint(s, &l);
2306 if (block_duration == EBML_UINT_INVALID) {
2307 free(block);
2308 return 0;
2309 }
2310 block_duration =
2311 block_duration * mkv_d->tc_scale / 1000000.0 + 0.5;
2312 break;
2313
2314 case MATROSKA_ID_BLOCK:
2315 block_length = ebml_read_length(s, &tmp);
2316 free(block);
2317 if (block_length > 500000000)
2318 return 0;
2319 block = malloc(block_length + AV_LZO_INPUT_PADDING);
2320 demuxer->filepos = stream_tell(s);
2321 if (stream_read(s, block, block_length) !=
2322 (int) block_length) {
2323 free(block);
2324 return 0;
2325 }
2326 l = tmp + block_length;
2327 break;
2328
2329 case MATROSKA_ID_REFERENCEBLOCK:;
2330 int64_t num = ebml_read_int(s, &l);
2331 if (num == EBML_INT_INVALID) {
2332 free(block);
2333 return 0;
2334 }
2335 if (num <= 0)
2336 block_bref = num;
2337 else
2338 block_fref = num;
2339 break;
2340
2341 case EBML_ID_INVALID:
2342 free(block);
2343 return 0;
2344
2345 default:
2346 ebml_read_skip(s, &l);
2347 break;
2348 }
2349 mkv_d->blockgroup_size -= l + il;
2350 mkv_d->cluster_size -= l + il;
2351 }
2352
2353 if (block) {
2354 int res = handle_block(demuxer, block, block_length,
2355 block_duration, block_bref, block_fref,
2356 0);
2357 free(block);
2358 if (res < 0)
2359 return 0;
2360 if (res)
2361 return 1;
2362 }
2363
2364 if (mkv_d->cluster_size > 0) {
2365 switch (ebml_read_id(s, &il)) {
2366 case MATROSKA_ID_TIMECODE:;
2367 uint64_t num = ebml_read_uint(s, &l);
2368 if (num == EBML_UINT_INVALID)
2369 return 0;
2370 mkv_d->cluster_tc = num * mkv_d->tc_scale;
2371 add_cluster_position(mkv_d, mkv_d->cluster_start,
2372 mkv_d->cluster_tc);
2373 break;
2374
2375 case MATROSKA_ID_BLOCKGROUP:
2376 mkv_d->blockgroup_size = ebml_read_length(s, &tmp);
2377 l = tmp;
2378 break;
2379
2380 case MATROSKA_ID_SIMPLEBLOCK:;
2381 int res;
2382 block_length = ebml_read_length(s, &tmp);
2383 if (block_length > 500000000)
2384 return 0;
2385 block = malloc(block_length);
2386 demuxer->filepos = stream_tell(s);
2387 if (stream_read(s, block, block_length) !=
2388 (int) block_length) {
2389 free(block);
2390 return 0;
2391 }
2392 l = tmp + block_length;
2393 res = handle_block(demuxer, block, block_length,
2394 block_duration, block_bref,
2395 block_fref, 1);
2396 free(block);
2397 mkv_d->cluster_size -= l + il;
2398 if (res < 0)
2399 return 0;
2400 else if (res)
2401 return 1;
2402 else
2403 mkv_d->cluster_size += l + il;
2404 break;
2405
2406 case EBML_ID_INVALID:
2407 return 0;
2408
2409 default:
2410 ebml_read_skip(s, &l);
2411 break;
2412 }
2413 mkv_d->cluster_size -= l + il;
2414 }
2415 }
2416
2417 while (ebml_read_id(s, &il) != MATROSKA_ID_CLUSTER) {
2418 ebml_read_skip(s, NULL);
2419 if (s->eof)
2420 return 0;
2421 }
2422 mkv_d->cluster_start = stream_tell(s) - il;
2423 mkv_d->cluster_size = ebml_read_length(s, NULL);
2424 }
2425
2426 return 0;
2427 }
2428
2429 static int seek_creating_index(struct demuxer *demuxer, float rel_seek_secs,
2430 int flags)
2431 {
2432 struct mkv_demuxer *mkv_d = demuxer->priv;
2433 struct stream *s = demuxer->stream;
2434 int64_t target_tc_ns = (int64_t) (rel_seek_secs * 1e9);
2435 if (target_tc_ns < 0)
2436 target_tc_ns = 0;
2437 uint64_t max_filepos = 0;
2438 int64_t max_tc = -1;
2439 int n = mkv_d->num_cluster_pos;
2440 if (n > 0) {
2441 max_filepos = mkv_d->cluster_positions[n - 1].filepos;
2442 max_tc = mkv_d->cluster_positions[n - 1].timecode;
2443 }
2444
2445 if (target_tc_ns > max_tc) {
2446 if ((off_t) max_filepos > stream_tell(s))
2447 stream_seek(s, max_filepos);
2448 else
2449 stream_seek(s, stream_tell(s) + mkv_d->cluster_size);
2450 /* parse all the clusters upto target_filepos */
2451 while (!s->eof) {
2452 uint64_t start = stream_tell(s);
2453 uint32_t type = ebml_read_id(s, NULL);
2454 uint64_t len = ebml_read_length(s, NULL);
2455 uint64_t end = stream_tell(s) + len;
2456 if (type == MATROSKA_ID_CLUSTER) {
2457 while (!s->eof && stream_tell(s) < end) {
2458 if (ebml_read_id(s, NULL) == MATROSKA_ID_TIMECODE) {
2459 uint64_t tc = ebml_read_uint(s, NULL);
2460 tc *= mkv_d->tc_scale;
2461 add_cluster_position(mkv_d, start, tc);
2462 if (tc >= target_tc_ns)
2463 goto enough_index;
2464 break;
2465 }
2466 }
2467 }
2468 if (s->eof)
2469 break;
2470 stream_seek(s, end);
2471 }
2472 enough_index:
2473 if (s->eof)
2474 stream_reset(s);
2475 }
2476 if (!mkv_d->num_cluster_pos) {
2477 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] no target for seek found\n");
2478 return -1;
2479 }
2480 uint64_t cluster_pos = mkv_d->cluster_positions[0].filepos;
2481 /* Let's find the nearest cluster */
2482 int64_t min_diff = 0xFFFFFFFFFFFFFFF;
2483 for (int i = 0; i < mkv_d->num_cluster_pos; i++) {
2484 int64_t diff = mkv_d->cluster_positions[i].timecode - target_tc_ns;
2485 if (flags & SEEK_BACKWARD && diff < 0 && -diff < min_diff) {
2486 cluster_pos = mkv_d->cluster_positions[i].filepos;
2487 min_diff = -diff;
2488 } else if (flags & SEEK_FORWARD
2489 && (diff < 0 ? -1 * diff : diff) < min_diff) {
2490 cluster_pos = mkv_d->cluster_positions[i].filepos;
2491 min_diff = diff < 0 ? -1 * diff : diff;
2492 }
2493 }
2494 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
2495 stream_seek(s, cluster_pos);
2496 return 0;
2497 }
2498
2499 static struct mkv_index *seek_with_cues(struct demuxer *demuxer, int seek_id,
2500 int64_t target_timecode, int flags)
2501 {
2502 struct mkv_demuxer *mkv_d = demuxer->priv;
2503 int64_t min_diff = 0xFFFFFFFFFFFFFFF;
2504 struct mkv_index *index = NULL;
2505
2506 /* let's find the entry in the indexes with the smallest */
2507 /* difference to the wanted timecode. */
2508 for (int i = 0; i < mkv_d->num_indexes; i++)
2509 if (seek_id < 0 || mkv_d->indexes[i].tnum == seek_id) {
2510 uint64_t diff =
2511 target_timecode -
2512 (int64_t) (mkv_d->indexes[i].timecode *
2513 mkv_d->tc_scale / 1000000.0 + 0.5);
2514
2515 if (flags & SEEK_BACKWARD) {
2516 // Seek backward: find the last index position
2517 // before target time
2518 if (diff < 0 || diff >= min_diff)
2519 continue;
2520 } else {
2521 // Seek forward: find the first index position
2522 // after target time. If no such index exists, find last
2523 // position between current position and target time.
2524 if (diff <= 0) {
2525 if (min_diff <= 0 && diff <= min_diff)
2526 continue;
2527 } else if (diff >=
2528 FFMIN(target_timecode - mkv_d->last_pts, min_diff))
2529 continue;
2530 }
2531 min_diff = diff;
2532 index = mkv_d->indexes + i;
2533 }
2534
2535 if (index) { /* We've found an entry. */
2536 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
2537 stream_seek(demuxer->stream, index->filepos);
2538 }
2539 return index;
2540 }
2541
2542 static void demux_mkv_seek(demuxer_t *demuxer, float rel_seek_secs,
2543 float audio_delay, int flags)
2544 {
2545 mkv_demuxer_t *mkv_d = demuxer->priv;
2546 uint64_t v_tnum = -1;
2547 if (demuxer->video->id >= 0)
2548 v_tnum = find_track_by_num(mkv_d, demuxer->video->id,
2549 MATROSKA_TRACK_VIDEO)->tnum;
2550 uint64_t a_tnum = -1;
2551 if (demuxer->audio->id >= 0)
2552 a_tnum = find_track_by_num(mkv_d, demuxer->audio->id,
2553 MATROSKA_TRACK_AUDIO)->tnum;
2554 if (!(flags & (SEEK_BACKWARD | SEEK_FORWARD))) {
2555 if (flags & SEEK_ABSOLUTE || rel_seek_secs < 0)
2556 flags |= SEEK_BACKWARD;
2557 else
2558 flags |= SEEK_FORWARD;
2559 }
2560 // Adjust the target a little bit to catch cases where the target position
2561 // specifies a keyframe with high, but not perfect, precision.
2562 rel_seek_secs += flags & SEEK_FORWARD ? -0.005 : 0.005;
2563
2564 free_cached_dps(demuxer);
2565 if (!(flags & SEEK_FACTOR)) { /* time in secs */
2566 mkv_index_t *index = NULL;
2567
2568 if (!(flags & SEEK_ABSOLUTE)) /* relative seek */
2569 rel_seek_secs += mkv_d->last_pts;
2570 int64_t target_timecode = rel_seek_secs * 1000.0;
2571 if (target_timecode < 0)
2572 target_timecode = 0;
2573
2574 if (mkv_d->indexes == NULL) { /* no index was found */
2575 if (seek_creating_index(demuxer, rel_seek_secs, flags) < 0)
2576 return;
2577 } else {
2578 int seek_id = (demuxer->video->id < 0) ?
2579 a_tnum : v_tnum;
2580 index = seek_with_cues(demuxer, seek_id, target_timecode, flags);
2581 if (!index)
2582 index = seek_with_cues(demuxer, -1, target_timecode, flags);
2583 }
2584
2585 if (demuxer->video->id >= 0)
2586 mkv_d->v_skip_to_keyframe = 1;
2587 if (flags & SEEK_FORWARD)
2588 mkv_d->skip_to_timecode = target_timecode;
2589 else
2590 mkv_d->skip_to_timecode = index ? index->timecode : 0;
2591 mkv_d->a_skip_to_keyframe = 1;
2592
2593 demux_mkv_fill_buffer(demuxer, NULL);
2594 } else if ((demuxer->movi_end <= 0) || !(flags & SEEK_ABSOLUTE))
2595 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
2596 else {
2597 stream_t *s = demuxer->stream;
2598 uint64_t target_filepos;
2599 mkv_index_t *index = NULL;
2600 int i;
2601
2602 if (mkv_d->indexes == NULL) { /* not implemented without index */
2603 mp_msg(MSGT_DEMUX, MSGL_V, "[mkv] seek unsupported flags\n");
2604 return;
2605 }
2606
2607 target_filepos = (uint64_t) (demuxer->movi_end * rel_seek_secs);
2608 for (i = 0; i < mkv_d->num_indexes; i++)
2609 if (mkv_d->indexes[i].tnum == v_tnum)
2610 if ((index == NULL)
2611 || ((mkv_d->indexes[i].filepos >= target_filepos)
2612 && ((index->filepos < target_filepos)
2613 || (mkv_d->indexes[i].filepos < index->filepos))))
2614 index = &mkv_d->indexes[i];
2615
2616 if (!index)
2617 return;
2618
2619 mkv_d->cluster_size = mkv_d->blockgroup_size = 0;
2620 stream_seek(s, index->filepos);
2621
2622 if (demuxer->video->id >= 0)
2623 mkv_d->v_skip_to_keyframe = 1;
2624 mkv_d->skip_to_timecode = index->timecode;
2625 mkv_d->a_skip_to_keyframe = 1;
2626
2627 demux_mkv_fill_buffer(demuxer, NULL);
2628 }
2629 }
2630
2631 static int demux_mkv_control(demuxer_t *demuxer, int cmd, void *arg)
2632 {
2633 mkv_demuxer_t *mkv_d = (mkv_demuxer_t *) demuxer->priv;
2634
2635 switch (cmd) {
2636 case DEMUXER_CTRL_CORRECT_PTS:
2637 return DEMUXER_CTRL_OK;
2638 case DEMUXER_CTRL_GET_TIME_LENGTH:
2639 if (mkv_d->duration == 0)
2640 return DEMUXER_CTRL_DONTKNOW;
2641
2642 *((double *) arg) = (double) mkv_d->duration;
2643 return DEMUXER_CTRL_OK;
2644
2645 case DEMUXER_CTRL_GET_PERCENT_POS:
2646 if (mkv_d->duration == 0) {
2647 return DEMUXER_CTRL_DONTKNOW;
2648 }
2649
2650 *((int *) arg) = (int) (100 * mkv_d->last_pts / mkv_d->duration);
2651 return DEMUXER_CTRL_OK;
2652
2653 case DEMUXER_CTRL_SWITCH_AUDIO:;
2654 int new_aid = *(int *) arg;
2655 int current_aid = demuxer->audio->id;
2656 if (current_aid < 0)
2657 current_aid = -1;
2658 if (new_aid == -1) // cycle to next
2659 new_aid = (current_aid + 2) % (mkv_d->num_audio_tracks + 1) - 1;
2660 if (new_aid < 0 || new_aid >= mkv_d->num_audio_tracks)
2661 new_aid = -2;
2662 *(int *) arg = new_aid;
2663 if (current_aid != new_aid)
2664 ds_free_packs(demuxer->audio);
2665 demuxer->audio->id = new_aid;
2666 return DEMUXER_CTRL_OK;
2667
2668 default:
2669 return DEMUXER_CTRL_NOTIMPL;
2670 }
2671 }
2672
2673 const demuxer_desc_t demuxer_desc_matroska = {
2674 "Matroska demuxer",
2675 "mkv",
2676 "Matroska",
2677 "Aurelien Jacobs",
2678 "",
2679 DEMUXER_TYPE_MATROSKA,
2680 1, // safe autodetect
2681 demux_mkv_open,
2682 demux_mkv_fill_buffer,
2683 NULL,
2684 demux_close_mkv,
2685 demux_mkv_seek,
2686 demux_mkv_control
2687 };