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.
7 * This file is part of MPlayer.
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.
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.
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.
35 #include "stream/stream.h"
40 #include "demux_real.h"
45 #include "subreader.h"
46 #include "libvo/sub.h"
50 #include "libavutil/common.h"
52 #ifdef CONFIG_QTX_CODECS
53 #include "loader/qtx/qtxsdk/components.h"
60 #include "libavutil/lzo.h"
61 #include "ffmpeg_files/intreadwrite.h"
62 #include "libavutil/avstring.h"
64 static const unsigned char sipr_swaps
[38][2] = {
65 {0,63},{1,22},{2,44},{3,90},{5,81},{7,31},{8,86},{9,58},{10,36},{12,68},
66 {13,39},{14,73},{15,53},{16,69},{17,57},{19,88},{20,34},{21,71},{24,46},
67 {25,94},{26,54},{28,75},{29,50},{32,70},{33,92},{35,74},{38,85},{40,56},
68 {42,87},{43,65},{45,59},{48,79},{49,93},{51,89},{55,95},{61,76},{67,83},
72 // Map flavour to bytes per second
73 #define SIPR_FLAVORS 4
74 #define ATRC_FLAVORS 8
75 #define COOK_FLAVORS 34
76 static const int sipr_fl2bps
[SIPR_FLAVORS
] = { 813, 1062, 625, 2000 };
77 static const int atrc_fl2bps
[ATRC_FLAVORS
] = {
78 8269, 11714, 13092, 16538, 18260, 22050, 33075, 44100 };
79 static const int cook_fl2bps
[COOK_FLAVORS
] = {
80 1000, 1378, 2024, 2584, 4005, 5513, 8010, 4005, 750, 2498,
81 4048, 5513, 8010, 11973, 8010, 2584, 4005, 2067, 2584, 2584,
82 4005, 4005, 5513, 5513, 8010, 12059, 1550, 8010, 12059, 5513,
83 12016, 16408, 22911, 33506
86 typedef struct mkv_content_encoding
{
87 uint64_t order
, type
, scope
;
89 uint8_t *comp_settings
;
90 int comp_settings_len
;
91 } mkv_content_encoding_t
;
93 typedef struct mkv_track
{
96 int id
; // -aid / -sid / -vid option value
104 uint32_t v_width
, v_height
, v_dwidth
, v_dheight
;
107 uint32_t a_formattag
;
108 uint32_t a_channels
, a_bps
;
112 double default_duration
;
116 unsigned char *private_data
;
117 unsigned int private_size
;
119 /* stuff for realmedia */
123 double rv_pts
; /* previous video timestamp */
124 double ra_pts
; /* previous audio timestamp */
126 /** realaudio descrambling */
127 int sub_packet_size
; ///< sub packet size, per stream
128 int sub_packet_h
; ///< number of coded frames per block
129 int coded_framesize
; ///< coded frame size, per stream
130 int audiopk_size
; ///< audio packet size
131 unsigned char *audio_buf
; ///< place to store reordered audio data
132 double *audio_timestamp
; ///< timestamp for each audio packet
133 int sub_packet_cnt
; ///< number of subpacket already received
134 int audio_filepos
; ///< file position of first audio packet in block
136 /* stuff for quicktime */
138 double qt_last_a_pts
;
142 /* generic content encoding support */
143 mkv_content_encoding_t
*encodings
;
146 /* For VobSubs and SSA/ASS */
150 typedef struct mkv_index
{
152 uint64_t timecode
, filepos
;
155 typedef struct mkv_demuxer
{
158 double duration
, last_pts
;
159 uint64_t last_filepos
;
161 mkv_track_t
**tracks
;
164 uint64_t tc_scale
, cluster_tc
;
166 uint64_t cluster_start
;
167 uint64_t cluster_size
;
168 uint64_t blockgroup_size
;
170 mkv_index_t
*indexes
;
178 bool parsed_chapters
;
179 bool parsed_attachments
;
184 } *cluster_positions
;
187 int64_t skip_to_timecode
;
188 int v_skip_to_keyframe
, a_skip_to_keyframe
;
190 int num_audio_tracks
;
193 #define REALHEADER_SIZE 16
194 #define RVPROPERTIES_SIZE 34
195 #define RAPROPERTIES4_SIZE 56
196 #define RAPROPERTIES5_SIZE 70
199 * \brief ensures there is space for at least one additional element
200 * \param array array to grow
201 * \param nelem current number of elements in array
202 * \param elsize size of one array element
204 static void *grow_array(void *array
, int nelem
, size_t elsize
)
207 array
= realloc(array
, (nelem
+ 32) * elsize
);
211 static bool is_parsed_header(struct mkv_demuxer
*mkv_d
, off_t pos
)
214 int high
= mkv_d
->num_parsed_pos
;
215 while (high
> low
+ 1) {
216 int mid
= high
+ low
>> 1;
217 if (mkv_d
->parsed_pos
[mid
] > pos
)
222 if (mkv_d
->num_parsed_pos
&& mkv_d
->parsed_pos
[low
] == pos
)
224 if (!(mkv_d
->num_parsed_pos
& 31))
225 mkv_d
->parsed_pos
= talloc_realloc(mkv_d
, mkv_d
->parsed_pos
, off_t
,
226 mkv_d
->num_parsed_pos
+ 32);
227 mkv_d
->num_parsed_pos
++;
228 for (int i
= mkv_d
->num_parsed_pos
- 1; i
> low
; i
--)
229 mkv_d
->parsed_pos
[i
] = mkv_d
->parsed_pos
[i
- 1];
230 mkv_d
->parsed_pos
[low
] = pos
;
234 static mkv_track_t
*find_track_by_num(struct mkv_demuxer
*d
, int n
, int type
)
236 for (int i
= 0; i
< d
->num_tracks
; i
++)
237 if (d
->tracks
[i
] != NULL
&& d
->tracks
[i
]->type
== type
)
238 if (d
->tracks
[i
]->id
== n
)
244 static void add_cluster_position(mkv_demuxer_t
*mkv_d
, uint64_t filepos
,
250 int n
= mkv_d
->num_cluster_pos
;
251 if (n
> 0 && mkv_d
->cluster_positions
[n
-1].filepos
>= filepos
)
254 mkv_d
->cluster_positions
=
255 grow_array(mkv_d
->cluster_positions
, mkv_d
->num_cluster_pos
,
256 sizeof(*mkv_d
->cluster_positions
));
257 mkv_d
->cluster_positions
[mkv_d
->num_cluster_pos
++] = (struct cluster_pos
){
259 .timecode
= timecode
,
264 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
265 static int aac_get_sample_rate_index(uint32_t sample_rate
)
267 static const int srates
[] = {
268 92017, 75132, 55426, 46009, 37566, 27713,
269 23004, 18783, 13856, 11502, 9391, 0
272 while (sample_rate
< srates
[i
])
277 static void demux_mkv_decode(mkv_track_t
*track
, uint8_t *src
,
278 uint8_t **dest
, uint32_t *size
, uint32_t type
)
280 uint8_t *orig_src
= src
;
284 for (int i
= 0; i
< track
->num_encodings
; i
++) {
285 struct mkv_content_encoding
*enc
= track
->encodings
+ i
;
286 if (!(enc
->scope
& type
))
289 if (src
!= *dest
&& src
!= orig_src
)
291 src
= *dest
; // output from last iteration is new source
293 if (enc
->comp_algo
== 0) {
295 /* zlib encoded track */
302 zstream
.zalloc
= (alloc_func
) 0;
303 zstream
.zfree
= (free_func
) 0;
304 zstream
.opaque
= (voidpf
) 0;
305 if (inflateInit(&zstream
) != Z_OK
) {
306 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
307 "[mkv] zlib initialization failed.\n");
310 zstream
.next_in
= (Bytef
*) src
;
311 zstream
.avail_in
= *size
;
314 zstream
.avail_out
= *size
;
318 *dest
= talloc_realloc_size(NULL
, *dest
, *size
);
319 zstream
.next_out
= (Bytef
*) (*dest
+ zstream
.total_out
);
320 result
= inflate(&zstream
, Z_NO_FLUSH
);
321 if (result
!= Z_OK
&& result
!= Z_STREAM_END
) {
322 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
323 "[mkv] zlib decompression failed.\n");
326 inflateEnd(&zstream
);
329 zstream
.avail_out
+= 4000;
330 } while (zstream
.avail_out
== 4000 && zstream
.avail_in
!= 0
331 && result
!= Z_STREAM_END
);
333 *size
= zstream
.total_out
;
334 inflateEnd(&zstream
);
336 } else if (enc
->comp_algo
== 2) {
337 /* lzo encoded track */
339 int dstlen
= *size
* 3;
344 *dest
= talloc_realloc_size(NULL
, *dest
,
345 dstlen
+ AV_LZO_OUTPUT_PADDING
);
347 int result
= av_lzo1x_decode(*dest
, &out_avail
, src
, &srclen
);
350 if (!(result
& AV_LZO_OUTPUT_FULL
)) {
351 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
352 "[mkv] lzo decompression failed.\n");
357 mp_msg(MSGT_DEMUX
, MSGL_DBG2
,
358 "[mkv] lzo decompression buffer too small.\n");
361 *size
= dstlen
- out_avail
;
362 } else if (enc
->comp_algo
== 3) {
363 *dest
= talloc_size(NULL
, *size
+ enc
->comp_settings_len
);
364 memcpy(*dest
, enc
->comp_settings
, enc
->comp_settings_len
);
365 memcpy(*dest
+ enc
->comp_settings_len
, src
, *size
);
366 *size
+= enc
->comp_settings_len
;
371 if (src
!= *dest
&& src
!= orig_src
)
376 static int demux_mkv_read_info(demuxer_t
*demuxer
)
378 mkv_demuxer_t
*mkv_d
= demuxer
->priv
;
379 stream_t
*s
= demuxer
->stream
;
381 mkv_d
->tc_scale
= 1000000;
384 struct ebml_info info
= {};
385 struct ebml_parse_ctx parse_ctx
= {};
386 if (ebml_read_element(s
, &parse_ctx
, &info
, &ebml_info_desc
) < 0)
388 if (info
.n_timecode_scale
) {
389 mkv_d
->tc_scale
= info
.timecode_scale
;
390 mp_msg(MSGT_DEMUX
, MSGL_V
,
391 "[mkv] | + timecode scale: %" PRIu64
"\n", mkv_d
->tc_scale
);
393 if (info
.n_duration
) {
394 mkv_d
->duration
= info
.duration
* mkv_d
->tc_scale
/ 1e9
;
395 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + duration: %.3fs\n",
398 if (info
.n_segment_uid
) {
399 int len
= info
.segment_uid
.len
;
400 if (len
!= sizeof(demuxer
->matroska_data
.segment_uid
)) {
401 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
402 "[mkv] segment uid invalid length %d\n", len
);
404 memcpy(demuxer
->matroska_data
.segment_uid
, info
.segment_uid
.start
,
406 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + segment uid");
407 for (int i
= 0; i
< len
; i
++)
408 mp_msg(MSGT_DEMUX
, MSGL_V
, " %02x",
409 demuxer
->matroska_data
.segment_uid
[i
]);
410 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
413 talloc_free(parse_ctx
.talloc_ctx
);
417 static void parse_trackencodings(struct demuxer
*demuxer
,
418 struct mkv_track
*track
,
419 struct ebml_content_encodings
*encodings
)
421 // initial allocation to be a non-NULL context before realloc
422 mkv_content_encoding_t
*ce
= talloc_size(track
, 1);
424 for (int n_enc
= 0; n_enc
< encodings
->n_content_encoding
; n_enc
++) {
425 struct ebml_content_encoding
*enc
= encodings
->content_encoding
+ n_enc
;
426 struct mkv_content_encoding e
= {};
427 e
.order
= enc
->content_encoding_order
;
428 if (enc
->n_content_encoding_scope
)
429 e
.scope
= enc
->content_encoding_scope
;
432 e
.type
= enc
->content_encoding_type
;
434 if (enc
->n_content_compression
) {
435 struct ebml_content_compression
*z
= &enc
->content_compression
;
436 e
.comp_algo
= z
->content_comp_algo
;
437 if (z
->n_content_comp_settings
) {
438 int sz
= z
->content_comp_settings
.len
;
439 e
.comp_settings
= talloc_size(ce
, sz
);
440 memcpy(e
.comp_settings
, z
->content_comp_settings
.start
, sz
);
441 e
.comp_settings_len
= sz
;
446 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Track "
447 "number %u has been encrypted and "
448 "decryption has not yet been\n"
449 "[mkv] implemented. Skipping track.\n",
451 } else if (e
.type
!= 0) {
452 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
453 "[mkv] Unknown content encoding type for "
454 "track %u. Skipping track.\n",
456 } else if (e
.comp_algo
!= 0 && e
.comp_algo
!= 2 && e
.comp_algo
!= 3) {
457 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
458 "[mkv] Track %u has been compressed with "
459 "an unknown/unsupported compression\n"
460 "[mkv] algorithm (%" PRIu64
"). Skipping track.\n",
461 track
->tnum
, e
.comp_algo
);
464 else if (e
.comp_algo
== 0) {
465 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
466 "[mkv] Track %u was compressed with zlib "
467 "but mplayer has not been compiled\n"
468 "[mkv] with support for zlib compression. "
474 for (i
= 0; i
< n_enc
; i
++)
475 if (e
.order
>= ce
[i
].order
)
477 ce
= talloc_realloc_size(track
, ce
, (n_enc
+ 1) * sizeof(*ce
));
478 memmove(ce
+ i
+ 1, ce
+ i
, (n_enc
- i
) * sizeof(*ce
));
479 memcpy(ce
+ i
, &e
, sizeof(e
));
482 track
->encodings
= ce
;
483 track
->num_encodings
= encodings
->n_content_encoding
;
486 static void parse_trackaudio(struct demuxer
*demuxer
, struct mkv_track
*track
,
487 struct ebml_audio
*audio
)
489 if (audio
->n_sampling_frequency
) {
490 track
->a_sfreq
= audio
->sampling_frequency
;
491 mp_msg(MSGT_DEMUX
, MSGL_V
,
492 "[mkv] | + Sampling frequency: %f\n", track
->a_sfreq
);
494 track
->a_sfreq
= 8000;
495 if (audio
->n_output_sampling_frequency
) {
496 track
->a_osfreq
= audio
->output_sampling_frequency
;
497 mp_msg(MSGT_DEMUX
, MSGL_V
,
498 "[mkv] | + Output sampling frequency: %f\n", track
->a_osfreq
);
500 track
->a_osfreq
= track
->a_sfreq
;
501 if (audio
->n_bit_depth
) {
502 track
->a_bps
= audio
->bit_depth
;
503 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Bit depth: %u\n",
506 if (audio
->n_channels
) {
507 track
->a_channels
= audio
->channels
;
508 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Channels: %u\n",
511 track
->a_channels
= 1;
514 static void parse_trackvideo(struct demuxer
*demuxer
, struct mkv_track
*track
,
515 struct ebml_video
*video
)
517 if (video
->n_frame_rate
) {
518 track
->v_frate
= video
->frame_rate
;
519 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Frame rate: %f\n",
521 if (track
->v_frate
> 0)
522 track
->default_duration
= 1 / track
->v_frate
;
524 if (video
->n_display_width
) {
525 track
->v_dwidth
= video
->display_width
;
526 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display width: %u\n",
529 if (video
->n_display_height
) {
530 track
->v_dheight
= video
->display_height
;
531 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display height: %u\n",
534 if (video
->n_pixel_width
) {
535 track
->v_width
= video
->pixel_width
;
536 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel width: %u\n",
539 if (video
->n_pixel_height
) {
540 track
->v_height
= video
->pixel_height
;
541 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel height: %u\n",
547 * \brief free any data associated with given track
548 * \param track track of which to free data
550 static void demux_mkv_free_trackentry(mkv_track_t
*track
)
552 free(track
->audio_buf
);
553 free(track
->audio_timestamp
);
557 static void parse_trackentry(struct demuxer
*demuxer
,
558 struct ebml_track_entry
*entry
)
560 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
561 struct mkv_track
*track
= talloc_zero_size(NULL
, sizeof(*track
));
563 track
->tnum
= entry
->track_number
;
565 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track number: %u\n",
568 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Missing track number!\n");
571 track
->name
= talloc_strndup(track
, entry
->name
.start
,
573 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Name: %s\n",
577 track
->type
= entry
->track_type
;
578 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track type: ");
579 switch (track
->type
) {
580 case MATROSKA_TRACK_AUDIO
:
581 mp_msg(MSGT_DEMUX
, MSGL_V
, "Audio\n");
583 case MATROSKA_TRACK_VIDEO
:
584 mp_msg(MSGT_DEMUX
, MSGL_V
, "Video\n");
586 case MATROSKA_TRACK_SUBTITLE
:
587 mp_msg(MSGT_DEMUX
, MSGL_V
, "Subtitle\n");
590 mp_msg(MSGT_DEMUX
, MSGL_V
, "unknown\n");
594 if (entry
->n_audio
) {
595 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Audio track\n");
596 parse_trackaudio(demuxer
, track
, &entry
->audio
);
599 if (entry
->n_video
) {
600 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Video track\n");
601 parse_trackvideo(demuxer
, track
, &entry
->video
);
604 if (entry
->n_codec_id
) {
605 track
->codec_id
= talloc_strndup(track
, entry
->codec_id
.start
,
606 entry
->codec_id
.len
);
607 if (!strcmp(track
->codec_id
, MKV_V_MSCOMP
)
608 || !strcmp(track
->codec_id
, MKV_A_ACM
))
609 track
->ms_compat
= 1;
610 else if (!strcmp(track
->codec_id
, MKV_S_VOBSUB
))
611 track
->subtitle_type
= MATROSKA_SUBTYPE_VOBSUB
;
612 else if (!strcmp(track
->codec_id
, MKV_S_TEXTSSA
)
613 || !strcmp(track
->codec_id
, MKV_S_TEXTASS
)
614 || !strcmp(track
->codec_id
, MKV_S_SSA
)
615 || !strcmp(track
->codec_id
, MKV_S_ASS
)) {
616 track
->subtitle_type
= MATROSKA_SUBTYPE_SSA
;
617 } else if (!strcmp(track
->codec_id
, MKV_S_TEXTASCII
))
618 track
->subtitle_type
= MATROSKA_SUBTYPE_TEXT
;
619 if (!strcmp(track
->codec_id
, MKV_S_TEXTUTF8
)) {
620 track
->subtitle_type
= MATROSKA_SUBTYPE_TEXT
;
622 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Codec ID: %s\n",
625 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Missing codec ID!\n");
627 if (entry
->n_codec_private
) {
628 int len
= entry
->codec_private
.len
;
629 track
->private_data
= talloc_size(track
, len
+ AV_LZO_INPUT_PADDING
);
630 memcpy(track
->private_data
, entry
->codec_private
.start
, len
);
631 track
->private_size
= len
;
632 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + CodecPrivate, length %u\n",
633 track
->private_size
);
636 if (entry
->n_language
) {
637 track
->language
= talloc_strndup(track
, entry
->language
.start
,
638 entry
->language
.len
);
639 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Language: %s\n",
642 track
->language
= talloc_strdup(track
, "eng");
644 if (entry
->n_flag_default
) {
645 track
->default_track
= entry
->flag_default
;
646 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default flag: %u\n",
647 track
->default_track
);
649 track
->default_track
= 1;
651 if (entry
->n_default_duration
) {
652 track
->default_duration
= entry
->default_duration
/ 1e9
;
653 if (entry
->default_duration
== 0)
654 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default duration: 0");
657 track
->v_frate
= 1e9
/ entry
->default_duration
;
658 mp_msg(MSGT_DEMUX
, MSGL_V
,
659 "[mkv] | + Default duration: %.3fms ( = %.3f fps)\n",
660 entry
->default_duration
/ 1000000.0, track
->v_frate
);
664 if (entry
->n_content_encodings
)
665 parse_trackencodings(demuxer
, track
, &entry
->content_encodings
);
667 mkv_d
->tracks
[mkv_d
->num_tracks
++] = track
;
670 static int demux_mkv_read_tracks(demuxer_t
*demuxer
)
672 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
673 stream_t
*s
= demuxer
->stream
;
675 struct ebml_tracks tracks
= {};
676 struct ebml_parse_ctx parse_ctx
= {};
677 if (ebml_read_element(s
, &parse_ctx
, &tracks
, &ebml_tracks_desc
) < 0)
680 mkv_d
->tracks
= talloc_size(mkv_d
,
681 tracks
.n_track_entry
* sizeof(*mkv_d
->tracks
));
682 for (int i
= 0; i
< tracks
.n_track_entry
; i
++) {
683 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + a track...\n");
684 parse_trackentry(demuxer
, &tracks
.track_entry
[i
]);
686 talloc_free(parse_ctx
.talloc_ctx
);
690 static int demux_mkv_read_cues(demuxer_t
*demuxer
)
692 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
693 stream_t
*s
= demuxer
->stream
;
695 if (index_mode
== 0 || index_mode
== 2) {
696 ebml_read_skip(s
, NULL
);
700 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing cues ] -----------\n");
701 struct ebml_cues cues
= {};
702 struct ebml_parse_ctx parse_ctx
= {};
703 if (ebml_read_element(s
, &parse_ctx
, &cues
, &ebml_cues_desc
) < 0)
705 for (int i
= 0; i
< cues
.n_cue_point
; i
++) {
706 struct ebml_cue_point
*cuepoint
= &cues
.cue_point
[i
];
707 if (cuepoint
->n_cue_time
!= 1 || !cuepoint
->n_cue_track_positions
) {
708 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Malformed CuePoint element\n");
711 uint64_t time
= cuepoint
->cue_time
;
712 for (int i
= 0; i
< cuepoint
->n_cue_track_positions
; i
++) {
713 struct ebml_cue_track_positions
*trackpos
=
714 &cuepoint
->cue_track_positions
[i
];
715 uint64_t track
= trackpos
->cue_track
;
716 uint64_t pos
= trackpos
->cue_cluster_position
;
718 grow_array(mkv_d
->indexes
, mkv_d
->num_indexes
,
719 sizeof(mkv_index_t
));
720 mkv_d
->indexes
[mkv_d
->num_indexes
].tnum
= track
;
721 mkv_d
->indexes
[mkv_d
->num_indexes
].timecode
= time
;
722 mkv_d
->indexes
[mkv_d
->num_indexes
].filepos
=
723 mkv_d
->segment_start
+ pos
;
724 mp_msg(MSGT_DEMUX
, MSGL_DBG2
,
725 "[mkv] |+ found cue point for track %" PRIu64
726 ": timecode %" PRIu64
", filepos: %" PRIu64
"\n", track
,
727 time
, mkv_d
->segment_start
+ pos
);
728 mkv_d
->num_indexes
++;
733 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] \\---- [ parsing cues ] -----------\n");
734 talloc_free(parse_ctx
.talloc_ctx
);
738 static int demux_mkv_read_chapters(struct demuxer
*demuxer
)
740 struct MPOpts
*opts
= demuxer
->opts
;
741 stream_t
*s
= demuxer
->stream
;
743 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing chapters ] ---------\n");
744 struct ebml_chapters file_chapters
= {};
745 struct ebml_parse_ctx parse_ctx
= {};
746 if (ebml_read_element(s
, &parse_ctx
, &file_chapters
,
747 &ebml_chapters_desc
) < 0)
750 int selected_edition
= 0;
751 int num_editions
= file_chapters
.n_edition_entry
;
752 struct ebml_edition_entry
*editions
= file_chapters
.edition_entry
;
753 if (opts
->edition_id
>= 0 && opts
->edition_id
< num_editions
) {
754 selected_edition
= opts
->edition_id
;
755 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] User-specified edition: %d\n",
758 for (int i
= 0; i
< num_editions
; i
++)
759 if (editions
[i
].edition_flag_default
) {
760 selected_edition
= i
;
761 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Default edition: %d\n", i
);
764 struct matroska_chapter
*m_chapters
= NULL
;
765 if (editions
[selected_edition
].edition_flag_ordered
) {
766 int count
= editions
[selected_edition
].n_chapter_atom
;
767 m_chapters
= talloc_array_ptrtype(demuxer
, m_chapters
, count
);
768 demuxer
->matroska_data
.ordered_chapters
= m_chapters
;
769 demuxer
->matroska_data
.num_ordered_chapters
= count
;
772 for (int idx
= 0; idx
< num_editions
; idx
++) {
773 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] New edition %d\n", idx
);
774 int warn_level
= idx
== selected_edition
? MSGL_WARN
: MSGL_V
;
775 if (editions
[idx
].n_edition_flag_default
)
776 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Default edition flag: %"PRIu64
777 "\n", editions
[idx
].edition_flag_default
);
778 if (editions
[idx
].n_edition_flag_ordered
)
779 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Ordered chapter flag: %"PRIu64
780 "\n", editions
[idx
].edition_flag_ordered
);
781 for (int i
= 0; i
< editions
[idx
].n_chapter_atom
; i
++) {
782 struct ebml_chapter_atom
*ca
= editions
[idx
].chapter_atom
+ i
;
783 struct matroska_chapter chapter
= { };
784 struct bstr name
= { "(unnamed)", 9 };
786 if (!ca
->n_chapter_time_start
)
787 mp_msg(MSGT_DEMUX
, warn_level
,
788 "[mkv] Chapter lacks start time\n");
789 chapter
.start
= ca
->chapter_time_start
/ 1000000;
790 chapter
.end
= ca
->chapter_time_end
/ 1000000;
792 if (ca
->n_chapter_display
) {
793 if (ca
->n_chapter_display
> 1)
794 mp_msg(MSGT_DEMUX
, warn_level
, "[mkv] Multiple chapter "
795 "names not supported, picking first\n");
796 if (!ca
->chapter_display
[0].n_chap_string
)
797 mp_msg(MSGT_DEMUX
, warn_level
, "[mkv] Malformed chapter "
800 name
= ca
->chapter_display
[0].chap_string
;
803 if (ca
->n_chapter_segment_uid
) {
804 chapter
.has_segment_uid
= true;
805 int len
= ca
->chapter_segment_uid
.len
;
806 if (len
!= sizeof(chapter
.segment_uid
))
807 mp_msg(MSGT_DEMUX
, warn_level
,
808 "[mkv] Chapter segment uid bad length %d\n", len
);
809 else if (ca
->n_chapter_segment_edition_uid
) {
810 mp_tmsg(MSGT_DEMUX
, warn_level
, "[mkv] Warning: "
811 "unsupported edition recursion in chapter; "
812 "will skip on playback!\n");
814 memcpy(chapter
.segment_uid
, ca
->chapter_segment_uid
.start
,
816 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Chapter segment uid ");
817 for (int i
= 0; i
< len
; i
++)
818 mp_msg(MSGT_DEMUX
, MSGL_V
, "%02x ",
819 chapter
.segment_uid
[i
]);
820 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
824 mp_msg(MSGT_DEMUX
, MSGL_V
,
825 "[mkv] Chapter %u from %02d:%02d:%02d.%03d "
826 "to %02d:%02d:%02d.%03d, %.*s\n", i
,
827 (int) (chapter
.start
/ 60 / 60 / 1000),
828 (int) ((chapter
.start
/ 60 / 1000) % 60),
829 (int) ((chapter
.start
/ 1000) % 60),
830 (int) (chapter
.start
% 1000),
831 (int) (chapter
.end
/ 60 / 60 / 1000),
832 (int) ((chapter
.end
/ 60 / 1000) % 60),
833 (int) ((chapter
.end
/ 1000) % 60),
834 (int) (chapter
.end
% 1000),
837 if (idx
== selected_edition
){
838 demuxer_add_chapter(demuxer
, name
, chapter
.start
, chapter
.end
);
839 if (editions
[idx
].edition_flag_ordered
) {
840 chapter
.name
= talloc_strndup(m_chapters
, name
.start
,
842 m_chapters
[i
] = chapter
;
847 if (num_editions
> 1)
848 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
849 "[mkv] Found %d editions, will play #%d (first is 0).\n",
850 num_editions
, selected_edition
);
853 talloc_free(parse_ctx
.talloc_ctx
);
854 mp_msg(MSGT_DEMUX
, MSGL_V
,
855 "[mkv] \\---- [ parsing chapters ] ---------\n");
859 static int demux_mkv_read_tags(demuxer_t
*demuxer
)
861 stream_t
*s
= demuxer
->stream
;
863 struct ebml_parse_ctx parse_ctx
= {};
864 struct ebml_tags tags
= {};
865 if (ebml_read_element(s
, &parse_ctx
, &tags
, &ebml_tags_desc
) < 0)
868 for (int i
= 0; i
< tags
.n_tag
; i
++) {
869 struct ebml_tag tag
= tags
.tag
[i
];
870 if (tag
.targets
.target_track_uid
|| tag
.targets
.target_edition_uid
||
871 tag
.targets
.target_chapter_uid
|| tag
.targets
.target_attachment_uid
)
874 for (int j
; j
< tag
.n_simple_tag
; j
++)
875 demux_info_add_bstr(demuxer
, tag
.simple_tag
[j
].tag_name
, tag
.simple_tag
[j
].tag_string
);
881 static int demux_mkv_read_attachments(demuxer_t
*demuxer
)
883 stream_t
*s
= demuxer
->stream
;
885 mp_msg(MSGT_DEMUX
, MSGL_V
,
886 "[mkv] /---- [ parsing attachments ] ---------\n");
888 struct ebml_attachments attachments
= {};
889 struct ebml_parse_ctx parse_ctx
= {};
890 if (ebml_read_element(s
, &parse_ctx
, &attachments
,
891 &ebml_attachments_desc
) < 0)
894 for (int i
= 0; i
< attachments
.n_attached_file
; i
++) {
895 struct ebml_attached_file
*attachment
= &attachments
.attached_file
[i
];
896 if (!attachment
->n_file_name
|| !attachment
->n_file_mime_type
897 || !attachment
->n_file_data
) {
898 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Malformed attachment\n");
901 struct bstr name
= attachment
->file_name
;
902 struct bstr mime
= attachment
->file_mime_type
;
903 demuxer_add_attachment(demuxer
, name
, mime
, attachment
->file_data
);
904 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Attachment: %.*s, %.*s, %zu bytes\n",
905 BSTR_P(name
), BSTR_P(mime
), attachment
->file_data
.len
);
909 talloc_free(parse_ctx
.talloc_ctx
);
910 mp_msg(MSGT_DEMUX
, MSGL_V
,
911 "[mkv] \\---- [ parsing attachments ] ---------\n");
915 static int read_header_element(struct demuxer
*demuxer
, uint32_t id
,
918 static int demux_mkv_read_seekhead(demuxer_t
*demuxer
)
920 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
921 struct stream
*s
= demuxer
->stream
;
923 struct ebml_seek_head seekhead
= {};
924 struct ebml_parse_ctx parse_ctx
= {};
926 mp_msg(MSGT_DEMUX
, MSGL_V
,
927 "[mkv] /---- [ parsing seek head ] ---------\n");
928 if (ebml_read_element(s
, &parse_ctx
, &seekhead
, &ebml_seek_head_desc
) < 0) {
932 /* off now holds the position of the next element after the seek head. */
933 off_t off
= stream_tell(s
);
934 for (int i
= 0; i
< seekhead
.n_seek
; i
++) {
935 struct ebml_seek
*seek
= &seekhead
.seek
[i
];
936 if (seek
->n_seek_id
!= 1 || seek
->n_seek_position
!= 1) {
937 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Invalid SeekHead entry\n");
940 uint64_t pos
= seek
->seek_position
+ mkv_d
->segment_start
;
941 if (pos
>= demuxer
->movi_end
) {
942 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] SeekHead position beyond "
943 "end of file - incomplete file?\n");
946 read_header_element(demuxer
, seek
->seek_id
, pos
);
948 if (!stream_seek(s
, off
)) {
949 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Couldn't seek back after "
954 mp_msg(MSGT_DEMUX
, MSGL_V
,
955 "[mkv] \\---- [ parsing seek head ] ---------\n");
956 talloc_free(parse_ctx
.talloc_ctx
);
960 static bool seek_pos_id(struct stream
*s
, off_t pos
, uint32_t id
)
962 if (!stream_seek(s
, pos
)) {
963 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Failed to seek in file\n");
966 if (ebml_read_id(s
, NULL
) != id
) {
967 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Expected element not found\n");
973 static int read_header_element(struct demuxer
*demuxer
, uint32_t id
,
976 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
977 stream_t
*s
= demuxer
->stream
;
978 off_t pos
= stream_tell(s
) - 4;
981 case MATROSKA_ID_INFO
:
982 if (mkv_d
->parsed_info
)
984 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
986 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment information...\n");
987 mkv_d
->parsed_info
= true;
988 return demux_mkv_read_info(demuxer
) ? -1 : 1;
990 case MATROSKA_ID_TRACKS
:
991 if (mkv_d
->parsed_tracks
)
993 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
995 mkv_d
->parsed_tracks
= true;
996 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment tracks...\n");
997 return demux_mkv_read_tracks(demuxer
) ? -1 : 1;
999 case MATROSKA_ID_CUES
:
1000 if (is_parsed_header(mkv_d
, pos
))
1002 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1004 return demux_mkv_read_cues(demuxer
) ? -1 : 1;
1006 case MATROSKA_ID_TAGS
:
1007 if (mkv_d
->parsed_tags
)
1009 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1011 mkv_d
->parsed_tags
= true;
1012 return demux_mkv_read_tags(demuxer
) ? -1 : 1;
1014 case MATROSKA_ID_SEEKHEAD
:
1015 if (is_parsed_header(mkv_d
, pos
))
1017 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1019 return demux_mkv_read_seekhead(demuxer
) ? -1 : 1;
1021 case MATROSKA_ID_CHAPTERS
:
1022 if (mkv_d
->parsed_chapters
)
1024 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1026 mkv_d
->parsed_chapters
= true;
1027 return demux_mkv_read_chapters(demuxer
) ? -1 : 1;
1029 case MATROSKA_ID_ATTACHMENTS
:
1030 if (mkv_d
->parsed_attachments
)
1032 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1034 mkv_d
->parsed_attachments
= true;
1035 return demux_mkv_read_attachments(demuxer
) ? -1 : 1;
1039 ebml_read_skip(s
, NULL
);
1043 ebml_read_skip(s
, NULL
);
1049 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1051 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1053 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1056 static void display_create_tracks(demuxer_t
*demuxer
)
1058 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1059 int i
, vid
= 0, aid
= 0, sid
= 0;
1061 for (i
= 0; i
< mkv_d
->num_tracks
; i
++) {
1062 char *type
= "unknown", str
[32];
1064 switch (mkv_d
->tracks
[i
]->type
) {
1065 case MATROSKA_TRACK_VIDEO
:
1067 mkv_d
->tracks
[i
]->id
= -1;
1068 if (vid
== MAX_V_STREAMS
)
1070 mkv_d
->tracks
[i
]->id
= vid
;
1071 demux_mkv_open_video(demuxer
, mkv_d
->tracks
[i
], vid
);
1072 if (mkv_d
->tracks
[i
]->name
)
1073 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VID_%d_NAME=%s\n", vid
,
1074 mkv_d
->tracks
[i
]->name
);
1075 sprintf(str
, "-vid %u", vid
++);
1077 case MATROSKA_TRACK_AUDIO
:
1079 mkv_d
->tracks
[i
]->id
= -1;
1080 if (aid
== MAX_A_STREAMS
)
1082 mkv_d
->tracks
[i
]->id
= aid
;
1083 demux_mkv_open_audio(demuxer
, mkv_d
->tracks
[i
], aid
);
1084 if (mkv_d
->tracks
[i
]->name
)
1085 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_NAME=%s\n", aid
,
1086 mkv_d
->tracks
[i
]->name
);
1087 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_LANG=%s\n", aid
,
1088 mkv_d
->tracks
[i
]->language
);
1089 sprintf(str
, "-aid %u, -alang %.5s", aid
++,
1090 mkv_d
->tracks
[i
]->language
);
1092 case MATROSKA_TRACK_SUBTITLE
:
1094 mkv_d
->tracks
[i
]->id
= -1;
1095 if (sid
== MAX_S_STREAMS
)
1097 mkv_d
->tracks
[i
]->id
= sid
;
1098 demux_mkv_open_sub(demuxer
, mkv_d
->tracks
[i
], sid
);
1099 if (mkv_d
->tracks
[i
]->name
)
1100 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_NAME=%s\n", sid
,
1101 mkv_d
->tracks
[i
]->name
);
1102 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", sid
,
1103 mkv_d
->tracks
[i
]->language
);
1104 sprintf(str
, "-sid %u, -slang %.5s", sid
++,
1105 mkv_d
->tracks
[i
]->language
);
1108 if (mkv_d
->tracks
[i
]->name
)
1109 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
,
1110 "[mkv] Track ID %u: %s (%s) \"%s\", %s\n",
1111 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
,
1112 mkv_d
->tracks
[i
]->name
, str
);
1114 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] Track ID %u: %s (%s), %s\n",
1115 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
,
1118 mkv_d
->num_audio_tracks
= aid
;
1125 } videocodec_info_t
;
1127 static const videocodec_info_t vinfo
[] = {
1128 {MKV_V_MJPEG
, mmioFOURCC('m', 'j', 'p', 'g'), 1},
1129 {MKV_V_MPEG1
, mmioFOURCC('m', 'p', 'g', '1'), 0},
1130 {MKV_V_MPEG2
, mmioFOURCC('m', 'p', 'g', '2'), 0},
1131 {MKV_V_MPEG4_SP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1132 {MKV_V_MPEG4_ASP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1133 {MKV_V_MPEG4_AP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1134 {MKV_V_MPEG4_AVC
, mmioFOURCC('a', 'v', 'c', '1'), 1},
1135 {MKV_V_THEORA
, mmioFOURCC('t', 'h', 'e', 'o'), 1},
1136 {MKV_V_VP8
, mmioFOURCC('V', 'P', '8', '0'), 0},
1140 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1143 BITMAPINFOHEADER
*bih
;
1144 void *ImageDesc
= NULL
;
1147 if (track
->ms_compat
) { /* MS compatibility mode */
1148 BITMAPINFOHEADER
*src
;
1150 if (track
->private_data
== NULL
1151 || track
->private_size
< sizeof(*bih
))
1154 src
= (BITMAPINFOHEADER
*) track
->private_data
;
1155 bih
= calloc(1, track
->private_size
);
1156 bih
->biSize
= le2me_32(src
->biSize
);
1157 bih
->biWidth
= le2me_32(src
->biWidth
);
1158 bih
->biHeight
= le2me_32(src
->biHeight
);
1159 bih
->biPlanes
= le2me_16(src
->biPlanes
);
1160 bih
->biBitCount
= le2me_16(src
->biBitCount
);
1161 bih
->biCompression
= le2me_32(src
->biCompression
);
1162 bih
->biSizeImage
= le2me_32(src
->biSizeImage
);
1163 bih
->biXPelsPerMeter
= le2me_32(src
->biXPelsPerMeter
);
1164 bih
->biYPelsPerMeter
= le2me_32(src
->biYPelsPerMeter
);
1165 bih
->biClrUsed
= le2me_32(src
->biClrUsed
);
1166 bih
->biClrImportant
= le2me_32(src
->biClrImportant
);
1169 track
->private_size
- sizeof(*bih
));
1171 if (track
->v_width
== 0)
1172 track
->v_width
= bih
->biWidth
;
1173 if (track
->v_height
== 0)
1174 track
->v_height
= bih
->biHeight
;
1176 bih
= calloc(1, sizeof(*bih
));
1177 bih
->biSize
= sizeof(*bih
);
1178 bih
->biWidth
= track
->v_width
;
1179 bih
->biHeight
= track
->v_height
;
1180 bih
->biBitCount
= 24;
1181 bih
->biSizeImage
= bih
->biWidth
* bih
->biHeight
* bih
->biBitCount
/ 8;
1183 if (track
->private_size
>= RVPROPERTIES_SIZE
1184 && (!strcmp(track
->codec_id
, MKV_V_REALV10
)
1185 || !strcmp(track
->codec_id
, MKV_V_REALV20
)
1186 || !strcmp(track
->codec_id
, MKV_V_REALV30
)
1187 || !strcmp(track
->codec_id
, MKV_V_REALV40
))) {
1188 unsigned char *dst
, *src
;
1192 src
= (uint8_t *) track
->private_data
+ RVPROPERTIES_SIZE
;
1194 cnt
= track
->private_size
- RVPROPERTIES_SIZE
;
1195 bih
= realloc(bih
, sizeof(*bih
) + 8 + cnt
);
1196 bih
->biSize
= 48 + cnt
;
1198 type2
= AV_RB32(src
- 4);
1199 if (type2
== 0x10003000 || type2
== 0x10003001)
1200 bih
->biCompression
= mmioFOURCC('R', 'V', '1', '3');
1202 bih
->biCompression
=
1203 mmioFOURCC('R', 'V', track
->codec_id
[9], '0');
1204 dst
= (unsigned char *) (bih
+ 1);
1205 // copy type1 and type2 info from rv properties
1206 memcpy(dst
, src
- 8, 8 + cnt
);
1207 track
->realmedia
= 1;
1209 #ifdef CONFIG_QTX_CODECS
1210 } else if (track
->private_size
>= sizeof(ImageDescription
)
1211 && !strcmp(track
->codec_id
, MKV_V_QUICKTIME
)) {
1212 ImageDescriptionPtr idesc
;
1214 idesc
= (ImageDescriptionPtr
) track
->private_data
;
1215 idesc
->idSize
= be2me_32(idesc
->idSize
);
1216 idesc
->cType
= be2me_32(idesc
->cType
);
1217 idesc
->version
= be2me_16(idesc
->version
);
1218 idesc
->revisionLevel
= be2me_16(idesc
->revisionLevel
);
1219 idesc
->vendor
= be2me_32(idesc
->vendor
);
1220 idesc
->temporalQuality
= be2me_32(idesc
->temporalQuality
);
1221 idesc
->spatialQuality
= be2me_32(idesc
->spatialQuality
);
1222 idesc
->width
= be2me_16(idesc
->width
);
1223 idesc
->height
= be2me_16(idesc
->height
);
1224 idesc
->hRes
= be2me_32(idesc
->hRes
);
1225 idesc
->vRes
= be2me_32(idesc
->vRes
);
1226 idesc
->dataSize
= be2me_32(idesc
->dataSize
);
1227 idesc
->frameCount
= be2me_16(idesc
->frameCount
);
1228 idesc
->depth
= be2me_16(idesc
->depth
);
1229 idesc
->clutID
= be2me_16(idesc
->clutID
);
1231 bih
->biCompression
= idesc
->cType
;
1233 #endif /* CONFIG_QTX_CODECS */
1236 const videocodec_info_t
*vi
= vinfo
;
1237 while (vi
->id
&& strcmp(vi
->id
, track
->codec_id
))
1239 bih
->biCompression
= vi
->fourcc
;
1240 if (vi
->extradata
&& track
->private_data
1241 && (track
->private_size
> 0)) {
1242 bih
->biSize
+= track
->private_size
;
1243 bih
= realloc(bih
, bih
->biSize
);
1244 memcpy(bih
+ 1, track
->private_data
, track
->private_size
);
1247 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Unknown/unsupported "
1248 "CodecID (%s) or missing/bad CodecPrivate\n"
1249 "[mkv] data (track %u).\n",
1250 track
->codec_id
, track
->tnum
);
1257 sh_v
= new_sh_video(demuxer
, vid
);
1259 sh_v
->format
= sh_v
->bih
->biCompression
;
1260 if (track
->v_frate
== 0.0)
1261 track
->v_frate
= 25.0;
1262 sh_v
->fps
= track
->v_frate
;
1263 sh_v
->frametime
= 1 / track
->v_frate
;
1265 if (!track
->realmedia
) {
1266 sh_v
->disp_w
= track
->v_width
;
1267 sh_v
->disp_h
= track
->v_height
;
1268 if (track
->v_dheight
)
1269 sh_v
->aspect
= (double) track
->v_dwidth
/ track
->v_dheight
;
1271 // vd_realvid.c will set aspect to disp_w/disp_h and rederive
1272 // disp_w and disp_h from the RealVideo stream contents returned
1273 // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
1274 // the Matroska file then it has already been set to PixelWidth/Height
1275 // by check_track_information.
1276 sh_v
->disp_w
= track
->v_dwidth
;
1277 sh_v
->disp_h
= track
->v_dheight
;
1279 sh_v
->ImageDesc
= ImageDesc
;
1280 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Aspect: %f\n", sh_v
->aspect
);
1282 sh_v
->ds
= demuxer
->video
;
1286 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1289 sh_audio_t
*sh_a
= new_sh_audio(demuxer
, aid
);
1293 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
1294 sh_a
->lang
= strdup(track
->language
);
1295 sh_a
->default_track
= track
->default_track
;
1296 sh_a
->ds
= demuxer
->audio
;
1297 sh_a
->wf
= malloc(sizeof(*sh_a
->wf
));
1298 if (track
->ms_compat
&& (track
->private_size
>= sizeof(*sh_a
->wf
))) {
1299 WAVEFORMATEX
*wf
= (WAVEFORMATEX
*) track
->private_data
;
1300 sh_a
->wf
= realloc(sh_a
->wf
, track
->private_size
);
1301 sh_a
->wf
->wFormatTag
= le2me_16(wf
->wFormatTag
);
1302 sh_a
->wf
->nChannels
= le2me_16(wf
->nChannels
);
1303 sh_a
->wf
->nSamplesPerSec
= le2me_32(wf
->nSamplesPerSec
);
1304 sh_a
->wf
->nAvgBytesPerSec
= le2me_32(wf
->nAvgBytesPerSec
);
1305 sh_a
->wf
->nBlockAlign
= le2me_16(wf
->nBlockAlign
);
1306 sh_a
->wf
->wBitsPerSample
= le2me_16(wf
->wBitsPerSample
);
1307 sh_a
->wf
->cbSize
= track
->private_size
- sizeof(*sh_a
->wf
);
1308 memcpy(sh_a
->wf
+ 1, wf
+ 1,
1309 track
->private_size
- sizeof(*sh_a
->wf
));
1310 if (track
->a_sfreq
== 0.0)
1311 track
->a_sfreq
= sh_a
->wf
->nSamplesPerSec
;
1312 if (track
->a_channels
== 0)
1313 track
->a_channels
= sh_a
->wf
->nChannels
;
1314 if (track
->a_bps
== 0)
1315 track
->a_bps
= sh_a
->wf
->wBitsPerSample
;
1316 track
->a_formattag
= sh_a
->wf
->wFormatTag
;
1318 memset(sh_a
->wf
, 0, sizeof(*sh_a
->wf
));
1319 if (!strcmp(track
->codec_id
, MKV_A_MP3
)
1320 || !strcmp(track
->codec_id
, MKV_A_MP2
))
1321 track
->a_formattag
= 0x0055;
1322 else if (!strncmp(track
->codec_id
, MKV_A_AC3
, strlen(MKV_A_AC3
)))
1323 track
->a_formattag
= 0x2000;
1324 else if (!strcmp(track
->codec_id
, MKV_A_DTS
))
1325 track
->a_formattag
= 0x2001;
1326 else if (!strcmp(track
->codec_id
, MKV_A_PCM
)
1327 || !strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1328 track
->a_formattag
= 0x0001;
1329 else if (!strcmp(track
->codec_id
, MKV_A_AAC_2MAIN
)
1330 || !strncmp(track
->codec_id
, MKV_A_AAC_2LC
,
1331 strlen(MKV_A_AAC_2LC
))
1332 || !strcmp(track
->codec_id
, MKV_A_AAC_2SSR
)
1333 || !strcmp(track
->codec_id
, MKV_A_AAC_4MAIN
)
1334 || !strncmp(track
->codec_id
, MKV_A_AAC_4LC
,
1335 strlen(MKV_A_AAC_4LC
))
1336 || !strcmp(track
->codec_id
, MKV_A_AAC_4SSR
)
1337 || !strcmp(track
->codec_id
, MKV_A_AAC_4LTP
)
1338 || !strcmp(track
->codec_id
, MKV_A_AAC
))
1339 track
->a_formattag
= mmioFOURCC('M', 'P', '4', 'A');
1340 else if (!strcmp(track
->codec_id
, MKV_A_VORBIS
)) {
1341 if (track
->private_data
== NULL
)
1343 track
->a_formattag
= mmioFOURCC('v', 'r', 'b', 's');
1344 } else if (!strcmp(track
->codec_id
, MKV_A_QDMC
))
1345 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', 'C');
1346 else if (!strcmp(track
->codec_id
, MKV_A_QDMC2
))
1347 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', '2');
1348 else if (!strcmp(track
->codec_id
, MKV_A_WAVPACK
))
1349 track
->a_formattag
= mmioFOURCC('W', 'V', 'P', 'K');
1350 else if (!strcmp(track
->codec_id
, MKV_A_TRUEHD
))
1351 track
->a_formattag
= mmioFOURCC('T', 'R', 'H', 'D');
1352 else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)) {
1353 if (track
->private_data
== NULL
|| track
->private_size
== 0) {
1354 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
1355 "[mkv] FLAC track does not contain valid headers.\n");
1358 track
->a_formattag
= mmioFOURCC('f', 'L', 'a', 'C');
1359 } else if (track
->private_size
>= RAPROPERTIES4_SIZE
) {
1360 if (!strcmp(track
->codec_id
, MKV_A_REAL28
))
1361 track
->a_formattag
= mmioFOURCC('2', '8', '_', '8');
1362 else if (!strcmp(track
->codec_id
, MKV_A_REALATRC
))
1363 track
->a_formattag
= mmioFOURCC('a', 't', 'r', 'c');
1364 else if (!strcmp(track
->codec_id
, MKV_A_REALCOOK
))
1365 track
->a_formattag
= mmioFOURCC('c', 'o', 'o', 'k');
1366 else if (!strcmp(track
->codec_id
, MKV_A_REALDNET
))
1367 track
->a_formattag
= mmioFOURCC('d', 'n', 'e', 't');
1368 else if (!strcmp(track
->codec_id
, MKV_A_REALSIPR
))
1369 track
->a_formattag
= mmioFOURCC('s', 'i', 'p', 'r');
1371 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Unknown/unsupported audio "
1372 "codec ID '%s' for track %u or missing/faulty\n[mkv] "
1373 "private codec data.\n", track
->codec_id
, track
->tnum
);
1374 free_sh_audio(demuxer
, track
->id
);
1379 sh_a
->format
= track
->a_formattag
;
1380 sh_a
->wf
->wFormatTag
= track
->a_formattag
;
1381 sh_a
->channels
= track
->a_channels
;
1382 sh_a
->wf
->nChannels
= track
->a_channels
;
1383 sh_a
->samplerate
= (uint32_t) track
->a_sfreq
;
1384 sh_a
->container_out_samplerate
= track
->a_osfreq
;
1385 sh_a
->wf
->nSamplesPerSec
= (uint32_t) track
->a_sfreq
;
1386 if (track
->a_bps
== 0) {
1387 sh_a
->samplesize
= 2;
1388 sh_a
->wf
->wBitsPerSample
= 16;
1390 sh_a
->samplesize
= track
->a_bps
/ 8;
1391 sh_a
->wf
->wBitsPerSample
= track
->a_bps
;
1393 if (track
->a_formattag
== 0x0055) { /* MP3 || MP2 */
1394 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1395 sh_a
->wf
->nBlockAlign
= 1152;
1396 } else if ((track
->a_formattag
== 0x2000) /* AC3 */
1397 || (track
->a_formattag
== 0x2001)) { /* DTS */
1400 } else if (track
->a_formattag
== 0x0001) { /* PCM || PCM_BE */
1401 sh_a
->wf
->nAvgBytesPerSec
= sh_a
->channels
* sh_a
->samplerate
* 2;
1402 sh_a
->wf
->nBlockAlign
= sh_a
->wf
->nAvgBytesPerSec
;
1403 if (!strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1404 sh_a
->format
= mmioFOURCC('t', 'w', 'o', 's');
1405 } else if (!strcmp(track
->codec_id
, MKV_A_QDMC
)
1406 || !strcmp(track
->codec_id
, MKV_A_QDMC2
)) {
1407 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1408 sh_a
->wf
->nBlockAlign
= 1486;
1409 track
->fix_i_bps
= 1;
1410 track
->qt_last_a_pts
= 0.0;
1411 if (track
->private_data
!= NULL
) {
1412 sh_a
->codecdata
= malloc(track
->private_size
);
1413 memcpy(sh_a
->codecdata
, track
->private_data
, track
->private_size
);
1414 sh_a
->codecdata_len
= track
->private_size
;
1416 } else if (track
->a_formattag
== mmioFOURCC('M', 'P', '4', 'A')) {
1417 int profile
, srate_idx
;
1419 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1420 sh_a
->wf
->nBlockAlign
= 1024;
1422 if (!strcmp(track
->codec_id
, MKV_A_AAC
)
1423 && (NULL
!= track
->private_data
)) {
1424 sh_a
->codecdata
= malloc(track
->private_size
);
1425 memcpy(sh_a
->codecdata
, track
->private_data
, track
->private_size
);
1426 sh_a
->codecdata_len
= track
->private_size
;
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))
1435 else if (!strncmp(&track
->codec_id
[12], "LC", 2))
1437 else if (!strncmp(&track
->codec_id
[12], "SSR", 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);
1446 if (strstr(track
->codec_id
, "SBR") != NULL
) {
1447 /* HE-AAC (aka SBR AAC) */
1448 sh_a
->codecdata_len
= 5;
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);
1458 sh_a
->codecdata_len
= 2;
1459 track
->default_duration
= 1024.0 / sh_a
->samplerate
;
1461 } else if (track
->a_formattag
== mmioFOURCC('v', 'r', 'b', 's')) { /* VORBIS */
1462 sh_a
->wf
->cbSize
= track
->private_size
;
1463 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(*sh_a
->wf
) + sh_a
->wf
->cbSize
);
1464 memcpy((unsigned char *) (sh_a
->wf
+ 1), track
->private_data
,
1466 } else if (track
->private_size
>= RAPROPERTIES4_SIZE
1467 && !strncmp(track
->codec_id
, MKV_A_REALATRC
, 7)) {
1468 /* Common initialization for all RealAudio codecs */
1469 unsigned char *src
= track
->private_data
;
1470 int codecdata_length
, version
;
1473 sh_a
->wf
->nAvgBytesPerSec
= 0; /* FIXME !? */
1475 version
= AV_RB16(src
+ 4);
1476 flavor
= AV_RB16(src
+ 22);
1477 track
->coded_framesize
= AV_RB32(src
+ 24);
1478 track
->sub_packet_h
= AV_RB16(src
+ 40);
1479 sh_a
->wf
->nBlockAlign
= track
->audiopk_size
= AV_RB16(src
+ 42);
1480 track
->sub_packet_size
= AV_RB16(src
+ 44);
1482 src
+= RAPROPERTIES4_SIZE
;
1486 src
+= RAPROPERTIES5_SIZE
;
1491 codecdata_length
= AV_RB32(src
);
1493 sh_a
->wf
->cbSize
= codecdata_length
;
1494 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(*sh_a
->wf
) + sh_a
->wf
->cbSize
);
1495 memcpy(((char *) (sh_a
->wf
+ 1)), src
, codecdata_length
);
1497 switch (track
->a_formattag
) {
1498 case mmioFOURCC('a', 't', 'r', 'c'):
1499 sh_a
->wf
->nAvgBytesPerSec
= atrc_fl2bps
[flavor
];
1500 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1502 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1503 track
->audio_timestamp
=
1504 malloc(track
->sub_packet_h
* sizeof(double));
1506 case mmioFOURCC('c', 'o', 'o', 'k'):
1507 sh_a
->wf
->nAvgBytesPerSec
= cook_fl2bps
[flavor
];
1508 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1510 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1511 track
->audio_timestamp
=
1512 malloc(track
->sub_packet_h
* sizeof(double));
1514 case mmioFOURCC('s', 'i', 'p', 'r'):
1515 sh_a
->wf
->nAvgBytesPerSec
= sipr_fl2bps
[flavor
];
1516 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1518 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1519 track
->audio_timestamp
=
1520 malloc(track
->sub_packet_h
* sizeof(double));
1522 case mmioFOURCC('2', '8', '_', '8'):
1523 sh_a
->wf
->nAvgBytesPerSec
= 3600;
1524 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1526 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1527 track
->audio_timestamp
=
1528 malloc(track
->sub_packet_h
* sizeof(double));
1532 track
->realmedia
= 1;
1533 } else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)
1534 || (track
->a_formattag
== 0xf1ac)) {
1540 if (track
->a_formattag
== mmioFOURCC('f', 'L', 'a', 'C')) {
1541 ptr
= track
->private_data
;
1542 size
= track
->private_size
;
1544 sh_a
->format
= mmioFOURCC('f', 'L', 'a', 'C');
1545 ptr
= track
->private_data
+ sizeof(*sh_a
->wf
);
1546 size
= track
->private_size
- sizeof(*sh_a
->wf
);
1548 if (size
< 4 || ptr
[0] != 'f' || ptr
[1] != 'L' || ptr
[2] != 'a'
1550 sh_a
->codecdata
= malloc(4);
1551 sh_a
->codecdata_len
= 4;
1552 memcpy(sh_a
->codecdata
, "fLaC", 4);
1554 sh_a
->codecdata
= malloc(size
);
1555 sh_a
->codecdata_len
= size
;
1556 memcpy(sh_a
->codecdata
, ptr
, size
);
1558 } else if (track
->a_formattag
== mmioFOURCC('W', 'V', 'P', 'K') || track
->a_formattag
== mmioFOURCC('T', 'R', 'H', 'D')) { /* do nothing, still works */
1559 } else if (!track
->ms_compat
1560 || (track
->private_size
< sizeof(*sh_a
->wf
))) {
1561 free_sh_audio(demuxer
, track
->id
);
1568 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1571 if (track
->subtitle_type
!= MATROSKA_SUBTYPE_UNKNOWN
) {
1574 sh_sub_t
*sh
= new_sh_sub(demuxer
, sid
);
1577 if (track
->subtitle_type
== MATROSKA_SUBTYPE_VOBSUB
)
1579 if (track
->subtitle_type
== MATROSKA_SUBTYPE_SSA
)
1581 size
= track
->private_size
;
1582 demux_mkv_decode(track
, track
->private_data
, &buffer
, &size
, 2);
1583 if (buffer
&& buffer
!= track
->private_data
) {
1584 talloc_free(track
->private_data
);
1585 talloc_steal(track
, buffer
);
1586 track
->private_data
= buffer
;
1587 track
->private_size
= size
;
1589 sh
->extradata
= malloc(track
->private_size
);
1590 memcpy(sh
->extradata
, track
->private_data
, track
->private_size
);
1591 sh
->extradata_len
= track
->private_size
;
1592 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
1593 sh
->lang
= strdup(track
->language
);
1594 sh
->default_track
= track
->default_track
;
1596 mp_tmsg(MSGT_DEMUX
, MSGL_ERR
,
1597 "[mkv] Subtitle type '%s' is not supported.\n",
1605 static int demux_mkv_open(demuxer_t
*demuxer
)
1607 stream_t
*s
= demuxer
->stream
;
1608 mkv_demuxer_t
*mkv_d
;
1612 stream_seek(s
, s
->start_pos
);
1613 if (ebml_read_id(s
, NULL
) != EBML_ID_EBML
)
1615 struct ebml_ebml ebml_master
= {};
1616 struct ebml_parse_ctx parse_ctx
= { .no_error_messages
= true };
1617 if (ebml_read_element(s
, &parse_ctx
, &ebml_master
, &ebml_ebml_desc
) < 0)
1619 if (ebml_master
.doc_type
.start
== NULL
) {
1620 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] File has EBML header but no doctype."
1621 " Assuming \"matroska\".\n");
1622 } else if (bstrcmp(ebml_master
.doc_type
, BSTR("matroska")) != 0
1623 && bstrcmp(ebml_master
.doc_type
, BSTR("webm")) != 0) {
1624 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "[mkv] no head found\n");
1625 talloc_free(parse_ctx
.talloc_ctx
);
1628 if (ebml_master
.doc_type_read_version
> 2) {
1629 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] This looks like a Matroska file, "
1630 "but we don't support format version %"PRIu64
"\n",
1631 ebml_master
.doc_type_read_version
);
1632 talloc_free(parse_ctx
.talloc_ctx
);
1635 if ((ebml_master
.n_ebml_read_version
1636 && ebml_master
.ebml_read_version
!= EBML_VERSION
)
1637 || (ebml_master
.n_ebml_max_size_length
1638 && ebml_master
.ebml_max_size_length
> 8)
1639 || (ebml_master
.n_ebml_max_id_length
1640 && ebml_master
.ebml_max_id_length
!= 4)) {
1641 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] This looks like a Matroska file, "
1642 "but the header has bad parameters\n");
1643 talloc_free(parse_ctx
.talloc_ctx
);
1646 talloc_free(parse_ctx
.talloc_ctx
);
1648 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Found the head...\n");
1650 if (ebml_read_id(s
, NULL
) != MATROSKA_ID_SEGMENT
) {
1651 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] but no segment :(\n");
1654 ebml_read_length(s
, NULL
); /* return bytes number until EOF */
1656 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] + a segment...\n");
1658 mkv_d
= talloc_zero(demuxer
, struct mkv_demuxer
);
1659 demuxer
->priv
= mkv_d
;
1660 mkv_d
->tc_scale
= 1000000;
1661 mkv_d
->segment_start
= stream_tell(s
);
1664 uint32_t id
= ebml_read_id(s
, NULL
);
1666 case MATROSKA_ID_CLUSTER
:
1667 mp_msg(MSGT_DEMUX
, MSGL_V
,
1668 "[mkv] |+ found cluster, headers are "
1669 "parsed completely :)\n");
1670 stream_seek(s
, stream_tell(s
) - 4);
1675 cont
= read_header_element(demuxer
, id
, 0) < 1;
1678 ebml_read_skip(s
, NULL
);
1683 display_create_tracks(demuxer
);
1685 /* select video track */
1687 if (demuxer
->video
->id
== -1) { /* automatically select a video track */
1688 /* search for a video track that has the 'default' flag set */
1689 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1690 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_VIDEO
1691 && mkv_d
->tracks
[i
]->default_track
) {
1692 track
= mkv_d
->tracks
[i
];
1697 /* no track has the 'default' flag set */
1698 /* let's take the first video track */
1699 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1700 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_VIDEO
1701 && mkv_d
->tracks
[i
]->id
>= 0) {
1702 track
= mkv_d
->tracks
[i
];
1705 } else if (demuxer
->video
->id
!= -2) /* -2 = no video at all */
1706 track
= find_track_by_num(mkv_d
, demuxer
->video
->id
,
1707 MATROSKA_TRACK_VIDEO
);
1709 if (track
&& demuxer
->v_streams
[track
->id
]) {
1710 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] Will play video track %u.\n",
1712 demuxer
->video
->id
= track
->id
;
1713 demuxer
->video
->sh
= demuxer
->v_streams
[track
->id
];
1715 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] No video track found/wanted.\n");
1716 demuxer
->video
->id
= -2;
1719 /* select audio track */
1722 /* search for an audio track that has the 'default' flag set */
1723 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1724 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_AUDIO
1725 && mkv_d
->tracks
[i
]->default_track
) {
1726 track
= mkv_d
->tracks
[i
];
1731 /* no track has the 'default' flag set */
1732 /* let's take the first audio track */
1733 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1734 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_AUDIO
1735 && mkv_d
->tracks
[i
]->id
>= 0) {
1736 track
= mkv_d
->tracks
[i
];
1740 if (track
&& demuxer
->a_streams
[track
->id
]) {
1741 demuxer
->audio
->id
= track
->id
;
1742 demuxer
->audio
->sh
= demuxer
->a_streams
[track
->id
];
1744 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] No audio track found/wanted.\n");
1745 demuxer
->audio
->id
= -2;
1748 if (s
->end_pos
== 0)
1749 demuxer
->seekable
= 0;
1751 demuxer
->movi_start
= s
->start_pos
;
1752 demuxer
->movi_end
= s
->end_pos
;
1753 demuxer
->seekable
= 1;
1756 demuxer
->accurate_seek
= true;
1758 return DEMUXER_TYPE_MATROSKA
;
1761 static void demux_close_mkv(demuxer_t
*demuxer
)
1763 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1767 if (mkv_d
->tracks
) {
1768 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1769 demux_mkv_free_trackentry(mkv_d
->tracks
[i
]);
1771 free(mkv_d
->indexes
);
1772 free(mkv_d
->cluster_positions
);
1776 static int demux_mkv_read_block_lacing(uint8_t *buffer
, uint64_t *size
,
1778 uint32_t **all_lace_sizes
)
1781 uint32_t *lace_size
= NULL
;
1785 *all_lace_sizes
= NULL
;
1792 switch ((flags
& 0x06) >> 1) {
1793 case 0: /* no lacing */
1795 lace_size
= calloc(*laces
, sizeof(uint32_t));
1796 lace_size
[0] = *size
;
1799 case 1: /* xiph lacing */
1800 case 2: /* fixed-size lacing */
1801 case 3: /* EBML lacing */
1807 lace_size
= calloc(*laces
, sizeof(uint32_t));
1809 switch ((flags
& 0x06) >> 1) {
1810 case 1: /* xiph lacing */
1811 for (i
= 0; i
< *laces
- 1; i
++) {
1816 lace_size
[i
] += *buffer
;
1818 } while (*buffer
++ == 0xFF);
1819 if (lace_size
[i
] > *size
- total
|| total
> *size
)
1821 total
+= lace_size
[i
];
1823 lace_size
[i
] = *size
- total
;
1826 case 2: /* fixed-size lacing */
1827 for (i
= 0; i
< *laces
; i
++)
1828 lace_size
[i
] = *size
/ *laces
;
1831 case 3:; /* EBML lacing */
1833 uint64_t num
= ebml_read_vlen_uint(buffer
, &l
);
1834 if (num
== EBML_UINT_INVALID
)
1843 total
= lace_size
[0] = num
;
1844 for (i
= 1; i
< *laces
- 1; i
++) {
1845 int64_t snum
= ebml_read_vlen_int(buffer
, &l
);
1846 if (snum
== EBML_INT_INVALID
)
1852 lace_size
[i
] = lace_size
[i
- 1] + snum
;
1853 if (lace_size
[i
] > *size
- total
|| total
> *size
)
1855 total
+= lace_size
[i
];
1857 lace_size
[i
] = *size
- total
;
1862 *all_lace_sizes
= lace_size
;
1867 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Bad input [lacing]\n");
1871 static void handle_subtitles(demuxer_t
*demuxer
, mkv_track_t
*track
,
1872 char *block
, int64_t size
,
1873 uint64_t block_duration
, uint64_t timecode
)
1877 if (block_duration
== 0) {
1878 mp_msg(MSGT_DEMUX
, MSGL_WARN
,
1879 "[mkv] Warning: No BlockDuration for subtitle track found.\n");
1884 dp
= new_demux_packet(size
);
1885 memcpy(dp
->buffer
, block
, size
);
1886 dp
->pts
= timecode
/ 1000.0;
1887 dp
->endpts
= (timecode
+ block_duration
) / 1000.0;
1888 ds_add_packet(demuxer
->sub
, dp
);
1891 static void handle_realvideo(demuxer_t
*demuxer
, mkv_track_t
*track
,
1892 uint8_t *buffer
, uint32_t size
, int block_bref
)
1894 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1896 uint32_t timestamp
= mkv_d
->last_pts
* 1000;
1898 dp
= new_demux_packet(size
);
1899 memcpy(dp
->buffer
, buffer
, size
);
1901 if (mkv_d
->v_skip_to_keyframe
) {
1902 dp
->pts
= mkv_d
->last_pts
;
1903 track
->rv_kf_base
= 0;
1904 track
->rv_kf_pts
= timestamp
;
1907 real_fix_timestamp(dp
->buffer
, timestamp
,
1908 ((sh_video_t
*) demuxer
->video
->sh
)->bih
->
1909 biCompression
, &track
->rv_kf_base
,
1910 &track
->rv_kf_pts
, NULL
);
1911 dp
->pos
= demuxer
->filepos
;
1912 dp
->flags
= block_bref
? 0 : 0x10;
1914 ds_add_packet(demuxer
->video
, dp
);
1917 static void handle_realaudio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1918 uint8_t *buffer
, uint32_t size
, int block_bref
)
1920 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1921 int sps
= track
->sub_packet_size
;
1922 int sph
= track
->sub_packet_h
;
1923 int cfs
= track
->coded_framesize
;
1924 int w
= track
->audiopk_size
;
1925 int spc
= track
->sub_packet_cnt
;
1929 if ((track
->a_formattag
== mmioFOURCC('2', '8', '_', '8'))
1930 || (track
->a_formattag
== mmioFOURCC('c', 'o', 'o', 'k'))
1931 || (track
->a_formattag
== mmioFOURCC('a', 't', 'r', 'c'))
1932 || (track
->a_formattag
== mmioFOURCC('s', 'i', 'p', 'r'))) {
1934 // spc = track->sub_packet_cnt = 0;
1935 switch (track
->a_formattag
) {
1936 case mmioFOURCC('2', '8', '_', '8'):
1937 for (x
= 0; x
< sph
/ 2; x
++)
1938 memcpy(track
->audio_buf
+ x
* 2 * w
+ spc
* cfs
,
1939 buffer
+ cfs
* x
, cfs
);
1941 case mmioFOURCC('c', 'o', 'o', 'k'):
1942 case mmioFOURCC('a', 't', 'r', 'c'):
1943 for (x
= 0; x
< w
/ sps
; x
++)
1944 memcpy(track
->audio_buf
+
1945 sps
* (sph
* x
+ ((sph
+ 1) / 2) * (spc
& 1) +
1946 (spc
>> 1)), buffer
+ sps
* x
, sps
);
1948 case mmioFOURCC('s', 'i', 'p', 'r'):
1949 memcpy(track
->audio_buf
+ spc
* w
, buffer
, w
);
1950 if (spc
== sph
- 1) {
1952 int bs
= sph
* w
* 2 / 96; // nibbles per subpacket
1953 // Perform reordering
1954 for (n
= 0; n
< 38; n
++) {
1956 int i
= bs
* sipr_swaps
[n
][0];
1957 int o
= bs
* sipr_swaps
[n
][1];
1958 // swap nibbles of block 'i' with 'o' TODO: optimize
1959 for (j
= 0; j
< bs
; j
++) {
1961 (track
->audio_buf
[i
>> 1] >> 4) :
1962 (track
->audio_buf
[i
>> 1] & 0x0F);
1964 (track
->audio_buf
[o
>> 1] >> 4) :
1965 (track
->audio_buf
[o
>> 1] & 0x0F);
1967 track
->audio_buf
[o
>> 1] =
1968 (track
->audio_buf
[o
>> 1] & 0x0F) | (x
<< 4);
1970 track
->audio_buf
[o
>> 1] =
1971 (track
->audio_buf
[o
>> 1] & 0xF0) | x
;
1973 track
->audio_buf
[i
>> 1] =
1974 (track
->audio_buf
[i
>> 1] & 0x0F) | (y
<< 4);
1976 track
->audio_buf
[i
>> 1] =
1977 (track
->audio_buf
[i
>> 1] & 0xF0) | y
;
1985 track
->audio_timestamp
[track
->sub_packet_cnt
] =
1986 (track
->ra_pts
== mkv_d
->last_pts
) ? 0 : (mkv_d
->last_pts
);
1987 track
->ra_pts
= mkv_d
->last_pts
;
1988 if (track
->sub_packet_cnt
== 0)
1989 track
->audio_filepos
= demuxer
->filepos
;
1990 if (++(track
->sub_packet_cnt
) == sph
) {
1992 ((sh_audio_t
*) demuxer
->audio
->sh
)->wf
->nBlockAlign
;
1993 track
->sub_packet_cnt
= 0;
1994 // Release all the audio packets
1995 for (x
= 0; x
< sph
* w
/ apk_usize
; x
++) {
1996 dp
= new_demux_packet(apk_usize
);
1997 memcpy(dp
->buffer
, track
->audio_buf
+ x
* apk_usize
,
1999 /* Put timestamp only on packets that correspond to original
2000 * audio packets in file */
2001 dp
->pts
= (x
* apk_usize
% w
) ? 0 :
2002 track
->audio_timestamp
[x
* apk_usize
/ w
];
2003 dp
->pos
= track
->audio_filepos
; // all equal
2004 dp
->flags
= x
? 0 : 0x10; // Mark first packet as keyframe
2005 ds_add_packet(demuxer
->audio
, dp
);
2008 } else { // Not a codec that require reordering
2009 dp
= new_demux_packet(size
);
2010 memcpy(dp
->buffer
, buffer
, size
);
2011 if (track
->ra_pts
== mkv_d
->last_pts
&& !mkv_d
->a_skip_to_keyframe
)
2014 dp
->pts
= mkv_d
->last_pts
;
2015 track
->ra_pts
= mkv_d
->last_pts
;
2017 dp
->pos
= demuxer
->filepos
;
2018 dp
->flags
= block_bref
? 0 : 0x10;
2019 ds_add_packet(demuxer
->audio
, dp
);
2023 static int handle_block(demuxer_t
*demuxer
, uint8_t *block
, uint64_t length
,
2024 uint64_t block_duration
, int64_t block_bref
,
2025 int64_t block_fref
, uint8_t simpleblock
)
2027 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2028 mkv_track_t
*track
= NULL
;
2029 demux_stream_t
*ds
= NULL
;
2030 uint64_t old_length
;
2032 uint32_t *lace_size
;
2033 uint8_t laces
, flags
;
2034 int i
, num
, tmp
, use_this_block
= 1;
2038 /* first byte(s): track num */
2039 num
= ebml_read_vlen_uint(block
, &tmp
);
2041 /* time (relative to cluster time) */
2042 time
= block
[0] << 8 | block
[1];
2045 old_length
= length
;
2047 if (demux_mkv_read_block_lacing(block
, &length
, &laces
, &lace_size
))
2049 block
+= old_length
- length
;
2051 tc
= (time
* mkv_d
->tc_scale
+ mkv_d
->cluster_tc
) / 1000000.0 + 0.5;
2054 current_pts
= tc
/ 1000.0;
2056 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2057 if (mkv_d
->tracks
[i
]->tnum
== num
) {
2058 track
= mkv_d
->tracks
[i
];
2061 if (track
== NULL
) {
2065 if (track
->type
== MATROSKA_TRACK_AUDIO
2066 && track
->id
== demuxer
->audio
->id
) {
2067 ds
= demuxer
->audio
;
2069 if (mkv_d
->a_skip_to_keyframe
) {
2071 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2073 } else if (block_bref
!= 0)
2076 if (mkv_d
->v_skip_to_keyframe
)
2079 if (track
->fix_i_bps
&& use_this_block
) {
2080 sh_audio_t
*sh
= (sh_audio_t
*) ds
->sh
;
2082 if (block_duration
!= 0) {
2083 sh
->i_bps
= length
* 1000 / block_duration
;
2084 track
->fix_i_bps
= 0;
2085 } else if (track
->qt_last_a_pts
== 0.0)
2086 track
->qt_last_a_pts
= current_pts
;
2087 else if (track
->qt_last_a_pts
!= current_pts
) {
2088 sh
->i_bps
= length
/ (current_pts
- track
->qt_last_a_pts
);
2089 track
->fix_i_bps
= 0;
2092 } else if (tc
< mkv_d
->skip_to_timecode
)
2094 else if (track
->type
== MATROSKA_TRACK_VIDEO
2095 && track
->id
== demuxer
->video
->id
) {
2096 ds
= demuxer
->video
;
2097 if (mkv_d
->v_skip_to_keyframe
) {
2099 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2101 } else if (block_bref
!= 0 || block_fref
!= 0)
2104 } else if (track
->type
== MATROSKA_TRACK_SUBTITLE
2105 && track
->id
== demuxer
->sub
->id
) {
2107 if (track
->subtitle_type
!= MATROSKA_SUBTYPE_VOBSUB
) {
2110 demux_mkv_decode(track
, block
, &buffer
, &size
, 1);
2111 handle_subtitles(demuxer
, track
, buffer
, size
, block_duration
, tc
);
2112 if (buffer
!= block
)
2113 talloc_free(buffer
);
2119 if (use_this_block
) {
2120 mkv_d
->last_pts
= current_pts
;
2121 mkv_d
->last_filepos
= demuxer
->filepos
;
2123 for (i
= 0; i
< laces
; i
++) {
2124 if (ds
== demuxer
->video
&& track
->realmedia
)
2125 handle_realvideo(demuxer
, track
, block
, lace_size
[i
],
2127 else if (ds
== demuxer
->audio
&& track
->realmedia
)
2128 handle_realaudio(demuxer
, track
, block
, lace_size
[i
],
2131 int size
= lace_size
[i
];
2134 demux_mkv_decode(track
, block
, &buffer
, &size
, 1);
2136 dp
= new_demux_packet(size
);
2137 memcpy(dp
->buffer
, buffer
, size
);
2138 if (buffer
!= block
)
2139 talloc_free(buffer
);
2140 dp
->flags
= (block_bref
== 0
2141 && block_fref
== 0) ? 0x10 : 0;
2142 /* If default_duration is 0, assume no pts value is known
2143 * for packets after the first one (rather than all pts
2144 * values being the same) */
2145 if (i
== 0 || track
->default_duration
)
2147 mkv_d
->last_pts
+ i
* track
->default_duration
;
2148 ds_add_packet(ds
, dp
);
2151 block
+= lace_size
[i
];
2154 if (ds
== demuxer
->video
) {
2155 mkv_d
->v_skip_to_keyframe
= 0;
2156 mkv_d
->skip_to_timecode
= 0;
2157 } else if (ds
== demuxer
->audio
)
2158 mkv_d
->a_skip_to_keyframe
= 0;
2168 static int demux_mkv_fill_buffer(demuxer_t
*demuxer
, demux_stream_t
*ds
)
2170 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2171 stream_t
*s
= demuxer
->stream
;
2176 while (mkv_d
->cluster_size
> 0) {
2177 uint64_t block_duration
= 0, block_length
= 0;
2178 int64_t block_bref
= 0, block_fref
= 0;
2179 uint8_t *block
= NULL
;
2181 while (mkv_d
->blockgroup_size
> 0) {
2182 switch (ebml_read_id(s
, &il
)) {
2183 case MATROSKA_ID_BLOCKDURATION
:
2184 block_duration
= ebml_read_uint(s
, &l
);
2185 if (block_duration
== EBML_UINT_INVALID
) {
2190 block_duration
* mkv_d
->tc_scale
/ 1000000.0 + 0.5;
2193 case MATROSKA_ID_BLOCK
:
2194 block_length
= ebml_read_length(s
, &tmp
);
2196 if (block_length
> 500000000)
2198 block
= malloc(block_length
+ AV_LZO_INPUT_PADDING
);
2199 demuxer
->filepos
= stream_tell(s
);
2200 if (stream_read(s
, block
, block_length
) !=
2201 (int) block_length
) {
2205 l
= tmp
+ block_length
;
2208 case MATROSKA_ID_REFERENCEBLOCK
:;
2209 int64_t num
= ebml_read_int(s
, &l
);
2210 if (num
== EBML_INT_INVALID
) {
2220 case EBML_ID_INVALID
:
2225 ebml_read_skip(s
, &l
);
2228 mkv_d
->blockgroup_size
-= l
+ il
;
2229 mkv_d
->cluster_size
-= l
+ il
;
2233 int res
= handle_block(demuxer
, block
, block_length
,
2234 block_duration
, block_bref
, block_fref
,
2243 if (mkv_d
->cluster_size
> 0) {
2244 switch (ebml_read_id(s
, &il
)) {
2245 case MATROSKA_ID_TIMECODE
:;
2246 uint64_t num
= ebml_read_uint(s
, &l
);
2247 if (num
== EBML_UINT_INVALID
)
2249 mkv_d
->cluster_tc
= num
* mkv_d
->tc_scale
;
2250 add_cluster_position(mkv_d
, mkv_d
->cluster_start
,
2254 case MATROSKA_ID_BLOCKGROUP
:
2255 mkv_d
->blockgroup_size
= ebml_read_length(s
, &tmp
);
2259 case MATROSKA_ID_SIMPLEBLOCK
:;
2261 block_length
= ebml_read_length(s
, &tmp
);
2262 if (block_length
> 500000000)
2264 block
= malloc(block_length
);
2265 demuxer
->filepos
= stream_tell(s
);
2266 if (stream_read(s
, block
, block_length
) !=
2267 (int) block_length
) {
2271 l
= tmp
+ block_length
;
2272 res
= handle_block(demuxer
, block
, block_length
,
2273 block_duration
, block_bref
,
2276 mkv_d
->cluster_size
-= l
+ il
;
2282 mkv_d
->cluster_size
+= l
+ il
;
2285 case EBML_ID_INVALID
:
2289 ebml_read_skip(s
, &l
);
2292 mkv_d
->cluster_size
-= l
+ il
;
2296 while (ebml_read_id(s
, &il
) != MATROSKA_ID_CLUSTER
) {
2297 ebml_read_skip(s
, NULL
);
2301 mkv_d
->cluster_start
= stream_tell(s
) - il
;
2302 mkv_d
->cluster_size
= ebml_read_length(s
, NULL
);
2308 static int seek_creating_index(struct demuxer
*demuxer
, float rel_seek_secs
,
2311 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
2312 struct stream
*s
= demuxer
->stream
;
2313 int64_t target_tc_ns
= (int64_t) (rel_seek_secs
* 1e9
);
2314 if (target_tc_ns
< 0)
2316 uint64_t max_filepos
= 0;
2317 int64_t max_tc
= -1;
2318 int n
= mkv_d
->num_cluster_pos
;
2320 max_filepos
= mkv_d
->cluster_positions
[n
- 1].filepos
;
2321 max_tc
= mkv_d
->cluster_positions
[n
- 1].timecode
;
2324 if (target_tc_ns
> max_tc
) {
2325 if ((off_t
) max_filepos
> stream_tell(s
))
2326 stream_seek(s
, max_filepos
);
2328 stream_seek(s
, stream_tell(s
) + mkv_d
->cluster_size
);
2329 /* parse all the clusters upto target_filepos */
2331 uint64_t start
= stream_tell(s
);
2332 uint32_t type
= ebml_read_id(s
, NULL
);
2333 uint64_t len
= ebml_read_length(s
, NULL
);
2334 uint64_t end
= stream_tell(s
) + len
;
2335 if (type
== MATROSKA_ID_CLUSTER
) {
2336 while (!s
->eof
&& stream_tell(s
) < end
) {
2337 if (ebml_read_id(s
, NULL
) == MATROSKA_ID_TIMECODE
) {
2338 uint64_t tc
= ebml_read_uint(s
, NULL
);
2339 tc
*= mkv_d
->tc_scale
;
2340 add_cluster_position(mkv_d
, start
, tc
);
2341 if (tc
>= target_tc_ns
)
2349 stream_seek(s
, end
);
2355 if (!mkv_d
->num_cluster_pos
) {
2356 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] no target for seek found\n");
2359 uint64_t cluster_pos
= mkv_d
->cluster_positions
[0].filepos
;
2360 /* Let's find the nearest cluster */
2361 int64_t min_diff
= 0xFFFFFFFFFFFFFFF;
2362 for (int i
= 0; i
< mkv_d
->num_cluster_pos
; i
++) {
2363 int64_t diff
= mkv_d
->cluster_positions
[i
].timecode
- target_tc_ns
;
2364 if (flags
& SEEK_BACKWARD
&& diff
< 0 && -diff
< min_diff
) {
2365 cluster_pos
= mkv_d
->cluster_positions
[i
].filepos
;
2367 } else if (flags
& SEEK_FORWARD
2368 && (diff
< 0 ? -1 * diff
: diff
) < min_diff
) {
2369 cluster_pos
= mkv_d
->cluster_positions
[i
].filepos
;
2370 min_diff
= diff
< 0 ? -1 * diff
: diff
;
2373 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2374 stream_seek(s
, cluster_pos
);
2378 static struct mkv_index
*seek_with_cues(struct demuxer
*demuxer
, int seek_id
,
2379 int64_t target_timecode
, int flags
)
2381 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
2382 struct mkv_index
*index
= NULL
;
2384 /* Find the entry in the index closest to the target timecode in the
2385 * give direction. If there are no such entries - we're trying to seek
2386 * backward from a target time before the first entry or forward from a
2387 * target time after the last entry - then still seek to the first/last
2388 * entry if that's further in the direction wanted than mkv_d->last_pts.
2390 int64_t min_diff
= target_timecode
- mkv_d
->last_pts
* 1000;
2391 if (flags
& SEEK_BACKWARD
)
2392 min_diff
= -min_diff
;
2393 min_diff
= FFMAX(min_diff
, 1);
2394 for (int i
= 0; i
< mkv_d
->num_indexes
; i
++)
2395 if (seek_id
< 0 || mkv_d
->indexes
[i
].tnum
== seek_id
) {
2398 (int64_t) (mkv_d
->indexes
[i
].timecode
*
2399 mkv_d
->tc_scale
/ 1000000.0 + 0.5);
2400 if (flags
& SEEK_BACKWARD
)
2403 if (min_diff
<= 0 && diff
<= min_diff
)
2405 } else if (diff
>= min_diff
)
2408 index
= mkv_d
->indexes
+ i
;
2411 if (index
) { /* We've found an entry. */
2412 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2413 stream_seek(demuxer
->stream
, index
->filepos
);
2418 static void demux_mkv_seek(demuxer_t
*demuxer
, float rel_seek_secs
,
2419 float audio_delay
, int flags
)
2421 mkv_demuxer_t
*mkv_d
= demuxer
->priv
;
2422 uint64_t v_tnum
= -1;
2423 if (demuxer
->video
->id
>= 0)
2424 v_tnum
= find_track_by_num(mkv_d
, demuxer
->video
->id
,
2425 MATROSKA_TRACK_VIDEO
)->tnum
;
2426 uint64_t a_tnum
= -1;
2427 if (demuxer
->audio
->id
>= 0)
2428 a_tnum
= find_track_by_num(mkv_d
, demuxer
->audio
->id
,
2429 MATROSKA_TRACK_AUDIO
)->tnum
;
2430 if (!(flags
& (SEEK_BACKWARD
| SEEK_FORWARD
))) {
2431 if (flags
& SEEK_ABSOLUTE
|| rel_seek_secs
< 0)
2432 flags
|= SEEK_BACKWARD
;
2434 flags
|= SEEK_FORWARD
;
2436 // Adjust the target a little bit to catch cases where the target position
2437 // specifies a keyframe with high, but not perfect, precision.
2438 rel_seek_secs
+= flags
& SEEK_FORWARD
? -0.005 : 0.005;
2440 if (!(flags
& SEEK_FACTOR
)) { /* time in secs */
2441 mkv_index_t
*index
= NULL
;
2443 if (!(flags
& SEEK_ABSOLUTE
)) /* relative seek */
2444 rel_seek_secs
+= mkv_d
->last_pts
;
2445 int64_t target_timecode
= rel_seek_secs
* 1000.0;
2446 if (target_timecode
< 0)
2447 target_timecode
= 0;
2449 if (mkv_d
->indexes
== NULL
) { /* no index was found */
2450 if (seek_creating_index(demuxer
, rel_seek_secs
, flags
) < 0)
2453 int seek_id
= (demuxer
->video
->id
< 0) ?
2455 index
= seek_with_cues(demuxer
, seek_id
, target_timecode
, flags
);
2457 index
= seek_with_cues(demuxer
, -1, target_timecode
, flags
);
2460 if (demuxer
->video
->id
>= 0)
2461 mkv_d
->v_skip_to_keyframe
= 1;
2462 if (flags
& SEEK_FORWARD
)
2463 mkv_d
->skip_to_timecode
= target_timecode
;
2465 mkv_d
->skip_to_timecode
= index
? index
->timecode
: 0;
2466 mkv_d
->a_skip_to_keyframe
= 1;
2468 demux_mkv_fill_buffer(demuxer
, NULL
);
2469 } else if ((demuxer
->movi_end
<= 0) || !(flags
& SEEK_ABSOLUTE
))
2470 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
2472 stream_t
*s
= demuxer
->stream
;
2473 uint64_t target_filepos
;
2474 mkv_index_t
*index
= NULL
;
2477 if (mkv_d
->indexes
== NULL
) { /* not implemented without index */
2478 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
2482 target_filepos
= (uint64_t) (demuxer
->movi_end
* rel_seek_secs
);
2483 for (i
= 0; i
< mkv_d
->num_indexes
; i
++)
2484 if (mkv_d
->indexes
[i
].tnum
== v_tnum
)
2486 || ((mkv_d
->indexes
[i
].filepos
>= target_filepos
)
2487 && ((index
->filepos
< target_filepos
)
2488 || (mkv_d
->indexes
[i
].filepos
< index
->filepos
))))
2489 index
= &mkv_d
->indexes
[i
];
2494 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2495 stream_seek(s
, index
->filepos
);
2497 if (demuxer
->video
->id
>= 0)
2498 mkv_d
->v_skip_to_keyframe
= 1;
2499 mkv_d
->skip_to_timecode
= index
->timecode
;
2500 mkv_d
->a_skip_to_keyframe
= 1;
2502 demux_mkv_fill_buffer(demuxer
, NULL
);
2506 static int demux_mkv_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
2508 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2511 case DEMUXER_CTRL_CORRECT_PTS
:
2512 return DEMUXER_CTRL_OK
;
2513 case DEMUXER_CTRL_GET_TIME_LENGTH
:
2514 if (mkv_d
->duration
== 0)
2515 return DEMUXER_CTRL_DONTKNOW
;
2517 *((double *) arg
) = (double) mkv_d
->duration
;
2518 return DEMUXER_CTRL_OK
;
2520 case DEMUXER_CTRL_GET_PERCENT_POS
:
2521 if (mkv_d
->duration
== 0) {
2522 return DEMUXER_CTRL_DONTKNOW
;
2525 *((int *) arg
) = (int) (100 * mkv_d
->last_pts
/ mkv_d
->duration
);
2526 return DEMUXER_CTRL_OK
;
2528 case DEMUXER_CTRL_SWITCH_AUDIO
:;
2529 int new_aid
= *(int *) arg
;
2530 int current_aid
= demuxer
->audio
->id
;
2531 if (current_aid
< 0)
2533 if (new_aid
== -1) // cycle to next
2534 new_aid
= (current_aid
+ 2) % (mkv_d
->num_audio_tracks
+ 1) - 1;
2535 if (new_aid
< 0 || new_aid
>= mkv_d
->num_audio_tracks
)
2537 *(int *) arg
= new_aid
;
2538 if (current_aid
!= new_aid
)
2539 ds_free_packs(demuxer
->audio
);
2540 demuxer
->audio
->id
= new_aid
;
2541 return DEMUXER_CTRL_OK
;
2544 return DEMUXER_CTRL_NOTIMPL
;
2548 const demuxer_desc_t demuxer_desc_matroska
= {
2554 DEMUXER_TYPE_MATROSKA
,
2555 1, // safe autodetect
2557 demux_mkv_fill_buffer
,