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"
46 #include "libavutil/common.h"
48 #ifdef CONFIG_QTX_CODECS
49 #include "loader/qtx/qtxsdk/components.h"
56 #include "libavutil/lzo.h"
57 #include "ffmpeg_files/intreadwrite.h"
58 #include "libavutil/avstring.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
;
378 mkv_d
->tc_scale
= 1000000;
381 struct ebml_info info
= {};
382 struct ebml_parse_ctx parse_ctx
= {};
383 if (ebml_read_element(s
, &parse_ctx
, &info
, &ebml_info_desc
) < 0)
385 if (info
.n_timecode_scale
) {
386 mkv_d
->tc_scale
= info
.timecode_scale
;
387 mp_msg(MSGT_DEMUX
, MSGL_V
,
388 "[mkv] | + timecode scale: %" PRIu64
"\n", mkv_d
->tc_scale
);
390 if (info
.n_duration
) {
391 mkv_d
->duration
= info
.duration
* mkv_d
->tc_scale
/ 1e9
;
392 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + duration: %.3fs\n",
395 if (info
.n_segment_uid
) {
396 int len
= info
.segment_uid
.len
;
397 if (len
!= sizeof(demuxer
->matroska_data
.segment_uid
)) {
398 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
399 "[mkv] segment uid invalid length %d\n", len
);
401 memcpy(demuxer
->matroska_data
.segment_uid
, info
.segment_uid
.start
,
403 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + segment uid");
404 for (int i
= 0; i
< len
; i
++)
405 mp_msg(MSGT_DEMUX
, MSGL_V
, " %02x",
406 demuxer
->matroska_data
.segment_uid
[i
]);
407 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
410 talloc_free(parse_ctx
.talloc_ctx
);
414 static void parse_trackencodings(struct demuxer
*demuxer
,
415 struct mkv_track
*track
,
416 struct ebml_content_encodings
*encodings
)
418 // initial allocation to be a non-NULL context before realloc
419 mkv_content_encoding_t
*ce
= talloc_size(track
, 1);
421 for (int n_enc
= 0; n_enc
< encodings
->n_content_encoding
; n_enc
++) {
422 struct ebml_content_encoding
*enc
= encodings
->content_encoding
+ n_enc
;
423 struct mkv_content_encoding e
= {};
424 e
.order
= enc
->content_encoding_order
;
425 if (enc
->n_content_encoding_scope
)
426 e
.scope
= enc
->content_encoding_scope
;
429 e
.type
= enc
->content_encoding_type
;
431 if (enc
->n_content_compression
) {
432 struct ebml_content_compression
*z
= &enc
->content_compression
;
433 e
.comp_algo
= z
->content_comp_algo
;
434 if (z
->n_content_comp_settings
) {
435 int sz
= z
->content_comp_settings
.len
;
436 e
.comp_settings
= talloc_size(ce
, sz
);
437 memcpy(e
.comp_settings
, z
->content_comp_settings
.start
, sz
);
438 e
.comp_settings_len
= sz
;
443 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Track "
444 "number %u has been encrypted and "
445 "decryption has not yet been\n"
446 "[mkv] implemented. Skipping track.\n",
448 } else if (e
.type
!= 0) {
449 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
450 "[mkv] Unknown content encoding type for "
451 "track %u. Skipping track.\n",
453 } else if (e
.comp_algo
!= 0 && e
.comp_algo
!= 2 && e
.comp_algo
!= 3) {
454 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
455 "[mkv] Track %u has been compressed with "
456 "an unknown/unsupported compression\n"
457 "[mkv] algorithm (%" PRIu64
"). Skipping track.\n",
458 track
->tnum
, e
.comp_algo
);
461 else if (e
.comp_algo
== 0) {
462 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
463 "[mkv] Track %u was compressed with zlib "
464 "but mplayer has not been compiled\n"
465 "[mkv] with support for zlib compression. "
471 for (i
= 0; i
< n_enc
; i
++)
472 if (e
.order
>= ce
[i
].order
)
474 ce
= talloc_realloc_size(track
, ce
, (n_enc
+ 1) * sizeof(*ce
));
475 memmove(ce
+ i
+ 1, ce
+ i
, (n_enc
- i
) * sizeof(*ce
));
476 memcpy(ce
+ i
, &e
, sizeof(e
));
479 track
->encodings
= ce
;
480 track
->num_encodings
= encodings
->n_content_encoding
;
483 static void parse_trackaudio(struct demuxer
*demuxer
, struct mkv_track
*track
,
484 struct ebml_audio
*audio
)
486 if (audio
->n_sampling_frequency
) {
487 track
->a_sfreq
= audio
->sampling_frequency
;
488 mp_msg(MSGT_DEMUX
, MSGL_V
,
489 "[mkv] | + Sampling frequency: %f\n", track
->a_sfreq
);
491 track
->a_sfreq
= 8000;
492 if (audio
->n_output_sampling_frequency
) {
493 track
->a_osfreq
= audio
->output_sampling_frequency
;
494 mp_msg(MSGT_DEMUX
, MSGL_V
,
495 "[mkv] | + Output sampling frequency: %f\n", track
->a_osfreq
);
497 track
->a_osfreq
= track
->a_sfreq
;
498 if (audio
->n_bit_depth
) {
499 track
->a_bps
= audio
->bit_depth
;
500 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Bit depth: %u\n",
503 if (audio
->n_channels
) {
504 track
->a_channels
= audio
->channels
;
505 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Channels: %u\n",
508 track
->a_channels
= 1;
511 static void parse_trackvideo(struct demuxer
*demuxer
, struct mkv_track
*track
,
512 struct ebml_video
*video
)
514 if (video
->n_frame_rate
) {
515 track
->v_frate
= video
->frame_rate
;
516 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Frame rate: %f\n",
518 if (track
->v_frate
> 0)
519 track
->default_duration
= 1 / track
->v_frate
;
521 if (video
->n_display_width
) {
522 track
->v_dwidth
= video
->display_width
;
523 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display width: %u\n",
526 if (video
->n_display_height
) {
527 track
->v_dheight
= video
->display_height
;
528 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display height: %u\n",
531 if (video
->n_pixel_width
) {
532 track
->v_width
= video
->pixel_width
;
533 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel width: %u\n",
536 if (video
->n_pixel_height
) {
537 track
->v_height
= video
->pixel_height
;
538 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel height: %u\n",
544 * \brief free any data associated with given track
545 * \param track track of which to free data
547 static void demux_mkv_free_trackentry(mkv_track_t
*track
)
549 free(track
->audio_buf
);
550 free(track
->audio_timestamp
);
554 static void parse_trackentry(struct demuxer
*demuxer
,
555 struct ebml_track_entry
*entry
)
557 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
558 struct mkv_track
*track
= talloc_zero_size(NULL
, sizeof(*track
));
560 track
->tnum
= entry
->track_number
;
562 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track number: %u\n",
565 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Missing track number!\n");
568 track
->name
= talloc_strndup(track
, entry
->name
.start
,
570 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Name: %s\n",
574 track
->type
= entry
->track_type
;
575 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track type: ");
576 switch (track
->type
) {
577 case MATROSKA_TRACK_AUDIO
:
578 mp_msg(MSGT_DEMUX
, MSGL_V
, "Audio\n");
580 case MATROSKA_TRACK_VIDEO
:
581 mp_msg(MSGT_DEMUX
, MSGL_V
, "Video\n");
583 case MATROSKA_TRACK_SUBTITLE
:
584 mp_msg(MSGT_DEMUX
, MSGL_V
, "Subtitle\n");
587 mp_msg(MSGT_DEMUX
, MSGL_V
, "unknown\n");
591 if (entry
->n_audio
) {
592 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Audio track\n");
593 parse_trackaudio(demuxer
, track
, &entry
->audio
);
596 if (entry
->n_video
) {
597 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Video track\n");
598 parse_trackvideo(demuxer
, track
, &entry
->video
);
601 if (entry
->n_codec_id
) {
602 track
->codec_id
= talloc_strndup(track
, entry
->codec_id
.start
,
603 entry
->codec_id
.len
);
604 if (!strcmp(track
->codec_id
, MKV_V_MSCOMP
)
605 || !strcmp(track
->codec_id
, MKV_A_ACM
))
606 track
->ms_compat
= 1;
607 else if (!strcmp(track
->codec_id
, MKV_S_VOBSUB
))
608 track
->subtitle_type
= 'v';
609 else if (!strcmp(track
->codec_id
, MKV_S_TEXTSSA
)
610 || !strcmp(track
->codec_id
, MKV_S_TEXTASS
)
611 || !strcmp(track
->codec_id
, MKV_S_SSA
)
612 || !strcmp(track
->codec_id
, MKV_S_ASS
))
613 track
->subtitle_type
= 'a';
614 else if (!strcmp(track
->codec_id
, MKV_S_TEXTASCII
)
615 || !strcmp(track
->codec_id
, MKV_S_TEXTUTF8
))
616 track
->subtitle_type
= 't';
617 else if (!strcmp(track
->codec_id
, MKV_S_PGS
))
618 track
->subtitle_type
= 'p';
619 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Codec ID: %s\n",
622 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Missing codec ID!\n");
624 if (entry
->n_codec_private
) {
625 int len
= entry
->codec_private
.len
;
626 track
->private_data
= talloc_size(track
, len
+ AV_LZO_INPUT_PADDING
);
627 memcpy(track
->private_data
, entry
->codec_private
.start
, len
);
628 track
->private_size
= len
;
629 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + CodecPrivate, length %u\n",
630 track
->private_size
);
633 if (entry
->n_language
) {
634 track
->language
= talloc_strndup(track
, entry
->language
.start
,
635 entry
->language
.len
);
636 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Language: %s\n",
639 track
->language
= talloc_strdup(track
, "eng");
641 if (entry
->n_flag_default
) {
642 track
->default_track
= entry
->flag_default
;
643 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default flag: %u\n",
644 track
->default_track
);
646 track
->default_track
= 1;
648 if (entry
->n_default_duration
) {
649 track
->default_duration
= entry
->default_duration
/ 1e9
;
650 if (entry
->default_duration
== 0)
651 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default duration: 0");
654 track
->v_frate
= 1e9
/ entry
->default_duration
;
655 mp_msg(MSGT_DEMUX
, MSGL_V
,
656 "[mkv] | + Default duration: %.3fms ( = %.3f fps)\n",
657 entry
->default_duration
/ 1000000.0, track
->v_frate
);
661 if (entry
->n_content_encodings
)
662 parse_trackencodings(demuxer
, track
, &entry
->content_encodings
);
664 mkv_d
->tracks
[mkv_d
->num_tracks
++] = track
;
667 static int demux_mkv_read_tracks(demuxer_t
*demuxer
)
669 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
670 stream_t
*s
= demuxer
->stream
;
672 struct ebml_tracks tracks
= {};
673 struct ebml_parse_ctx parse_ctx
= {};
674 if (ebml_read_element(s
, &parse_ctx
, &tracks
, &ebml_tracks_desc
) < 0)
677 mkv_d
->tracks
= talloc_size(mkv_d
,
678 tracks
.n_track_entry
* sizeof(*mkv_d
->tracks
));
679 for (int i
= 0; i
< tracks
.n_track_entry
; i
++) {
680 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + a track...\n");
681 parse_trackentry(demuxer
, &tracks
.track_entry
[i
]);
683 talloc_free(parse_ctx
.talloc_ctx
);
687 static int demux_mkv_read_cues(demuxer_t
*demuxer
)
689 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
690 stream_t
*s
= demuxer
->stream
;
692 if (index_mode
== 0 || index_mode
== 2) {
693 ebml_read_skip(s
, NULL
);
697 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing cues ] -----------\n");
698 struct ebml_cues cues
= {};
699 struct ebml_parse_ctx parse_ctx
= {};
700 if (ebml_read_element(s
, &parse_ctx
, &cues
, &ebml_cues_desc
) < 0)
702 for (int i
= 0; i
< cues
.n_cue_point
; i
++) {
703 struct ebml_cue_point
*cuepoint
= &cues
.cue_point
[i
];
704 if (cuepoint
->n_cue_time
!= 1 || !cuepoint
->n_cue_track_positions
) {
705 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Malformed CuePoint element\n");
708 uint64_t time
= cuepoint
->cue_time
;
709 for (int i
= 0; i
< cuepoint
->n_cue_track_positions
; i
++) {
710 struct ebml_cue_track_positions
*trackpos
=
711 &cuepoint
->cue_track_positions
[i
];
712 uint64_t track
= trackpos
->cue_track
;
713 uint64_t pos
= trackpos
->cue_cluster_position
;
715 grow_array(mkv_d
->indexes
, mkv_d
->num_indexes
,
716 sizeof(mkv_index_t
));
717 mkv_d
->indexes
[mkv_d
->num_indexes
].tnum
= track
;
718 mkv_d
->indexes
[mkv_d
->num_indexes
].timecode
= time
;
719 mkv_d
->indexes
[mkv_d
->num_indexes
].filepos
=
720 mkv_d
->segment_start
+ pos
;
721 mp_msg(MSGT_DEMUX
, MSGL_DBG2
,
722 "[mkv] |+ found cue point for track %" PRIu64
723 ": timecode %" PRIu64
", filepos: %" PRIu64
"\n", track
,
724 time
, mkv_d
->segment_start
+ pos
);
725 mkv_d
->num_indexes
++;
730 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] \\---- [ parsing cues ] -----------\n");
731 talloc_free(parse_ctx
.talloc_ctx
);
735 static int demux_mkv_read_chapters(struct demuxer
*demuxer
)
737 struct MPOpts
*opts
= demuxer
->opts
;
738 stream_t
*s
= demuxer
->stream
;
740 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing chapters ] ---------\n");
741 struct ebml_chapters file_chapters
= {};
742 struct ebml_parse_ctx parse_ctx
= {};
743 if (ebml_read_element(s
, &parse_ctx
, &file_chapters
,
744 &ebml_chapters_desc
) < 0)
747 int selected_edition
= 0;
748 int num_editions
= file_chapters
.n_edition_entry
;
749 struct ebml_edition_entry
*editions
= file_chapters
.edition_entry
;
750 if (opts
->edition_id
>= 0 && opts
->edition_id
< num_editions
) {
751 selected_edition
= opts
->edition_id
;
752 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] User-specified edition: %d\n",
755 for (int i
= 0; i
< num_editions
; i
++)
756 if (editions
[i
].edition_flag_default
) {
757 selected_edition
= i
;
758 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Default edition: %d\n", i
);
761 struct matroska_chapter
*m_chapters
= NULL
;
762 if (editions
[selected_edition
].edition_flag_ordered
) {
763 int count
= editions
[selected_edition
].n_chapter_atom
;
764 m_chapters
= talloc_array_ptrtype(demuxer
, m_chapters
, count
);
765 demuxer
->matroska_data
.ordered_chapters
= m_chapters
;
766 demuxer
->matroska_data
.num_ordered_chapters
= count
;
769 for (int idx
= 0; idx
< num_editions
; idx
++) {
770 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] New edition %d\n", idx
);
771 int warn_level
= idx
== selected_edition
? MSGL_WARN
: MSGL_V
;
772 if (editions
[idx
].n_edition_flag_default
)
773 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Default edition flag: %"PRIu64
774 "\n", editions
[idx
].edition_flag_default
);
775 if (editions
[idx
].n_edition_flag_ordered
)
776 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Ordered chapter flag: %"PRIu64
777 "\n", editions
[idx
].edition_flag_ordered
);
778 for (int i
= 0; i
< editions
[idx
].n_chapter_atom
; i
++) {
779 struct ebml_chapter_atom
*ca
= editions
[idx
].chapter_atom
+ i
;
780 struct matroska_chapter chapter
= { };
781 struct bstr name
= { "(unnamed)", 9 };
783 if (!ca
->n_chapter_time_start
)
784 mp_msg(MSGT_DEMUX
, warn_level
,
785 "[mkv] Chapter lacks start time\n");
786 chapter
.start
= ca
->chapter_time_start
;
787 chapter
.end
= ca
->chapter_time_end
;
789 if (ca
->n_chapter_display
) {
790 if (ca
->n_chapter_display
> 1)
791 mp_msg(MSGT_DEMUX
, warn_level
, "[mkv] Multiple chapter "
792 "names not supported, picking first\n");
793 if (!ca
->chapter_display
[0].n_chap_string
)
794 mp_msg(MSGT_DEMUX
, warn_level
, "[mkv] Malformed chapter "
797 name
= ca
->chapter_display
[0].chap_string
;
800 if (ca
->n_chapter_segment_uid
) {
801 chapter
.has_segment_uid
= true;
802 int len
= ca
->chapter_segment_uid
.len
;
803 if (len
!= sizeof(chapter
.segment_uid
))
804 mp_msg(MSGT_DEMUX
, warn_level
,
805 "[mkv] Chapter segment uid bad length %d\n", len
);
806 else if (ca
->n_chapter_segment_edition_uid
) {
807 mp_tmsg(MSGT_DEMUX
, warn_level
, "[mkv] Warning: "
808 "unsupported edition recursion in chapter; "
809 "will skip on playback!\n");
811 memcpy(chapter
.segment_uid
, ca
->chapter_segment_uid
.start
,
813 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Chapter segment uid ");
814 for (int i
= 0; i
< len
; i
++)
815 mp_msg(MSGT_DEMUX
, MSGL_V
, "%02x ",
816 chapter
.segment_uid
[i
]);
817 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
821 mp_msg(MSGT_DEMUX
, MSGL_V
,
822 "[mkv] Chapter %u from %02d:%02d:%02d.%03d "
823 "to %02d:%02d:%02d.%03d, %.*s\n", i
,
824 (int) (chapter
.start
/ 60 / 60 / 1000000000),
825 (int) ((chapter
.start
/ 60 / 1000000000) % 60),
826 (int) ((chapter
.start
/ 1000000000) % 60),
827 (int) (chapter
.start
% 1000000000),
828 (int) (chapter
.end
/ 60 / 60 / 1000000000),
829 (int) ((chapter
.end
/ 60 / 1000000000) % 60),
830 (int) ((chapter
.end
/ 1000000000) % 60),
831 (int) (chapter
.end
% 1000000000),
834 if (idx
== selected_edition
){
835 demuxer_add_chapter(demuxer
, name
, chapter
.start
, chapter
.end
);
836 if (editions
[idx
].edition_flag_ordered
) {
837 chapter
.name
= talloc_strndup(m_chapters
, name
.start
,
839 m_chapters
[i
] = chapter
;
844 if (num_editions
> 1)
845 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
846 "[mkv] Found %d editions, will play #%d (first is 0).\n",
847 num_editions
, selected_edition
);
850 talloc_free(parse_ctx
.talloc_ctx
);
851 mp_msg(MSGT_DEMUX
, MSGL_V
,
852 "[mkv] \\---- [ parsing chapters ] ---------\n");
856 static int demux_mkv_read_tags(demuxer_t
*demuxer
)
858 stream_t
*s
= demuxer
->stream
;
860 struct ebml_parse_ctx parse_ctx
= {};
861 struct ebml_tags tags
= {};
862 if (ebml_read_element(s
, &parse_ctx
, &tags
, &ebml_tags_desc
) < 0)
865 for (int i
= 0; i
< tags
.n_tag
; i
++) {
866 struct ebml_tag tag
= tags
.tag
[i
];
867 if (tag
.targets
.target_track_uid
|| tag
.targets
.target_edition_uid
||
868 tag
.targets
.target_chapter_uid
|| tag
.targets
.target_attachment_uid
)
871 for (int j
= 0; j
< tag
.n_simple_tag
; j
++)
872 demux_info_add_bstr(demuxer
, tag
.simple_tag
[j
].tag_name
, tag
.simple_tag
[j
].tag_string
);
878 static int demux_mkv_read_attachments(demuxer_t
*demuxer
)
880 stream_t
*s
= demuxer
->stream
;
882 mp_msg(MSGT_DEMUX
, MSGL_V
,
883 "[mkv] /---- [ parsing attachments ] ---------\n");
885 struct ebml_attachments attachments
= {};
886 struct ebml_parse_ctx parse_ctx
= {};
887 if (ebml_read_element(s
, &parse_ctx
, &attachments
,
888 &ebml_attachments_desc
) < 0)
891 for (int i
= 0; i
< attachments
.n_attached_file
; i
++) {
892 struct ebml_attached_file
*attachment
= &attachments
.attached_file
[i
];
893 if (!attachment
->n_file_name
|| !attachment
->n_file_mime_type
894 || !attachment
->n_file_data
) {
895 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Malformed attachment\n");
898 struct bstr name
= attachment
->file_name
;
899 struct bstr mime
= attachment
->file_mime_type
;
900 demuxer_add_attachment(demuxer
, name
, mime
, attachment
->file_data
);
901 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Attachment: %.*s, %.*s, %zu bytes\n",
902 BSTR_P(name
), BSTR_P(mime
), attachment
->file_data
.len
);
906 talloc_free(parse_ctx
.talloc_ctx
);
907 mp_msg(MSGT_DEMUX
, MSGL_V
,
908 "[mkv] \\---- [ parsing attachments ] ---------\n");
912 static int read_header_element(struct demuxer
*demuxer
, uint32_t id
,
915 static int demux_mkv_read_seekhead(demuxer_t
*demuxer
)
917 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
918 struct stream
*s
= demuxer
->stream
;
920 struct ebml_seek_head seekhead
= {};
921 struct ebml_parse_ctx parse_ctx
= {};
923 mp_msg(MSGT_DEMUX
, MSGL_V
,
924 "[mkv] /---- [ parsing seek head ] ---------\n");
925 if (ebml_read_element(s
, &parse_ctx
, &seekhead
, &ebml_seek_head_desc
) < 0) {
929 /* off now holds the position of the next element after the seek head. */
930 off_t off
= stream_tell(s
);
931 for (int i
= 0; i
< seekhead
.n_seek
; i
++) {
932 struct ebml_seek
*seek
= &seekhead
.seek
[i
];
933 if (seek
->n_seek_id
!= 1 || seek
->n_seek_position
!= 1) {
934 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Invalid SeekHead entry\n");
937 uint64_t pos
= seek
->seek_position
+ mkv_d
->segment_start
;
938 if (pos
>= demuxer
->movi_end
) {
939 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] SeekHead position beyond "
940 "end of file - incomplete file?\n");
943 read_header_element(demuxer
, seek
->seek_id
, pos
);
945 if (!stream_seek(s
, off
)) {
946 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Couldn't seek back after "
951 mp_msg(MSGT_DEMUX
, MSGL_V
,
952 "[mkv] \\---- [ parsing seek head ] ---------\n");
953 talloc_free(parse_ctx
.talloc_ctx
);
957 static bool seek_pos_id(struct stream
*s
, off_t pos
, uint32_t id
)
959 if (!stream_seek(s
, pos
)) {
960 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Failed to seek in file\n");
963 if (ebml_read_id(s
, NULL
) != id
) {
964 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Expected element not found\n");
970 static int read_header_element(struct demuxer
*demuxer
, uint32_t id
,
973 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
974 stream_t
*s
= demuxer
->stream
;
975 off_t pos
= stream_tell(s
) - 4;
978 case MATROSKA_ID_INFO
:
979 if (mkv_d
->parsed_info
)
981 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
983 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment information...\n");
984 mkv_d
->parsed_info
= true;
985 return demux_mkv_read_info(demuxer
) ? -1 : 1;
987 case MATROSKA_ID_TRACKS
:
988 if (mkv_d
->parsed_tracks
)
990 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
992 mkv_d
->parsed_tracks
= true;
993 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment tracks...\n");
994 return demux_mkv_read_tracks(demuxer
) ? -1 : 1;
996 case MATROSKA_ID_CUES
:
997 if (is_parsed_header(mkv_d
, pos
))
999 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1001 return demux_mkv_read_cues(demuxer
) ? -1 : 1;
1003 case MATROSKA_ID_TAGS
:
1004 if (mkv_d
->parsed_tags
)
1006 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1008 mkv_d
->parsed_tags
= true;
1009 return demux_mkv_read_tags(demuxer
) ? -1 : 1;
1011 case MATROSKA_ID_SEEKHEAD
:
1012 if (is_parsed_header(mkv_d
, pos
))
1014 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1016 return demux_mkv_read_seekhead(demuxer
) ? -1 : 1;
1018 case MATROSKA_ID_CHAPTERS
:
1019 if (mkv_d
->parsed_chapters
)
1021 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1023 mkv_d
->parsed_chapters
= true;
1024 return demux_mkv_read_chapters(demuxer
) ? -1 : 1;
1026 case MATROSKA_ID_ATTACHMENTS
:
1027 if (mkv_d
->parsed_attachments
)
1029 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1031 mkv_d
->parsed_attachments
= true;
1032 return demux_mkv_read_attachments(demuxer
) ? -1 : 1;
1036 ebml_read_skip(s
, NULL
);
1040 ebml_read_skip(s
, NULL
);
1046 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1048 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1050 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1053 static void display_create_tracks(demuxer_t
*demuxer
)
1055 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1056 int i
, vid
= 0, aid
= 0, sid
= 0;
1058 for (i
= 0; i
< mkv_d
->num_tracks
; i
++) {
1059 char *type
= "unknown", str
[32];
1061 switch (mkv_d
->tracks
[i
]->type
) {
1062 case MATROSKA_TRACK_VIDEO
:
1064 mkv_d
->tracks
[i
]->id
= -1;
1065 if (vid
== MAX_V_STREAMS
)
1067 mkv_d
->tracks
[i
]->id
= vid
;
1068 demux_mkv_open_video(demuxer
, mkv_d
->tracks
[i
], vid
);
1069 if (mkv_d
->tracks
[i
]->name
)
1070 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VID_%d_NAME=%s\n", vid
,
1071 mkv_d
->tracks
[i
]->name
);
1072 sprintf(str
, "-vid %u", vid
++);
1074 case MATROSKA_TRACK_AUDIO
:
1076 mkv_d
->tracks
[i
]->id
= -1;
1077 if (aid
== MAX_A_STREAMS
)
1079 mkv_d
->tracks
[i
]->id
= aid
;
1080 demux_mkv_open_audio(demuxer
, mkv_d
->tracks
[i
], aid
);
1081 if (mkv_d
->tracks
[i
]->name
)
1082 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_NAME=%s\n", aid
,
1083 mkv_d
->tracks
[i
]->name
);
1084 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_LANG=%s\n", aid
,
1085 mkv_d
->tracks
[i
]->language
);
1086 sprintf(str
, "-aid %u, -alang %.5s", aid
++,
1087 mkv_d
->tracks
[i
]->language
);
1089 case MATROSKA_TRACK_SUBTITLE
:
1091 mkv_d
->tracks
[i
]->id
= -1;
1092 if (sid
== MAX_S_STREAMS
)
1094 mkv_d
->tracks
[i
]->id
= sid
;
1095 demux_mkv_open_sub(demuxer
, mkv_d
->tracks
[i
], sid
);
1096 if (mkv_d
->tracks
[i
]->name
)
1097 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_NAME=%s\n", sid
,
1098 mkv_d
->tracks
[i
]->name
);
1099 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", sid
,
1100 mkv_d
->tracks
[i
]->language
);
1101 sprintf(str
, "-sid %u, -slang %.5s", sid
++,
1102 mkv_d
->tracks
[i
]->language
);
1105 if (mkv_d
->tracks
[i
]->name
)
1106 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
,
1107 "[mkv] Track ID %u: %s (%s) \"%s\", %s\n",
1108 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
,
1109 mkv_d
->tracks
[i
]->name
, str
);
1111 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] Track ID %u: %s (%s), %s\n",
1112 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
,
1115 mkv_d
->num_audio_tracks
= aid
;
1116 mkv_d
->num_video_tracks
= vid
;
1123 } videocodec_info_t
;
1125 static const videocodec_info_t vinfo
[] = {
1126 {MKV_V_MJPEG
, mmioFOURCC('m', 'j', 'p', 'g'), 1},
1127 {MKV_V_MPEG1
, mmioFOURCC('m', 'p', 'g', '1'), 0},
1128 {MKV_V_MPEG2
, mmioFOURCC('m', 'p', 'g', '2'), 0},
1129 {MKV_V_MPEG4_SP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1130 {MKV_V_MPEG4_ASP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1131 {MKV_V_MPEG4_AP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1132 {MKV_V_MPEG4_AVC
, mmioFOURCC('a', 'v', 'c', '1'), 1},
1133 {MKV_V_THEORA
, mmioFOURCC('t', 'h', 'e', 'o'), 1},
1134 {MKV_V_VP8
, mmioFOURCC('V', 'P', '8', '0'), 0},
1138 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1141 BITMAPINFOHEADER
*bih
;
1142 void *ImageDesc
= NULL
;
1145 if (track
->ms_compat
) { /* MS compatibility mode */
1146 BITMAPINFOHEADER
*src
;
1148 if (track
->private_data
== NULL
1149 || track
->private_size
< sizeof(*bih
))
1152 src
= (BITMAPINFOHEADER
*) track
->private_data
;
1153 bih
= calloc(1, track
->private_size
);
1154 bih
->biSize
= le2me_32(src
->biSize
);
1155 bih
->biWidth
= le2me_32(src
->biWidth
);
1156 bih
->biHeight
= le2me_32(src
->biHeight
);
1157 bih
->biPlanes
= le2me_16(src
->biPlanes
);
1158 bih
->biBitCount
= le2me_16(src
->biBitCount
);
1159 bih
->biCompression
= le2me_32(src
->biCompression
);
1160 bih
->biSizeImage
= le2me_32(src
->biSizeImage
);
1161 bih
->biXPelsPerMeter
= le2me_32(src
->biXPelsPerMeter
);
1162 bih
->biYPelsPerMeter
= le2me_32(src
->biYPelsPerMeter
);
1163 bih
->biClrUsed
= le2me_32(src
->biClrUsed
);
1164 bih
->biClrImportant
= le2me_32(src
->biClrImportant
);
1167 track
->private_size
- sizeof(*bih
));
1169 if (track
->v_width
== 0)
1170 track
->v_width
= bih
->biWidth
;
1171 if (track
->v_height
== 0)
1172 track
->v_height
= bih
->biHeight
;
1174 bih
= calloc(1, sizeof(*bih
));
1175 bih
->biSize
= sizeof(*bih
);
1176 bih
->biWidth
= track
->v_width
;
1177 bih
->biHeight
= track
->v_height
;
1178 bih
->biBitCount
= 24;
1179 bih
->biSizeImage
= bih
->biWidth
* bih
->biHeight
* bih
->biBitCount
/ 8;
1181 if (track
->private_size
>= RVPROPERTIES_SIZE
1182 && (!strcmp(track
->codec_id
, MKV_V_REALV10
)
1183 || !strcmp(track
->codec_id
, MKV_V_REALV20
)
1184 || !strcmp(track
->codec_id
, MKV_V_REALV30
)
1185 || !strcmp(track
->codec_id
, MKV_V_REALV40
))) {
1186 unsigned char *dst
, *src
;
1190 src
= (uint8_t *) track
->private_data
+ RVPROPERTIES_SIZE
;
1192 cnt
= track
->private_size
- RVPROPERTIES_SIZE
;
1193 bih
= realloc(bih
, sizeof(*bih
) + 8 + cnt
);
1194 bih
->biSize
= 48 + cnt
;
1196 type2
= AV_RB32(src
- 4);
1197 if (type2
== 0x10003000 || type2
== 0x10003001)
1198 bih
->biCompression
= mmioFOURCC('R', 'V', '1', '3');
1200 bih
->biCompression
=
1201 mmioFOURCC('R', 'V', track
->codec_id
[9], '0');
1202 dst
= (unsigned char *) (bih
+ 1);
1203 // copy type1 and type2 info from rv properties
1204 memcpy(dst
, src
- 8, 8 + cnt
);
1205 track
->realmedia
= 1;
1207 #ifdef CONFIG_QTX_CODECS
1208 } else if (track
->private_size
>= sizeof(ImageDescription
)
1209 && !strcmp(track
->codec_id
, MKV_V_QUICKTIME
)) {
1210 ImageDescriptionPtr idesc
;
1212 idesc
= (ImageDescriptionPtr
) track
->private_data
;
1213 idesc
->idSize
= be2me_32(idesc
->idSize
);
1214 idesc
->cType
= be2me_32(idesc
->cType
);
1215 idesc
->version
= be2me_16(idesc
->version
);
1216 idesc
->revisionLevel
= be2me_16(idesc
->revisionLevel
);
1217 idesc
->vendor
= be2me_32(idesc
->vendor
);
1218 idesc
->temporalQuality
= be2me_32(idesc
->temporalQuality
);
1219 idesc
->spatialQuality
= be2me_32(idesc
->spatialQuality
);
1220 idesc
->width
= be2me_16(idesc
->width
);
1221 idesc
->height
= be2me_16(idesc
->height
);
1222 idesc
->hRes
= be2me_32(idesc
->hRes
);
1223 idesc
->vRes
= be2me_32(idesc
->vRes
);
1224 idesc
->dataSize
= be2me_32(idesc
->dataSize
);
1225 idesc
->frameCount
= be2me_16(idesc
->frameCount
);
1226 idesc
->depth
= be2me_16(idesc
->depth
);
1227 idesc
->clutID
= be2me_16(idesc
->clutID
);
1229 bih
->biCompression
= idesc
->cType
;
1231 #endif /* CONFIG_QTX_CODECS */
1234 const videocodec_info_t
*vi
= vinfo
;
1235 while (vi
->id
&& strcmp(vi
->id
, track
->codec_id
))
1237 bih
->biCompression
= vi
->fourcc
;
1238 if (vi
->extradata
&& track
->private_data
1239 && (track
->private_size
> 0)) {
1240 bih
->biSize
+= track
->private_size
;
1241 bih
= realloc(bih
, bih
->biSize
);
1242 memcpy(bih
+ 1, track
->private_data
, track
->private_size
);
1245 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Unknown/unsupported "
1246 "CodecID (%s) or missing/bad CodecPrivate\n"
1247 "[mkv] data (track %u).\n",
1248 track
->codec_id
, track
->tnum
);
1255 sh_v
= new_sh_video(demuxer
, vid
);
1256 sh_v
->title
= talloc_strdup(sh_v
, track
->name
);
1258 sh_v
->format
= sh_v
->bih
->biCompression
;
1259 if (track
->v_frate
== 0.0)
1260 track
->v_frate
= 25.0;
1261 sh_v
->fps
= track
->v_frate
;
1262 sh_v
->frametime
= 1 / track
->v_frate
;
1264 if (!track
->realmedia
) {
1265 sh_v
->disp_w
= track
->v_width
;
1266 sh_v
->disp_h
= track
->v_height
;
1267 if (track
->v_dheight
)
1268 sh_v
->aspect
= (double) track
->v_dwidth
/ track
->v_dheight
;
1270 // vd_realvid.c will set aspect to disp_w/disp_h and rederive
1271 // disp_w and disp_h from the RealVideo stream contents returned
1272 // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
1273 // the Matroska file then it has already been set to PixelWidth/Height
1274 // by check_track_information.
1275 sh_v
->disp_w
= track
->v_dwidth
;
1276 sh_v
->disp_h
= track
->v_dheight
;
1278 sh_v
->ImageDesc
= ImageDesc
;
1279 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Aspect: %f\n", sh_v
->aspect
);
1281 sh_v
->ds
= demuxer
->video
;
1285 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1288 sh_audio_t
*sh_a
= new_sh_audio(demuxer
, aid
);
1292 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
1293 sh_a
->lang
= talloc_strdup(sh_a
, track
->language
);
1294 sh_a
->title
= talloc_strdup(sh_a
, track
->name
);
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 (!strncmp(track
->codec_id
, MKV_A_EAC3
, strlen(MKV_A_EAC3
)))
1325 track
->a_formattag
= mmioFOURCC('E', 'A', 'C', '3');
1326 else if (!strcmp(track
->codec_id
, MKV_A_DTS
))
1327 track
->a_formattag
= 0x2001;
1328 else if (!strcmp(track
->codec_id
, MKV_A_PCM
)
1329 || !strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1330 track
->a_formattag
= 0x0001;
1331 else if (!strcmp(track
->codec_id
, MKV_A_AAC_2MAIN
)
1332 || !strncmp(track
->codec_id
, MKV_A_AAC_2LC
,
1333 strlen(MKV_A_AAC_2LC
))
1334 || !strcmp(track
->codec_id
, MKV_A_AAC_2SSR
)
1335 || !strcmp(track
->codec_id
, MKV_A_AAC_4MAIN
)
1336 || !strncmp(track
->codec_id
, MKV_A_AAC_4LC
,
1337 strlen(MKV_A_AAC_4LC
))
1338 || !strcmp(track
->codec_id
, MKV_A_AAC_4SSR
)
1339 || !strcmp(track
->codec_id
, MKV_A_AAC_4LTP
)
1340 || !strcmp(track
->codec_id
, MKV_A_AAC
))
1341 track
->a_formattag
= mmioFOURCC('M', 'P', '4', 'A');
1342 else if (!strcmp(track
->codec_id
, MKV_A_VORBIS
)) {
1343 if (track
->private_data
== NULL
)
1345 track
->a_formattag
= mmioFOURCC('v', 'r', 'b', 's');
1346 } else if (!strcmp(track
->codec_id
, MKV_A_QDMC
))
1347 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', 'C');
1348 else if (!strcmp(track
->codec_id
, MKV_A_QDMC2
))
1349 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', '2');
1350 else if (!strcmp(track
->codec_id
, MKV_A_WAVPACK
))
1351 track
->a_formattag
= mmioFOURCC('W', 'V', 'P', 'K');
1352 else if (!strcmp(track
->codec_id
, MKV_A_TRUEHD
))
1353 track
->a_formattag
= mmioFOURCC('T', 'R', 'H', 'D');
1354 else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)) {
1355 if (track
->private_data
== NULL
|| track
->private_size
== 0) {
1356 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
1357 "[mkv] FLAC track does not contain valid headers.\n");
1360 track
->a_formattag
= mmioFOURCC('f', 'L', 'a', 'C');
1361 } else if (track
->private_size
>= RAPROPERTIES4_SIZE
) {
1362 if (!strcmp(track
->codec_id
, MKV_A_REAL28
))
1363 track
->a_formattag
= mmioFOURCC('2', '8', '_', '8');
1364 else if (!strcmp(track
->codec_id
, MKV_A_REALATRC
))
1365 track
->a_formattag
= mmioFOURCC('a', 't', 'r', 'c');
1366 else if (!strcmp(track
->codec_id
, MKV_A_REALCOOK
))
1367 track
->a_formattag
= mmioFOURCC('c', 'o', 'o', 'k');
1368 else if (!strcmp(track
->codec_id
, MKV_A_REALDNET
))
1369 track
->a_formattag
= mmioFOURCC('d', 'n', 'e', 't');
1370 else if (!strcmp(track
->codec_id
, MKV_A_REALSIPR
))
1371 track
->a_formattag
= mmioFOURCC('s', 'i', 'p', 'r');
1373 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Unknown/unsupported audio "
1374 "codec ID '%s' for track %u or missing/faulty\n[mkv] "
1375 "private codec data.\n", track
->codec_id
, track
->tnum
);
1376 free_sh_audio(demuxer
, track
->id
);
1381 sh_a
->format
= track
->a_formattag
;
1382 sh_a
->wf
->wFormatTag
= track
->a_formattag
;
1383 sh_a
->channels
= track
->a_channels
;
1384 sh_a
->wf
->nChannels
= track
->a_channels
;
1385 sh_a
->samplerate
= (uint32_t) track
->a_sfreq
;
1386 sh_a
->container_out_samplerate
= track
->a_osfreq
;
1387 sh_a
->wf
->nSamplesPerSec
= (uint32_t) track
->a_sfreq
;
1388 if (track
->a_bps
== 0) {
1389 sh_a
->samplesize
= 2;
1390 sh_a
->wf
->wBitsPerSample
= 16;
1392 sh_a
->samplesize
= track
->a_bps
/ 8;
1393 sh_a
->wf
->wBitsPerSample
= track
->a_bps
;
1395 if (track
->a_formattag
== 0x0055) { /* MP3 || MP2 */
1396 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1397 sh_a
->wf
->nBlockAlign
= 1152;
1398 } else if ((track
->a_formattag
== 0x2000) /* AC3 */
1399 || track
->a_formattag
== mmioFOURCC('E', 'A', 'C', '3')
1400 || (track
->a_formattag
== 0x2001)) { /* DTS */
1403 } else if (track
->a_formattag
== 0x0001) { /* PCM || PCM_BE */
1404 sh_a
->wf
->nAvgBytesPerSec
= sh_a
->channels
* sh_a
->samplerate
* 2;
1405 sh_a
->wf
->nBlockAlign
= sh_a
->wf
->nAvgBytesPerSec
;
1406 if (!strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1407 sh_a
->format
= mmioFOURCC('t', 'w', 'o', 's');
1408 } else if (!strcmp(track
->codec_id
, MKV_A_QDMC
)
1409 || !strcmp(track
->codec_id
, MKV_A_QDMC2
)) {
1410 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1411 sh_a
->wf
->nBlockAlign
= 1486;
1412 track
->fix_i_bps
= 1;
1413 track
->qt_last_a_pts
= 0.0;
1414 if (track
->private_data
!= NULL
) {
1415 sh_a
->codecdata
= malloc(track
->private_size
);
1416 memcpy(sh_a
->codecdata
, track
->private_data
, track
->private_size
);
1417 sh_a
->codecdata_len
= track
->private_size
;
1419 } else if (track
->a_formattag
== mmioFOURCC('M', 'P', '4', 'A')) {
1420 int profile
, srate_idx
;
1422 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1423 sh_a
->wf
->nBlockAlign
= 1024;
1425 if (!strcmp(track
->codec_id
, MKV_A_AAC
)
1426 && (NULL
!= track
->private_data
)) {
1427 sh_a
->codecdata
= malloc(track
->private_size
);
1428 memcpy(sh_a
->codecdata
, track
->private_data
, track
->private_size
);
1429 sh_a
->codecdata_len
= track
->private_size
;
1433 /* Recreate the 'private data' */
1434 /* which faad2 uses in its initialization */
1435 srate_idx
= aac_get_sample_rate_index(sh_a
->samplerate
);
1436 if (!strncmp(&track
->codec_id
[12], "MAIN", 4))
1438 else if (!strncmp(&track
->codec_id
[12], "LC", 2))
1440 else if (!strncmp(&track
->codec_id
[12], "SSR", 3))
1444 sh_a
->codecdata
= malloc(5);
1445 sh_a
->codecdata
[0] = ((profile
+ 1) << 3) | ((srate_idx
& 0xE) >> 1);
1446 sh_a
->codecdata
[1] =
1447 ((srate_idx
& 0x1) << 7) | (track
->a_channels
<< 3);
1449 if (strstr(track
->codec_id
, "SBR") != NULL
) {
1450 /* HE-AAC (aka SBR AAC) */
1451 sh_a
->codecdata_len
= 5;
1453 sh_a
->samplerate
*= 2;
1454 sh_a
->wf
->nSamplesPerSec
*= 2;
1455 srate_idx
= aac_get_sample_rate_index(sh_a
->samplerate
);
1456 sh_a
->codecdata
[2] = AAC_SYNC_EXTENSION_TYPE
>> 3;
1457 sh_a
->codecdata
[3] = ((AAC_SYNC_EXTENSION_TYPE
& 0x07) << 5) | 5;
1458 sh_a
->codecdata
[4] = (1 << 7) | (srate_idx
<< 3);
1459 track
->default_duration
= 1024.0 / (sh_a
->samplerate
/ 2);
1461 sh_a
->codecdata_len
= 2;
1462 track
->default_duration
= 1024.0 / sh_a
->samplerate
;
1464 } else if (track
->a_formattag
== mmioFOURCC('v', 'r', 'b', 's')) { /* VORBIS */
1465 sh_a
->wf
->cbSize
= track
->private_size
;
1466 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(*sh_a
->wf
) + sh_a
->wf
->cbSize
);
1467 memcpy((unsigned char *) (sh_a
->wf
+ 1), track
->private_data
,
1469 } else if (track
->private_size
>= RAPROPERTIES4_SIZE
1470 && !strncmp(track
->codec_id
, MKV_A_REALATRC
, 7)) {
1471 /* Common initialization for all RealAudio codecs */
1472 unsigned char *src
= track
->private_data
;
1473 int codecdata_length
, version
;
1476 sh_a
->wf
->nAvgBytesPerSec
= 0; /* FIXME !? */
1478 version
= AV_RB16(src
+ 4);
1479 flavor
= AV_RB16(src
+ 22);
1480 track
->coded_framesize
= AV_RB32(src
+ 24);
1481 track
->sub_packet_h
= AV_RB16(src
+ 40);
1482 sh_a
->wf
->nBlockAlign
= track
->audiopk_size
= AV_RB16(src
+ 42);
1483 track
->sub_packet_size
= AV_RB16(src
+ 44);
1485 src
+= RAPROPERTIES4_SIZE
;
1489 src
+= RAPROPERTIES5_SIZE
;
1494 codecdata_length
= AV_RB32(src
);
1496 sh_a
->wf
->cbSize
= codecdata_length
;
1497 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(*sh_a
->wf
) + sh_a
->wf
->cbSize
);
1498 memcpy(((char *) (sh_a
->wf
+ 1)), src
, codecdata_length
);
1500 switch (track
->a_formattag
) {
1501 case mmioFOURCC('a', 't', 'r', 'c'):
1502 sh_a
->wf
->nAvgBytesPerSec
= atrc_fl2bps
[flavor
];
1503 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1505 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1506 track
->audio_timestamp
=
1507 malloc(track
->sub_packet_h
* sizeof(double));
1509 case mmioFOURCC('c', 'o', 'o', 'k'):
1510 sh_a
->wf
->nAvgBytesPerSec
= cook_fl2bps
[flavor
];
1511 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1513 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1514 track
->audio_timestamp
=
1515 malloc(track
->sub_packet_h
* sizeof(double));
1517 case mmioFOURCC('s', 'i', 'p', 'r'):
1518 sh_a
->wf
->nAvgBytesPerSec
= sipr_fl2bps
[flavor
];
1519 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));
1525 case mmioFOURCC('2', '8', '_', '8'):
1526 sh_a
->wf
->nAvgBytesPerSec
= 3600;
1527 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1529 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1530 track
->audio_timestamp
=
1531 malloc(track
->sub_packet_h
* sizeof(double));
1535 track
->realmedia
= 1;
1536 } else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)
1537 || (track
->a_formattag
== 0xf1ac)) {
1543 if (track
->a_formattag
== mmioFOURCC('f', 'L', 'a', 'C')) {
1544 ptr
= track
->private_data
;
1545 size
= track
->private_size
;
1547 sh_a
->format
= mmioFOURCC('f', 'L', 'a', 'C');
1548 ptr
= track
->private_data
+ sizeof(*sh_a
->wf
);
1549 size
= track
->private_size
- sizeof(*sh_a
->wf
);
1551 if (size
< 4 || ptr
[0] != 'f' || ptr
[1] != 'L' || ptr
[2] != 'a'
1553 sh_a
->codecdata
= malloc(4);
1554 sh_a
->codecdata_len
= 4;
1555 memcpy(sh_a
->codecdata
, "fLaC", 4);
1557 sh_a
->codecdata
= malloc(size
);
1558 sh_a
->codecdata_len
= size
;
1559 memcpy(sh_a
->codecdata
, ptr
, size
);
1561 } else if (track
->a_formattag
== mmioFOURCC('W', 'V', 'P', 'K') || track
->a_formattag
== mmioFOURCC('T', 'R', 'H', 'D')) { /* do nothing, still works */
1562 } else if (!track
->ms_compat
1563 || (track
->private_size
< sizeof(*sh_a
->wf
))) {
1564 free_sh_audio(demuxer
, track
->id
);
1571 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1574 if (track
->subtitle_type
) {
1577 sh_sub_t
*sh
= new_sh_sub(demuxer
, sid
);
1579 sh
->type
= track
->subtitle_type
;
1580 size
= track
->private_size
;
1581 demux_mkv_decode(track
, track
->private_data
, &buffer
, &size
, 2);
1582 if (buffer
&& buffer
!= track
->private_data
) {
1583 talloc_free(track
->private_data
);
1584 talloc_steal(track
, buffer
);
1585 track
->private_data
= buffer
;
1586 track
->private_size
= size
;
1588 sh
->extradata
= malloc(track
->private_size
);
1589 memcpy(sh
->extradata
, track
->private_data
, track
->private_size
);
1590 sh
->extradata_len
= track
->private_size
;
1591 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
1592 sh
->lang
= talloc_strdup(sh
, track
->language
);
1593 sh
->title
= talloc_strdup(sh
, track
->name
);
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 demuxer
->audio
->id
= -2; // wait for higher-level code to select track
1721 if (s
->end_pos
== 0)
1722 demuxer
->seekable
= 0;
1724 demuxer
->movi_start
= s
->start_pos
;
1725 demuxer
->movi_end
= s
->end_pos
;
1726 demuxer
->seekable
= 1;
1729 demuxer
->accurate_seek
= true;
1731 return DEMUXER_TYPE_MATROSKA
;
1734 static void demux_close_mkv(demuxer_t
*demuxer
)
1736 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1740 if (mkv_d
->tracks
) {
1741 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1742 demux_mkv_free_trackentry(mkv_d
->tracks
[i
]);
1744 free(mkv_d
->indexes
);
1745 free(mkv_d
->cluster_positions
);
1749 static int demux_mkv_read_block_lacing(uint8_t *buffer
, uint64_t *size
,
1751 uint32_t **all_lace_sizes
)
1754 uint32_t *lace_size
= NULL
;
1758 *all_lace_sizes
= NULL
;
1765 switch ((flags
& 0x06) >> 1) {
1766 case 0: /* no lacing */
1768 lace_size
= calloc(*laces
, sizeof(uint32_t));
1769 lace_size
[0] = *size
;
1772 case 1: /* xiph lacing */
1773 case 2: /* fixed-size lacing */
1774 case 3: /* EBML lacing */
1780 lace_size
= calloc(*laces
, sizeof(uint32_t));
1782 switch ((flags
& 0x06) >> 1) {
1783 case 1: /* xiph lacing */
1784 for (i
= 0; i
< *laces
- 1; i
++) {
1789 lace_size
[i
] += *buffer
;
1791 } while (*buffer
++ == 0xFF);
1792 if (lace_size
[i
] > *size
- total
|| total
> *size
)
1794 total
+= lace_size
[i
];
1796 lace_size
[i
] = *size
- total
;
1799 case 2: /* fixed-size lacing */
1800 for (i
= 0; i
< *laces
; i
++)
1801 lace_size
[i
] = *size
/ *laces
;
1804 case 3:; /* EBML lacing */
1806 uint64_t num
= ebml_read_vlen_uint(buffer
, &l
);
1807 if (num
== EBML_UINT_INVALID
)
1816 total
= lace_size
[0] = num
;
1817 for (i
= 1; i
< *laces
- 1; i
++) {
1818 int64_t snum
= ebml_read_vlen_int(buffer
, &l
);
1819 if (snum
== EBML_INT_INVALID
)
1825 lace_size
[i
] = lace_size
[i
- 1] + snum
;
1826 if (lace_size
[i
] > *size
- total
|| total
> *size
)
1828 total
+= lace_size
[i
];
1830 lace_size
[i
] = *size
- total
;
1835 *all_lace_sizes
= lace_size
;
1840 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Bad input [lacing]\n");
1844 static void handle_realvideo(demuxer_t
*demuxer
, mkv_track_t
*track
,
1845 uint8_t *buffer
, uint32_t size
, int64_t block_bref
)
1847 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1849 uint32_t timestamp
= mkv_d
->last_pts
* 1000;
1851 dp
= new_demux_packet(size
);
1852 memcpy(dp
->buffer
, buffer
, size
);
1854 if (mkv_d
->v_skip_to_keyframe
) {
1855 dp
->pts
= mkv_d
->last_pts
;
1856 track
->rv_kf_base
= 0;
1857 track
->rv_kf_pts
= timestamp
;
1860 real_fix_timestamp(dp
->buffer
, timestamp
,
1861 ((sh_video_t
*) demuxer
->video
->sh
)->bih
->
1862 biCompression
, &track
->rv_kf_base
,
1863 &track
->rv_kf_pts
, NULL
);
1864 dp
->pos
= demuxer
->filepos
;
1865 dp
->flags
= block_bref
? 0 : 0x10;
1867 ds_add_packet(demuxer
->video
, dp
);
1870 static void handle_realaudio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1871 uint8_t *buffer
, uint32_t size
, int64_t block_bref
)
1873 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1874 int sps
= track
->sub_packet_size
;
1875 int sph
= track
->sub_packet_h
;
1876 int cfs
= track
->coded_framesize
;
1877 int w
= track
->audiopk_size
;
1878 int spc
= track
->sub_packet_cnt
;
1882 if ((track
->a_formattag
== mmioFOURCC('2', '8', '_', '8'))
1883 || (track
->a_formattag
== mmioFOURCC('c', 'o', 'o', 'k'))
1884 || (track
->a_formattag
== mmioFOURCC('a', 't', 'r', 'c'))
1885 || (track
->a_formattag
== mmioFOURCC('s', 'i', 'p', 'r'))) {
1887 // spc = track->sub_packet_cnt = 0;
1888 switch (track
->a_formattag
) {
1889 case mmioFOURCC('2', '8', '_', '8'):
1890 for (x
= 0; x
< sph
/ 2; x
++)
1891 memcpy(track
->audio_buf
+ x
* 2 * w
+ spc
* cfs
,
1892 buffer
+ cfs
* x
, cfs
);
1894 case mmioFOURCC('c', 'o', 'o', 'k'):
1895 case mmioFOURCC('a', 't', 'r', 'c'):
1896 for (x
= 0; x
< w
/ sps
; x
++)
1897 memcpy(track
->audio_buf
+
1898 sps
* (sph
* x
+ ((sph
+ 1) / 2) * (spc
& 1) +
1899 (spc
>> 1)), buffer
+ sps
* x
, sps
);
1901 case mmioFOURCC('s', 'i', 'p', 'r'):
1902 memcpy(track
->audio_buf
+ spc
* w
, buffer
, w
);
1903 if (spc
== sph
- 1) {
1905 int bs
= sph
* w
* 2 / 96; // nibbles per subpacket
1906 // Perform reordering
1907 for (n
= 0; n
< 38; n
++) {
1909 int i
= bs
* sipr_swaps
[n
][0];
1910 int o
= bs
* sipr_swaps
[n
][1];
1911 // swap nibbles of block 'i' with 'o' TODO: optimize
1912 for (j
= 0; j
< bs
; j
++) {
1914 (track
->audio_buf
[i
>> 1] >> 4) :
1915 (track
->audio_buf
[i
>> 1] & 0x0F);
1917 (track
->audio_buf
[o
>> 1] >> 4) :
1918 (track
->audio_buf
[o
>> 1] & 0x0F);
1920 track
->audio_buf
[o
>> 1] =
1921 (track
->audio_buf
[o
>> 1] & 0x0F) | (x
<< 4);
1923 track
->audio_buf
[o
>> 1] =
1924 (track
->audio_buf
[o
>> 1] & 0xF0) | x
;
1926 track
->audio_buf
[i
>> 1] =
1927 (track
->audio_buf
[i
>> 1] & 0x0F) | (y
<< 4);
1929 track
->audio_buf
[i
>> 1] =
1930 (track
->audio_buf
[i
>> 1] & 0xF0) | y
;
1938 track
->audio_timestamp
[track
->sub_packet_cnt
] =
1939 (track
->ra_pts
== mkv_d
->last_pts
) ? 0 : (mkv_d
->last_pts
);
1940 track
->ra_pts
= mkv_d
->last_pts
;
1941 if (track
->sub_packet_cnt
== 0)
1942 track
->audio_filepos
= demuxer
->filepos
;
1943 if (++(track
->sub_packet_cnt
) == sph
) {
1945 ((sh_audio_t
*) demuxer
->audio
->sh
)->wf
->nBlockAlign
;
1946 track
->sub_packet_cnt
= 0;
1947 // Release all the audio packets
1948 for (x
= 0; x
< sph
* w
/ apk_usize
; x
++) {
1949 dp
= new_demux_packet(apk_usize
);
1950 memcpy(dp
->buffer
, track
->audio_buf
+ x
* apk_usize
,
1952 /* Put timestamp only on packets that correspond to original
1953 * audio packets in file */
1954 dp
->pts
= (x
* apk_usize
% w
) ? 0 :
1955 track
->audio_timestamp
[x
* apk_usize
/ w
];
1956 dp
->pos
= track
->audio_filepos
; // all equal
1957 dp
->flags
= x
? 0 : 0x10; // Mark first packet as keyframe
1958 ds_add_packet(demuxer
->audio
, dp
);
1961 } else { // Not a codec that require reordering
1962 dp
= new_demux_packet(size
);
1963 memcpy(dp
->buffer
, buffer
, size
);
1964 if (track
->ra_pts
== mkv_d
->last_pts
&& !mkv_d
->a_skip_to_keyframe
)
1967 dp
->pts
= mkv_d
->last_pts
;
1968 track
->ra_pts
= mkv_d
->last_pts
;
1970 dp
->pos
= demuxer
->filepos
;
1971 dp
->flags
= block_bref
? 0 : 0x10;
1972 ds_add_packet(demuxer
->audio
, dp
);
1976 static int handle_block(demuxer_t
*demuxer
, uint8_t *block
, uint64_t length
,
1977 uint64_t block_duration
, int64_t block_bref
,
1978 int64_t block_fref
, uint8_t simpleblock
)
1980 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1981 mkv_track_t
*track
= NULL
;
1982 demux_stream_t
*ds
= NULL
;
1983 uint64_t old_length
;
1985 uint32_t *lace_size
;
1986 uint8_t laces
, flags
;
1987 int i
, num
, tmp
, use_this_block
= 1;
1991 /* first byte(s): track num */
1992 num
= ebml_read_vlen_uint(block
, &tmp
);
1994 /* time (relative to cluster time) */
1995 time
= block
[0] << 8 | block
[1];
1998 old_length
= length
;
2000 if (demux_mkv_read_block_lacing(block
, &length
, &laces
, &lace_size
))
2002 block
+= old_length
- length
;
2004 tc
= time
* mkv_d
->tc_scale
+ mkv_d
->cluster_tc
;
2005 current_pts
= tc
/ 1e9
;
2007 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2008 if (mkv_d
->tracks
[i
]->tnum
== num
) {
2009 track
= mkv_d
->tracks
[i
];
2012 if (track
== NULL
) {
2016 if (track
->type
== MATROSKA_TRACK_AUDIO
2017 && track
->id
== demuxer
->audio
->id
) {
2018 ds
= demuxer
->audio
;
2020 if (mkv_d
->a_skip_to_keyframe
) {
2022 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2024 } else if (block_bref
!= 0)
2027 if (mkv_d
->v_skip_to_keyframe
)
2030 if (track
->fix_i_bps
&& use_this_block
) {
2031 sh_audio_t
*sh
= (sh_audio_t
*) ds
->sh
;
2033 if (block_duration
!= 0) {
2034 sh
->i_bps
= length
* 1e9
/ block_duration
;
2035 track
->fix_i_bps
= 0;
2036 } else if (track
->qt_last_a_pts
== 0.0)
2037 track
->qt_last_a_pts
= current_pts
;
2038 else if (track
->qt_last_a_pts
!= current_pts
) {
2039 sh
->i_bps
= length
/ (current_pts
- track
->qt_last_a_pts
);
2040 track
->fix_i_bps
= 0;
2043 } else if (tc
< mkv_d
->skip_to_timecode
)
2045 else if (track
->type
== MATROSKA_TRACK_VIDEO
2046 && track
->id
== demuxer
->video
->id
) {
2047 ds
= demuxer
->video
;
2048 if (mkv_d
->v_skip_to_keyframe
) {
2050 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2052 } else if (block_bref
!= 0 || block_fref
!= 0)
2055 } else if (track
->type
== MATROSKA_TRACK_SUBTITLE
2056 && track
->id
== demuxer
->sub
->id
) {
2059 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Subtitles use Matroska "
2060 "lacing. This is abnormal and not supported.\n");
2063 sub_utf8
= 1; // XXX this variable should be eventually removed
2067 if (use_this_block
) {
2068 mkv_d
->last_pts
= current_pts
;
2069 mkv_d
->last_filepos
= demuxer
->filepos
;
2071 for (i
= 0; i
< laces
; i
++) {
2072 if (ds
== demuxer
->video
&& track
->realmedia
)
2073 handle_realvideo(demuxer
, track
, block
, lace_size
[i
],
2075 else if (ds
== demuxer
->audio
&& track
->realmedia
)
2076 handle_realaudio(demuxer
, track
, block
, lace_size
[i
],
2079 int size
= lace_size
[i
];
2082 demux_mkv_decode(track
, block
, &buffer
, &size
, 1);
2084 dp
= new_demux_packet(size
);
2085 memcpy(dp
->buffer
, buffer
, size
);
2086 if (buffer
!= block
)
2087 talloc_free(buffer
);
2088 dp
->flags
= (block_bref
== 0
2089 && block_fref
== 0) ? 0x10 : 0;
2090 /* If default_duration is 0, assume no pts value is known
2091 * for packets after the first one (rather than all pts
2092 * values being the same) */
2093 if (i
== 0 || track
->default_duration
)
2095 mkv_d
->last_pts
+ i
* track
->default_duration
;
2096 dp
->duration
= block_duration
/ 1e9
;
2097 ds_add_packet(ds
, dp
);
2100 block
+= lace_size
[i
];
2103 if (ds
== demuxer
->video
) {
2104 mkv_d
->v_skip_to_keyframe
= 0;
2105 mkv_d
->skip_to_timecode
= 0;
2106 } else if (ds
== demuxer
->audio
)
2107 mkv_d
->a_skip_to_keyframe
= 0;
2117 static int demux_mkv_fill_buffer(demuxer_t
*demuxer
, demux_stream_t
*ds
)
2119 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2120 stream_t
*s
= demuxer
->stream
;
2125 while (mkv_d
->cluster_size
> 0) {
2126 uint64_t block_duration
= 0, block_length
= 0;
2127 int64_t block_bref
= 0, block_fref
= 0;
2128 uint8_t *block
= NULL
;
2130 while (mkv_d
->blockgroup_size
> 0) {
2131 switch (ebml_read_id(s
, &il
)) {
2132 case MATROSKA_ID_BLOCKDURATION
:
2133 block_duration
= ebml_read_uint(s
, &l
);
2134 if (block_duration
== EBML_UINT_INVALID
) {
2138 block_duration
*= mkv_d
->tc_scale
;
2141 case MATROSKA_ID_BLOCK
:
2142 block_length
= ebml_read_length(s
, &tmp
);
2144 if (block_length
> 500000000)
2146 block
= malloc(block_length
+ AV_LZO_INPUT_PADDING
);
2147 demuxer
->filepos
= stream_tell(s
);
2148 if (stream_read(s
, block
, block_length
) !=
2149 (int) block_length
) {
2153 l
= tmp
+ block_length
;
2156 case MATROSKA_ID_REFERENCEBLOCK
:;
2157 int64_t num
= ebml_read_int(s
, &l
);
2158 if (num
== EBML_INT_INVALID
) {
2168 case EBML_ID_INVALID
:
2173 ebml_read_skip(s
, &l
);
2176 mkv_d
->blockgroup_size
-= l
+ il
;
2177 mkv_d
->cluster_size
-= l
+ il
;
2181 int res
= handle_block(demuxer
, block
, block_length
,
2182 block_duration
, block_bref
, block_fref
,
2191 if (mkv_d
->cluster_size
> 0) {
2192 switch (ebml_read_id(s
, &il
)) {
2193 case MATROSKA_ID_TIMECODE
:;
2194 uint64_t num
= ebml_read_uint(s
, &l
);
2195 if (num
== EBML_UINT_INVALID
)
2197 mkv_d
->cluster_tc
= num
* mkv_d
->tc_scale
;
2198 add_cluster_position(mkv_d
, mkv_d
->cluster_start
,
2202 case MATROSKA_ID_BLOCKGROUP
:
2203 mkv_d
->blockgroup_size
= ebml_read_length(s
, &tmp
);
2207 case MATROSKA_ID_SIMPLEBLOCK
:;
2209 block_length
= ebml_read_length(s
, &tmp
);
2210 if (block_length
> 500000000)
2212 block
= malloc(block_length
);
2213 demuxer
->filepos
= stream_tell(s
);
2214 if (stream_read(s
, block
, block_length
) !=
2215 (int) block_length
) {
2219 l
= tmp
+ block_length
;
2220 res
= handle_block(demuxer
, block
, block_length
,
2221 block_duration
, block_bref
,
2224 mkv_d
->cluster_size
-= l
+ il
;
2230 mkv_d
->cluster_size
+= l
+ il
;
2233 case EBML_ID_INVALID
:
2237 ebml_read_skip(s
, &l
);
2240 mkv_d
->cluster_size
-= l
+ il
;
2244 while (ebml_read_id(s
, &il
) != MATROSKA_ID_CLUSTER
) {
2245 ebml_read_skip(s
, NULL
);
2249 mkv_d
->cluster_start
= stream_tell(s
) - il
;
2250 mkv_d
->cluster_size
= ebml_read_length(s
, NULL
);
2256 static int seek_creating_index(struct demuxer
*demuxer
, float rel_seek_secs
,
2259 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
2260 struct stream
*s
= demuxer
->stream
;
2261 int64_t target_tc_ns
= (int64_t) (rel_seek_secs
* 1e9
);
2262 if (target_tc_ns
< 0)
2264 uint64_t max_filepos
= 0;
2265 int64_t max_tc
= -1;
2266 int n
= mkv_d
->num_cluster_pos
;
2268 max_filepos
= mkv_d
->cluster_positions
[n
- 1].filepos
;
2269 max_tc
= mkv_d
->cluster_positions
[n
- 1].timecode
;
2272 if (target_tc_ns
> max_tc
) {
2273 if ((off_t
) max_filepos
> stream_tell(s
))
2274 stream_seek(s
, max_filepos
);
2276 stream_seek(s
, stream_tell(s
) + mkv_d
->cluster_size
);
2277 /* parse all the clusters upto target_filepos */
2279 uint64_t start
= stream_tell(s
);
2280 uint32_t type
= ebml_read_id(s
, NULL
);
2281 uint64_t len
= ebml_read_length(s
, NULL
);
2282 uint64_t end
= stream_tell(s
) + len
;
2283 if (type
== MATROSKA_ID_CLUSTER
) {
2284 while (!s
->eof
&& stream_tell(s
) < end
) {
2285 if (ebml_read_id(s
, NULL
) == MATROSKA_ID_TIMECODE
) {
2286 uint64_t tc
= ebml_read_uint(s
, NULL
);
2287 tc
*= mkv_d
->tc_scale
;
2288 add_cluster_position(mkv_d
, start
, tc
);
2289 if (tc
>= target_tc_ns
)
2297 stream_seek(s
, end
);
2303 if (!mkv_d
->num_cluster_pos
) {
2304 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] no target for seek found\n");
2307 uint64_t cluster_pos
= mkv_d
->cluster_positions
[0].filepos
;
2308 /* Let's find the nearest cluster */
2309 int64_t min_diff
= 0xFFFFFFFFFFFFFFF;
2310 for (int i
= 0; i
< mkv_d
->num_cluster_pos
; i
++) {
2311 int64_t diff
= mkv_d
->cluster_positions
[i
].timecode
- target_tc_ns
;
2312 if (flags
& SEEK_BACKWARD
&& diff
< 0 && -diff
< min_diff
) {
2313 cluster_pos
= mkv_d
->cluster_positions
[i
].filepos
;
2315 } else if (flags
& SEEK_FORWARD
2316 && (diff
< 0 ? -1 * diff
: diff
) < min_diff
) {
2317 cluster_pos
= mkv_d
->cluster_positions
[i
].filepos
;
2318 min_diff
= diff
< 0 ? -1 * diff
: diff
;
2321 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2322 stream_seek(s
, cluster_pos
);
2326 static struct mkv_index
*seek_with_cues(struct demuxer
*demuxer
, int seek_id
,
2327 int64_t target_timecode
, int flags
)
2329 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
2330 struct mkv_index
*index
= NULL
;
2332 /* Find the entry in the index closest to the target timecode in the
2333 * give direction. If there are no such entries - we're trying to seek
2334 * backward from a target time before the first entry or forward from a
2335 * target time after the last entry - then still seek to the first/last
2336 * entry if that's further in the direction wanted than mkv_d->last_pts.
2338 int64_t min_diff
= target_timecode
- (int64_t)(mkv_d
->last_pts
* 1e9
+ 0.5);
2339 if (flags
& SEEK_BACKWARD
)
2340 min_diff
= -min_diff
;
2341 min_diff
= FFMAX(min_diff
, 1);
2342 for (int i
= 0; i
< mkv_d
->num_indexes
; i
++)
2343 if (seek_id
< 0 || mkv_d
->indexes
[i
].tnum
== seek_id
) {
2346 (int64_t) (mkv_d
->indexes
[i
].timecode
* mkv_d
->tc_scale
);
2347 if (flags
& SEEK_BACKWARD
)
2350 if (min_diff
<= 0 && diff
<= min_diff
)
2352 } else if (diff
>= min_diff
)
2355 index
= mkv_d
->indexes
+ i
;
2358 if (index
) { /* We've found an entry. */
2359 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2360 stream_seek(demuxer
->stream
, index
->filepos
);
2365 static void demux_mkv_seek(demuxer_t
*demuxer
, float rel_seek_secs
,
2366 float audio_delay
, int flags
)
2368 mkv_demuxer_t
*mkv_d
= demuxer
->priv
;
2369 uint64_t v_tnum
= -1;
2370 if (demuxer
->video
->id
>= 0)
2371 v_tnum
= find_track_by_num(mkv_d
, demuxer
->video
->id
,
2372 MATROSKA_TRACK_VIDEO
)->tnum
;
2373 uint64_t a_tnum
= -1;
2374 if (demuxer
->audio
->id
>= 0)
2375 a_tnum
= find_track_by_num(mkv_d
, demuxer
->audio
->id
,
2376 MATROSKA_TRACK_AUDIO
)->tnum
;
2377 if (!(flags
& (SEEK_BACKWARD
| SEEK_FORWARD
))) {
2378 if (flags
& SEEK_ABSOLUTE
|| rel_seek_secs
< 0)
2379 flags
|= SEEK_BACKWARD
;
2381 flags
|= SEEK_FORWARD
;
2383 // Adjust the target a little bit to catch cases where the target position
2384 // specifies a keyframe with high, but not perfect, precision.
2385 rel_seek_secs
+= flags
& SEEK_FORWARD
? -0.005 : 0.005;
2387 if (!(flags
& SEEK_FACTOR
)) { /* time in secs */
2388 mkv_index_t
*index
= NULL
;
2390 if (!(flags
& SEEK_ABSOLUTE
)) /* relative seek */
2391 rel_seek_secs
+= mkv_d
->last_pts
;
2392 rel_seek_secs
= FFMAX(rel_seek_secs
, 0);
2393 int64_t target_timecode
= rel_seek_secs
* 1e9
+ 0.5;
2395 if (mkv_d
->indexes
== NULL
) { /* no index was found */
2396 if (seek_creating_index(demuxer
, rel_seek_secs
, flags
) < 0)
2399 int seek_id
= (demuxer
->video
->id
< 0) ?
2401 index
= seek_with_cues(demuxer
, seek_id
, target_timecode
, flags
);
2403 index
= seek_with_cues(demuxer
, -1, target_timecode
, flags
);
2406 if (demuxer
->video
->id
>= 0)
2407 mkv_d
->v_skip_to_keyframe
= 1;
2408 if (flags
& SEEK_FORWARD
)
2409 mkv_d
->skip_to_timecode
= target_timecode
;
2411 mkv_d
->skip_to_timecode
= index
? index
->timecode
* mkv_d
->tc_scale
2413 mkv_d
->a_skip_to_keyframe
= 1;
2415 demux_mkv_fill_buffer(demuxer
, NULL
);
2416 } else if ((demuxer
->movi_end
<= 0) || !(flags
& SEEK_ABSOLUTE
))
2417 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
2419 stream_t
*s
= demuxer
->stream
;
2420 uint64_t target_filepos
;
2421 mkv_index_t
*index
= NULL
;
2424 if (mkv_d
->indexes
== NULL
) { /* not implemented without index */
2425 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
2429 target_filepos
= (uint64_t) (demuxer
->movi_end
* rel_seek_secs
);
2430 for (i
= 0; i
< mkv_d
->num_indexes
; i
++)
2431 if (mkv_d
->indexes
[i
].tnum
== v_tnum
)
2433 || ((mkv_d
->indexes
[i
].filepos
>= target_filepos
)
2434 && ((index
->filepos
< target_filepos
)
2435 || (mkv_d
->indexes
[i
].filepos
< index
->filepos
))))
2436 index
= &mkv_d
->indexes
[i
];
2441 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2442 stream_seek(s
, index
->filepos
);
2444 if (demuxer
->video
->id
>= 0)
2445 mkv_d
->v_skip_to_keyframe
= 1;
2446 mkv_d
->skip_to_timecode
= index
->timecode
* mkv_d
->tc_scale
;
2447 mkv_d
->a_skip_to_keyframe
= 1;
2449 demux_mkv_fill_buffer(demuxer
, NULL
);
2453 static int demux_mkv_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
2455 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2458 case DEMUXER_CTRL_CORRECT_PTS
:
2459 return DEMUXER_CTRL_OK
;
2460 case DEMUXER_CTRL_GET_TIME_LENGTH
:
2461 if (mkv_d
->duration
== 0)
2462 return DEMUXER_CTRL_DONTKNOW
;
2464 *((double *) arg
) = (double) mkv_d
->duration
;
2465 return DEMUXER_CTRL_OK
;
2467 case DEMUXER_CTRL_GET_PERCENT_POS
:
2468 if (mkv_d
->duration
== 0) {
2469 return DEMUXER_CTRL_DONTKNOW
;
2472 *((int *) arg
) = (int) (100 * mkv_d
->last_pts
/ mkv_d
->duration
);
2473 return DEMUXER_CTRL_OK
;
2475 case DEMUXER_CTRL_SWITCH_AUDIO
:;
2476 int new_aid
= *(int *) arg
;
2477 int current_aid
= demuxer
->audio
->id
;
2478 if (current_aid
< 0)
2480 if (new_aid
== -1) // cycle to next
2481 new_aid
= (current_aid
+ 2) % (mkv_d
->num_audio_tracks
+ 1) - 1;
2482 if (new_aid
< 0 || new_aid
>= mkv_d
->num_audio_tracks
)
2484 *(int *) arg
= new_aid
;
2485 if (current_aid
!= new_aid
)
2486 ds_free_packs(demuxer
->audio
);
2487 demuxer
->audio
->id
= new_aid
;
2488 return DEMUXER_CTRL_OK
;
2490 case DEMUXER_CTRL_SWITCH_VIDEO
:;
2491 int new_vid
= *(int *) arg
;
2492 int current_vid
= demuxer
->video
->id
;
2493 if (current_vid
< 0)
2495 if (new_vid
== -1) // cycle to next
2496 new_vid
= (current_vid
+ 2) % (mkv_d
->num_video_tracks
+ 1) - 1;
2497 if (new_vid
< 0 || new_vid
>= mkv_d
->num_video_tracks
)
2499 *(int *) arg
= new_vid
;
2500 if (current_vid
!= new_vid
)
2501 ds_free_packs(demuxer
->video
);
2502 demuxer
->video
->id
= new_vid
;
2503 return DEMUXER_CTRL_OK
;
2506 return DEMUXER_CTRL_NOTIMPL
;
2510 const demuxer_desc_t demuxer_desc_matroska
= {
2516 DEMUXER_TYPE_MATROSKA
,
2517 1, // safe autodetect
2519 demux_mkv_fill_buffer
,