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