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.
34 #include "stream/stream.h"
39 #include "demux_real.h"
44 #include "subreader.h"
45 #include "libvo/sub.h"
49 #include "libavutil/common.h"
51 #ifdef CONFIG_QTX_CODECS
52 #include "loader/qtx/qtxsdk/components.h"
59 #include "libavutil/lzo.h"
60 #include "ffmpeg_files/intreadwrite.h"
61 #include "libavutil/avstring.h"
63 static const unsigned char sipr_swaps
[38][2] = {
64 {0,63},{1,22},{2,44},{3,90},{5,81},{7,31},{8,86},{9,58},{10,36},{12,68},
65 {13,39},{14,73},{15,53},{16,69},{17,57},{19,88},{20,34},{21,71},{24,46},
66 {25,94},{26,54},{28,75},{29,50},{32,70},{33,92},{35,74},{38,85},{40,56},
67 {42,87},{43,65},{45,59},{48,79},{49,93},{51,89},{55,95},{61,76},{67,83},
71 // Map flavour to bytes per second
72 #define SIPR_FLAVORS 4
73 #define ATRC_FLAVORS 8
74 #define COOK_FLAVORS 34
75 static const int sipr_fl2bps
[SIPR_FLAVORS
] = { 813, 1062, 625, 2000 };
76 static const int atrc_fl2bps
[ATRC_FLAVORS
] =
77 { 8269, 11714, 13092, 16538, 18260, 22050, 33075, 44100 };
78 static const int cook_fl2bps
[COOK_FLAVORS
] = {
79 1000, 1378, 2024, 2584, 4005, 5513, 8010, 4005, 750, 2498,
80 4048, 5513, 8010, 11973, 8010, 2584, 4005, 2067, 2584, 2584,
81 4005, 4005, 5513, 5513, 8010, 12059, 1550, 8010, 12059, 5513,
82 12016, 16408, 22911, 33506
85 typedef struct mkv_content_encoding
{
86 uint64_t order
, type
, scope
;
88 uint8_t *comp_settings
;
89 int comp_settings_len
;
90 } mkv_content_encoding_t
;
92 typedef struct mkv_track
{
95 int id
; // -aid / -sid / -vid option value
103 uint32_t v_width
, v_height
, v_dwidth
, v_dheight
;
106 uint32_t a_formattag
;
107 uint32_t a_channels
, a_bps
;
110 double default_duration
;
114 unsigned char *private_data
;
115 unsigned int private_size
;
117 /* stuff for realmedia */
121 double rv_pts
; /* previous video timestamp */
122 double ra_pts
; /* previous audio timestamp */
124 /** realaudio descrambling */
125 int sub_packet_size
; ///< sub packet size, per stream
126 int sub_packet_h
; ///< number of coded frames per block
127 int coded_framesize
; ///< coded frame size, per stream
128 int audiopk_size
; ///< audio packet size
129 unsigned char *audio_buf
; ///< place to store reordered audio data
130 double *audio_timestamp
; ///< timestamp for each audio packet
131 int sub_packet_cnt
; ///< number of subpacket already received
132 int audio_filepos
; ///< file position of first audio packet in block
134 /* stuff for quicktime */
136 double qt_last_a_pts
;
140 /* The timecodes of video frames might have to be reordered if they're
141 in display order (the timecodes, not the frames themselves!). In this
142 case demux packets have to be cached with the help of these variables. */
143 int reorder_timecodes
;
144 demux_packet_t
**cached_dps
;
145 int num_cached_dps
, num_allocated_dps
;
148 /* generic content encoding support */
149 mkv_content_encoding_t
*encodings
;
152 /* For VobSubs and SSA/ASS */
156 typedef struct mkv_index
{
158 uint64_t timecode
, filepos
;
161 typedef struct mkv_demuxer
{
164 double duration
, last_pts
;
165 uint64_t last_filepos
;
167 mkv_track_t
**tracks
;
170 uint64_t tc_scale
, cluster_tc
;
172 uint64_t cluster_start
;
173 uint64_t cluster_size
;
174 uint64_t blockgroup_size
;
176 mkv_index_t
*indexes
;
184 bool parsed_chapters
;
185 bool parsed_attachments
;
190 } *cluster_positions
;
193 int64_t skip_to_timecode
;
194 int v_skip_to_keyframe
, a_skip_to_keyframe
;
196 int num_audio_tracks
;
199 #define REALHEADER_SIZE 16
200 #define RVPROPERTIES_SIZE 34
201 #define RAPROPERTIES4_SIZE 56
202 #define RAPROPERTIES5_SIZE 70
205 * \brief ensures there is space for at least one additional element
206 * \param array array to grow
207 * \param nelem current number of elements in array
208 * \param elsize size of one array element
210 static void *grow_array(void *array
, int nelem
, size_t elsize
)
213 array
= realloc(array
, (nelem
+ 32) * elsize
);
217 static bool is_parsed_header(struct mkv_demuxer
*mkv_d
, off_t pos
)
220 int high
= mkv_d
->num_parsed_pos
;
221 while (high
> low
+ 1) {
222 int mid
= high
+ low
>> 1;
223 if (mkv_d
->parsed_pos
[mid
] > pos
)
228 if (mkv_d
->num_parsed_pos
&& mkv_d
->parsed_pos
[low
] == pos
)
230 if (!(mkv_d
->num_parsed_pos
& 31))
231 mkv_d
->parsed_pos
= talloc_realloc(mkv_d
, mkv_d
->parsed_pos
, off_t
,
232 mkv_d
->num_parsed_pos
+ 32);
233 mkv_d
->num_parsed_pos
++;
234 for (int i
= mkv_d
->num_parsed_pos
- 1; i
> low
; i
--)
235 mkv_d
->parsed_pos
[i
] = mkv_d
->parsed_pos
[i
- 1];
236 mkv_d
->parsed_pos
[low
] = pos
;
240 static mkv_track_t
*find_track_by_num(struct mkv_demuxer
*d
, int n
, int type
)
242 for (int i
= 0; i
< d
->num_tracks
; i
++)
243 if (d
->tracks
[i
] != NULL
&& d
->tracks
[i
]->type
== type
)
244 if (d
->tracks
[i
]->id
== n
)
250 static void add_cluster_position(mkv_demuxer_t
*mkv_d
, uint64_t filepos
,
256 int n
= mkv_d
->num_cluster_pos
;
257 if (n
> 0 && mkv_d
->cluster_positions
[n
-1].filepos
>= filepos
)
260 mkv_d
->cluster_positions
=
261 grow_array(mkv_d
->cluster_positions
, mkv_d
->num_cluster_pos
,
262 sizeof(*mkv_d
->cluster_positions
));
263 mkv_d
->cluster_positions
[mkv_d
->num_cluster_pos
++] = (struct cluster_pos
){
265 .timecode
= timecode
,
270 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
271 static int aac_get_sample_rate_index(uint32_t sample_rate
)
273 static const int srates
[] = {
274 92017, 75132, 55426, 46009, 37566, 27713,
275 23004, 18783, 13856, 11502, 9391, 0
278 while (sample_rate
< srates
[i
])
283 /** \brief Free cached demux packets
285 * Reordering the timecodes requires caching of demux packets. This function
286 * frees all these cached packets and the memory for the cached pointers
289 * \param demuxer The demuxer for which the cache is to be freed.
291 static void free_cached_dps(demuxer_t
*demuxer
)
293 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
297 for (k
= 0; k
< mkv_d
->num_tracks
; k
++) {
298 track
= mkv_d
->tracks
[k
];
299 for (i
= 0; i
< track
->num_cached_dps
; i
++)
300 free_demux_packet(track
->cached_dps
[i
]);
301 free(track
->cached_dps
);
302 track
->cached_dps
= NULL
;
303 track
->num_cached_dps
= 0;
304 track
->num_allocated_dps
= 0;
309 static void demux_mkv_decode(mkv_track_t
*track
, uint8_t *src
,
310 uint8_t **dest
, uint32_t *size
, uint32_t type
)
312 uint8_t *orig_src
= src
;
316 for (int i
= 0; i
< track
->num_encodings
; i
++) {
317 struct mkv_content_encoding
*enc
= track
->encodings
+ i
;
318 if (!(enc
->scope
& type
))
321 if (src
!= *dest
&& src
!= orig_src
)
323 src
= *dest
; // output from last iteration is new source
325 if (enc
->comp_algo
== 0) {
327 /* zlib encoded track */
334 zstream
.zalloc
= (alloc_func
) 0;
335 zstream
.zfree
= (free_func
) 0;
336 zstream
.opaque
= (voidpf
) 0;
337 if (inflateInit(&zstream
) != Z_OK
) {
338 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
339 "[mkv] zlib initialization failed.\n");
342 zstream
.next_in
= (Bytef
*) src
;
343 zstream
.avail_in
= *size
;
346 zstream
.avail_out
= *size
;
350 *dest
= talloc_realloc_size(NULL
, *dest
, *size
);
351 zstream
.next_out
= (Bytef
*) (*dest
+ zstream
.total_out
);
352 result
= inflate(&zstream
, Z_NO_FLUSH
);
353 if (result
!= Z_OK
&& result
!= Z_STREAM_END
) {
354 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
355 "[mkv] zlib decompression failed.\n");
358 inflateEnd(&zstream
);
361 zstream
.avail_out
+= 4000;
362 } while (zstream
.avail_out
== 4000 && zstream
.avail_in
!= 0
363 && result
!= Z_STREAM_END
);
365 *size
= zstream
.total_out
;
366 inflateEnd(&zstream
);
368 } else if (enc
->comp_algo
== 2) {
369 /* lzo encoded track */
370 int dstlen
= *size
* 3;
375 if (dstlen
> SIZE_MAX
- AV_LZO_OUTPUT_PADDING
)
377 *dest
= talloc_realloc_size(NULL
, *dest
,
378 dstlen
+ AV_LZO_OUTPUT_PADDING
);
379 int result
= av_lzo1x_decode(*dest
, &dstlen
, src
, &srclen
);
382 if (!(result
& AV_LZO_OUTPUT_FULL
)) {
384 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
385 "[mkv] lzo decompression failed.\n");
390 mp_msg(MSGT_DEMUX
, MSGL_DBG2
,
391 "[mkv] lzo decompression buffer too small.\n");
395 } else if (enc
->comp_algo
== 3) {
396 *dest
= talloc_size(NULL
, *size
+ enc
->comp_settings_len
);
397 memcpy(*dest
, enc
->comp_settings
, enc
->comp_settings_len
);
398 memcpy(*dest
+ enc
->comp_settings_len
, src
, *size
);
399 *size
+= enc
->comp_settings_len
;
404 if (src
!= *dest
&& src
!= orig_src
)
409 static int demux_mkv_read_info(demuxer_t
*demuxer
)
411 mkv_demuxer_t
*mkv_d
= demuxer
->priv
;
412 stream_t
*s
= demuxer
->stream
;
414 mkv_d
->tc_scale
= 1000000;
417 struct ebml_info info
= {};
418 struct ebml_parse_ctx parse_ctx
= {};
419 if (ebml_read_element(s
, &parse_ctx
, &info
, &ebml_info_desc
) < 0)
421 if (info
.n_timecode_scale
) {
422 mkv_d
->tc_scale
= info
.timecode_scale
;
423 mp_msg(MSGT_DEMUX
, MSGL_V
,
424 "[mkv] | + timecode scale: %" PRIu64
"\n", mkv_d
->tc_scale
);
426 if (info
.n_duration
) {
427 mkv_d
->duration
= info
.duration
* mkv_d
->tc_scale
/ 1e9
;
428 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + duration: %.3fs\n",
431 if (info
.n_segment_uid
) {
432 int len
= info
.segment_uid
.len
;
433 if (len
!= sizeof(demuxer
->matroska_data
.segment_uid
)) {
434 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
435 "[mkv] segment uid invalid length %d\n", len
);
437 memcpy(demuxer
->matroska_data
.segment_uid
, info
.segment_uid
.start
,
439 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + segment uid");
440 for (int i
= 0; i
< len
; i
++)
441 mp_msg(MSGT_DEMUX
, MSGL_V
, " %02x",
442 demuxer
->matroska_data
.segment_uid
[i
]);
443 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
446 talloc_free(parse_ctx
.talloc_ctx
);
450 static void parse_trackencodings(struct demuxer
*demuxer
,
451 struct mkv_track
*track
,
452 struct ebml_content_encodings
*encodings
)
454 // initial allocation to be a non-NULL context before realloc
455 mkv_content_encoding_t
*ce
= talloc_size(track
, 1);
457 for (int n_enc
= 0; n_enc
< encodings
->n_content_encoding
; n_enc
++) {
458 struct ebml_content_encoding
*enc
= encodings
->content_encoding
+ n_enc
;
459 struct mkv_content_encoding e
= {};
460 e
.order
= enc
->content_encoding_order
;
461 if (enc
->n_content_encoding_scope
)
462 e
.scope
= enc
->content_encoding_scope
;
465 e
.type
= enc
->content_encoding_type
;
467 if (enc
->n_content_compression
) {
468 struct ebml_content_compression
*z
= &enc
->content_compression
;
469 e
.comp_algo
= z
->content_comp_algo
;
470 if (z
->n_content_comp_settings
) {
471 int sz
= z
->content_comp_settings
.len
;
472 e
.comp_settings
= talloc_size(ce
, sz
);
473 memcpy(e
.comp_settings
, z
->content_comp_settings
.start
, sz
);
474 e
.comp_settings_len
= sz
;
479 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Track "
480 "number %u has been encrypted and "
481 "decryption has not yet been\n"
482 "[mkv] implemented. Skipping track.\n",
484 } else if (e
.type
!= 0) {
485 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
486 "[mkv] Unknown content encoding type for "
487 "track %u. Skipping track.\n",
489 } else if (e
.comp_algo
!= 0 && e
.comp_algo
!= 2 && e
.comp_algo
!= 3) {
490 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
491 "[mkv] Track %u has been compressed with "
492 "an unknown/unsupported compression\n"
493 "[mkv] algorithm (%" PRIu64
"). Skipping track.\n",
494 track
->tnum
, e
.comp_algo
);
497 else if (e
.comp_algo
== 0) {
498 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
499 "[mkv] Track %u was compressed with zlib "
500 "but mplayer has not been compiled\n"
501 "[mkv] with support for zlib compression. "
507 for (i
= 0; i
< n_enc
; i
++)
508 if (e
.order
>= ce
[i
].order
)
510 ce
= talloc_realloc_size(track
, ce
, (n_enc
+ 1) * sizeof(*ce
));
511 memmove(ce
+ i
+ 1, ce
+ i
, (n_enc
- i
) * sizeof(*ce
));
512 memcpy(ce
+ i
, &e
, sizeof(e
));
515 track
->encodings
= ce
;
516 track
->num_encodings
= encodings
->n_content_encoding
;
519 static void parse_trackaudio(struct demuxer
*demuxer
, struct mkv_track
*track
,
520 struct ebml_audio
*audio
)
522 if (audio
->n_sampling_frequency
) {
523 track
->a_sfreq
= audio
->sampling_frequency
;
524 mp_msg(MSGT_DEMUX
, MSGL_V
,
525 "[mkv] | + Sampling frequency: %f\n", track
->a_sfreq
);
527 track
->a_sfreq
= 8000;
528 if (audio
->n_bit_depth
) {
529 track
->a_bps
= audio
->bit_depth
;
530 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Bit depth: %u\n",
533 if (audio
->n_channels
) {
534 track
->a_channels
= audio
->channels
;
535 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Channels: %u\n",
538 track
->a_channels
= 1;
541 static void parse_trackvideo(struct demuxer
*demuxer
, struct mkv_track
*track
,
542 struct ebml_video
*video
)
544 if (video
->n_frame_rate
) {
545 track
->v_frate
= video
->frame_rate
;
546 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Frame rate: %f\n",
548 if (track
->v_frate
> 0)
549 track
->default_duration
= 1 / track
->v_frate
;
551 if (video
->n_display_width
) {
552 track
->v_dwidth
= video
->display_width
;
553 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display width: %u\n",
556 if (video
->n_display_height
) {
557 track
->v_dheight
= video
->display_height
;
558 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display height: %u\n",
561 if (video
->n_pixel_width
) {
562 track
->v_width
= video
->pixel_width
;
563 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel width: %u\n",
566 if (video
->n_pixel_height
) {
567 track
->v_height
= video
->pixel_height
;
568 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel height: %u\n",
574 * \brief free any data associated with given track
575 * \param track track of which to free data
577 static void demux_mkv_free_trackentry(mkv_track_t
*track
)
579 free(track
->audio_buf
);
580 free(track
->audio_timestamp
);
584 static void parse_trackentry(struct demuxer
*demuxer
,
585 struct ebml_track_entry
*entry
)
587 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
588 struct mkv_track
*track
= talloc_zero_size(NULL
, sizeof(*track
));
590 track
->tnum
= entry
->track_number
;
592 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track number: %u\n",
595 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Missing track number!\n");
598 track
->name
= talloc_strndup(track
, entry
->name
.start
,
600 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Name: %s\n",
604 track
->type
= entry
->track_type
;
605 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track type: ");
606 switch (track
->type
) {
607 case MATROSKA_TRACK_AUDIO
:
608 mp_msg(MSGT_DEMUX
, MSGL_V
, "Audio\n");
610 case MATROSKA_TRACK_VIDEO
:
611 mp_msg(MSGT_DEMUX
, MSGL_V
, "Video\n");
613 case MATROSKA_TRACK_SUBTITLE
:
614 mp_msg(MSGT_DEMUX
, MSGL_V
, "Subtitle\n");
617 mp_msg(MSGT_DEMUX
, MSGL_V
, "unknown\n");
621 if (entry
->n_audio
) {
622 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Audio track\n");
623 parse_trackaudio(demuxer
, track
, &entry
->audio
);
626 if (entry
->n_video
) {
627 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Video track\n");
628 parse_trackvideo(demuxer
, track
, &entry
->video
);
631 if (entry
->n_codec_id
) {
632 track
->codec_id
= talloc_strndup(track
, entry
->codec_id
.start
,
633 entry
->codec_id
.len
);
634 if (!strcmp(track
->codec_id
, MKV_V_MSCOMP
)
635 || !strcmp(track
->codec_id
, MKV_A_ACM
))
636 track
->ms_compat
= 1;
637 else if (!strcmp(track
->codec_id
, MKV_S_VOBSUB
))
638 track
->subtitle_type
= MATROSKA_SUBTYPE_VOBSUB
;
639 else if (!strcmp(track
->codec_id
, MKV_S_TEXTSSA
)
640 || !strcmp(track
->codec_id
, MKV_S_TEXTASS
)
641 || !strcmp(track
->codec_id
, MKV_S_SSA
)
642 || !strcmp(track
->codec_id
, MKV_S_ASS
)) {
643 track
->subtitle_type
= MATROSKA_SUBTYPE_SSA
;
644 } else if (!strcmp(track
->codec_id
, MKV_S_TEXTASCII
))
645 track
->subtitle_type
= MATROSKA_SUBTYPE_TEXT
;
646 if (!strcmp(track
->codec_id
, MKV_S_TEXTUTF8
)) {
647 track
->subtitle_type
= MATROSKA_SUBTYPE_TEXT
;
649 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Codec ID: %s\n",
652 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Missing codec ID!\n");
654 if (entry
->n_codec_private
) {
655 int len
= entry
->codec_private
.len
;
656 track
->private_data
= talloc_size(track
, len
+ AV_LZO_INPUT_PADDING
);
657 memcpy(track
->private_data
, entry
->codec_private
.start
, len
);
658 track
->private_size
= len
;
659 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + CodecPrivate, length %u\n",
660 track
->private_size
);
663 if (entry
->n_language
) {
664 track
->language
= talloc_strndup(track
, entry
->language
.start
,
665 entry
->language
.len
);
666 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Language: %s\n",
669 track
->language
= talloc_strdup(track
, "eng");
671 if (entry
->n_flag_default
) {
672 track
->default_track
= entry
->flag_default
;
673 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default flag: %u\n",
674 track
->default_track
);
676 track
->default_track
= 1;
678 if (entry
->n_default_duration
) {
679 track
->default_duration
= entry
->default_duration
/ 1e9
;
680 if (entry
->default_duration
== 0)
681 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default duration: 0");
684 track
->v_frate
= 1e9
/ entry
->default_duration
;
685 mp_msg(MSGT_DEMUX
, MSGL_V
,
686 "[mkv] | + Default duration: %.3fms ( = %.3f fps)\n",
687 entry
->default_duration
/ 1000000.0, track
->v_frate
);
691 if (entry
->n_content_encodings
)
692 parse_trackencodings(demuxer
, track
, &entry
->content_encodings
);
694 mkv_d
->tracks
[mkv_d
->num_tracks
++] = track
;
697 static int demux_mkv_read_tracks(demuxer_t
*demuxer
)
699 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
700 stream_t
*s
= demuxer
->stream
;
702 struct ebml_tracks tracks
= {};
703 struct ebml_parse_ctx parse_ctx
= {};
704 if (ebml_read_element(s
, &parse_ctx
, &tracks
, &ebml_tracks_desc
) < 0)
707 mkv_d
->tracks
= talloc_size(mkv_d
,
708 tracks
.n_track_entry
* sizeof(*mkv_d
->tracks
));
709 for (int i
= 0; i
< tracks
.n_track_entry
; i
++) {
710 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + a track...\n");
711 parse_trackentry(demuxer
, &tracks
.track_entry
[i
]);
713 talloc_free(parse_ctx
.talloc_ctx
);
717 static int demux_mkv_read_cues(demuxer_t
*demuxer
)
719 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
720 stream_t
*s
= demuxer
->stream
;
722 if (index_mode
== 0 || index_mode
== 2) {
723 ebml_read_skip(s
, NULL
);
727 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing cues ] -----------\n");
728 struct ebml_cues cues
= {};
729 struct ebml_parse_ctx parse_ctx
= {};
730 if (ebml_read_element(s
, &parse_ctx
, &cues
, &ebml_cues_desc
) < 0)
732 for (int i
= 0; i
< cues
.n_cue_point
; i
++) {
733 struct ebml_cue_point
*cuepoint
= &cues
.cue_point
[i
];
734 if (cuepoint
->n_cue_time
!= 1 || !cuepoint
->n_cue_track_positions
) {
735 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Malformed CuePoint element\n");
738 uint64_t time
= cuepoint
->cue_time
;
739 for (int i
= 0; i
< cuepoint
->n_cue_track_positions
; i
++) {
740 struct ebml_cue_track_positions
*trackpos
=
741 &cuepoint
->cue_track_positions
[i
];
742 uint64_t track
= trackpos
->cue_track
;
743 uint64_t pos
= trackpos
->cue_cluster_position
;
745 grow_array(mkv_d
->indexes
, mkv_d
->num_indexes
,
746 sizeof(mkv_index_t
));
747 mkv_d
->indexes
[mkv_d
->num_indexes
].tnum
= track
;
748 mkv_d
->indexes
[mkv_d
->num_indexes
].timecode
= time
;
749 mkv_d
->indexes
[mkv_d
->num_indexes
].filepos
=
750 mkv_d
->segment_start
+ pos
;
751 mp_msg(MSGT_DEMUX
, MSGL_DBG2
,
752 "[mkv] |+ found cue point for track %" PRIu64
753 ": timecode %" PRIu64
", filepos: %" PRIu64
"\n", track
,
754 time
, mkv_d
->segment_start
+ pos
);
755 mkv_d
->num_indexes
++;
760 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] \\---- [ parsing cues ] -----------\n");
761 talloc_free(parse_ctx
.talloc_ctx
);
765 static int demux_mkv_read_chapters(struct demuxer
*demuxer
)
767 struct MPOpts
*opts
= demuxer
->opts
;
768 stream_t
*s
= demuxer
->stream
;
770 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing chapters ] ---------\n");
771 struct ebml_chapters file_chapters
= {};
772 struct ebml_parse_ctx parse_ctx
= {};
773 if (ebml_read_element(s
, &parse_ctx
, &file_chapters
,
774 &ebml_chapters_desc
) < 0)
777 int selected_edition
= 0;
778 int num_editions
= file_chapters
.n_edition_entry
;
779 struct ebml_edition_entry
*editions
= file_chapters
.edition_entry
;
780 if (opts
->edition_id
>= 0 && opts
->edition_id
< num_editions
) {
781 selected_edition
= opts
->edition_id
;
782 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] User-specified edition: %d\n",
785 for (int i
= 0; i
< num_editions
; i
++)
786 if (editions
[i
].edition_flag_default
) {
787 selected_edition
= i
;
788 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Default edition: %d\n", i
);
791 struct matroska_chapter
*m_chapters
= NULL
;
792 if (editions
[selected_edition
].edition_flag_ordered
) {
793 int count
= editions
[selected_edition
].n_chapter_atom
;
794 m_chapters
= talloc_array_ptrtype(demuxer
, m_chapters
, count
);
795 demuxer
->matroska_data
.ordered_chapters
= m_chapters
;
796 demuxer
->matroska_data
.num_ordered_chapters
= count
;
799 for (int idx
= 0; idx
< num_editions
; idx
++) {
800 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] New edition %d\n", idx
);
801 int warn_level
= idx
== selected_edition
? MSGL_WARN
: MSGL_V
;
802 if (editions
[idx
].n_edition_flag_default
)
803 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Default edition flag: %"PRIu64
804 "\n", editions
[idx
].edition_flag_default
);
805 if (editions
[idx
].n_edition_flag_ordered
)
806 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Ordered chapter flag: %"PRIu64
807 "\n", editions
[idx
].edition_flag_ordered
);
808 for (int i
= 0; i
< editions
[idx
].n_chapter_atom
; i
++) {
809 struct ebml_chapter_atom
*ca
= editions
[idx
].chapter_atom
+ i
;
810 struct matroska_chapter chapter
= { };
811 struct bstr name
= { "(unnamed)", 9 };
813 if (!ca
->n_chapter_time_start
)
814 mp_msg(MSGT_DEMUX
, warn_level
,
815 "[mkv] Chapter lacks start time\n");
816 chapter
.start
= ca
->chapter_time_start
/ 1000000;
817 chapter
.end
= ca
->chapter_time_end
/ 1000000;
819 if (ca
->n_chapter_display
) {
820 if (ca
->n_chapter_display
> 1)
821 mp_msg(MSGT_DEMUX
, warn_level
, "[mkv] Multiple chapter "
822 "names not supported, picking first\n");
823 if (!ca
->chapter_display
[0].n_chap_string
)
824 mp_msg(MSGT_DEMUX
, warn_level
, "[mkv] Malformed chapter "
827 name
= ca
->chapter_display
[0].chap_string
;
830 if (ca
->n_chapter_segment_uid
) {
831 chapter
.has_segment_uid
= true;
832 int len
= ca
->chapter_segment_uid
.len
;
833 if (len
!= sizeof(chapter
.segment_uid
))
834 mp_msg(MSGT_DEMUX
, warn_level
,
835 "[mkv] Chapter segment uid bad length %d\n", len
);
836 else if (ca
->n_chapter_segment_edition_uid
) {
837 mp_tmsg(MSGT_DEMUX
, warn_level
, "[mkv] Warning: "
838 "unsupported edition recursion in chapter; "
839 "will skip on playback!\n");
841 memcpy(chapter
.segment_uid
, ca
->chapter_segment_uid
.start
,
843 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Chapter segment uid ");
844 for (int i
= 0; i
< len
; i
++)
845 mp_msg(MSGT_DEMUX
, MSGL_V
, "%02x ",
846 chapter
.segment_uid
[i
]);
847 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
851 mp_msg(MSGT_DEMUX
, MSGL_V
,
852 "[mkv] Chapter %u from %02d:%02d:%02d.%03d "
853 "to %02d:%02d:%02d.%03d, %.*s\n", i
,
854 (int) (chapter
.start
/ 60 / 60 / 1000),
855 (int) ((chapter
.start
/ 60 / 1000) % 60),
856 (int) ((chapter
.start
/ 1000) % 60),
857 (int) (chapter
.start
% 1000),
858 (int) (chapter
.end
/ 60 / 60 / 1000),
859 (int) ((chapter
.end
/ 60 / 1000) % 60),
860 (int) ((chapter
.end
/ 1000) % 60),
861 (int) (chapter
.end
% 1000),
864 if (idx
== selected_edition
){
865 demuxer_add_chapter(demuxer
, name
, chapter
.start
, chapter
.end
);
866 if (editions
[idx
].edition_flag_ordered
) {
867 chapter
.name
= talloc_strndup(m_chapters
, name
.start
,
869 m_chapters
[i
] = chapter
;
874 if (num_editions
> 1)
875 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
876 "[mkv] Found %d editions, will play #%d (first is 0).\n",
877 num_editions
, selected_edition
);
880 talloc_free(parse_ctx
.talloc_ctx
);
881 mp_msg(MSGT_DEMUX
, MSGL_V
,
882 "[mkv] \\---- [ parsing chapters ] ---------\n");
886 static int demux_mkv_read_tags(demuxer_t
*demuxer
)
888 stream_t
*s
= demuxer
->stream
;
890 struct ebml_parse_ctx parse_ctx
= {};
891 struct ebml_tags tags
= {};
892 if (ebml_read_element(s
, &parse_ctx
, &tags
, &ebml_tags_desc
) < 0)
895 for (int i
= 0; i
< tags
.n_tag
; i
++) {
896 struct ebml_tag tag
= tags
.tag
[i
];
897 if (tag
.targets
.target_track_uid
|| tag
.targets
.target_edition_uid
||
898 tag
.targets
.target_chapter_uid
|| tag
.targets
.target_attachment_uid
)
901 for (int j
; j
< tag
.n_simple_tag
; j
++)
902 demux_info_add_bstr(demuxer
, tag
.simple_tag
[j
].tag_name
, tag
.simple_tag
[j
].tag_string
);
908 static int demux_mkv_read_attachments(demuxer_t
*demuxer
)
910 stream_t
*s
= demuxer
->stream
;
912 mp_msg(MSGT_DEMUX
, MSGL_V
,
913 "[mkv] /---- [ parsing attachments ] ---------\n");
915 struct ebml_attachments attachments
= {};
916 struct ebml_parse_ctx parse_ctx
= {};
917 if (ebml_read_element(s
, &parse_ctx
, &attachments
,
918 &ebml_attachments_desc
) < 0)
921 for (int i
= 0; i
< attachments
.n_attached_file
; i
++) {
922 struct ebml_attached_file
*attachment
= &attachments
.attached_file
[i
];
923 if (!attachment
->n_file_name
|| !attachment
->n_file_mime_type
924 || !attachment
->n_file_data
) {
925 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Malformed attachment\n");
928 struct bstr name
= attachment
->file_name
;
929 struct bstr mime
= attachment
->file_mime_type
;
930 demuxer_add_attachment(demuxer
, name
, mime
, attachment
->file_data
);
931 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Attachment: %.*s, %.*s, %zu bytes\n",
932 BSTR_P(name
), BSTR_P(mime
), attachment
->file_data
.len
);
936 talloc_free(parse_ctx
.talloc_ctx
);
937 mp_msg(MSGT_DEMUX
, MSGL_V
,
938 "[mkv] \\---- [ parsing attachments ] ---------\n");
942 static int read_header_element(struct demuxer
*demuxer
, uint32_t id
,
945 static int demux_mkv_read_seekhead(demuxer_t
*demuxer
)
947 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
948 struct stream
*s
= demuxer
->stream
;
950 struct ebml_seek_head seekhead
= {};
951 struct ebml_parse_ctx parse_ctx
= {};
953 mp_msg(MSGT_DEMUX
, MSGL_V
,
954 "[mkv] /---- [ parsing seek head ] ---------\n");
955 if (ebml_read_element(s
, &parse_ctx
, &seekhead
, &ebml_seek_head_desc
) < 0) {
959 /* off now holds the position of the next element after the seek head. */
960 off_t off
= stream_tell(s
);
961 for (int i
= 0; i
< seekhead
.n_seek
; i
++) {
962 struct ebml_seek
*seek
= &seekhead
.seek
[i
];
963 if (seek
->n_seek_id
!= 1 || seek
->n_seek_position
!= 1) {
964 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Invalid SeekHead entry\n");
967 uint64_t pos
= seek
->seek_position
+ mkv_d
->segment_start
;
968 if (pos
>= demuxer
->movi_end
) {
969 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] SeekHead position beyond "
970 "end of file - incomplete file?\n");
973 read_header_element(demuxer
, seek
->seek_id
, pos
);
975 if (!stream_seek(s
, off
)) {
976 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Couldn't seek back after "
981 mp_msg(MSGT_DEMUX
, MSGL_V
,
982 "[mkv] \\---- [ parsing seek head ] ---------\n");
983 talloc_free(parse_ctx
.talloc_ctx
);
987 static bool seek_pos_id(struct stream
*s
, off_t pos
, uint32_t id
)
989 if (!stream_seek(s
, pos
)) {
990 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Failed to seek in file\n");
993 if (ebml_read_id(s
, NULL
) != id
) {
994 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Expected element not found\n");
1000 static int read_header_element(struct demuxer
*demuxer
, uint32_t id
,
1003 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
1004 stream_t
*s
= demuxer
->stream
;
1005 off_t pos
= stream_tell(s
) - 4;
1008 case MATROSKA_ID_INFO
:
1009 if (mkv_d
->parsed_info
)
1011 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1013 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment information...\n");
1014 mkv_d
->parsed_info
= true;
1015 return demux_mkv_read_info(demuxer
) ? -1 : 1;
1017 case MATROSKA_ID_TRACKS
:
1018 if (mkv_d
->parsed_tracks
)
1020 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1022 mkv_d
->parsed_tracks
= true;
1023 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment tracks...\n");
1024 return demux_mkv_read_tracks(demuxer
) ? -1 : 1;
1026 case MATROSKA_ID_CUES
:
1027 if (is_parsed_header(mkv_d
, pos
))
1029 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1031 return demux_mkv_read_cues(demuxer
) ? -1 : 1;
1033 case MATROSKA_ID_TAGS
:
1034 if (mkv_d
->parsed_tags
)
1036 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1038 mkv_d
->parsed_tags
= true;
1039 return demux_mkv_read_tags(demuxer
) ? -1 : 1;
1041 case MATROSKA_ID_SEEKHEAD
:
1042 if (is_parsed_header(mkv_d
, pos
))
1044 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1046 return demux_mkv_read_seekhead(demuxer
) ? -1 : 1;
1048 case MATROSKA_ID_CHAPTERS
:
1049 if (mkv_d
->parsed_chapters
)
1051 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1053 mkv_d
->parsed_chapters
= true;
1054 return demux_mkv_read_chapters(demuxer
) ? -1 : 1;
1056 case MATROSKA_ID_ATTACHMENTS
:
1057 if (mkv_d
->parsed_attachments
)
1059 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1061 mkv_d
->parsed_attachments
= true;
1062 return demux_mkv_read_attachments(demuxer
) ? -1 : 1;
1066 ebml_read_skip(s
, NULL
);
1070 ebml_read_skip(s
, NULL
);
1076 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1078 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1080 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1083 static void display_create_tracks(demuxer_t
*demuxer
)
1085 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1086 int i
, vid
= 0, aid
= 0, sid
= 0;
1088 for (i
= 0; i
< mkv_d
->num_tracks
; i
++) {
1089 char *type
= "unknown", str
[32];
1091 switch (mkv_d
->tracks
[i
]->type
) {
1092 case MATROSKA_TRACK_VIDEO
:
1094 mkv_d
->tracks
[i
]->id
= -1;
1095 if (vid
== MAX_V_STREAMS
)
1097 mkv_d
->tracks
[i
]->id
= vid
;
1098 demux_mkv_open_video(demuxer
, mkv_d
->tracks
[i
], vid
);
1099 if (mkv_d
->tracks
[i
]->name
)
1100 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VID_%d_NAME=%s\n", vid
,
1101 mkv_d
->tracks
[i
]->name
);
1102 sprintf(str
, "-vid %u", vid
++);
1104 case MATROSKA_TRACK_AUDIO
:
1106 mkv_d
->tracks
[i
]->id
= -1;
1107 if (aid
== MAX_A_STREAMS
)
1109 mkv_d
->tracks
[i
]->id
= aid
;
1110 demux_mkv_open_audio(demuxer
, mkv_d
->tracks
[i
], aid
);
1111 if (mkv_d
->tracks
[i
]->name
)
1112 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_NAME=%s\n", aid
,
1113 mkv_d
->tracks
[i
]->name
);
1114 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_LANG=%s\n", aid
,
1115 mkv_d
->tracks
[i
]->language
);
1116 sprintf(str
, "-aid %u, -alang %.5s", aid
++,
1117 mkv_d
->tracks
[i
]->language
);
1119 case MATROSKA_TRACK_SUBTITLE
:
1121 mkv_d
->tracks
[i
]->id
= -1;
1122 if (sid
== MAX_S_STREAMS
)
1124 mkv_d
->tracks
[i
]->id
= sid
;
1125 demux_mkv_open_sub(demuxer
, mkv_d
->tracks
[i
], sid
);
1126 if (mkv_d
->tracks
[i
]->name
)
1127 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_NAME=%s\n", sid
,
1128 mkv_d
->tracks
[i
]->name
);
1129 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", sid
,
1130 mkv_d
->tracks
[i
]->language
);
1131 sprintf(str
, "-sid %u, -slang %.5s", sid
++,
1132 mkv_d
->tracks
[i
]->language
);
1135 if (mkv_d
->tracks
[i
]->name
)
1136 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
,
1137 "[mkv] Track ID %u: %s (%s) \"%s\", %s\n",
1138 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
,
1139 mkv_d
->tracks
[i
]->name
, str
);
1141 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] Track ID %u: %s (%s), %s\n",
1142 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
,
1145 mkv_d
->num_audio_tracks
= aid
;
1152 } videocodec_info_t
;
1154 static const videocodec_info_t vinfo
[] = {
1155 {MKV_V_MPEG1
, mmioFOURCC('m', 'p', 'g', '1'), 0},
1156 {MKV_V_MPEG2
, mmioFOURCC('m', 'p', 'g', '2'), 0},
1157 {MKV_V_MPEG4_SP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1158 {MKV_V_MPEG4_ASP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1159 {MKV_V_MPEG4_AP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1160 {MKV_V_MPEG4_AVC
, mmioFOURCC('a', 'v', 'c', '1'), 1},
1161 {MKV_V_THEORA
, mmioFOURCC('t', 'h', 'e', 'o'), 1},
1165 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1168 struct MPOpts
*opts
= demuxer
->opts
;
1169 BITMAPINFOHEADER
*bih
;
1170 void *ImageDesc
= NULL
;
1173 if (track
->ms_compat
) { /* MS compatibility mode */
1174 BITMAPINFOHEADER
*src
;
1176 if (track
->private_data
== NULL
1177 || track
->private_size
< sizeof(BITMAPINFOHEADER
))
1180 src
= (BITMAPINFOHEADER
*) track
->private_data
;
1181 bih
= calloc(1, track
->private_size
);
1182 bih
->biSize
= le2me_32(src
->biSize
);
1183 bih
->biWidth
= le2me_32(src
->biWidth
);
1184 bih
->biHeight
= le2me_32(src
->biHeight
);
1185 bih
->biPlanes
= le2me_16(src
->biPlanes
);
1186 bih
->biBitCount
= le2me_16(src
->biBitCount
);
1187 bih
->biCompression
= le2me_32(src
->biCompression
);
1188 bih
->biSizeImage
= le2me_32(src
->biSizeImage
);
1189 bih
->biXPelsPerMeter
= le2me_32(src
->biXPelsPerMeter
);
1190 bih
->biYPelsPerMeter
= le2me_32(src
->biYPelsPerMeter
);
1191 bih
->biClrUsed
= le2me_32(src
->biClrUsed
);
1192 bih
->biClrImportant
= le2me_32(src
->biClrImportant
);
1193 memcpy((char *) bih
+ sizeof(BITMAPINFOHEADER
),
1194 (char *) src
+ sizeof(BITMAPINFOHEADER
),
1195 track
->private_size
- sizeof(BITMAPINFOHEADER
));
1197 if (track
->v_width
== 0)
1198 track
->v_width
= bih
->biWidth
;
1199 if (track
->v_height
== 0)
1200 track
->v_height
= bih
->biHeight
;
1202 bih
= calloc(1, sizeof(BITMAPINFOHEADER
));
1203 bih
->biSize
= sizeof(BITMAPINFOHEADER
);
1204 bih
->biWidth
= track
->v_width
;
1205 bih
->biHeight
= track
->v_height
;
1206 bih
->biBitCount
= 24;
1207 bih
->biSizeImage
= bih
->biWidth
* bih
->biHeight
* bih
->biBitCount
/ 8;
1209 if (track
->private_size
>= RVPROPERTIES_SIZE
1210 && (!strcmp(track
->codec_id
, MKV_V_REALV10
)
1211 || !strcmp(track
->codec_id
, MKV_V_REALV20
)
1212 || !strcmp(track
->codec_id
, MKV_V_REALV30
)
1213 || !strcmp(track
->codec_id
, MKV_V_REALV40
))) {
1214 unsigned char *dst
, *src
;
1218 src
= (uint8_t *) track
->private_data
+ RVPROPERTIES_SIZE
;
1220 cnt
= track
->private_size
- RVPROPERTIES_SIZE
;
1221 bih
= realloc(bih
, sizeof(BITMAPINFOHEADER
) + 8 + cnt
);
1222 bih
->biSize
= 48 + cnt
;
1224 type2
= AV_RB32(src
- 4);
1225 if (type2
== 0x10003000 || type2
== 0x10003001)
1226 bih
->biCompression
= mmioFOURCC('R', 'V', '1', '3');
1228 bih
->biCompression
=
1229 mmioFOURCC('R', 'V', track
->codec_id
[9], '0');
1230 dst
= (unsigned char *) (bih
+ 1);
1231 // copy type1 and type2 info from rv properties
1232 memcpy(dst
, src
- 8, 8);
1233 stream_read(demuxer
->stream
, dst
+ 8, cnt
);
1234 track
->realmedia
= 1;
1236 #ifdef CONFIG_QTX_CODECS
1237 } else if (track
->private_size
>= sizeof(ImageDescription
)
1238 && !strcmp(track
->codec_id
, MKV_V_QUICKTIME
)) {
1239 ImageDescriptionPtr idesc
;
1241 idesc
= (ImageDescriptionPtr
) track
->private_data
;
1242 idesc
->idSize
= be2me_32(idesc
->idSize
);
1243 idesc
->cType
= be2me_32(idesc
->cType
);
1244 idesc
->version
= be2me_16(idesc
->version
);
1245 idesc
->revisionLevel
= be2me_16(idesc
->revisionLevel
);
1246 idesc
->vendor
= be2me_32(idesc
->vendor
);
1247 idesc
->temporalQuality
= be2me_32(idesc
->temporalQuality
);
1248 idesc
->spatialQuality
= be2me_32(idesc
->spatialQuality
);
1249 idesc
->width
= be2me_16(idesc
->width
);
1250 idesc
->height
= be2me_16(idesc
->height
);
1251 idesc
->hRes
= be2me_32(idesc
->hRes
);
1252 idesc
->vRes
= be2me_32(idesc
->vRes
);
1253 idesc
->dataSize
= be2me_32(idesc
->dataSize
);
1254 idesc
->frameCount
= be2me_16(idesc
->frameCount
);
1255 idesc
->depth
= be2me_16(idesc
->depth
);
1256 idesc
->clutID
= be2me_16(idesc
->clutID
);
1258 bih
->biCompression
= idesc
->cType
;
1260 #endif /* CONFIG_QTX_CODECS */
1263 const videocodec_info_t
*vi
= vinfo
;
1264 while (vi
->id
&& strcmp(vi
->id
, track
->codec_id
))
1266 bih
->biCompression
= vi
->fourcc
;
1267 if (vi
->extradata
&& track
->private_data
1268 && (track
->private_size
> 0)) {
1269 bih
->biSize
+= track
->private_size
;
1270 bih
= realloc(bih
, bih
->biSize
);
1271 memcpy(bih
+ 1, track
->private_data
, track
->private_size
);
1273 track
->reorder_timecodes
= opts
->user_correct_pts
== 0;
1275 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Unknown/unsupported "
1276 "CodecID (%s) or missing/bad CodecPrivate\n"
1277 "[mkv] data (track %u).\n",
1278 track
->codec_id
, track
->tnum
);
1285 sh_v
= new_sh_video(demuxer
, vid
);
1287 sh_v
->format
= sh_v
->bih
->biCompression
;
1288 if (track
->v_frate
== 0.0)
1289 track
->v_frate
= 25.0;
1290 sh_v
->fps
= track
->v_frate
;
1291 sh_v
->frametime
= 1 / track
->v_frate
;
1293 if (!track
->realmedia
) {
1294 sh_v
->disp_w
= track
->v_width
;
1295 sh_v
->disp_h
= track
->v_height
;
1296 if (track
->v_dheight
)
1297 sh_v
->aspect
= (double) track
->v_dwidth
/ track
->v_dheight
;
1299 // vd_realvid.c will set aspect to disp_w/disp_h and rederive
1300 // disp_w and disp_h from the RealVideo stream contents returned
1301 // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
1302 // the Matroska file then it has already been set to PixelWidth/Height
1303 // by check_track_information.
1304 sh_v
->disp_w
= track
->v_dwidth
;
1305 sh_v
->disp_h
= track
->v_dheight
;
1307 sh_v
->ImageDesc
= ImageDesc
;
1308 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Aspect: %f\n", sh_v
->aspect
);
1310 sh_v
->ds
= demuxer
->video
;
1314 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1317 sh_audio_t
*sh_a
= new_sh_audio(demuxer
, aid
);
1321 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
1322 sh_a
->lang
= strdup(track
->language
);
1323 sh_a
->default_track
= track
->default_track
;
1324 sh_a
->ds
= demuxer
->audio
;
1325 sh_a
->wf
= malloc(sizeof(WAVEFORMATEX
));
1326 if (track
->ms_compat
&& (track
->private_size
>= sizeof(WAVEFORMATEX
))) {
1327 WAVEFORMATEX
*wf
= (WAVEFORMATEX
*) track
->private_data
;
1328 sh_a
->wf
= realloc(sh_a
->wf
, track
->private_size
);
1329 sh_a
->wf
->wFormatTag
= le2me_16(wf
->wFormatTag
);
1330 sh_a
->wf
->nChannels
= le2me_16(wf
->nChannels
);
1331 sh_a
->wf
->nSamplesPerSec
= le2me_32(wf
->nSamplesPerSec
);
1332 sh_a
->wf
->nAvgBytesPerSec
= le2me_32(wf
->nAvgBytesPerSec
);
1333 sh_a
->wf
->nBlockAlign
= le2me_16(wf
->nBlockAlign
);
1334 sh_a
->wf
->wBitsPerSample
= le2me_16(wf
->wBitsPerSample
);
1335 sh_a
->wf
->cbSize
= track
->private_size
- sizeof(WAVEFORMATEX
);
1336 memcpy(sh_a
->wf
+ 1, wf
+ 1,
1337 track
->private_size
- sizeof(WAVEFORMATEX
));
1338 if (track
->a_sfreq
== 0.0)
1339 track
->a_sfreq
= sh_a
->wf
->nSamplesPerSec
;
1340 if (track
->a_channels
== 0)
1341 track
->a_channels
= sh_a
->wf
->nChannels
;
1342 if (track
->a_bps
== 0)
1343 track
->a_bps
= sh_a
->wf
->wBitsPerSample
;
1344 track
->a_formattag
= sh_a
->wf
->wFormatTag
;
1346 memset(sh_a
->wf
, 0, sizeof(WAVEFORMATEX
));
1347 if (!strcmp(track
->codec_id
, MKV_A_MP3
)
1348 || !strcmp(track
->codec_id
, MKV_A_MP2
))
1349 track
->a_formattag
= 0x0055;
1350 else if (!strncmp(track
->codec_id
, MKV_A_AC3
, strlen(MKV_A_AC3
)))
1351 track
->a_formattag
= 0x2000;
1352 else if (!strcmp(track
->codec_id
, MKV_A_DTS
))
1353 track
->a_formattag
= 0x2001;
1354 else if (!strcmp(track
->codec_id
, MKV_A_PCM
)
1355 || !strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1356 track
->a_formattag
= 0x0001;
1357 else if (!strcmp(track
->codec_id
, MKV_A_AAC_2MAIN
)
1358 || !strncmp(track
->codec_id
, MKV_A_AAC_2LC
,
1359 strlen(MKV_A_AAC_2LC
))
1360 || !strcmp(track
->codec_id
, MKV_A_AAC_2SSR
)
1361 || !strcmp(track
->codec_id
, MKV_A_AAC_4MAIN
)
1362 || !strncmp(track
->codec_id
, MKV_A_AAC_4LC
,
1363 strlen(MKV_A_AAC_4LC
))
1364 || !strcmp(track
->codec_id
, MKV_A_AAC_4SSR
)
1365 || !strcmp(track
->codec_id
, MKV_A_AAC_4LTP
)
1366 || !strcmp(track
->codec_id
, MKV_A_AAC
))
1367 track
->a_formattag
= mmioFOURCC('M', 'P', '4', 'A');
1368 else if (!strcmp(track
->codec_id
, MKV_A_VORBIS
)) {
1369 if (track
->private_data
== NULL
)
1371 track
->a_formattag
= mmioFOURCC('v', 'r', 'b', 's');
1372 } else if (!strcmp(track
->codec_id
, MKV_A_QDMC
))
1373 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', 'C');
1374 else if (!strcmp(track
->codec_id
, MKV_A_QDMC2
))
1375 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', '2');
1376 else if (!strcmp(track
->codec_id
, MKV_A_WAVPACK
))
1377 track
->a_formattag
= mmioFOURCC('W', 'V', 'P', 'K');
1378 else if (!strcmp(track
->codec_id
, MKV_A_TRUEHD
))
1379 track
->a_formattag
= mmioFOURCC('T', 'R', 'H', 'D');
1380 else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)) {
1381 if (track
->private_data
== NULL
|| track
->private_size
== 0) {
1382 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
1383 "[mkv] FLAC track does not contain valid headers.\n");
1386 track
->a_formattag
= mmioFOURCC('f', 'L', 'a', 'C');
1387 } else if (track
->private_size
>= RAPROPERTIES4_SIZE
) {
1388 if (!strcmp(track
->codec_id
, MKV_A_REAL28
))
1389 track
->a_formattag
= mmioFOURCC('2', '8', '_', '8');
1390 else if (!strcmp(track
->codec_id
, MKV_A_REALATRC
))
1391 track
->a_formattag
= mmioFOURCC('a', 't', 'r', 'c');
1392 else if (!strcmp(track
->codec_id
, MKV_A_REALCOOK
))
1393 track
->a_formattag
= mmioFOURCC('c', 'o', 'o', 'k');
1394 else if (!strcmp(track
->codec_id
, MKV_A_REALDNET
))
1395 track
->a_formattag
= mmioFOURCC('d', 'n', 'e', 't');
1396 else if (!strcmp(track
->codec_id
, MKV_A_REALSIPR
))
1397 track
->a_formattag
= mmioFOURCC('s', 'i', 'p', 'r');
1399 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Unknown/unsupported audio "
1400 "codec ID '%s' for track %u or missing/faulty\n[mkv] "
1401 "private codec data.\n", track
->codec_id
, track
->tnum
);
1402 free_sh_audio(demuxer
, track
->id
);
1407 sh_a
->format
= track
->a_formattag
;
1408 sh_a
->wf
->wFormatTag
= track
->a_formattag
;
1409 sh_a
->channels
= track
->a_channels
;
1410 sh_a
->wf
->nChannels
= track
->a_channels
;
1411 sh_a
->samplerate
= (uint32_t) track
->a_sfreq
;
1412 sh_a
->wf
->nSamplesPerSec
= (uint32_t) track
->a_sfreq
;
1413 if (track
->a_bps
== 0) {
1414 sh_a
->samplesize
= 2;
1415 sh_a
->wf
->wBitsPerSample
= 16;
1417 sh_a
->samplesize
= track
->a_bps
/ 8;
1418 sh_a
->wf
->wBitsPerSample
= track
->a_bps
;
1420 if (track
->a_formattag
== 0x0055) { /* MP3 || MP2 */
1421 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1422 sh_a
->wf
->nBlockAlign
= 1152;
1423 } else if ((track
->a_formattag
== 0x2000) /* AC3 */
1424 || (track
->a_formattag
== 0x2001)) { /* DTS */
1427 } else if (track
->a_formattag
== 0x0001) { /* PCM || PCM_BE */
1428 sh_a
->wf
->nAvgBytesPerSec
= sh_a
->channels
* sh_a
->samplerate
* 2;
1429 sh_a
->wf
->nBlockAlign
= sh_a
->wf
->nAvgBytesPerSec
;
1430 if (!strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1431 sh_a
->format
= mmioFOURCC('t', 'w', 'o', 's');
1432 } else if (!strcmp(track
->codec_id
, MKV_A_QDMC
)
1433 || !strcmp(track
->codec_id
, MKV_A_QDMC2
)) {
1434 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1435 sh_a
->wf
->nBlockAlign
= 1486;
1436 track
->fix_i_bps
= 1;
1437 track
->qt_last_a_pts
= 0.0;
1438 if (track
->private_data
!= NULL
) {
1439 sh_a
->codecdata
= malloc(track
->private_size
);
1440 memcpy(sh_a
->codecdata
, track
->private_data
, track
->private_size
);
1441 sh_a
->codecdata_len
= track
->private_size
;
1443 } else if (track
->a_formattag
== mmioFOURCC('M', 'P', '4', 'A')) {
1444 int profile
, srate_idx
;
1446 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1447 sh_a
->wf
->nBlockAlign
= 1024;
1449 if (!strcmp(track
->codec_id
, MKV_A_AAC
)
1450 && (NULL
!= track
->private_data
)) {
1451 sh_a
->codecdata
= malloc(track
->private_size
);
1452 memcpy(sh_a
->codecdata
, track
->private_data
, track
->private_size
);
1453 sh_a
->codecdata_len
= track
->private_size
;
1457 /* Recreate the 'private data' */
1458 /* which faad2 uses in its initialization */
1459 srate_idx
= aac_get_sample_rate_index(sh_a
->samplerate
);
1460 if (!strncmp(&track
->codec_id
[12], "MAIN", 4))
1462 else if (!strncmp(&track
->codec_id
[12], "LC", 2))
1464 else if (!strncmp(&track
->codec_id
[12], "SSR", 3))
1468 sh_a
->codecdata
= malloc(5);
1469 sh_a
->codecdata
[0] = ((profile
+ 1) << 3) | ((srate_idx
& 0xE) >> 1);
1470 sh_a
->codecdata
[1] =
1471 ((srate_idx
& 0x1) << 7) | (track
->a_channels
<< 3);
1473 if (strstr(track
->codec_id
, "SBR") != NULL
) {
1474 /* HE-AAC (aka SBR AAC) */
1475 sh_a
->codecdata_len
= 5;
1477 sh_a
->samplerate
*= 2;
1478 sh_a
->wf
->nSamplesPerSec
*= 2;
1479 srate_idx
= aac_get_sample_rate_index(sh_a
->samplerate
);
1480 sh_a
->codecdata
[2] = AAC_SYNC_EXTENSION_TYPE
>> 3;
1481 sh_a
->codecdata
[3] = ((AAC_SYNC_EXTENSION_TYPE
& 0x07) << 5) | 5;
1482 sh_a
->codecdata
[4] = (1 << 7) | (srate_idx
<< 3);
1483 track
->default_duration
= 1024.0 / (sh_a
->samplerate
/ 2);
1485 sh_a
->codecdata_len
= 2;
1486 track
->default_duration
= 1024.0 / sh_a
->samplerate
;
1488 } else if (track
->a_formattag
== mmioFOURCC('v', 'r', 'b', 's')) { /* VORBIS */
1489 sh_a
->wf
->cbSize
= track
->private_size
;
1490 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(WAVEFORMATEX
) + sh_a
->wf
->cbSize
);
1491 memcpy((unsigned char *) (sh_a
->wf
+ 1), track
->private_data
,
1493 } else if (track
->private_size
>= RAPROPERTIES4_SIZE
1494 && !strncmp(track
->codec_id
, MKV_A_REALATRC
, 7)) {
1495 /* Common initialization for all RealAudio codecs */
1496 unsigned char *src
= track
->private_data
;
1497 int codecdata_length
, version
;
1500 sh_a
->wf
->nAvgBytesPerSec
= 0; /* FIXME !? */
1502 version
= AV_RB16(src
+ 4);
1503 flavor
= AV_RB16(src
+ 22);
1504 track
->coded_framesize
= AV_RB32(src
+ 24);
1505 track
->sub_packet_h
= AV_RB16(src
+ 40);
1506 sh_a
->wf
->nBlockAlign
= track
->audiopk_size
= AV_RB16(src
+ 42);
1507 track
->sub_packet_size
= AV_RB16(src
+ 44);
1509 src
+= RAPROPERTIES4_SIZE
;
1513 src
+= RAPROPERTIES5_SIZE
;
1518 codecdata_length
= AV_RB32(src
);
1520 sh_a
->wf
->cbSize
= codecdata_length
;
1521 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(WAVEFORMATEX
) + sh_a
->wf
->cbSize
);
1522 memcpy(((char *) (sh_a
->wf
+ 1)), src
, codecdata_length
);
1524 switch (track
->a_formattag
) {
1525 case mmioFOURCC('a', 't', 'r', 'c'):
1526 sh_a
->wf
->nAvgBytesPerSec
= atrc_fl2bps
[flavor
];
1527 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1529 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1530 track
->audio_timestamp
=
1531 malloc(track
->sub_packet_h
* sizeof(double));
1533 case mmioFOURCC('c', 'o', 'o', 'k'):
1534 sh_a
->wf
->nAvgBytesPerSec
= cook_fl2bps
[flavor
];
1535 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1537 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1538 track
->audio_timestamp
=
1539 malloc(track
->sub_packet_h
* sizeof(double));
1541 case mmioFOURCC('s', 'i', 'p', 'r'):
1542 sh_a
->wf
->nAvgBytesPerSec
= sipr_fl2bps
[flavor
];
1543 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1545 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1546 track
->audio_timestamp
=
1547 malloc(track
->sub_packet_h
* sizeof(double));
1549 case mmioFOURCC('2', '8', '_', '8'):
1550 sh_a
->wf
->nAvgBytesPerSec
= 3600;
1551 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1553 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1554 track
->audio_timestamp
=
1555 malloc(track
->sub_packet_h
* sizeof(double));
1559 track
->realmedia
= 1;
1560 } else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)
1561 || (track
->a_formattag
== 0xf1ac)) {
1567 if (track
->a_formattag
== mmioFOURCC('f', 'L', 'a', 'C')) {
1568 ptr
= track
->private_data
;
1569 size
= track
->private_size
;
1571 sh_a
->format
= mmioFOURCC('f', 'L', 'a', 'C');
1572 ptr
= track
->private_data
+ sizeof(WAVEFORMATEX
);
1573 size
= track
->private_size
- sizeof(WAVEFORMATEX
);
1575 if (size
< 4 || ptr
[0] != 'f' || ptr
[1] != 'L' || ptr
[2] != 'a'
1577 sh_a
->codecdata
= malloc(4);
1578 sh_a
->codecdata_len
= 4;
1579 memcpy(sh_a
->codecdata
, "fLaC", 4);
1581 sh_a
->codecdata
= malloc(size
);
1582 sh_a
->codecdata_len
= size
;
1583 memcpy(sh_a
->codecdata
, ptr
, size
);
1585 } else if (track
->a_formattag
== mmioFOURCC('W', 'V', 'P', 'K') || track
->a_formattag
== mmioFOURCC('T', 'R', 'H', 'D')) { /* do nothing, still works */
1586 } else if (!track
->ms_compat
1587 || (track
->private_size
< sizeof(WAVEFORMATEX
))) {
1588 free_sh_audio(demuxer
, track
->id
);
1595 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1598 if (track
->subtitle_type
!= MATROSKA_SUBTYPE_UNKNOWN
) {
1601 sh_sub_t
*sh
= new_sh_sub(demuxer
, sid
);
1604 if (track
->subtitle_type
== MATROSKA_SUBTYPE_VOBSUB
)
1606 if (track
->subtitle_type
== MATROSKA_SUBTYPE_SSA
)
1608 size
= track
->private_size
;
1609 demux_mkv_decode(track
, track
->private_data
, &buffer
, &size
, 2);
1610 if (buffer
&& buffer
!= track
->private_data
) {
1611 talloc_free(track
->private_data
);
1612 talloc_steal(track
, buffer
);
1613 track
->private_data
= buffer
;
1614 track
->private_size
= size
;
1616 sh
->extradata
= malloc(track
->private_size
);
1617 memcpy(sh
->extradata
, track
->private_data
, track
->private_size
);
1618 sh
->extradata_len
= track
->private_size
;
1619 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
1620 sh
->lang
= strdup(track
->language
);
1621 sh
->default_track
= track
->default_track
;
1623 mp_tmsg(MSGT_DEMUX
, MSGL_ERR
,
1624 "[mkv] Subtitle type '%s' is not supported.\n",
1632 static int demux_mkv_open(demuxer_t
*demuxer
)
1634 stream_t
*s
= demuxer
->stream
;
1635 mkv_demuxer_t
*mkv_d
;
1639 stream_seek(s
, s
->start_pos
);
1640 if (ebml_read_id(s
, NULL
) != EBML_ID_EBML
)
1642 struct ebml_ebml ebml_master
= {};
1643 struct ebml_parse_ctx parse_ctx
= { .no_error_messages
= true };
1644 if (ebml_read_element(s
, &parse_ctx
, &ebml_master
, &ebml_ebml_desc
) < 0)
1646 if (ebml_master
.doc_type
.len
!= 8 || strncmp(ebml_master
.doc_type
.start
,
1648 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "[mkv] no head found\n");
1649 talloc_free(parse_ctx
.talloc_ctx
);
1652 if (ebml_master
.doc_type_read_version
> 2) {
1653 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] This looks like a Matroska file, "
1654 "but we don't support format version %"PRIu64
"\n",
1655 ebml_master
.doc_type_read_version
);
1656 talloc_free(parse_ctx
.talloc_ctx
);
1659 if ((ebml_master
.n_ebml_read_version
1660 && ebml_master
.ebml_read_version
!= EBML_VERSION
)
1661 || (ebml_master
.n_ebml_max_size_length
1662 && ebml_master
.ebml_max_size_length
> 8)
1663 || (ebml_master
.n_ebml_max_id_length
1664 && ebml_master
.ebml_max_id_length
!= 4)) {
1665 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] This looks like a Matroska file, "
1666 "but the header has bad parameters\n");
1667 talloc_free(parse_ctx
.talloc_ctx
);
1670 talloc_free(parse_ctx
.talloc_ctx
);
1672 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Found the head...\n");
1674 if (ebml_read_id(s
, NULL
) != MATROSKA_ID_SEGMENT
) {
1675 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] but no segment :(\n");
1678 ebml_read_length(s
, NULL
); /* return bytes number until EOF */
1680 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] + a segment...\n");
1682 mkv_d
= talloc_zero(demuxer
, struct mkv_demuxer
);
1683 demuxer
->priv
= mkv_d
;
1684 mkv_d
->tc_scale
= 1000000;
1685 mkv_d
->segment_start
= stream_tell(s
);
1688 uint32_t id
= ebml_read_id(s
, NULL
);
1690 case MATROSKA_ID_CLUSTER
:
1691 mp_msg(MSGT_DEMUX
, MSGL_V
,
1692 "[mkv] |+ found cluster, headers are "
1693 "parsed completely :)\n");
1694 stream_seek(s
, stream_tell(s
) - 4);
1699 cont
= read_header_element(demuxer
, id
, 0) < 1;
1702 ebml_read_skip(s
, NULL
);
1707 display_create_tracks(demuxer
);
1709 /* select video track */
1711 if (demuxer
->video
->id
== -1) { /* automatically select a video track */
1712 /* search for a video track that has the 'default' flag set */
1713 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1714 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_VIDEO
1715 && mkv_d
->tracks
[i
]->default_track
) {
1716 track
= mkv_d
->tracks
[i
];
1721 /* no track has the 'default' flag set */
1722 /* let's take the first video track */
1723 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1724 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_VIDEO
1725 && track
->id
>= 0) {
1726 track
= mkv_d
->tracks
[i
];
1729 } else if (demuxer
->video
->id
!= -2) /* -2 = no video at all */
1730 track
= find_track_by_num(mkv_d
, demuxer
->video
->id
,
1731 MATROSKA_TRACK_VIDEO
);
1733 if (track
&& demuxer
->v_streams
[track
->id
]) {
1734 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] Will play video track %u.\n",
1736 demuxer
->video
->id
= track
->id
;
1737 demuxer
->video
->sh
= demuxer
->v_streams
[track
->id
];
1739 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] No video track found/wanted.\n");
1740 demuxer
->video
->id
= -2;
1743 /* select audio track */
1746 /* search for an audio track that has the 'default' flag set */
1747 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1748 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_AUDIO
1749 && mkv_d
->tracks
[i
]->default_track
) {
1750 track
= mkv_d
->tracks
[i
];
1755 /* no track has the 'default' flag set */
1756 /* let's take the first audio track */
1757 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1758 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_AUDIO
1759 && track
->id
>= 0) {
1760 track
= mkv_d
->tracks
[i
];
1764 if (track
&& demuxer
->a_streams
[track
->id
]) {
1765 demuxer
->audio
->id
= track
->id
;
1766 demuxer
->audio
->sh
= demuxer
->a_streams
[track
->id
];
1768 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] No audio track found/wanted.\n");
1769 demuxer
->audio
->id
= -2;
1772 if (s
->end_pos
== 0 || (mkv_d
->indexes
== NULL
&& index_mode
< 0))
1773 demuxer
->seekable
= 0;
1775 demuxer
->movi_start
= s
->start_pos
;
1776 demuxer
->movi_end
= s
->end_pos
;
1777 demuxer
->seekable
= 1;
1780 demuxer
->accurate_seek
= true;
1782 return DEMUXER_TYPE_MATROSKA
;
1785 static void demux_close_mkv(demuxer_t
*demuxer
)
1787 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1791 free_cached_dps(demuxer
);
1792 if (mkv_d
->tracks
) {
1793 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1794 demux_mkv_free_trackentry(mkv_d
->tracks
[i
]);
1796 free(mkv_d
->indexes
);
1797 free(mkv_d
->cluster_positions
);
1801 static int demux_mkv_read_block_lacing(uint8_t *buffer
, uint64_t *size
,
1803 uint32_t **all_lace_sizes
)
1805 uint32_t total
= 0, *lace_size
;
1809 *all_lace_sizes
= NULL
;
1815 switch ((flags
& 0x06) >> 1) {
1816 case 0: /* no lacing */
1818 lace_size
= calloc(*laces
, sizeof(uint32_t));
1819 lace_size
[0] = *size
;
1822 case 1: /* xiph lacing */
1823 case 2: /* fixed-size lacing */
1824 case 3: /* EBML lacing */
1828 lace_size
= calloc(*laces
, sizeof(uint32_t));
1830 switch ((flags
& 0x06) >> 1) {
1831 case 1: /* xiph lacing */
1832 for (i
= 0; i
< *laces
- 1; i
++) {
1835 lace_size
[i
] += *buffer
;
1837 } while (*buffer
++ == 0xFF);
1838 total
+= lace_size
[i
];
1840 lace_size
[i
] = *size
- total
;
1843 case 2: /* fixed-size lacing */
1844 for (i
= 0; i
< *laces
; i
++)
1845 lace_size
[i
] = *size
/ *laces
;
1848 case 3:; /* EBML lacing */
1850 uint64_t num
= ebml_read_vlen_uint(buffer
, &l
);
1851 if (num
== EBML_UINT_INVALID
) {
1858 total
= lace_size
[0] = num
;
1859 for (i
= 1; i
< *laces
- 1; i
++) {
1861 snum
= ebml_read_vlen_int(buffer
, &l
);
1862 if (snum
== EBML_INT_INVALID
) {
1868 lace_size
[i
] = lace_size
[i
- 1] + snum
;
1869 total
+= lace_size
[i
];
1871 lace_size
[i
] = *size
- total
;
1876 *all_lace_sizes
= lace_size
;
1880 static void handle_subtitles(demuxer_t
*demuxer
, mkv_track_t
*track
,
1881 char *block
, int64_t size
,
1882 uint64_t block_duration
, uint64_t timecode
)
1886 if (block_duration
== 0) {
1887 mp_msg(MSGT_DEMUX
, MSGL_WARN
,
1888 "[mkv] Warning: No BlockDuration for subtitle track found.\n");
1893 dp
= new_demux_packet(size
);
1894 memcpy(dp
->buffer
, block
, size
);
1895 dp
->pts
= timecode
/ 1000.0;
1896 dp
->endpts
= (timecode
+ block_duration
) / 1000.0;
1897 ds_add_packet(demuxer
->sub
, dp
);
1900 static void handle_realvideo(demuxer_t
*demuxer
, mkv_track_t
*track
,
1901 uint8_t *buffer
, uint32_t size
, int block_bref
)
1903 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1905 uint32_t timestamp
= mkv_d
->last_pts
* 1000;
1907 dp
= new_demux_packet(size
);
1908 memcpy(dp
->buffer
, buffer
, size
);
1910 if (mkv_d
->v_skip_to_keyframe
) {
1911 dp
->pts
= mkv_d
->last_pts
;
1912 track
->rv_kf_base
= 0;
1913 track
->rv_kf_pts
= timestamp
;
1916 real_fix_timestamp(dp
->buffer
, timestamp
,
1917 ((sh_video_t
*) demuxer
->video
->sh
)->bih
->
1918 biCompression
, &track
->rv_kf_base
,
1919 &track
->rv_kf_pts
, NULL
);
1920 dp
->pos
= demuxer
->filepos
;
1921 dp
->flags
= block_bref
? 0 : 0x10;
1923 ds_add_packet(demuxer
->video
, dp
);
1926 static void handle_realaudio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1927 uint8_t *buffer
, uint32_t size
, int block_bref
)
1929 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1930 int sps
= track
->sub_packet_size
;
1931 int sph
= track
->sub_packet_h
;
1932 int cfs
= track
->coded_framesize
;
1933 int w
= track
->audiopk_size
;
1934 int spc
= track
->sub_packet_cnt
;
1938 if ((track
->a_formattag
== mmioFOURCC('2', '8', '_', '8'))
1939 || (track
->a_formattag
== mmioFOURCC('c', 'o', 'o', 'k'))
1940 || (track
->a_formattag
== mmioFOURCC('a', 't', 'r', 'c'))
1941 || (track
->a_formattag
== mmioFOURCC('s', 'i', 'p', 'r'))) {
1943 // spc = track->sub_packet_cnt = 0;
1944 switch (track
->a_formattag
) {
1945 case mmioFOURCC('2', '8', '_', '8'):
1946 for (x
= 0; x
< sph
/ 2; x
++)
1947 memcpy(track
->audio_buf
+ x
* 2 * w
+ spc
* cfs
,
1948 buffer
+ cfs
* x
, cfs
);
1950 case mmioFOURCC('c', 'o', 'o', 'k'):
1951 case mmioFOURCC('a', 't', 'r', 'c'):
1952 for (x
= 0; x
< w
/ sps
; x
++)
1953 memcpy(track
->audio_buf
+
1954 sps
* (sph
* x
+ ((sph
+ 1) / 2) * (spc
& 1) +
1955 (spc
>> 1)), buffer
+ sps
* x
, sps
);
1957 case mmioFOURCC('s', 'i', 'p', 'r'):
1958 memcpy(track
->audio_buf
+ spc
* w
, buffer
, w
);
1959 if (spc
== sph
- 1) {
1961 int bs
= sph
* w
* 2 / 96; // nibbles per subpacket
1962 // Perform reordering
1963 for (n
= 0; n
< 38; n
++) {
1965 int i
= bs
* sipr_swaps
[n
][0];
1966 int o
= bs
* sipr_swaps
[n
][1];
1967 // swap nibbles of block 'i' with 'o' TODO: optimize
1968 for (j
= 0; j
< bs
; j
++) {
1970 (track
->audio_buf
[i
>> 1] >> 4) :
1971 (track
->audio_buf
[i
>> 1] & 0x0F);
1973 (track
->audio_buf
[o
>> 1] >> 4) :
1974 (track
->audio_buf
[o
>> 1] & 0x0F);
1976 track
->audio_buf
[o
>> 1] =
1977 (track
->audio_buf
[o
>> 1] & 0x0F) | (x
<< 4);
1979 track
->audio_buf
[o
>> 1] =
1980 (track
->audio_buf
[o
>> 1] & 0xF0) | x
;
1982 track
->audio_buf
[i
>> 1] =
1983 (track
->audio_buf
[i
>> 1] & 0x0F) | (y
<< 4);
1985 track
->audio_buf
[i
>> 1] =
1986 (track
->audio_buf
[i
>> 1] & 0xF0) | y
;
1994 track
->audio_timestamp
[track
->sub_packet_cnt
] =
1995 (track
->ra_pts
== mkv_d
->last_pts
) ? 0 : (mkv_d
->last_pts
);
1996 track
->ra_pts
= mkv_d
->last_pts
;
1997 if (track
->sub_packet_cnt
== 0)
1998 track
->audio_filepos
= demuxer
->filepos
;
1999 if (++(track
->sub_packet_cnt
) == sph
) {
2001 ((WAVEFORMATEX
*) ((sh_audio_t
*) demuxer
->audio
->sh
)->wf
)->
2003 track
->sub_packet_cnt
= 0;
2004 // Release all the audio packets
2005 for (x
= 0; x
< sph
* w
/ apk_usize
; x
++) {
2006 dp
= new_demux_packet(apk_usize
);
2007 memcpy(dp
->buffer
, track
->audio_buf
+ x
* apk_usize
,
2009 /* Put timestamp only on packets that correspond to original
2010 * audio packets in file */
2011 dp
->pts
= (x
* apk_usize
% w
) ? 0 :
2012 track
->audio_timestamp
[x
* apk_usize
/ w
];
2013 dp
->pos
= track
->audio_filepos
; // all equal
2014 dp
->flags
= x
? 0 : 0x10; // Mark first packet as keyframe
2015 ds_add_packet(demuxer
->audio
, dp
);
2018 } else { // Not a codec that require reordering
2019 dp
= new_demux_packet(size
);
2020 memcpy(dp
->buffer
, buffer
, size
);
2021 if (track
->ra_pts
== mkv_d
->last_pts
&& !mkv_d
->a_skip_to_keyframe
)
2024 dp
->pts
= mkv_d
->last_pts
;
2025 track
->ra_pts
= mkv_d
->last_pts
;
2027 dp
->pos
= demuxer
->filepos
;
2028 dp
->flags
= block_bref
? 0 : 0x10;
2029 ds_add_packet(demuxer
->audio
, dp
);
2033 /** Reorder timecodes and add cached demux packets to the queues.
2035 * Timecode reordering is needed if a video track contains B frames that
2036 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2037 * MPlayer doesn't like timestamps in display order. This function adjusts
2038 * the timestamp of cached frames (which are exactly one I/P frame followed
2039 * by one or more B frames) so that they are in coding order again.
2041 * Example: The track with 25 FPS contains four frames with the timecodes
2042 * I at 0ms, P at 120ms, B at 40ms and B at 80ms. As soon as the next I
2043 * or P frame arrives these timecodes can be changed to I at 0ms, P at 40ms,
2044 * B at 80ms and B at 120ms.
2046 * This works for simple H.264 B-frame pyramids, but not for arbitrary orders.
2048 * \param demuxer The Matroska demuxer struct for this instance.
2049 * \param track The track structure whose cache should be handled.
2051 static void flush_cached_dps(demuxer_t
*demuxer
, mkv_track_t
*track
)
2055 if (track
->num_cached_dps
== 0)
2060 for (i
= 1; i
< track
->num_cached_dps
; i
++)
2061 if (track
->cached_dps
[i
- 1]->pts
> track
->cached_dps
[i
]->pts
) {
2062 double tmp_pts
= track
->cached_dps
[i
- 1]->pts
;
2063 track
->cached_dps
[i
- 1]->pts
= track
->cached_dps
[i
]->pts
;
2064 track
->cached_dps
[i
]->pts
= tmp_pts
;
2069 for (i
= 0; i
< track
->num_cached_dps
; i
++)
2070 ds_add_packet(demuxer
->video
, track
->cached_dps
[i
]);
2071 track
->num_cached_dps
= 0;
2074 /** Cache video frames if timecodes have to be reordered.
2076 * Timecode reordering is needed if a video track contains B frames that
2077 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2078 * This function takes in a Matroska block read from the file, allocates a
2079 * demux packet for it, fills in its values, allocates space for storing
2080 * pointers to the cached demux packets and adds the packet to it. If
2081 * the packet contains an I or a P frame then ::flush_cached_dps is called
2082 * in order to send the old cached frames downstream.
2084 * \param demuxer The Matroska demuxer struct for this instance.
2085 * \param track The packet is meant for this track.
2086 * \param buffer The actual frame contents.
2087 * \param size The frame size in bytes.
2088 * \param block_bref A relative timecode (backward reference). If it is \c 0
2089 * then the frame is an I frame.
2090 * \param block_fref A relative timecode (forward reference). If it is \c 0
2091 * then the frame is either an I frame or a P frame depending on the value
2092 * of \a block_bref. Otherwise it's a B frame.
2094 static void handle_video_bframes(demuxer_t
*demuxer
, mkv_track_t
*track
,
2095 uint8_t *buffer
, uint32_t size
,
2096 int block_bref
, int block_fref
)
2098 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2101 dp
= new_demux_packet(size
);
2102 memcpy(dp
->buffer
, buffer
, size
);
2103 dp
->pos
= demuxer
->filepos
;
2104 dp
->pts
= mkv_d
->last_pts
;
2105 if ((track
->num_cached_dps
> 0) && (dp
->pts
< track
->max_pts
))
2107 if (block_fref
== 0) /* I or P frame */
2108 flush_cached_dps(demuxer
, track
);
2109 if (block_bref
!= 0) /* I frame, don't cache it */
2111 if ((track
->num_cached_dps
+ 1) > track
->num_allocated_dps
) {
2112 track
->cached_dps
= (demux_packet_t
**)
2113 realloc(track
->cached_dps
,
2114 (track
->num_cached_dps
+ 10) * sizeof(demux_packet_t
*));
2115 track
->num_allocated_dps
+= 10;
2117 track
->cached_dps
[track
->num_cached_dps
] = dp
;
2118 track
->num_cached_dps
++;
2119 if (dp
->pts
> track
->max_pts
)
2120 track
->max_pts
= dp
->pts
;
2123 static int handle_block(demuxer_t
*demuxer
, uint8_t *block
, uint64_t length
,
2124 uint64_t block_duration
, int64_t block_bref
,
2125 int64_t block_fref
, uint8_t simpleblock
)
2127 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2128 mkv_track_t
*track
= NULL
;
2129 demux_stream_t
*ds
= NULL
;
2130 uint64_t old_length
;
2132 uint32_t *lace_size
;
2133 uint8_t laces
, flags
;
2134 int i
, num
, tmp
, use_this_block
= 1;
2138 /* first byte(s): track num */
2139 num
= ebml_read_vlen_uint(block
, &tmp
);
2141 /* time (relative to cluster time) */
2142 time
= block
[0] << 8 | block
[1];
2145 old_length
= length
;
2147 if (demux_mkv_read_block_lacing(block
, &length
, &laces
, &lace_size
))
2149 block
+= old_length
- length
;
2151 tc
= (time
* mkv_d
->tc_scale
+ mkv_d
->cluster_tc
) / 1000000.0 + 0.5;
2154 current_pts
= tc
/ 1000.0;
2156 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2157 if (mkv_d
->tracks
[i
]->tnum
== num
) {
2158 track
= mkv_d
->tracks
[i
];
2161 if (track
== NULL
) {
2165 if (track
->type
== MATROSKA_TRACK_AUDIO
2166 && track
->id
== demuxer
->audio
->id
) {
2167 ds
= demuxer
->audio
;
2169 if (mkv_d
->a_skip_to_keyframe
) {
2171 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2173 } else if (block_bref
!= 0)
2175 } else if (mkv_d
->v_skip_to_keyframe
)
2178 if (track
->fix_i_bps
&& use_this_block
) {
2179 sh_audio_t
*sh
= (sh_audio_t
*) ds
->sh
;
2181 if (block_duration
!= 0) {
2182 sh
->i_bps
= length
* 1000 / block_duration
;
2183 track
->fix_i_bps
= 0;
2184 } else if (track
->qt_last_a_pts
== 0.0)
2185 track
->qt_last_a_pts
= current_pts
;
2186 else if (track
->qt_last_a_pts
!= current_pts
) {
2187 sh
->i_bps
= length
/ (current_pts
- track
->qt_last_a_pts
);
2188 track
->fix_i_bps
= 0;
2191 } else if (tc
< mkv_d
->skip_to_timecode
)
2193 else if (track
->type
== MATROSKA_TRACK_VIDEO
2194 && track
->id
== demuxer
->video
->id
) {
2195 ds
= demuxer
->video
;
2196 if (mkv_d
->v_skip_to_keyframe
) {
2198 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2200 } else if (block_bref
!= 0 || block_fref
!= 0)
2203 } else if (track
->type
== MATROSKA_TRACK_SUBTITLE
2204 && track
->id
== demuxer
->sub
->id
) {
2206 if (track
->subtitle_type
!= MATROSKA_SUBTYPE_VOBSUB
) {
2209 demux_mkv_decode(track
, block
, &buffer
, &size
, 1);
2210 handle_subtitles(demuxer
, track
, buffer
, size
, block_duration
, tc
);
2211 if (buffer
!= block
)
2212 talloc_free(buffer
);
2218 if (use_this_block
) {
2219 mkv_d
->last_pts
= current_pts
;
2220 mkv_d
->last_filepos
= demuxer
->filepos
;
2222 for (i
= 0; i
< laces
; i
++) {
2223 if (ds
== demuxer
->video
&& track
->realmedia
)
2224 handle_realvideo(demuxer
, track
, block
, lace_size
[i
],
2226 else if (ds
== demuxer
->audio
&& track
->realmedia
)
2227 handle_realaudio(demuxer
, track
, block
, lace_size
[i
],
2229 else if (ds
== demuxer
->video
&& track
->reorder_timecodes
)
2230 handle_video_bframes(demuxer
, track
, block
, lace_size
[i
],
2231 block_bref
, block_fref
);
2233 int size
= lace_size
[i
];
2236 demux_mkv_decode(track
, block
, &buffer
, &size
, 1);
2238 dp
= new_demux_packet(size
);
2239 memcpy(dp
->buffer
, buffer
, size
);
2240 if (buffer
!= block
)
2241 talloc_free(buffer
);
2242 dp
->flags
= (block_bref
== 0
2243 && block_fref
== 0) ? 0x10 : 0;
2244 /* If default_duration is 0, assume no pts value is known
2245 * for packets after the first one (rather than all pts
2246 * values being the same) */
2247 if (i
== 0 || track
->default_duration
)
2249 mkv_d
->last_pts
+ i
* track
->default_duration
;
2250 ds_add_packet(ds
, dp
);
2253 block
+= lace_size
[i
];
2256 if (ds
== demuxer
->video
) {
2257 mkv_d
->v_skip_to_keyframe
= 0;
2258 mkv_d
->skip_to_timecode
= 0;
2259 } else if (ds
== demuxer
->audio
)
2260 mkv_d
->a_skip_to_keyframe
= 0;
2270 static int demux_mkv_fill_buffer(demuxer_t
*demuxer
, demux_stream_t
*ds
)
2272 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2273 stream_t
*s
= demuxer
->stream
;
2278 while (mkv_d
->cluster_size
> 0) {
2279 uint64_t block_duration
= 0, block_length
= 0;
2280 int64_t block_bref
= 0, block_fref
= 0;
2281 uint8_t *block
= NULL
;
2283 while (mkv_d
->blockgroup_size
> 0) {
2284 switch (ebml_read_id(s
, &il
)) {
2285 case MATROSKA_ID_BLOCKDURATION
:
2286 block_duration
= ebml_read_uint(s
, &l
);
2287 if (block_duration
== EBML_UINT_INVALID
) {
2292 block_duration
* mkv_d
->tc_scale
/ 1000000.0 + 0.5;
2295 case MATROSKA_ID_BLOCK
:
2296 block_length
= ebml_read_length(s
, &tmp
);
2298 if (block_length
> SIZE_MAX
- AV_LZO_INPUT_PADDING
)
2300 block
= malloc(block_length
+ AV_LZO_INPUT_PADDING
);
2301 demuxer
->filepos
= stream_tell(s
);
2302 if (stream_read(s
, block
, block_length
) !=
2303 (int) block_length
) {
2307 l
= tmp
+ block_length
;
2310 case MATROSKA_ID_REFERENCEBLOCK
:;
2311 int64_t num
= ebml_read_int(s
, &l
);
2312 if (num
== EBML_INT_INVALID
) {
2322 case EBML_ID_INVALID
:
2327 ebml_read_skip(s
, &l
);
2330 mkv_d
->blockgroup_size
-= l
+ il
;
2331 mkv_d
->cluster_size
-= l
+ il
;
2335 int res
= handle_block(demuxer
, block
, block_length
,
2336 block_duration
, block_bref
, block_fref
,
2345 if (mkv_d
->cluster_size
> 0) {
2346 switch (ebml_read_id(s
, &il
)) {
2347 case MATROSKA_ID_TIMECODE
:;
2348 uint64_t num
= ebml_read_uint(s
, &l
);
2349 if (num
== EBML_UINT_INVALID
)
2351 mkv_d
->cluster_tc
= num
* mkv_d
->tc_scale
;
2352 add_cluster_position(mkv_d
, mkv_d
->cluster_start
,
2356 case MATROSKA_ID_BLOCKGROUP
:
2357 mkv_d
->blockgroup_size
= ebml_read_length(s
, &tmp
);
2361 case MATROSKA_ID_SIMPLEBLOCK
:;
2363 block_length
= ebml_read_length(s
, &tmp
);
2364 block
= malloc(block_length
);
2365 demuxer
->filepos
= stream_tell(s
);
2366 if (stream_read(s
, block
, block_length
) !=
2367 (int) block_length
) {
2371 l
= tmp
+ block_length
;
2372 res
= handle_block(demuxer
, block
, block_length
,
2373 block_duration
, block_bref
,
2376 mkv_d
->cluster_size
-= l
+ il
;
2382 mkv_d
->cluster_size
+= l
+ il
;
2385 case EBML_ID_INVALID
:
2389 ebml_read_skip(s
, &l
);
2392 mkv_d
->cluster_size
-= l
+ il
;
2396 while (ebml_read_id(s
, &il
) != MATROSKA_ID_CLUSTER
) {
2397 ebml_read_skip(s
, NULL
);
2401 mkv_d
->cluster_start
= stream_tell(s
) - il
;
2402 mkv_d
->cluster_size
= ebml_read_length(s
, NULL
);
2408 static void demux_mkv_seek(demuxer_t
*demuxer
, float rel_seek_secs
,
2409 float audio_delay
, int flags
)
2411 mkv_demuxer_t
*mkv_d
= demuxer
->priv
;
2412 uint64_t v_tnum
= -1;
2413 if (demuxer
->video
->id
>= 0)
2414 v_tnum
= find_track_by_num(mkv_d
, demuxer
->video
->id
,
2415 MATROSKA_TRACK_VIDEO
)->tnum
;
2416 uint64_t a_tnum
= -1;
2417 if (demuxer
->audio
->id
>= 0)
2418 a_tnum
= find_track_by_num(mkv_d
, demuxer
->audio
->id
,
2419 MATROSKA_TRACK_VIDEO
)->tnum
;
2420 if (!(flags
& (SEEK_BACKWARD
| SEEK_FORWARD
))) {
2421 if (flags
& SEEK_ABSOLUTE
|| rel_seek_secs
< 0)
2422 flags
|= SEEK_BACKWARD
;
2424 flags
|= SEEK_FORWARD
;
2426 // Adjust the target a little bit to catch cases where the target position
2427 // specifies a keyframe with high, but not perfect, precision.
2428 rel_seek_secs
+= flags
& SEEK_FORWARD
? -0.005 : 0.005;
2430 free_cached_dps(demuxer
);
2431 if (!(flags
& SEEK_FACTOR
)) { /* time in secs */
2432 mkv_index_t
*index
= NULL
;
2433 stream_t
*s
= demuxer
->stream
;
2434 int64_t target_timecode
= 0, diff
, min_diff
= 0xFFFFFFFFFFFFFFFLL
;
2437 if (!(flags
& SEEK_ABSOLUTE
)) /* relative seek */
2438 target_timecode
= (int64_t) (mkv_d
->last_pts
* 1000.0);
2439 target_timecode
+= (int64_t) (rel_seek_secs
* 1000.0);
2440 if (target_timecode
< 0)
2441 target_timecode
= 0;
2443 if (mkv_d
->indexes
== NULL
) { /* no index was found */
2444 int64_t target_tc_ns
= (int64_t) (rel_seek_secs
* 1e9
);
2445 if (target_tc_ns
< 0)
2447 uint64_t max_filepos
= 0;
2448 int64_t max_tc
= -1;
2449 int n
= mkv_d
->num_cluster_pos
;
2451 max_filepos
= mkv_d
->cluster_positions
[n
- 1].filepos
;
2452 max_tc
= mkv_d
->cluster_positions
[n
- 1].timecode
;
2455 if (target_tc_ns
> max_tc
) {
2456 if ((off_t
) max_filepos
> stream_tell(s
))
2457 stream_seek(s
, max_filepos
);
2459 stream_seek(s
, stream_tell(s
) + mkv_d
->cluster_size
);
2460 /* parse all the clusters upto target_filepos */
2462 uint64_t start
= stream_tell(s
);
2463 uint32_t type
= ebml_read_id(s
, NULL
);
2464 uint64_t len
= ebml_read_length(s
, NULL
);
2465 uint64_t end
= stream_tell(s
) + len
;
2466 if (type
== MATROSKA_ID_CLUSTER
) {
2467 while (!s
->eof
&& stream_tell(s
) < end
) {
2468 if (ebml_read_id(s
, NULL
)
2469 == MATROSKA_ID_TIMECODE
) {
2470 uint64_t tc
= ebml_read_uint(s
, NULL
);
2471 tc
*= mkv_d
->tc_scale
;
2472 add_cluster_position(mkv_d
, start
, tc
);
2473 if (tc
>= target_tc_ns
)
2479 stream_seek(s
, end
);
2485 if (!mkv_d
->num_cluster_pos
) {
2486 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] no target for seek found\n");
2489 uint64_t cluster_pos
= mkv_d
->cluster_positions
[0].filepos
;
2490 /* Let's find the nearest cluster */
2491 for (i
= 0; i
< mkv_d
->num_cluster_pos
; i
++) {
2492 diff
= mkv_d
->cluster_positions
[i
].timecode
- target_tc_ns
;
2493 if (flags
& SEEK_BACKWARD
&& diff
< 0 && -diff
< min_diff
) {
2494 cluster_pos
= mkv_d
->cluster_positions
[i
].filepos
;
2496 } else if (flags
& SEEK_FORWARD
2497 && (diff
< 0 ? -1 * diff
: diff
) < min_diff
) {
2498 cluster_pos
= mkv_d
->cluster_positions
[i
].filepos
;
2499 min_diff
= diff
< 0 ? -1 * diff
: diff
;
2502 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2503 stream_seek(s
, cluster_pos
);
2505 int seek_id
= (demuxer
->video
->id
< 0) ?
2508 /* let's find the entry in the indexes with the smallest */
2509 /* difference to the wanted timecode. */
2510 for (i
= 0; i
< mkv_d
->num_indexes
; i
++)
2511 if (mkv_d
->indexes
[i
].tnum
== seek_id
) {
2514 (int64_t) (mkv_d
->indexes
[i
].timecode
*
2515 mkv_d
->tc_scale
/ 1000000.0 + 0.5);
2517 if (flags
& SEEK_BACKWARD
) {
2518 // Seek backward: find the last index position
2519 // before target time
2520 if (diff
< 0 || diff
>= min_diff
)
2523 // Seek forward: find the first index position
2524 // after target time. If no such index exists, find last
2525 // position between current position and target time.
2527 if (min_diff
<= 0 && diff
<= min_diff
)
2530 FFMIN(target_timecode
- mkv_d
->last_pts
,
2535 index
= mkv_d
->indexes
+ i
;
2538 if (index
) { /* We've found an entry. */
2539 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2540 stream_seek(s
, index
->filepos
);
2544 if (demuxer
->video
->id
>= 0)
2545 mkv_d
->v_skip_to_keyframe
= 1;
2546 if (flags
& SEEK_FORWARD
)
2547 mkv_d
->skip_to_timecode
= target_timecode
;
2549 mkv_d
->skip_to_timecode
= index
? index
->timecode
: 0;
2550 mkv_d
->a_skip_to_keyframe
= 1;
2552 demux_mkv_fill_buffer(demuxer
, NULL
);
2553 } else if ((demuxer
->movi_end
<= 0) || !(flags
& SEEK_ABSOLUTE
))
2554 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
2556 stream_t
*s
= demuxer
->stream
;
2557 uint64_t target_filepos
;
2558 mkv_index_t
*index
= NULL
;
2561 if (mkv_d
->indexes
== NULL
) { /* not implemented without index */
2562 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
2566 target_filepos
= (uint64_t) (demuxer
->movi_end
* rel_seek_secs
);
2567 for (i
= 0; i
< mkv_d
->num_indexes
; i
++)
2568 if (mkv_d
->indexes
[i
].tnum
== v_tnum
)
2570 || ((mkv_d
->indexes
[i
].filepos
>= target_filepos
)
2571 && ((index
->filepos
< target_filepos
)
2572 || (mkv_d
->indexes
[i
].filepos
< index
->filepos
))))
2573 index
= &mkv_d
->indexes
[i
];
2578 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2579 stream_seek(s
, index
->filepos
);
2581 if (demuxer
->video
->id
>= 0)
2582 mkv_d
->v_skip_to_keyframe
= 1;
2583 mkv_d
->skip_to_timecode
= index
->timecode
;
2584 mkv_d
->a_skip_to_keyframe
= 1;
2586 demux_mkv_fill_buffer(demuxer
, NULL
);
2590 static int demux_mkv_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
2592 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2595 case DEMUXER_CTRL_CORRECT_PTS
:
2596 return DEMUXER_CTRL_OK
;
2597 case DEMUXER_CTRL_GET_TIME_LENGTH
:
2598 if (mkv_d
->duration
== 0)
2599 return DEMUXER_CTRL_DONTKNOW
;
2601 *((double *) arg
) = (double) mkv_d
->duration
;
2602 return DEMUXER_CTRL_OK
;
2604 case DEMUXER_CTRL_GET_PERCENT_POS
:
2605 if (mkv_d
->duration
== 0) {
2606 return DEMUXER_CTRL_DONTKNOW
;
2609 *((int *) arg
) = (int) (100 * mkv_d
->last_pts
/ mkv_d
->duration
);
2610 return DEMUXER_CTRL_OK
;
2612 case DEMUXER_CTRL_SWITCH_AUDIO
:
2613 if (demuxer
->audio
&& demuxer
->audio
->sh
) {
2614 sh_audio_t
*sh
= demuxer
->a_streams
[demuxer
->audio
->id
];
2615 int aid
= *(int *) arg
;
2617 aid
= (sh
->aid
+ 1) % mkv_d
->num_audio_tracks
;
2618 if (aid
!= sh
->aid
) {
2619 mkv_track_t
*track
=
2620 find_track_by_num(mkv_d
, aid
, MATROSKA_TRACK_AUDIO
);
2622 demuxer
->audio
->id
= track
->id
;
2623 sh
= demuxer
->a_streams
[demuxer
->audio
->id
];
2624 ds_free_packs(demuxer
->audio
);
2627 *(int *) arg
= sh
->aid
;
2630 return DEMUXER_CTRL_OK
;
2633 return DEMUXER_CTRL_NOTIMPL
;
2637 const demuxer_desc_t demuxer_desc_matroska
= {
2643 DEMUXER_TYPE_MATROSKA
,
2644 1, // safe autodetect
2646 demux_mkv_fill_buffer
,