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