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.
30 #include <libavutil/common.h>
31 #include <libavutil/lzo.h>
32 #include <libavutil/intreadwrite.h>
33 #include <libavutil/avstring.h>
44 #include "stream/stream.h"
49 #include "demux_real.h"
56 #ifdef CONFIG_QTX_CODECS
57 #include "loader/qtx/qtxsdk/components.h"
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},
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
82 typedef struct mkv_content_encoding
{
83 uint64_t order
, type
, scope
;
85 uint8_t *comp_settings
;
86 int comp_settings_len
;
87 } mkv_content_encoding_t
;
89 typedef struct mkv_track
{
92 int id
; // -aid / -sid / -vid option value
100 uint32_t v_width
, v_height
, v_dwidth
, v_dheight
;
103 uint32_t a_formattag
;
104 uint32_t a_channels
, a_bps
;
108 double default_duration
;
112 unsigned char *private_data
;
113 unsigned int private_size
;
115 /* stuff for realmedia */
119 double rv_pts
; /* previous video timestamp */
120 double ra_pts
; /* previous audio timestamp */
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
132 /* stuff for quicktime */
134 double qt_last_a_pts
;
138 /* generic content encoding support */
139 mkv_content_encoding_t
*encodings
;
142 /* For VobSubs and SSA/ASS */
146 typedef struct mkv_index
{
148 uint64_t timecode
, filepos
;
151 typedef struct mkv_demuxer
{
154 double duration
, last_pts
;
155 uint64_t last_filepos
;
157 mkv_track_t
**tracks
;
160 uint64_t tc_scale
, cluster_tc
;
162 uint64_t cluster_start
;
163 uint64_t cluster_size
;
164 uint64_t blockgroup_size
;
166 mkv_index_t
*indexes
;
174 bool parsed_chapters
;
175 bool parsed_attachments
;
180 } *cluster_positions
;
183 uint64_t skip_to_timecode
;
184 int v_skip_to_keyframe
, a_skip_to_keyframe
;
186 int num_audio_tracks
;
187 int num_video_tracks
;
190 #define REALHEADER_SIZE 16
191 #define RVPROPERTIES_SIZE 34
192 #define RAPROPERTIES4_SIZE 56
193 #define RAPROPERTIES5_SIZE 70
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
201 static void *grow_array(void *array
, int nelem
, size_t elsize
)
204 array
= realloc(array
, (nelem
+ 32) * elsize
);
208 static bool is_parsed_header(struct mkv_demuxer
*mkv_d
, off_t pos
)
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
)
219 if (mkv_d
->num_parsed_pos
&& mkv_d
->parsed_pos
[low
] == pos
)
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
;
231 static mkv_track_t
*find_track_by_num(struct mkv_demuxer
*d
, int n
, int type
)
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
)
241 static void add_cluster_position(mkv_demuxer_t
*mkv_d
, uint64_t filepos
,
247 int n
= mkv_d
->num_cluster_pos
;
248 if (n
> 0 && mkv_d
->cluster_positions
[n
-1].filepos
>= filepos
)
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
){
256 .timecode
= timecode
,
261 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
262 static int aac_get_sample_rate_index(uint32_t sample_rate
)
264 static const int srates
[] = {
265 92017, 75132, 55426, 46009, 37566, 27713,
266 23004, 18783, 13856, 11502, 9391, 0
269 while (sample_rate
< srates
[i
])
274 static void demux_mkv_decode(mkv_track_t
*track
, uint8_t *src
,
275 uint8_t **dest
, uint32_t *size
, uint32_t type
)
277 uint8_t *orig_src
= src
;
281 for (int i
= 0; i
< track
->num_encodings
; i
++) {
282 struct mkv_content_encoding
*enc
= track
->encodings
+ i
;
283 if (!(enc
->scope
& type
))
286 if (src
!= *dest
&& src
!= orig_src
)
288 src
= *dest
; // output from last iteration is new source
290 if (enc
->comp_algo
== 0) {
292 /* zlib encoded track */
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");
307 zstream
.next_in
= (Bytef
*) src
;
308 zstream
.avail_in
= *size
;
311 zstream
.avail_out
= *size
;
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");
323 inflateEnd(&zstream
);
326 zstream
.avail_out
+= 4000;
327 } while (zstream
.avail_out
== 4000 && zstream
.avail_in
!= 0
328 && result
!= Z_STREAM_END
);
330 *size
= zstream
.total_out
;
331 inflateEnd(&zstream
);
333 } else if (enc
->comp_algo
== 2) {
334 /* lzo encoded track */
336 int dstlen
= *size
* 3;
341 *dest
= talloc_realloc_size(NULL
, *dest
,
342 dstlen
+ AV_LZO_OUTPUT_PADDING
);
344 int result
= av_lzo1x_decode(*dest
, &out_avail
, src
, &srclen
);
347 if (!(result
& AV_LZO_OUTPUT_FULL
)) {
348 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
349 "[mkv] lzo decompression failed.\n");
354 mp_msg(MSGT_DEMUX
, MSGL_DBG2
,
355 "[mkv] lzo decompression buffer too small.\n");
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
;
368 if (src
!= *dest
&& src
!= orig_src
)
373 static int demux_mkv_read_info(demuxer_t
*demuxer
)
375 mkv_demuxer_t
*mkv_d
= demuxer
->priv
;
376 stream_t
*s
= demuxer
->stream
;
379 mkv_d
->tc_scale
= 1000000;
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)
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
);
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",
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
);
402 memcpy(demuxer
->matroska_data
.segment_uid
, info
.segment_uid
.start
,
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");
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
)
415 for (int i
= 0; i
< MP_TALLOC_ELEMS(uids
); i
++) {
416 if (!memcmp(info
.segment_uid
.start
, uids
[i
], 16))
419 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
,
420 "[mkv] This is not one of the wanted files. "
421 "Stopping attempt to open.\n");
425 talloc_free(parse_ctx
.talloc_ctx
);
429 static void parse_trackencodings(struct demuxer
*demuxer
,
430 struct mkv_track
*track
,
431 struct ebml_content_encodings
*encodings
)
433 // initial allocation to be a non-NULL context before realloc
434 mkv_content_encoding_t
*ce
= talloc_size(track
, 1);
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
;
444 e
.type
= enc
->content_encoding_type
;
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
;
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",
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",
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
);
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. "
486 for (i
= 0; i
< n_enc
; i
++)
487 if (e
.order
>= ce
[i
].order
)
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
));
494 track
->encodings
= ce
;
495 track
->num_encodings
= encodings
->n_content_encoding
;
498 static void parse_trackaudio(struct demuxer
*demuxer
, struct mkv_track
*track
,
499 struct ebml_audio
*audio
)
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
);
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
);
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",
518 if (audio
->n_channels
) {
519 track
->a_channels
= audio
->channels
;
520 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Channels: %u\n",
523 track
->a_channels
= 1;
526 static void parse_trackvideo(struct demuxer
*demuxer
, struct mkv_track
*track
,
527 struct ebml_video
*video
)
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",
533 if (track
->v_frate
> 0)
534 track
->default_duration
= 1 / track
->v_frate
;
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",
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",
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",
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",
559 * \brief free any data associated with given track
560 * \param track track of which to free data
562 static void demux_mkv_free_trackentry(mkv_track_t
*track
)
564 free(track
->audio_buf
);
565 free(track
->audio_timestamp
);
569 static void parse_trackentry(struct demuxer
*demuxer
,
570 struct ebml_track_entry
*entry
)
572 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
573 struct mkv_track
*track
= talloc_zero_size(NULL
, sizeof(*track
));
575 track
->tnum
= entry
->track_number
;
577 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track number: %u\n",
580 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Missing track number!\n");
583 track
->name
= talloc_strndup(track
, entry
->name
.start
,
585 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Name: %s\n",
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");
595 case MATROSKA_TRACK_VIDEO
:
596 mp_msg(MSGT_DEMUX
, MSGL_V
, "Video\n");
598 case MATROSKA_TRACK_SUBTITLE
:
599 mp_msg(MSGT_DEMUX
, MSGL_V
, "Subtitle\n");
602 mp_msg(MSGT_DEMUX
, MSGL_V
, "unknown\n");
606 if (entry
->n_audio
) {
607 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Audio track\n");
608 parse_trackaudio(demuxer
, track
, &entry
->audio
);
611 if (entry
->n_video
) {
612 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Video track\n");
613 parse_trackvideo(demuxer
, track
, &entry
->video
);
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",
637 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Missing codec ID!\n");
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
);
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",
654 track
->language
= talloc_strdup(track
, "eng");
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
);
661 track
->default_track
= 1;
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");
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
);
676 if (entry
->n_content_encodings
)
677 parse_trackencodings(demuxer
, track
, &entry
->content_encodings
);
679 mkv_d
->tracks
[mkv_d
->num_tracks
++] = track
;
682 static int demux_mkv_read_tracks(demuxer_t
*demuxer
)
684 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
685 stream_t
*s
= demuxer
->stream
;
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)
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
]);
698 talloc_free(parse_ctx
.talloc_ctx
);
702 static int demux_mkv_read_cues(demuxer_t
*demuxer
)
704 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
705 stream_t
*s
= demuxer
->stream
;
707 if (index_mode
== 0 || index_mode
== 2) {
708 ebml_read_skip(s
, NULL
);
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)
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");
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
;
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
++;
744 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] \\---- [ parsing cues ] -----------\n");
745 talloc_free(parse_ctx
.talloc_ctx
);
749 static int demux_mkv_read_chapters(struct demuxer
*demuxer
)
751 struct MPOpts
*opts
= demuxer
->opts
;
752 stream_t
*s
= demuxer
->stream
;
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)
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",
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
);
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
;
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 };
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
;
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 "
811 name
= ca
->chapter_display
[0].chap_string
;
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");
825 memcpy(chapter
.segment_uid
, ca
->chapter_segment_uid
.start
,
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");
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),
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
,
853 m_chapters
[i
] = chapter
;
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
);
863 talloc_free(parse_ctx
.talloc_ctx
);
864 mp_msg(MSGT_DEMUX
, MSGL_V
,
865 "[mkv] \\---- [ parsing chapters ] ---------\n");
869 static int demux_mkv_read_tags(demuxer_t
*demuxer
)
871 stream_t
*s
= demuxer
->stream
;
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)
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
)
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
);
891 static int demux_mkv_read_attachments(demuxer_t
*demuxer
)
893 stream_t
*s
= demuxer
->stream
;
895 mp_msg(MSGT_DEMUX
, MSGL_V
,
896 "[mkv] /---- [ parsing attachments ] ---------\n");
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)
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");
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
);
918 talloc_free(parse_ctx
.talloc_ctx
);
919 mp_msg(MSGT_DEMUX
, MSGL_V
,
920 "[mkv] \\---- [ parsing attachments ] ---------\n");
924 static int read_header_element(struct demuxer
*demuxer
, uint32_t id
,
927 static int demux_mkv_read_seekhead(demuxer_t
*demuxer
)
929 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
930 struct stream
*s
= demuxer
->stream
;
932 struct ebml_seek_head seekhead
= {};
933 struct ebml_parse_ctx parse_ctx
= {};
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) {
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");
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");
955 int r
= read_header_element(demuxer
, seek
->seek_id
, pos
);
961 if (!stream_seek(s
, off
)) {
962 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Couldn't seek back after "
967 mp_msg(MSGT_DEMUX
, MSGL_V
,
968 "[mkv] \\---- [ parsing seek head ] ---------\n");
969 talloc_free(parse_ctx
.talloc_ctx
);
973 static bool seek_pos_id(struct stream
*s
, off_t pos
, uint32_t id
)
975 if (!stream_seek(s
, pos
)) {
976 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Failed to seek in file\n");
979 if (ebml_read_id(s
, NULL
) != id
) {
980 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Expected element not found\n");
986 static int read_header_element(struct demuxer
*demuxer
, uint32_t id
,
989 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
990 stream_t
*s
= demuxer
->stream
;
991 off_t pos
= stream_tell(s
) - 4;
995 case MATROSKA_ID_INFO
:
996 if (mkv_d
->parsed_info
)
998 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1000 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment information...\n");
1001 mkv_d
->parsed_info
= true;
1002 return demux_mkv_read_info(demuxer
);
1004 case MATROSKA_ID_TRACKS
:
1005 if (mkv_d
->parsed_tracks
)
1007 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1009 mkv_d
->parsed_tracks
= true;
1010 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment tracks...\n");
1011 return demux_mkv_read_tracks(demuxer
);
1013 case MATROSKA_ID_CUES
:
1014 if (is_parsed_header(mkv_d
, pos
))
1016 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1018 return demux_mkv_read_cues(demuxer
);
1020 case MATROSKA_ID_TAGS
:
1021 if (mkv_d
->parsed_tags
)
1023 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1025 mkv_d
->parsed_tags
= true;
1026 return demux_mkv_read_tags(demuxer
);
1028 case MATROSKA_ID_SEEKHEAD
:
1029 if (is_parsed_header(mkv_d
, pos
))
1031 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1033 return demux_mkv_read_seekhead(demuxer
);
1035 case MATROSKA_ID_CHAPTERS
:
1036 if (mkv_d
->parsed_chapters
)
1038 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1040 mkv_d
->parsed_chapters
= true;
1041 return demux_mkv_read_chapters(demuxer
);
1043 case MATROSKA_ID_ATTACHMENTS
:
1044 if (mkv_d
->parsed_attachments
)
1046 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1048 mkv_d
->parsed_attachments
= true;
1049 return demux_mkv_read_attachments(demuxer
);
1058 ebml_read_skip(s
, NULL
);
1064 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1066 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1068 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1071 static void display_create_tracks(demuxer_t
*demuxer
)
1073 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1074 int i
, vid
= 0, aid
= 0, sid
= 0;
1076 for (i
= 0; i
< mkv_d
->num_tracks
; i
++) {
1077 char *type
= "unknown", str
[32];
1079 switch (mkv_d
->tracks
[i
]->type
) {
1080 case MATROSKA_TRACK_VIDEO
:
1082 mkv_d
->tracks
[i
]->id
= -1;
1083 if (vid
== MAX_V_STREAMS
)
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
++);
1092 case MATROSKA_TRACK_AUDIO
:
1094 mkv_d
->tracks
[i
]->id
= -1;
1095 if (aid
== MAX_A_STREAMS
)
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
);
1107 case MATROSKA_TRACK_SUBTITLE
:
1109 mkv_d
->tracks
[i
]->id
= -1;
1110 if (sid
== MAX_S_STREAMS
)
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
);
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
);
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
,
1133 mkv_d
->num_audio_tracks
= aid
;
1134 mkv_d
->num_video_tracks
= vid
;
1141 } videocodec_info_t
;
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},
1156 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1159 BITMAPINFOHEADER
*bih
;
1160 void *ImageDesc
= NULL
;
1163 if (track
->ms_compat
) { /* MS compatibility mode */
1164 BITMAPINFOHEADER
*src
;
1166 if (track
->private_data
== NULL
1167 || track
->private_size
< sizeof(*bih
))
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
);
1185 track
->private_size
- sizeof(*bih
));
1187 if (track
->v_width
== 0)
1188 track
->v_width
= bih
->biWidth
;
1189 if (track
->v_height
== 0)
1190 track
->v_height
= bih
->biHeight
;
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;
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
;
1208 src
= (uint8_t *) track
->private_data
+ RVPROPERTIES_SIZE
;
1210 cnt
= track
->private_size
- RVPROPERTIES_SIZE
;
1211 bih
= realloc(bih
, sizeof(*bih
) + 8 + cnt
);
1212 bih
->biSize
= 48 + cnt
;
1214 type2
= AV_RB32(src
- 4);
1215 if (type2
== 0x10003000 || type2
== 0x10003001)
1216 bih
->biCompression
= mmioFOURCC('R', 'V', '1', '3');
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;
1225 #ifdef CONFIG_QTX_CODECS
1226 } else if (track
->private_size
>= sizeof(ImageDescription
)
1227 && !strcmp(track
->codec_id
, MKV_V_QUICKTIME
)) {
1228 ImageDescriptionPtr idesc
;
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
);
1247 bih
->biCompression
= idesc
->cType
;
1249 #endif /* CONFIG_QTX_CODECS */
1252 const videocodec_info_t
*vi
= vinfo
;
1253 while (vi
->id
&& strcmp(vi
->id
, track
->codec_id
))
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
);
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
);
1273 sh_v
= new_sh_video(demuxer
, vid
);
1274 sh_v
->title
= talloc_strdup(sh_v
, track
->name
);
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
;
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
;
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
;
1296 sh_v
->ImageDesc
= ImageDesc
;
1297 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Aspect: %f\n", sh_v
->aspect
);
1299 sh_v
->ds
= demuxer
->video
;
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') },
1336 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1339 sh_audio_t
*sh_a
= new_sh_audio(demuxer
, aid
);
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
))
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
;
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
;
1376 if (!bstr_startswith0(bstr(track
->codec_id
), t
->id
))
1379 if (strcmp(track
->codec_id
, t
->id
))
1382 track
->a_formattag
= t
->formattag
;
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;
1398 sh_a
->samplesize
= track
->a_bps
/ 8;
1399 sh_a
->wf
->wBitsPerSample
= track
->a_bps
;
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 */
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
;
1424 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1425 sh_a
->wf
->nBlockAlign
= 1024;
1427 if (!strcmp(track
->codec_id
, MKV_A_AAC
) && track
->private_data
)
1428 goto copy_private_data
;
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')) {
1463 if (track
->private_size
== 0 || track
->ms_compat
&& !sh_a
->wf
->cbSize
)
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
,
1471 } else if (!strncmp(track
->codec_id
, MKV_A_REALATRC
, 7)) {
1472 if (track
->private_size
< RAPROPERTIES4_SIZE
)
1474 /* Common initialization for all RealAudio codecs */
1475 unsigned char *src
= track
->private_data
;
1476 int codecdata_length
, version
;
1479 sh_a
->wf
->nAvgBytesPerSec
= 0; /* FIXME !? */
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);
1488 src
+= RAPROPERTIES4_SIZE
;
1492 src
+= RAPROPERTIES5_SIZE
;
1497 codecdata_length
= AV_RB32(src
);
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
);
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
;
1508 case mmioFOURCC('c', 'o', 'o', 'k'):
1509 sh_a
->wf
->nAvgBytesPerSec
= cook_fl2bps
[flavor
];
1510 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1512 case mmioFOURCC('s', 'i', 'p', 'r'):
1513 sh_a
->wf
->nAvgBytesPerSec
= sipr_fl2bps
[flavor
];
1514 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1516 case mmioFOURCC('2', '8', '_', '8'):
1517 sh_a
->wf
->nAvgBytesPerSec
= 3600;
1518 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1521 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1522 track
->audio_timestamp
=
1523 malloc(track
->sub_packet_h
* sizeof(double));
1527 track
->realmedia
= 1;
1528 } else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)
1529 || (track
->a_formattag
== 0xf1ac)) {
1535 if (!track
->ms_compat
) {
1536 ptr
= track
->private_data
;
1537 size
= track
->private_size
;
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
);
1543 if (size
< 4 || ptr
[0] != 'f' || ptr
[1] != 'L' || ptr
[2] != 'a'
1545 sh_a
->codecdata
= malloc(4);
1546 sh_a
->codecdata_len
= 4;
1547 memcpy(sh_a
->codecdata
, "fLaC", 4);
1549 sh_a
->codecdata
= malloc(size
);
1550 sh_a
->codecdata_len
= size
;
1551 memcpy(sh_a
->codecdata
, ptr
, size
);
1553 } else if (track
->a_formattag
== mmioFOURCC('W', 'V', 'P', 'K') ||
1554 track
->a_formattag
== mmioFOURCC('T', 'R', 'H', 'D')) {
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
);
1561 } else if (!track
->ms_compat
) {
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
);
1575 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1578 if (track
->subtitle_type
) {
1581 sh_sub_t
*sh
= new_sh_sub(demuxer
, sid
);
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
;
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
;
1600 mp_tmsg(MSGT_DEMUX
, MSGL_ERR
,
1601 "[mkv] Subtitle type '%s' is not supported.\n",
1609 static void mkv_free(struct demuxer
*demuxer
)
1611 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
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
);
1620 static int demux_mkv_open(demuxer_t
*demuxer
)
1622 stream_t
*s
= demuxer
->stream
;
1623 mkv_demuxer_t
*mkv_d
;
1626 stream_seek(s
, s
->start_pos
);
1627 if (ebml_read_id(s
, NULL
) != EBML_ID_EBML
)
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)
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
);
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
);
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
);
1660 talloc_free(parse_ctx
.talloc_ctx
);
1662 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Found the head...\n");
1664 if (ebml_read_id(s
, NULL
) != MATROSKA_ID_SEGMENT
) {
1665 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] but no segment :(\n");
1668 ebml_read_length(s
, NULL
); /* return bytes number until EOF */
1670 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] + a segment...\n");
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
);
1678 uint32_t id
= ebml_read_id(s
, NULL
);
1680 mp_tmsg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Unexpected end of file\n");
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);
1689 int res
= read_header_element(demuxer
, id
, 0);
1696 display_create_tracks(demuxer
);
1698 /* select video track */
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
];
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
];
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
);
1722 if (track
&& demuxer
->v_streams
[track
->id
]) {
1723 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] Will play video track %u.\n",
1725 demuxer
->video
->id
= track
->id
;
1726 demuxer
->video
->sh
= demuxer
->v_streams
[track
->id
];
1728 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] No video track found/wanted.\n");
1729 demuxer
->video
->id
= -2;
1732 demuxer
->audio
->id
= -2; // wait for higher-level code to select track
1734 if (s
->end_pos
== 0)
1735 demuxer
->seekable
= 0;
1737 demuxer
->movi_start
= s
->start_pos
;
1738 demuxer
->movi_end
= s
->end_pos
;
1739 demuxer
->seekable
= 1;
1742 demuxer
->accurate_seek
= true;
1744 return DEMUXER_TYPE_MATROSKA
;
1747 static int demux_mkv_read_block_lacing(uint8_t *buffer
, uint64_t *size
,
1749 uint32_t **all_lace_sizes
)
1752 uint32_t *lace_size
= NULL
;
1756 *all_lace_sizes
= NULL
;
1763 switch ((flags
& 0x06) >> 1) {
1764 case 0: /* no lacing */
1766 lace_size
= calloc(*laces
, sizeof(uint32_t));
1767 lace_size
[0] = *size
;
1770 case 1: /* xiph lacing */
1771 case 2: /* fixed-size lacing */
1772 case 3: /* EBML lacing */
1778 lace_size
= calloc(*laces
, sizeof(uint32_t));
1780 switch ((flags
& 0x06) >> 1) {
1781 case 1: /* xiph lacing */
1782 for (i
= 0; i
< *laces
- 1; i
++) {
1787 lace_size
[i
] += *buffer
;
1789 } while (*buffer
++ == 0xFF);
1790 if (lace_size
[i
] > *size
- total
|| total
> *size
)
1792 total
+= lace_size
[i
];
1794 lace_size
[i
] = *size
- total
;
1797 case 2: /* fixed-size lacing */
1798 for (i
= 0; i
< *laces
; i
++)
1799 lace_size
[i
] = *size
/ *laces
;
1802 case 3:; /* EBML lacing */
1804 uint64_t num
= ebml_read_vlen_uint(buffer
, &l
);
1805 if (num
== EBML_UINT_INVALID
)
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
)
1823 lace_size
[i
] = lace_size
[i
- 1] + snum
;
1824 if (lace_size
[i
] > *size
- total
|| total
> *size
)
1826 total
+= lace_size
[i
];
1828 lace_size
[i
] = *size
- total
;
1833 *all_lace_sizes
= lace_size
;
1838 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Bad input [lacing]\n");
1842 static void handle_realvideo(demuxer_t
*demuxer
, mkv_track_t
*track
,
1843 uint8_t *buffer
, uint32_t size
, int64_t block_bref
)
1845 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1847 uint32_t timestamp
= mkv_d
->last_pts
* 1000;
1849 dp
= new_demux_packet(size
);
1850 memcpy(dp
->buffer
, buffer
, size
);
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
;
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;
1865 ds_add_packet(demuxer
->video
, dp
);
1868 static void handle_realaudio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1869 uint8_t *buffer
, uint32_t size
, int64_t block_bref
)
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
;
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'))) {
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
);
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
);
1899 case mmioFOURCC('s', 'i', 'p', 'r'):
1900 memcpy(track
->audio_buf
+ spc
* w
, buffer
, w
);
1901 if (spc
== sph
- 1) {
1903 int bs
= sph
* w
* 2 / 96; // nibbles per subpacket
1904 // Perform reordering
1905 for (n
= 0; n
< 38; n
++) {
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
++) {
1912 (track
->audio_buf
[i
>> 1] >> 4) :
1913 (track
->audio_buf
[i
>> 1] & 0x0F);
1915 (track
->audio_buf
[o
>> 1] >> 4) :
1916 (track
->audio_buf
[o
>> 1] & 0x0F);
1918 track
->audio_buf
[o
>> 1] =
1919 (track
->audio_buf
[o
>> 1] & 0x0F) | (x
<< 4);
1921 track
->audio_buf
[o
>> 1] =
1922 (track
->audio_buf
[o
>> 1] & 0xF0) | x
;
1924 track
->audio_buf
[i
>> 1] =
1925 (track
->audio_buf
[i
>> 1] & 0x0F) | (y
<< 4);
1927 track
->audio_buf
[i
>> 1] =
1928 (track
->audio_buf
[i
>> 1] & 0xF0) | y
;
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
) {
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
,
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
);
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
)
1965 dp
->pts
= mkv_d
->last_pts
;
1966 track
->ra_pts
= mkv_d
->last_pts
;
1968 dp
->pos
= demuxer
->filepos
;
1969 dp
->flags
= block_bref
? 0 : 0x10;
1970 ds_add_packet(demuxer
->audio
, dp
);
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
)
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
;
1983 uint32_t *lace_size
;
1984 uint8_t laces
, flags
;
1985 int i
, num
, tmp
, use_this_block
= 1;
1989 /* first byte(s): track num */
1990 num
= ebml_read_vlen_uint(block
, &tmp
);
1992 /* time (relative to cluster time) */
1993 time
= block
[0] << 8 | block
[1];
1996 old_length
= length
;
1998 if (demux_mkv_read_block_lacing(block
, &length
, &laces
, &lace_size
))
2000 block
+= old_length
- length
;
2002 tc
= time
* mkv_d
->tc_scale
+ mkv_d
->cluster_tc
;
2003 current_pts
= tc
/ 1e9
;
2005 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2006 if (mkv_d
->tracks
[i
]->tnum
== num
) {
2007 track
= mkv_d
->tracks
[i
];
2010 if (track
== NULL
) {
2014 if (track
->type
== MATROSKA_TRACK_AUDIO
2015 && track
->id
== demuxer
->audio
->id
) {
2016 ds
= demuxer
->audio
;
2018 if (mkv_d
->a_skip_to_keyframe
) {
2020 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2022 } else if (block_bref
!= 0)
2025 if (mkv_d
->v_skip_to_keyframe
)
2028 if (track
->fix_i_bps
&& use_this_block
) {
2029 sh_audio_t
*sh
= (sh_audio_t
*) ds
->sh
;
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;
2041 } else if (tc
< mkv_d
->skip_to_timecode
)
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
) {
2048 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2050 } else if (block_bref
!= 0 || block_fref
!= 0)
2053 } else if (track
->type
== MATROSKA_TRACK_SUBTITLE
2054 && track
->id
== demuxer
->sub
->id
) {
2057 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Subtitles use Matroska "
2058 "lacing. This is abnormal and not supported.\n");
2061 sub_utf8
= 1; // XXX this variable should be eventually removed
2065 if (use_this_block
) {
2066 mkv_d
->last_pts
= current_pts
;
2067 mkv_d
->last_filepos
= demuxer
->filepos
;
2069 for (i
= 0; i
< laces
; i
++) {
2070 if (ds
== demuxer
->video
&& track
->realmedia
)
2071 handle_realvideo(demuxer
, track
, block
, lace_size
[i
],
2073 else if (ds
== demuxer
->audio
&& track
->realmedia
)
2074 handle_realaudio(demuxer
, track
, block
, lace_size
[i
],
2077 int size
= lace_size
[i
];
2080 demux_mkv_decode(track
, block
, &buffer
, &size
, 1);
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
)
2093 mkv_d
->last_pts
+ i
* track
->default_duration
;
2094 dp
->duration
= block_duration
/ 1e9
;
2095 ds_add_packet(ds
, dp
);
2098 block
+= lace_size
[i
];
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;
2115 static int demux_mkv_fill_buffer(demuxer_t
*demuxer
, demux_stream_t
*ds
)
2117 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2118 stream_t
*s
= demuxer
->stream
;
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
;
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
) {
2136 block_duration
*= mkv_d
->tc_scale
;
2139 case MATROSKA_ID_BLOCK
:
2140 block_length
= ebml_read_length(s
, &tmp
);
2142 if (block_length
> 500000000)
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
) {
2151 l
= tmp
+ block_length
;
2154 case MATROSKA_ID_REFERENCEBLOCK
:;
2155 int64_t num
= ebml_read_int(s
, &l
);
2156 if (num
== EBML_INT_INVALID
) {
2166 case EBML_ID_INVALID
:
2171 ebml_read_skip(s
, &l
);
2174 mkv_d
->blockgroup_size
-= l
+ il
;
2175 mkv_d
->cluster_size
-= l
+ il
;
2179 int res
= handle_block(demuxer
, block
, block_length
,
2180 block_duration
, block_bref
, block_fref
,
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
)
2195 mkv_d
->cluster_tc
= num
* mkv_d
->tc_scale
;
2196 add_cluster_position(mkv_d
, mkv_d
->cluster_start
,
2200 case MATROSKA_ID_BLOCKGROUP
:
2201 mkv_d
->blockgroup_size
= ebml_read_length(s
, &tmp
);
2205 case MATROSKA_ID_SIMPLEBLOCK
:;
2207 block_length
= ebml_read_length(s
, &tmp
);
2208 if (block_length
> 500000000)
2210 block
= malloc(block_length
);
2211 demuxer
->filepos
= stream_tell(s
);
2212 if (stream_read(s
, block
, block_length
) !=
2213 (int) block_length
) {
2217 l
= tmp
+ block_length
;
2218 res
= handle_block(demuxer
, block
, block_length
,
2219 block_duration
, block_bref
,
2222 mkv_d
->cluster_size
-= l
+ il
;
2228 mkv_d
->cluster_size
+= l
+ il
;
2231 case EBML_ID_INVALID
:
2235 ebml_read_skip(s
, &l
);
2238 mkv_d
->cluster_size
-= l
+ il
;
2242 while (ebml_read_id(s
, &il
) != MATROSKA_ID_CLUSTER
) {
2243 ebml_read_skip(s
, NULL
);
2247 mkv_d
->cluster_start
= stream_tell(s
) - il
;
2248 mkv_d
->cluster_size
= ebml_read_length(s
, NULL
);
2254 static int seek_creating_index(struct demuxer
*demuxer
, float rel_seek_secs
,
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)
2262 uint64_t max_filepos
= 0;
2263 int64_t max_tc
= -1;
2264 int n
= mkv_d
->num_cluster_pos
;
2266 max_filepos
= mkv_d
->cluster_positions
[n
- 1].filepos
;
2267 max_tc
= mkv_d
->cluster_positions
[n
- 1].timecode
;
2270 if (target_tc_ns
> max_tc
) {
2271 if ((off_t
) max_filepos
> stream_tell(s
))
2272 stream_seek(s
, max_filepos
);
2274 stream_seek(s
, stream_tell(s
) + mkv_d
->cluster_size
);
2275 /* parse all the clusters upto target_filepos */
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
)
2295 stream_seek(s
, end
);
2301 if (!mkv_d
->num_cluster_pos
) {
2302 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] no target for seek found\n");
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
;
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
;
2319 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2320 stream_seek(s
, cluster_pos
);
2324 static struct mkv_index
*seek_with_cues(struct demuxer
*demuxer
, int seek_id
,
2325 int64_t target_timecode
, int flags
)
2327 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
2328 struct mkv_index
*index
= NULL
;
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.
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
) {
2344 (int64_t) (mkv_d
->indexes
[i
].timecode
* mkv_d
->tc_scale
);
2345 if (flags
& SEEK_BACKWARD
)
2348 if (min_diff
<= 0 && diff
<= min_diff
)
2350 } else if (diff
>= min_diff
)
2353 index
= mkv_d
->indexes
+ i
;
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
);
2363 static void demux_mkv_seek(demuxer_t
*demuxer
, float rel_seek_secs
,
2364 float audio_delay
, int flags
)
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
;
2379 flags
|= SEEK_FORWARD
;
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;
2385 if (!(flags
& SEEK_FACTOR
)) { /* time in secs */
2386 mkv_index_t
*index
= NULL
;
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;
2393 if (mkv_d
->indexes
== NULL
) { /* no index was found */
2394 if (seek_creating_index(demuxer
, rel_seek_secs
, flags
) < 0)
2397 int seek_id
= (demuxer
->video
->id
< 0) ?
2399 index
= seek_with_cues(demuxer
, seek_id
, target_timecode
, flags
);
2401 index
= seek_with_cues(demuxer
, -1, target_timecode
, flags
);
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
;
2409 mkv_d
->skip_to_timecode
= index
? index
->timecode
* mkv_d
->tc_scale
2411 mkv_d
->a_skip_to_keyframe
= 1;
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");
2417 stream_t
*s
= demuxer
->stream
;
2418 uint64_t target_filepos
;
2419 mkv_index_t
*index
= NULL
;
2422 if (mkv_d
->indexes
== NULL
) { /* not implemented without index */
2423 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
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
)
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
];
2439 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2440 stream_seek(s
, index
->filepos
);
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;
2447 demux_mkv_fill_buffer(demuxer
, NULL
);
2451 static int demux_mkv_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
2453 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
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
;
2462 *((double *) arg
) = (double) mkv_d
->duration
;
2463 return DEMUXER_CTRL_OK
;
2465 case DEMUXER_CTRL_GET_PERCENT_POS
:
2466 if (mkv_d
->duration
== 0) {
2467 return DEMUXER_CTRL_DONTKNOW
;
2470 *((int *) arg
) = (int) (100 * mkv_d
->last_pts
/ mkv_d
->duration
);
2471 return DEMUXER_CTRL_OK
;
2473 case DEMUXER_CTRL_SWITCH_AUDIO
:;
2474 int new_aid
= *(int *) arg
;
2475 int current_aid
= demuxer
->audio
->id
;
2476 if (current_aid
< 0)
2478 if (new_aid
== -1) { // cycle to next
2479 new_aid
= current_aid
;
2481 new_aid
= (new_aid
+ 2) % (mkv_d
->num_audio_tracks
+ 1) - 1;
2482 if (new_aid
== -1 || demuxer
->a_streams
[new_aid
])
2486 if (new_aid
< 0 || new_aid
>= mkv_d
->num_audio_tracks
||
2487 !demuxer
->a_streams
[new_aid
])
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
;
2495 case DEMUXER_CTRL_SWITCH_VIDEO
:;
2496 int new_vid
= *(int *) arg
;
2497 int current_vid
= demuxer
->video
->id
;
2498 if (current_vid
< 0)
2500 if (new_vid
== -1) { // cycle to next
2501 new_vid
= current_vid
;
2503 new_vid
= (new_vid
+ 2) % (mkv_d
->num_video_tracks
+ 1) - 1;
2504 if (new_vid
== -1 || demuxer
->v_streams
[new_vid
])
2508 if (new_vid
< 0 || new_vid
>= mkv_d
->num_video_tracks
||
2509 !demuxer
->v_streams
[new_vid
])
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
;
2518 return DEMUXER_CTRL_NOTIMPL
;
2522 const demuxer_desc_t demuxer_desc_matroska
= {
2528 DEMUXER_TYPE_MATROSKA
,
2529 1, // safe autodetect
2531 demux_mkv_fill_buffer
,