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"
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
{
102 uint32_t v_width
, v_height
, v_dwidth
, v_dheight
;
105 uint32_t a_formattag
;
106 uint32_t a_channels
, a_bps
;
109 double default_duration
;
113 unsigned char *private_data
;
114 unsigned int private_size
;
116 /* stuff for realmedia */
120 double rv_pts
; /* previous video timestamp */
121 double ra_pts
; /* previous audio timestamp */
123 /** realaudio descrambling */
124 int sub_packet_size
; ///< sub packet size, per stream
125 int sub_packet_h
; ///< number of coded frames per block
126 int coded_framesize
; ///< coded frame size, per stream
127 int audiopk_size
; ///< audio packet size
128 unsigned char *audio_buf
; ///< place to store reordered audio data
129 double *audio_timestamp
; ///< timestamp for each audio packet
130 int sub_packet_cnt
; ///< number of subpacket already received
131 int audio_filepos
; ///< file position of first audio packet in block
133 /* stuff for quicktime */
135 double qt_last_a_pts
;
139 /* The timecodes of video frames might have to be reordered if they're
140 in display order (the timecodes, not the frames themselves!). In this
141 case demux packets have to be cached with the help of these variables. */
142 int reorder_timecodes
;
143 demux_packet_t
**cached_dps
;
144 int num_cached_dps
, num_allocated_dps
;
147 /* generic content encoding support */
148 mkv_content_encoding_t
*encodings
;
151 /* For VobSubs and SSA/ASS */
155 typedef struct mkv_index
{
157 uint64_t timecode
, filepos
;
160 typedef struct mkv_demuxer
{
163 double duration
, last_pts
;
164 uint64_t last_filepos
;
166 mkv_track_t
**tracks
;
169 uint64_t tc_scale
, cluster_tc
;
171 uint64_t cluster_start
;
172 uint64_t cluster_size
;
173 uint64_t blockgroup_size
;
175 mkv_index_t
*indexes
;
183 bool parsed_chapters
;
184 bool parsed_attachments
;
189 } *cluster_positions
;
192 int64_t skip_to_timecode
;
193 int v_skip_to_keyframe
, a_skip_to_keyframe
;
196 int audio_tracks
[MAX_A_STREAMS
];
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
*demux_mkv_find_track_by_num(mkv_demuxer_t
*d
, int n
,
245 for (i
= 0, id
= 0; i
< d
->num_tracks
; i
++)
246 if (d
->tracks
[i
] != NULL
&& d
->tracks
[i
]->type
== type
)
253 static void add_cluster_position(mkv_demuxer_t
*mkv_d
, uint64_t filepos
,
259 int n
= mkv_d
->num_cluster_pos
;
260 if (n
> 0 && mkv_d
->cluster_positions
[n
-1].filepos
>= filepos
)
263 mkv_d
->cluster_positions
=
264 grow_array(mkv_d
->cluster_positions
, mkv_d
->num_cluster_pos
,
265 sizeof(*mkv_d
->cluster_positions
));
266 mkv_d
->cluster_positions
[mkv_d
->num_cluster_pos
++] = (struct cluster_pos
){
268 .timecode
= timecode
,
273 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
274 static int aac_get_sample_rate_index(uint32_t sample_rate
)
276 static const int srates
[] = {
277 92017, 75132, 55426, 46009, 37566, 27713,
278 23004, 18783, 13856, 11502, 9391, 0
281 while (sample_rate
< srates
[i
])
286 /** \brief Free cached demux packets
288 * Reordering the timecodes requires caching of demux packets. This function
289 * frees all these cached packets and the memory for the cached pointers
292 * \param demuxer The demuxer for which the cache is to be freed.
294 static void free_cached_dps(demuxer_t
*demuxer
)
296 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
300 for (k
= 0; k
< mkv_d
->num_tracks
; k
++) {
301 track
= mkv_d
->tracks
[k
];
302 for (i
= 0; i
< track
->num_cached_dps
; i
++)
303 free_demux_packet(track
->cached_dps
[i
]);
304 free(track
->cached_dps
);
305 track
->cached_dps
= NULL
;
306 track
->num_cached_dps
= 0;
307 track
->num_allocated_dps
= 0;
312 static int demux_mkv_decode(mkv_track_t
*track
, uint8_t *src
,
313 uint8_t **dest
, uint32_t *size
, uint32_t type
)
319 if (track
->num_encodings
<= 0)
322 for (i
= 0; i
< track
->num_encodings
; i
++) {
323 if (!(track
->encodings
[i
].scope
& type
))
327 if (track
->encodings
[i
].comp_algo
== 0) {
328 /* zlib encoded track */
331 zstream
.zalloc
= (alloc_func
) 0;
332 zstream
.zfree
= (free_func
) 0;
333 zstream
.opaque
= (voidpf
) 0;
334 if (inflateInit(&zstream
) != Z_OK
) {
335 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
336 "[mkv] zlib initialization failed.\n");
339 zstream
.next_in
= (Bytef
*) src
;
340 zstream
.avail_in
= *size
;
344 zstream
.avail_out
= *size
;
347 *dest
= realloc(*dest
, *size
);
348 zstream
.next_out
= (Bytef
*) (*dest
+ zstream
.total_out
);
349 result
= inflate(&zstream
, Z_NO_FLUSH
);
350 if (result
!= Z_OK
&& result
!= Z_STREAM_END
) {
351 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
352 "[mkv] zlib decompression failed.\n");
355 inflateEnd(&zstream
);
358 zstream
.avail_out
+= 4000;
359 } while (zstream
.avail_out
== 4000 && zstream
.avail_in
!= 0
360 && result
!= Z_STREAM_END
);
362 *size
= zstream
.total_out
;
363 inflateEnd(&zstream
);
366 if (track
->encodings
[i
].comp_algo
== 2) {
367 /* lzo encoded track */
368 int dstlen
= *size
* 3;
373 if (dstlen
> SIZE_MAX
- AV_LZO_OUTPUT_PADDING
)
375 *dest
= realloc(*dest
, dstlen
+ AV_LZO_OUTPUT_PADDING
);
376 result
= av_lzo1x_decode(*dest
, &dstlen
, src
, &srclen
);
379 if (!(result
& AV_LZO_OUTPUT_FULL
)) {
381 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
382 "[mkv] lzo decompression failed.\n");
387 mp_msg(MSGT_DEMUX
, MSGL_DBG2
,
388 "[mkv] lzo decompression buffer too small.\n");
399 static int demux_mkv_read_info(demuxer_t
*demuxer
)
401 mkv_demuxer_t
*mkv_d
= demuxer
->priv
;
402 stream_t
*s
= demuxer
->stream
;
404 mkv_d
->tc_scale
= 1000000;
407 struct ebml_info info
= {};
408 struct ebml_parse_ctx parse_ctx
= {};
409 if (ebml_read_element(s
, &parse_ctx
, &info
, &ebml_info_desc
) < 0)
411 if (info
.n_timecode_scale
) {
412 mkv_d
->tc_scale
= info
.timecode_scale
;
413 mp_msg(MSGT_DEMUX
, MSGL_V
,
414 "[mkv] | + timecode scale: %" PRIu64
"\n", mkv_d
->tc_scale
);
416 if (info
.n_duration
) {
417 mkv_d
->duration
= info
.duration
* mkv_d
->tc_scale
/ 1e9
;
418 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + duration: %.3fs\n",
421 if (info
.n_segment_uid
) {
422 int len
= info
.segment_uid
.len
;
423 if (len
!= sizeof(demuxer
->matroska_data
.segment_uid
)) {
424 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
425 "[mkv] segment uid invalid length %d\n", len
);
427 memcpy(demuxer
->matroska_data
.segment_uid
, info
.segment_uid
.start
,
429 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + segment uid");
430 for (int i
= 0; i
< len
; i
++)
431 mp_msg(MSGT_DEMUX
, MSGL_V
, " %02x",
432 demuxer
->matroska_data
.segment_uid
[i
]);
433 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
436 talloc_free(parse_ctx
.talloc_ctx
);
440 static int demux_mkv_read_trackencodings(demuxer_t
*demuxer
,
443 stream_t
*s
= demuxer
->stream
;
444 // initial allocation to be a non-NULL context before realloc
445 mkv_content_encoding_t
*ce
= talloc_size(track
, 1);
447 struct ebml_content_encodings encodings
= {};
448 struct ebml_parse_ctx parse_ctx
= {};
449 if (ebml_read_element(s
, &parse_ctx
, &encodings
,
450 &ebml_content_encodings_desc
) < 0)
452 for (int n_enc
= 0; n_enc
< encodings
.n_content_encoding
; n_enc
++) {
453 struct ebml_content_encoding
*enc
= encodings
.content_encoding
+ n_enc
;
454 struct mkv_content_encoding e
= {};
455 e
.order
= enc
->content_encoding_order
;
456 if (enc
->n_content_encoding_scope
)
457 e
.scope
= enc
->content_encoding_scope
;
460 e
.type
= enc
->content_encoding_type
;
462 if (enc
->n_content_compression
) {
463 struct ebml_content_compression
*z
= &enc
->content_compression
;
464 e
.comp_algo
= z
->content_comp_algo
;
465 if (z
->n_content_comp_settings
) {
466 int sz
= z
->content_comp_settings
.len
;
467 e
.comp_settings
= talloc_size(ce
, sz
);
468 memcpy(e
.comp_settings
, z
->content_comp_settings
.start
, sz
);
469 e
.comp_settings_len
= sz
;
474 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Track "
475 "number %u has been encrypted and "
476 "decryption has not yet been\n"
477 "[mkv] implemented. Skipping track.\n",
479 } else if (e
.type
!= 0) {
480 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
481 "[mkv] Unknown content encoding type for "
482 "track %u. Skipping track.\n",
484 } else if (e
.comp_algo
!= 0 && e
.comp_algo
!= 2) {
485 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
486 "[mkv] Track %u has been compressed with "
487 "an unknown/unsupported compression\n"
488 "[mkv] algorithm (%" PRIu64
"). Skipping track.\n",
489 track
->tnum
, e
.comp_algo
);
492 else if (e
.comp_algo
== 0) {
493 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
494 "[mkv] Track %u was compressed with zlib "
495 "but mplayer has not been compiled\n"
496 "[mkv] with support for zlib compression. "
502 for (i
= 0; i
< n_enc
; i
++)
503 if (e
.order
<= ce
[i
].order
)
505 ce
= talloc_realloc_size(track
, ce
, (n_enc
+ 1) * sizeof(*ce
));
506 memmove(ce
+ i
+ 1, ce
+ i
, (n_enc
- i
) * sizeof(*ce
));
507 memcpy(ce
+ i
, &e
, sizeof(e
));
510 track
->encodings
= ce
;
511 track
->num_encodings
= encodings
.n_content_encoding
;
512 talloc_free(parse_ctx
.talloc_ctx
);
513 return parse_ctx
.bytes_read
;
516 static int demux_mkv_read_trackaudio(demuxer_t
*demuxer
, mkv_track_t
*track
)
518 stream_t
*s
= demuxer
->stream
;
520 struct ebml_audio audio
= {};
521 struct ebml_parse_ctx parse_ctx
= {};
522 if (ebml_read_element(s
, &parse_ctx
, &audio
, &ebml_audio_desc
) < 0)
524 if (audio
.n_sampling_frequency
) {
525 track
->a_sfreq
= audio
.sampling_frequency
;
526 mp_msg(MSGT_DEMUX
, MSGL_V
,
527 "[mkv] | + Sampling frequency: %f\n", track
->a_sfreq
);
529 track
->a_sfreq
= 8000;
530 if (audio
.n_bit_depth
) {
531 track
->a_bps
= audio
.bit_depth
;
532 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Bit depth: %u\n",
535 if (audio
.n_channels
) {
536 track
->a_channels
= audio
.channels
;
537 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Channels: %u\n",
540 track
->a_channels
= 1;
541 talloc_free(parse_ctx
.talloc_ctx
);
542 return parse_ctx
.bytes_read
;
545 static int demux_mkv_read_trackvideo(demuxer_t
*demuxer
, mkv_track_t
*track
)
547 stream_t
*s
= demuxer
->stream
;
549 struct ebml_video video
= {};
550 struct ebml_parse_ctx parse_ctx
= {};
551 if (ebml_read_element(s
, &parse_ctx
, &video
, &ebml_video_desc
) < 0)
553 if (video
.n_frame_rate
) {
554 track
->v_frate
= video
.frame_rate
;
555 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Frame rate: %f\n",
557 // XXX default_duration should take priority
558 if (track
->v_frate
> 0)
559 track
->default_duration
= 1 / track
->v_frate
;
561 if (video
.n_display_width
) {
562 track
->v_dwidth
= video
.display_width
;
563 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display width: %u\n",
566 if (video
.n_display_height
) {
567 track
->v_dheight
= video
.display_height
;
568 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display height: %u\n",
571 if (video
.n_pixel_width
) {
572 track
->v_width
= video
.pixel_width
;
573 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel width: %u\n",
576 if (video
.n_pixel_height
) {
577 track
->v_height
= video
.pixel_height
;
578 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel height: %u\n",
581 talloc_free(parse_ctx
.talloc_ctx
);
582 return parse_ctx
.bytes_read
;
586 * \brief free any data associated with given track
587 * \param track track of which to free data
589 static void demux_mkv_free_trackentry(mkv_track_t
*track
)
592 free(track
->codec_id
);
593 free(track
->language
);
594 free(track
->private_data
);
595 free(track
->audio_buf
);
596 free(track
->audio_timestamp
);
600 static int demux_mkv_read_trackentry(demuxer_t
*demuxer
)
602 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
603 stream_t
*s
= demuxer
->stream
;
605 uint64_t len
, length
, l
;
609 track
= talloc_zero_size(NULL
, sizeof(*track
));
610 /* set default values */
611 track
->default_track
= 1;
613 track
->language
= strdup("eng");
615 len
= length
= ebml_read_length(s
, &il
);
618 switch (ebml_read_id(s
, &il
)) {
619 case MATROSKA_ID_TRACKNUMBER
:
620 num
= ebml_read_uint(s
, &l
);
621 if (num
== EBML_UINT_INVALID
)
624 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track number: %u\n",
628 case MATROSKA_ID_NAME
:
629 track
->name
= ebml_read_utf8(s
, &l
);
630 if (track
->name
== NULL
)
632 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Name: %s\n",
636 case MATROSKA_ID_TRACKTYPE
:
637 num
= ebml_read_uint(s
, &l
);
638 if (num
== EBML_UINT_INVALID
)
641 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track type: ");
642 switch (track
->type
) {
643 case MATROSKA_TRACK_AUDIO
:
644 mp_msg(MSGT_DEMUX
, MSGL_V
, "Audio\n");
646 case MATROSKA_TRACK_VIDEO
:
647 mp_msg(MSGT_DEMUX
, MSGL_V
, "Video\n");
649 case MATROSKA_TRACK_SUBTITLE
:
650 mp_msg(MSGT_DEMUX
, MSGL_V
, "Subtitle\n");
653 mp_msg(MSGT_DEMUX
, MSGL_V
, "unknown\n");
658 case MATROSKA_ID_AUDIO
:
659 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Audio track\n");
660 l
= demux_mkv_read_trackaudio(demuxer
, track
);
665 case MATROSKA_ID_VIDEO
:
666 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Video track\n");
667 l
= demux_mkv_read_trackvideo(demuxer
, track
);
672 case MATROSKA_ID_CODECID
:
673 track
->codec_id
= ebml_read_ascii(s
, &l
);
674 if (track
->codec_id
== NULL
)
676 if (!strcmp(track
->codec_id
, MKV_V_MSCOMP
)
677 || !strcmp(track
->codec_id
, MKV_A_ACM
))
678 track
->ms_compat
= 1;
679 else if (!strcmp(track
->codec_id
, MKV_S_VOBSUB
))
680 track
->subtitle_type
= MATROSKA_SUBTYPE_VOBSUB
;
681 else if (!strcmp(track
->codec_id
, MKV_S_TEXTSSA
)
682 || !strcmp(track
->codec_id
, MKV_S_TEXTASS
)
683 || !strcmp(track
->codec_id
, MKV_S_SSA
)
684 || !strcmp(track
->codec_id
, MKV_S_ASS
)) {
685 track
->subtitle_type
= MATROSKA_SUBTYPE_SSA
;
686 } else if (!strcmp(track
->codec_id
, MKV_S_TEXTASCII
))
687 track
->subtitle_type
= MATROSKA_SUBTYPE_TEXT
;
688 if (!strcmp(track
->codec_id
, MKV_S_TEXTUTF8
)) {
689 track
->subtitle_type
= MATROSKA_SUBTYPE_TEXT
;
691 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Codec ID: %s\n",
695 case MATROSKA_ID_CODECPRIVATE
:;
697 num
= ebml_read_length(s
, &x
);
698 // audit: cheap guard against overflows later..
699 if (num
> SIZE_MAX
- 1000)
702 track
->private_data
= malloc(num
+ AV_LZO_INPUT_PADDING
);
703 if (stream_read(s
, track
->private_data
, num
) != (int) num
)
705 track
->private_size
= num
;
706 mp_msg(MSGT_DEMUX
, MSGL_V
,
707 "[mkv] | + CodecPrivate, length " "%u\n",
708 track
->private_size
);
711 case MATROSKA_ID_LANGUAGE
:
712 free(track
->language
);
713 track
->language
= ebml_read_utf8(s
, &l
);
714 if (track
->language
== NULL
)
716 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Language: %s\n",
720 case MATROSKA_ID_FLAGDEFAULT
:
721 num
= ebml_read_uint(s
, &l
);
722 if (num
== EBML_UINT_INVALID
)
724 track
->default_track
= num
;
725 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default flag: %u\n",
726 track
->default_track
);
729 case MATROSKA_ID_DEFAULTDURATION
:
730 num
= ebml_read_uint(s
, &l
);
731 if (num
== EBML_UINT_INVALID
)
734 mp_msg(MSGT_DEMUX
, MSGL_V
,
735 "[mkv] | + Default duration: 0");
737 track
->v_frate
= 1000000000.0 / num
;
738 track
->default_duration
= num
/ 1000000000.0;
739 mp_msg(MSGT_DEMUX
, MSGL_V
,
740 "[mkv] | + Default duration: "
741 "%.3fms ( = %.3f fps)\n", num
/ 1000000.0,
746 case MATROSKA_ID_CONTENTENCODINGS
:
747 l
= demux_mkv_read_trackencodings(demuxer
, track
);
753 ebml_read_skip(s
, &l
);
759 mkv_d
->tracks
[mkv_d
->num_tracks
++] = track
;
763 demux_mkv_free_trackentry(track
);
767 static int demux_mkv_read_tracks(demuxer_t
*demuxer
)
769 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
770 stream_t
*s
= demuxer
->stream
;
774 mkv_d
->tracks
= malloc(sizeof(*mkv_d
->tracks
));
775 mkv_d
->num_tracks
= 0;
777 length
= ebml_read_length(s
, NULL
);
779 switch (ebml_read_id(s
, &il
)) {
780 case MATROSKA_ID_TRACKENTRY
:
781 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + a track...\n");
782 mkv_d
->tracks
= realloc(mkv_d
->tracks
, (mkv_d
->num_tracks
+ 1)
783 * sizeof(*mkv_d
->tracks
));
784 l
= demux_mkv_read_trackentry(demuxer
);
790 ebml_read_skip(s
, &l
);
798 static int demux_mkv_read_cues(demuxer_t
*demuxer
)
800 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
801 stream_t
*s
= demuxer
->stream
;
803 if (index_mode
== 0 || index_mode
== 2) {
804 ebml_read_skip(s
, NULL
);
808 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing cues ] -----------\n");
809 struct ebml_cues cues
= {};
810 struct ebml_parse_ctx parse_ctx
= {};
811 if (ebml_read_element(s
, &parse_ctx
, &cues
, &ebml_cues_desc
) < 0)
813 for (int i
= 0; i
< cues
.n_cue_point
; i
++) {
814 struct ebml_cue_point
*cuepoint
= &cues
.cue_point
[i
];
815 if (cuepoint
->n_cue_time
!= 1 || !cuepoint
->n_cue_track_positions
) {
816 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Malformed CuePoint element\n");
819 uint64_t time
= cuepoint
->cue_time
;
820 for (int i
= 0; i
< cuepoint
->n_cue_track_positions
; i
++) {
821 struct ebml_cue_track_positions
*trackpos
=
822 &cuepoint
->cue_track_positions
[i
];
823 uint64_t track
= trackpos
->cue_track
;
824 uint64_t pos
= trackpos
->cue_cluster_position
;
826 grow_array(mkv_d
->indexes
, mkv_d
->num_indexes
,
827 sizeof(mkv_index_t
));
828 mkv_d
->indexes
[mkv_d
->num_indexes
].tnum
= track
;
829 mkv_d
->indexes
[mkv_d
->num_indexes
].timecode
= time
;
830 mkv_d
->indexes
[mkv_d
->num_indexes
].filepos
=
831 mkv_d
->segment_start
+ pos
;
832 mp_msg(MSGT_DEMUX
, MSGL_DBG2
,
833 "[mkv] |+ found cue point for track %" PRIu64
834 ": timecode %" PRIu64
", filepos: %" PRIu64
"\n", track
,
835 time
, mkv_d
->segment_start
+ pos
);
836 mkv_d
->num_indexes
++;
841 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] \\---- [ parsing cues ] -----------\n");
842 talloc_free(parse_ctx
.talloc_ctx
);
846 static int demux_mkv_read_chapters(struct demuxer
*demuxer
)
848 struct MPOpts
*opts
= demuxer
->opts
;
849 stream_t
*s
= demuxer
->stream
;
851 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing chapters ] ---------\n");
852 struct ebml_chapters file_chapters
= {};
853 struct ebml_parse_ctx parse_ctx
= {};
854 if (ebml_read_element(s
, &parse_ctx
, &file_chapters
,
855 &ebml_chapters_desc
) < 0)
858 int selected_edition
= 0;
859 int num_editions
= file_chapters
.n_edition_entry
;
860 struct ebml_edition_entry
*editions
= file_chapters
.edition_entry
;
861 if (opts
->edition_id
>= 0 && opts
->edition_id
< num_editions
) {
862 selected_edition
= opts
->edition_id
;
863 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] User-specified edition: %d\n",
866 for (int i
= 0; i
< num_editions
; i
++)
867 if (editions
[i
].edition_flag_default
) {
868 selected_edition
= i
;
869 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Default edition: %d\n", i
);
872 struct matroska_chapter
*m_chapters
= NULL
;
873 if (editions
[selected_edition
].edition_flag_ordered
) {
874 int count
= editions
[selected_edition
].n_chapter_atom
;
875 m_chapters
= talloc_array_ptrtype(demuxer
, m_chapters
, count
);
876 demuxer
->matroska_data
.ordered_chapters
= m_chapters
;
877 demuxer
->matroska_data
.num_ordered_chapters
= count
;
880 for (int idx
= 0; idx
< num_editions
; idx
++) {
881 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] New edition %d\n", idx
);
882 int warn_level
= idx
== selected_edition
? MSGL_WARN
: MSGL_V
;
883 if (editions
[idx
].n_edition_flag_default
)
884 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Default edition flag: %"PRIu64
885 "\n", editions
[idx
].edition_flag_default
);
886 if (editions
[idx
].n_edition_flag_ordered
)
887 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Ordered chapter flag: %"PRIu64
888 "\n", editions
[idx
].edition_flag_ordered
);
889 for (int i
= 0; i
< editions
[idx
].n_chapter_atom
; i
++) {
890 struct ebml_chapter_atom
*ca
= editions
[idx
].chapter_atom
+ i
;
891 struct matroska_chapter chapter
= { };
892 struct bstr name
= { "(unnamed)", 9 };
894 if (!ca
->n_chapter_time_start
)
895 mp_msg(MSGT_DEMUX
, warn_level
,
896 "[mkv] Chapter lacks start time\n");
897 chapter
.start
= ca
->chapter_time_start
/ 1000000;
898 chapter
.end
= ca
->chapter_time_end
/ 1000000;
900 if (ca
->n_chapter_display
) {
901 if (ca
->n_chapter_display
> 1)
902 mp_msg(MSGT_DEMUX
, warn_level
, "[mkv] Multiple chapter "
903 "names not supported, picking first\n");
904 if (!ca
->chapter_display
[0].n_chap_string
)
905 mp_msg(MSGT_DEMUX
, warn_level
, "[mkv] Malformed chapter "
908 name
= ca
->chapter_display
[0].chap_string
;
911 if (ca
->n_chapter_segment_uid
) {
912 chapter
.has_segment_uid
= true;
913 int len
= ca
->chapter_segment_uid
.len
;
914 if (len
!= sizeof(chapter
.segment_uid
))
915 mp_msg(MSGT_DEMUX
, warn_level
,
916 "[mkv] Chapter segment uid bad length %d\n", len
);
917 else if (ca
->n_chapter_segment_edition_uid
) {
918 mp_tmsg(MSGT_DEMUX
, warn_level
, "[mkv] Warning: "
919 "unsupported edition recursion in chapter; "
920 "will skip on playback!\n");
922 memcpy(chapter
.segment_uid
, ca
->chapter_segment_uid
.start
,
924 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Chapter segment uid ");
925 for (int i
= 0; i
< len
; i
++)
926 mp_msg(MSGT_DEMUX
, MSGL_V
, "%02x ",
927 chapter
.segment_uid
[i
]);
928 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
932 mp_msg(MSGT_DEMUX
, MSGL_V
,
933 "[mkv] Chapter %u from %02d:%02d:%02d.%03d "
934 "to %02d:%02d:%02d.%03d, %.*s\n", idx
,
935 (int) (chapter
.start
/ 60 / 60 / 1000),
936 (int) ((chapter
.start
/ 60 / 1000) % 60),
937 (int) ((chapter
.start
/ 1000) % 60),
938 (int) (chapter
.start
% 1000),
939 (int) (chapter
.end
/ 60 / 60 / 1000),
940 (int) ((chapter
.end
/ 60 / 1000) % 60),
941 (int) ((chapter
.end
/ 1000) % 60),
942 (int) (chapter
.end
% 1000),
943 name
.len
, name
.start
);
945 if (idx
== selected_edition
){
946 demuxer_add_chapter(demuxer
, name
.start
, name
.len
,
947 chapter
.start
, chapter
.end
);
948 if (editions
[idx
].edition_flag_ordered
) {
949 chapter
.name
= talloc_strndup(m_chapters
, name
.start
,
951 m_chapters
[i
] = chapter
;
956 if (num_editions
> 1)
957 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
958 "[mkv] Found %d editions, will play #%d (first is 0).\n",
959 num_editions
, selected_edition
);
962 talloc_free(parse_ctx
.talloc_ctx
);
963 mp_msg(MSGT_DEMUX
, MSGL_V
,
964 "[mkv] \\---- [ parsing chapters ] ---------\n");
968 static int demux_mkv_read_tags(demuxer_t
*demuxer
)
970 ebml_read_skip(demuxer
->stream
, NULL
);
974 static int demux_mkv_read_attachments(demuxer_t
*demuxer
)
976 stream_t
*s
= demuxer
->stream
;
978 mp_msg(MSGT_DEMUX
, MSGL_V
,
979 "[mkv] /---- [ parsing attachments ] ---------\n");
981 struct ebml_attachments attachments
= {};
982 struct ebml_parse_ctx parse_ctx
= {};
983 if (ebml_read_element(s
, &parse_ctx
, &attachments
,
984 &ebml_attachments_desc
) < 0)
987 for (int i
= 0; i
< attachments
.n_attached_file
; i
++) {
988 struct ebml_attached_file
*attachment
= &attachments
.attached_file
[i
];
989 if (!attachment
->n_file_name
|| !attachment
->n_file_mime_type
990 || !attachment
->n_file_data
) {
991 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Malformed attachment\n");
994 struct bstr name
= attachment
->file_name
;
995 struct bstr mime
= attachment
->file_mime_type
;
996 char *data
= attachment
->file_data
.start
;
997 int data_size
= attachment
->file_data
.len
;
998 demuxer_add_attachment(demuxer
, name
.start
, name
.len
, mime
.start
,
999 mime
.len
, data
, data_size
);
1000 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Attachment: %.*s, %.*s, %u bytes\n",
1001 name
.len
, name
.start
, mime
.len
, mime
.start
, data_size
);
1005 talloc_free(parse_ctx
.talloc_ctx
);
1006 mp_msg(MSGT_DEMUX
, MSGL_V
,
1007 "[mkv] \\---- [ parsing attachments ] ---------\n");
1011 static int read_header_element(struct demuxer
*demuxer
, uint32_t id
,
1014 static int demux_mkv_read_seekhead(demuxer_t
*demuxer
)
1016 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
1017 struct stream
*s
= demuxer
->stream
;
1019 struct ebml_seek_head seekhead
= {};
1020 struct ebml_parse_ctx parse_ctx
= {};
1022 mp_msg(MSGT_DEMUX
, MSGL_V
,
1023 "[mkv] /---- [ parsing seek head ] ---------\n");
1024 if (ebml_read_element(s
, &parse_ctx
, &seekhead
, &ebml_seek_head_desc
) < 0) {
1028 /* off now holds the position of the next element after the seek head. */
1029 off_t off
= stream_tell(s
);
1030 for (int i
= 0; i
< seekhead
.n_seek
; i
++) {
1031 struct ebml_seek
*seek
= &seekhead
.seek
[i
];
1032 if (seek
->n_seek_id
!= 1 || seek
->n_seek_position
!= 1) {
1033 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Invalid SeekHead entry\n");
1036 uint64_t pos
= seek
->seek_position
+ mkv_d
->segment_start
;
1037 if (pos
>= demuxer
->movi_end
) {
1038 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] SeekHead position beyond "
1039 "end of file - incomplete file?\n");
1042 read_header_element(demuxer
, seek
->seek_id
, pos
);
1044 if (!stream_seek(s
, off
)) {
1045 mp_msg(MSGT_DEMUX
, MSGL_ERR
, "[mkv] Couldn't seek back after "
1050 mp_msg(MSGT_DEMUX
, MSGL_V
,
1051 "[mkv] \\---- [ parsing seek head ] ---------\n");
1052 talloc_free(parse_ctx
.talloc_ctx
);
1056 static bool seek_pos_id(struct stream
*s
, off_t pos
, uint32_t id
)
1058 if (!stream_seek(s
, pos
)) {
1059 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Failed to seek in file\n");
1062 if (ebml_read_id(s
, NULL
) != id
) {
1063 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Expected element not found\n");
1069 static int read_header_element(struct demuxer
*demuxer
, uint32_t id
,
1072 struct mkv_demuxer
*mkv_d
= demuxer
->priv
;
1073 stream_t
*s
= demuxer
->stream
;
1074 off_t pos
= stream_tell(s
) - 4;
1077 case MATROSKA_ID_INFO
:
1078 if (mkv_d
->parsed_info
)
1080 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1082 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment information...\n");
1083 mkv_d
->parsed_info
= true;
1084 return demux_mkv_read_info(demuxer
) ? -1 : 1;
1086 case MATROSKA_ID_TRACKS
:
1087 if (mkv_d
->parsed_tracks
)
1089 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1091 mkv_d
->parsed_tracks
= true;
1092 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment tracks...\n");
1093 return demux_mkv_read_tracks(demuxer
) ? -1 : 1;
1095 case MATROSKA_ID_CUES
:
1096 if (is_parsed_header(mkv_d
, pos
))
1098 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1100 return demux_mkv_read_cues(demuxer
) ? -1 : 1;
1102 case MATROSKA_ID_TAGS
:
1103 if (mkv_d
->parsed_tags
)
1105 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1107 mkv_d
->parsed_tags
= true;
1108 return demux_mkv_read_tags(demuxer
) ? -1 : 1;
1110 case MATROSKA_ID_SEEKHEAD
:
1111 if (is_parsed_header(mkv_d
, pos
))
1113 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1115 return demux_mkv_read_seekhead(demuxer
) ? -1 : 1;
1117 case MATROSKA_ID_CHAPTERS
:
1118 if (mkv_d
->parsed_chapters
)
1120 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1122 mkv_d
->parsed_chapters
= true;
1123 return demux_mkv_read_chapters(demuxer
) ? -1 : 1;
1125 case MATROSKA_ID_ATTACHMENTS
:
1126 if (mkv_d
->parsed_attachments
)
1128 if (at_filepos
&& !seek_pos_id(s
, at_filepos
, id
))
1130 mkv_d
->parsed_attachments
= true;
1131 return demux_mkv_read_attachments(demuxer
) ? -1 : 1;
1135 ebml_read_skip(s
, NULL
);
1139 ebml_read_skip(s
, NULL
);
1145 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1147 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1149 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1152 static void display_create_tracks(demuxer_t
*demuxer
)
1154 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1155 int i
, vid
= 0, aid
= 0, sid
= 0;
1157 for (i
= 0; i
< mkv_d
->num_tracks
; i
++) {
1158 char *type
= "unknown", str
[32];
1160 switch (mkv_d
->tracks
[i
]->type
) {
1161 case MATROSKA_TRACK_VIDEO
:
1163 demux_mkv_open_video(demuxer
, mkv_d
->tracks
[i
], vid
);
1164 if (mkv_d
->tracks
[i
]->name
)
1165 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VID_%d_NAME=%s\n", vid
,
1166 mkv_d
->tracks
[i
]->name
);
1167 sprintf(str
, "-vid %u", vid
++);
1169 case MATROSKA_TRACK_AUDIO
:
1171 demux_mkv_open_audio(demuxer
, mkv_d
->tracks
[i
], aid
);
1172 if (mkv_d
->tracks
[i
]->name
)
1173 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_NAME=%s\n", aid
,
1174 mkv_d
->tracks
[i
]->name
);
1175 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_LANG=%s\n", aid
,
1176 mkv_d
->tracks
[i
]->language
);
1177 sprintf(str
, "-aid %u, -alang %.5s", aid
++,
1178 mkv_d
->tracks
[i
]->language
);
1180 case MATROSKA_TRACK_SUBTITLE
:
1182 demux_mkv_open_sub(demuxer
, mkv_d
->tracks
[i
], sid
);
1183 if (mkv_d
->tracks
[i
]->name
)
1184 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_NAME=%s\n", sid
,
1185 mkv_d
->tracks
[i
]->name
);
1186 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", sid
,
1187 mkv_d
->tracks
[i
]->language
);
1188 sprintf(str
, "-sid %u, -slang %.5s", sid
++,
1189 mkv_d
->tracks
[i
]->language
);
1192 if (mkv_d
->tracks
[i
]->name
)
1193 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
,
1194 "[mkv] Track ID %u: %s (%s) \"%s\", %s\n",
1195 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
,
1196 mkv_d
->tracks
[i
]->name
, str
);
1198 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] Track ID %u: %s (%s), %s\n",
1199 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
,
1208 } videocodec_info_t
;
1210 static const videocodec_info_t vinfo
[] = {
1211 {MKV_V_MPEG1
, mmioFOURCC('m', 'p', 'g', '1'), 0},
1212 {MKV_V_MPEG2
, mmioFOURCC('m', 'p', 'g', '2'), 0},
1213 {MKV_V_MPEG4_SP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1214 {MKV_V_MPEG4_ASP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1215 {MKV_V_MPEG4_AP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1216 {MKV_V_MPEG4_AVC
, mmioFOURCC('a', 'v', 'c', '1'), 1},
1217 {MKV_V_THEORA
, mmioFOURCC('t', 'h', 'e', 'o'), 1},
1221 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1224 struct MPOpts
*opts
= demuxer
->opts
;
1225 BITMAPINFOHEADER
*bih
;
1226 void *ImageDesc
= NULL
;
1229 if (track
->ms_compat
) { /* MS compatibility mode */
1230 BITMAPINFOHEADER
*src
;
1232 if (track
->private_data
== NULL
1233 || track
->private_size
< sizeof(BITMAPINFOHEADER
))
1236 src
= (BITMAPINFOHEADER
*) track
->private_data
;
1237 bih
= calloc(1, track
->private_size
);
1238 bih
->biSize
= le2me_32(src
->biSize
);
1239 bih
->biWidth
= le2me_32(src
->biWidth
);
1240 bih
->biHeight
= le2me_32(src
->biHeight
);
1241 bih
->biPlanes
= le2me_16(src
->biPlanes
);
1242 bih
->biBitCount
= le2me_16(src
->biBitCount
);
1243 bih
->biCompression
= le2me_32(src
->biCompression
);
1244 bih
->biSizeImage
= le2me_32(src
->biSizeImage
);
1245 bih
->biXPelsPerMeter
= le2me_32(src
->biXPelsPerMeter
);
1246 bih
->biYPelsPerMeter
= le2me_32(src
->biYPelsPerMeter
);
1247 bih
->biClrUsed
= le2me_32(src
->biClrUsed
);
1248 bih
->biClrImportant
= le2me_32(src
->biClrImportant
);
1249 memcpy((char *) bih
+ sizeof(BITMAPINFOHEADER
),
1250 (char *) src
+ sizeof(BITMAPINFOHEADER
),
1251 track
->private_size
- sizeof(BITMAPINFOHEADER
));
1253 if (track
->v_width
== 0)
1254 track
->v_width
= bih
->biWidth
;
1255 if (track
->v_height
== 0)
1256 track
->v_height
= bih
->biHeight
;
1258 bih
= calloc(1, sizeof(BITMAPINFOHEADER
));
1259 bih
->biSize
= sizeof(BITMAPINFOHEADER
);
1260 bih
->biWidth
= track
->v_width
;
1261 bih
->biHeight
= track
->v_height
;
1262 bih
->biBitCount
= 24;
1263 bih
->biSizeImage
= bih
->biWidth
* bih
->biHeight
* bih
->biBitCount
/ 8;
1265 if (track
->private_size
>= RVPROPERTIES_SIZE
1266 && (!strcmp(track
->codec_id
, MKV_V_REALV10
)
1267 || !strcmp(track
->codec_id
, MKV_V_REALV20
)
1268 || !strcmp(track
->codec_id
, MKV_V_REALV30
)
1269 || !strcmp(track
->codec_id
, MKV_V_REALV40
))) {
1270 unsigned char *dst
, *src
;
1274 src
= (uint8_t *) track
->private_data
+ RVPROPERTIES_SIZE
;
1276 cnt
= track
->private_size
- RVPROPERTIES_SIZE
;
1277 bih
= realloc(bih
, sizeof(BITMAPINFOHEADER
) + 8 + cnt
);
1278 bih
->biSize
= 48 + cnt
;
1280 type2
= AV_RB32(src
- 4);
1281 if (type2
== 0x10003000 || type2
== 0x10003001)
1282 bih
->biCompression
= mmioFOURCC('R', 'V', '1', '3');
1284 bih
->biCompression
=
1285 mmioFOURCC('R', 'V', track
->codec_id
[9], '0');
1286 dst
= (unsigned char *) (bih
+ 1);
1287 // copy type1 and type2 info from rv properties
1288 memcpy(dst
, src
- 8, 8);
1289 stream_read(demuxer
->stream
, dst
+ 8, cnt
);
1290 track
->realmedia
= 1;
1292 #ifdef CONFIG_QTX_CODECS
1293 } else if (track
->private_size
>= sizeof(ImageDescription
)
1294 && !strcmp(track
->codec_id
, MKV_V_QUICKTIME
)) {
1295 ImageDescriptionPtr idesc
;
1297 idesc
= (ImageDescriptionPtr
) track
->private_data
;
1298 idesc
->idSize
= be2me_32(idesc
->idSize
);
1299 idesc
->cType
= be2me_32(idesc
->cType
);
1300 idesc
->version
= be2me_16(idesc
->version
);
1301 idesc
->revisionLevel
= be2me_16(idesc
->revisionLevel
);
1302 idesc
->vendor
= be2me_32(idesc
->vendor
);
1303 idesc
->temporalQuality
= be2me_32(idesc
->temporalQuality
);
1304 idesc
->spatialQuality
= be2me_32(idesc
->spatialQuality
);
1305 idesc
->width
= be2me_16(idesc
->width
);
1306 idesc
->height
= be2me_16(idesc
->height
);
1307 idesc
->hRes
= be2me_32(idesc
->hRes
);
1308 idesc
->vRes
= be2me_32(idesc
->vRes
);
1309 idesc
->dataSize
= be2me_32(idesc
->dataSize
);
1310 idesc
->frameCount
= be2me_16(idesc
->frameCount
);
1311 idesc
->depth
= be2me_16(idesc
->depth
);
1312 idesc
->clutID
= be2me_16(idesc
->clutID
);
1314 bih
->biCompression
= idesc
->cType
;
1316 #endif /* CONFIG_QTX_CODECS */
1319 const videocodec_info_t
*vi
= vinfo
;
1320 while (vi
->id
&& strcmp(vi
->id
, track
->codec_id
))
1322 bih
->biCompression
= vi
->fourcc
;
1323 if (vi
->extradata
&& track
->private_data
1324 && (track
->private_size
> 0)) {
1325 bih
->biSize
+= track
->private_size
;
1326 bih
= realloc(bih
, bih
->biSize
);
1327 memcpy(bih
+ 1, track
->private_data
, track
->private_size
);
1329 track
->reorder_timecodes
= opts
->user_correct_pts
== 0;
1331 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Unknown/unsupported "
1332 "CodecID (%s) or missing/bad CodecPrivate\n"
1333 "[mkv] data (track %u).\n",
1334 track
->codec_id
, track
->tnum
);
1341 sh_v
= new_sh_video_vid(demuxer
, track
->tnum
, vid
);
1343 sh_v
->format
= sh_v
->bih
->biCompression
;
1344 if (track
->v_frate
== 0.0)
1345 track
->v_frate
= 25.0;
1346 sh_v
->fps
= track
->v_frate
;
1347 sh_v
->frametime
= 1 / track
->v_frate
;
1349 if (!track
->realmedia
) {
1350 sh_v
->disp_w
= track
->v_width
;
1351 sh_v
->disp_h
= track
->v_height
;
1352 if (track
->v_dheight
)
1353 sh_v
->aspect
= (double) track
->v_dwidth
/ track
->v_dheight
;
1355 // vd_realvid.c will set aspect to disp_w/disp_h and rederive
1356 // disp_w and disp_h from the RealVideo stream contents returned
1357 // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
1358 // the Matroska file then it has already been set to PixelWidth/Height
1359 // by check_track_information.
1360 sh_v
->disp_w
= track
->v_dwidth
;
1361 sh_v
->disp_h
= track
->v_dheight
;
1363 sh_v
->ImageDesc
= ImageDesc
;
1364 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Aspect: %f\n", sh_v
->aspect
);
1366 sh_v
->ds
= demuxer
->video
;
1370 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1373 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1374 sh_audio_t
*sh_a
= new_sh_audio_aid(demuxer
, track
->tnum
, aid
);
1377 mkv_d
->audio_tracks
[mkv_d
->last_aid
] = track
->tnum
;
1379 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
1380 sh_a
->lang
= strdup(track
->language
);
1381 sh_a
->default_track
= track
->default_track
;
1382 sh_a
->ds
= demuxer
->audio
;
1383 sh_a
->wf
= malloc(sizeof(WAVEFORMATEX
));
1384 if (track
->ms_compat
&& (track
->private_size
>= sizeof(WAVEFORMATEX
))) {
1385 WAVEFORMATEX
*wf
= (WAVEFORMATEX
*) track
->private_data
;
1386 sh_a
->wf
= realloc(sh_a
->wf
, track
->private_size
);
1387 sh_a
->wf
->wFormatTag
= le2me_16(wf
->wFormatTag
);
1388 sh_a
->wf
->nChannels
= le2me_16(wf
->nChannels
);
1389 sh_a
->wf
->nSamplesPerSec
= le2me_32(wf
->nSamplesPerSec
);
1390 sh_a
->wf
->nAvgBytesPerSec
= le2me_32(wf
->nAvgBytesPerSec
);
1391 sh_a
->wf
->nBlockAlign
= le2me_16(wf
->nBlockAlign
);
1392 sh_a
->wf
->wBitsPerSample
= le2me_16(wf
->wBitsPerSample
);
1393 sh_a
->wf
->cbSize
= track
->private_size
- sizeof(WAVEFORMATEX
);
1394 memcpy(sh_a
->wf
+ 1, wf
+ 1,
1395 track
->private_size
- sizeof(WAVEFORMATEX
));
1396 if (track
->a_sfreq
== 0.0)
1397 track
->a_sfreq
= sh_a
->wf
->nSamplesPerSec
;
1398 if (track
->a_channels
== 0)
1399 track
->a_channels
= sh_a
->wf
->nChannels
;
1400 if (track
->a_bps
== 0)
1401 track
->a_bps
= sh_a
->wf
->wBitsPerSample
;
1402 track
->a_formattag
= sh_a
->wf
->wFormatTag
;
1404 memset(sh_a
->wf
, 0, sizeof(WAVEFORMATEX
));
1405 if (!strcmp(track
->codec_id
, MKV_A_MP3
)
1406 || !strcmp(track
->codec_id
, MKV_A_MP2
))
1407 track
->a_formattag
= 0x0055;
1408 else if (!strncmp(track
->codec_id
, MKV_A_AC3
, strlen(MKV_A_AC3
)))
1409 track
->a_formattag
= 0x2000;
1410 else if (!strcmp(track
->codec_id
, MKV_A_DTS
))
1411 track
->a_formattag
= 0x2001;
1412 else if (!strcmp(track
->codec_id
, MKV_A_PCM
)
1413 || !strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1414 track
->a_formattag
= 0x0001;
1415 else if (!strcmp(track
->codec_id
, MKV_A_AAC_2MAIN
)
1416 || !strncmp(track
->codec_id
, MKV_A_AAC_2LC
,
1417 strlen(MKV_A_AAC_2LC
))
1418 || !strcmp(track
->codec_id
, MKV_A_AAC_2SSR
)
1419 || !strcmp(track
->codec_id
, MKV_A_AAC_4MAIN
)
1420 || !strncmp(track
->codec_id
, MKV_A_AAC_4LC
,
1421 strlen(MKV_A_AAC_4LC
))
1422 || !strcmp(track
->codec_id
, MKV_A_AAC_4SSR
)
1423 || !strcmp(track
->codec_id
, MKV_A_AAC_4LTP
)
1424 || !strcmp(track
->codec_id
, MKV_A_AAC
))
1425 track
->a_formattag
= mmioFOURCC('M', 'P', '4', 'A');
1426 else if (!strcmp(track
->codec_id
, MKV_A_VORBIS
)) {
1427 if (track
->private_data
== NULL
)
1429 track
->a_formattag
= mmioFOURCC('v', 'r', 'b', 's');
1430 } else if (!strcmp(track
->codec_id
, MKV_A_QDMC
))
1431 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', 'C');
1432 else if (!strcmp(track
->codec_id
, MKV_A_QDMC2
))
1433 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', '2');
1434 else if (!strcmp(track
->codec_id
, MKV_A_WAVPACK
))
1435 track
->a_formattag
= mmioFOURCC('W', 'V', 'P', 'K');
1436 else if (!strcmp(track
->codec_id
, MKV_A_TRUEHD
))
1437 track
->a_formattag
= mmioFOURCC('T', 'R', 'H', 'D');
1438 else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)) {
1439 if (track
->private_data
== NULL
|| track
->private_size
== 0) {
1440 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
1441 "[mkv] FLAC track does not contain valid headers.\n");
1444 track
->a_formattag
= mmioFOURCC('f', 'L', 'a', 'C');
1445 } else if (track
->private_size
>= RAPROPERTIES4_SIZE
) {
1446 if (!strcmp(track
->codec_id
, MKV_A_REAL28
))
1447 track
->a_formattag
= mmioFOURCC('2', '8', '_', '8');
1448 else if (!strcmp(track
->codec_id
, MKV_A_REALATRC
))
1449 track
->a_formattag
= mmioFOURCC('a', 't', 'r', 'c');
1450 else if (!strcmp(track
->codec_id
, MKV_A_REALCOOK
))
1451 track
->a_formattag
= mmioFOURCC('c', 'o', 'o', 'k');
1452 else if (!strcmp(track
->codec_id
, MKV_A_REALDNET
))
1453 track
->a_formattag
= mmioFOURCC('d', 'n', 'e', 't');
1454 else if (!strcmp(track
->codec_id
, MKV_A_REALSIPR
))
1455 track
->a_formattag
= mmioFOURCC('s', 'i', 'p', 'r');
1457 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Unknown/unsupported audio "
1458 "codec ID '%s' for track %u or missing/faulty\n[mkv] "
1459 "private codec data.\n", track
->codec_id
, track
->tnum
);
1460 free_sh_audio(demuxer
, track
->tnum
);
1465 sh_a
->format
= track
->a_formattag
;
1466 sh_a
->wf
->wFormatTag
= track
->a_formattag
;
1467 sh_a
->channels
= track
->a_channels
;
1468 sh_a
->wf
->nChannels
= track
->a_channels
;
1469 sh_a
->samplerate
= (uint32_t) track
->a_sfreq
;
1470 sh_a
->wf
->nSamplesPerSec
= (uint32_t) track
->a_sfreq
;
1471 if (track
->a_bps
== 0) {
1472 sh_a
->samplesize
= 2;
1473 sh_a
->wf
->wBitsPerSample
= 16;
1475 sh_a
->samplesize
= track
->a_bps
/ 8;
1476 sh_a
->wf
->wBitsPerSample
= track
->a_bps
;
1478 if (track
->a_formattag
== 0x0055) { /* MP3 || MP2 */
1479 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1480 sh_a
->wf
->nBlockAlign
= 1152;
1481 } else if ((track
->a_formattag
== 0x2000) /* AC3 */
1482 || (track
->a_formattag
== 0x2001)) { /* DTS */
1485 } else if (track
->a_formattag
== 0x0001) { /* PCM || PCM_BE */
1486 sh_a
->wf
->nAvgBytesPerSec
= sh_a
->channels
* sh_a
->samplerate
* 2;
1487 sh_a
->wf
->nBlockAlign
= sh_a
->wf
->nAvgBytesPerSec
;
1488 if (!strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1489 sh_a
->format
= mmioFOURCC('t', 'w', 'o', 's');
1490 } else if (!strcmp(track
->codec_id
, MKV_A_QDMC
)
1491 || !strcmp(track
->codec_id
, MKV_A_QDMC2
)) {
1492 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1493 sh_a
->wf
->nBlockAlign
= 1486;
1494 track
->fix_i_bps
= 1;
1495 track
->qt_last_a_pts
= 0.0;
1496 if (track
->private_data
!= NULL
) {
1497 sh_a
->codecdata
= malloc(track
->private_size
);
1498 memcpy(sh_a
->codecdata
, track
->private_data
, track
->private_size
);
1499 sh_a
->codecdata_len
= track
->private_size
;
1501 } else if (track
->a_formattag
== mmioFOURCC('M', 'P', '4', 'A')) {
1502 int profile
, srate_idx
;
1504 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1505 sh_a
->wf
->nBlockAlign
= 1024;
1507 if (!strcmp(track
->codec_id
, MKV_A_AAC
)
1508 && (NULL
!= track
->private_data
)) {
1509 sh_a
->codecdata
= malloc(track
->private_size
);
1510 memcpy(sh_a
->codecdata
, track
->private_data
, track
->private_size
);
1511 sh_a
->codecdata_len
= track
->private_size
;
1515 /* Recreate the 'private data' */
1516 /* which faad2 uses in its initialization */
1517 srate_idx
= aac_get_sample_rate_index(sh_a
->samplerate
);
1518 if (!strncmp(&track
->codec_id
[12], "MAIN", 4))
1520 else if (!strncmp(&track
->codec_id
[12], "LC", 2))
1522 else if (!strncmp(&track
->codec_id
[12], "SSR", 3))
1526 sh_a
->codecdata
= malloc(5);
1527 sh_a
->codecdata
[0] = ((profile
+ 1) << 3) | ((srate_idx
& 0xE) >> 1);
1528 sh_a
->codecdata
[1] =
1529 ((srate_idx
& 0x1) << 7) | (track
->a_channels
<< 3);
1531 if (strstr(track
->codec_id
, "SBR") != NULL
) {
1532 /* HE-AAC (aka SBR AAC) */
1533 sh_a
->codecdata_len
= 5;
1535 sh_a
->samplerate
*= 2;
1536 sh_a
->wf
->nSamplesPerSec
*= 2;
1537 srate_idx
= aac_get_sample_rate_index(sh_a
->samplerate
);
1538 sh_a
->codecdata
[2] = AAC_SYNC_EXTENSION_TYPE
>> 3;
1539 sh_a
->codecdata
[3] = ((AAC_SYNC_EXTENSION_TYPE
& 0x07) << 5) | 5;
1540 sh_a
->codecdata
[4] = (1 << 7) | (srate_idx
<< 3);
1541 track
->default_duration
= 1024.0 / (sh_a
->samplerate
/ 2);
1543 sh_a
->codecdata_len
= 2;
1544 track
->default_duration
= 1024.0 / sh_a
->samplerate
;
1546 } else if (track
->a_formattag
== mmioFOURCC('v', 'r', 'b', 's')) { /* VORBIS */
1547 sh_a
->wf
->cbSize
= track
->private_size
;
1548 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(WAVEFORMATEX
) + sh_a
->wf
->cbSize
);
1549 memcpy((unsigned char *) (sh_a
->wf
+ 1), track
->private_data
,
1551 } else if (track
->private_size
>= RAPROPERTIES4_SIZE
1552 && !strncmp(track
->codec_id
, MKV_A_REALATRC
, 7)) {
1553 /* Common initialization for all RealAudio codecs */
1554 unsigned char *src
= track
->private_data
;
1555 int codecdata_length
, version
;
1558 sh_a
->wf
->nAvgBytesPerSec
= 0; /* FIXME !? */
1560 version
= AV_RB16(src
+ 4);
1561 flavor
= AV_RB16(src
+ 22);
1562 track
->coded_framesize
= AV_RB32(src
+ 24);
1563 track
->sub_packet_h
= AV_RB16(src
+ 40);
1564 sh_a
->wf
->nBlockAlign
= track
->audiopk_size
= AV_RB16(src
+ 42);
1565 track
->sub_packet_size
= AV_RB16(src
+ 44);
1567 src
+= RAPROPERTIES4_SIZE
;
1571 src
+= RAPROPERTIES5_SIZE
;
1576 codecdata_length
= AV_RB32(src
);
1578 sh_a
->wf
->cbSize
= codecdata_length
;
1579 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(WAVEFORMATEX
) + sh_a
->wf
->cbSize
);
1580 memcpy(((char *) (sh_a
->wf
+ 1)), src
, codecdata_length
);
1582 switch (track
->a_formattag
) {
1583 case mmioFOURCC('a', 't', 'r', 'c'):
1584 sh_a
->wf
->nAvgBytesPerSec
= atrc_fl2bps
[flavor
];
1585 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1587 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1588 track
->audio_timestamp
=
1589 malloc(track
->sub_packet_h
* sizeof(double));
1591 case mmioFOURCC('c', 'o', 'o', 'k'):
1592 sh_a
->wf
->nAvgBytesPerSec
= cook_fl2bps
[flavor
];
1593 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1595 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1596 track
->audio_timestamp
=
1597 malloc(track
->sub_packet_h
* sizeof(double));
1599 case mmioFOURCC('s', 'i', 'p', 'r'):
1600 sh_a
->wf
->nAvgBytesPerSec
= sipr_fl2bps
[flavor
];
1601 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1603 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1604 track
->audio_timestamp
=
1605 malloc(track
->sub_packet_h
* sizeof(double));
1607 case mmioFOURCC('2', '8', '_', '8'):
1608 sh_a
->wf
->nAvgBytesPerSec
= 3600;
1609 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1611 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1612 track
->audio_timestamp
=
1613 malloc(track
->sub_packet_h
* sizeof(double));
1617 track
->realmedia
= 1;
1618 } else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)
1619 || (track
->a_formattag
== 0xf1ac)) {
1625 if (track
->a_formattag
== mmioFOURCC('f', 'L', 'a', 'C')) {
1626 ptr
= track
->private_data
;
1627 size
= track
->private_size
;
1629 sh_a
->format
= mmioFOURCC('f', 'L', 'a', 'C');
1630 ptr
= track
->private_data
+ sizeof(WAVEFORMATEX
);
1631 size
= track
->private_size
- sizeof(WAVEFORMATEX
);
1633 if (size
< 4 || ptr
[0] != 'f' || ptr
[1] != 'L' || ptr
[2] != 'a'
1635 sh_a
->codecdata
= malloc(4);
1636 sh_a
->codecdata_len
= 4;
1637 memcpy(sh_a
->codecdata
, "fLaC", 4);
1639 sh_a
->codecdata
= malloc(size
);
1640 sh_a
->codecdata_len
= size
;
1641 memcpy(sh_a
->codecdata
, ptr
, size
);
1643 } else if (track
->a_formattag
== mmioFOURCC('W', 'V', 'P', 'K') || track
->a_formattag
== mmioFOURCC('T', 'R', 'H', 'D')) { /* do nothing, still works */
1644 } else if (!track
->ms_compat
1645 || (track
->private_size
< sizeof(WAVEFORMATEX
))) {
1646 free_sh_audio(demuxer
, track
->tnum
);
1653 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1656 if (track
->subtitle_type
!= MATROSKA_SUBTYPE_UNKNOWN
) {
1659 sh_sub_t
*sh
= new_sh_sub_sid(demuxer
, track
->tnum
, sid
);
1662 if (track
->subtitle_type
== MATROSKA_SUBTYPE_VOBSUB
)
1664 if (track
->subtitle_type
== MATROSKA_SUBTYPE_SSA
)
1666 size
= track
->private_size
;
1667 m
= demux_mkv_decode(track
, track
->private_data
, &buffer
, &size
, 2);
1669 free(track
->private_data
);
1670 track
->private_data
= buffer
;
1671 track
->private_size
= size
;
1673 sh
->extradata
= malloc(track
->private_size
);
1674 memcpy(sh
->extradata
, track
->private_data
, track
->private_size
);
1675 sh
->extradata_len
= track
->private_size
;
1676 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
1677 sh
->lang
= strdup(track
->language
);
1678 sh
->default_track
= track
->default_track
;
1680 mp_tmsg(MSGT_DEMUX
, MSGL_ERR
,
1681 "[mkv] Subtitle type '%s' is not supported.\n",
1689 static int demux_mkv_open(demuxer_t
*demuxer
)
1691 stream_t
*s
= demuxer
->stream
;
1692 mkv_demuxer_t
*mkv_d
;
1696 stream_seek(s
, s
->start_pos
);
1697 if (ebml_read_id(s
, NULL
) != EBML_ID_EBML
)
1699 struct ebml_ebml ebml_master
= {};
1700 struct ebml_parse_ctx parse_ctx
= { .no_error_messages
= true };
1701 if (ebml_read_element(s
, &parse_ctx
, &ebml_master
, &ebml_ebml_desc
) < 0)
1703 if (ebml_master
.doc_type
.len
!= 8 || strncmp(ebml_master
.doc_type
.start
,
1705 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "[mkv] no head found\n");
1706 talloc_free(parse_ctx
.talloc_ctx
);
1709 if (ebml_master
.doc_type_read_version
> 2) {
1710 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] This looks like a Matroska file, "
1711 "but we don't support format version %"PRIu64
"\n",
1712 ebml_master
.doc_type_read_version
);
1713 talloc_free(parse_ctx
.talloc_ctx
);
1716 if ((ebml_master
.n_ebml_read_version
1717 && ebml_master
.ebml_read_version
!= EBML_VERSION
)
1718 || (ebml_master
.n_ebml_max_size_length
1719 && ebml_master
.ebml_max_size_length
> 8)
1720 || (ebml_master
.n_ebml_max_id_length
1721 && ebml_master
.ebml_max_id_length
!= 4)) {
1722 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] This looks like a Matroska file, "
1723 "but the header has bad parameters\n");
1724 talloc_free(parse_ctx
.talloc_ctx
);
1727 talloc_free(parse_ctx
.talloc_ctx
);
1729 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Found the head...\n");
1731 if (ebml_read_id(s
, NULL
) != MATROSKA_ID_SEGMENT
) {
1732 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] but no segment :(\n");
1735 ebml_read_length(s
, NULL
); /* return bytes number until EOF */
1737 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] + a segment...\n");
1739 mkv_d
= talloc_zero(demuxer
, struct mkv_demuxer
);
1740 demuxer
->priv
= mkv_d
;
1741 mkv_d
->tc_scale
= 1000000;
1742 mkv_d
->segment_start
= stream_tell(s
);
1745 uint32_t id
= ebml_read_id(s
, NULL
);
1747 case MATROSKA_ID_CLUSTER
:
1748 mp_msg(MSGT_DEMUX
, MSGL_V
,
1749 "[mkv] |+ found cluster, headers are "
1750 "parsed completely :)\n");
1751 stream_seek(s
, stream_tell(s
) - 4);
1756 cont
= read_header_element(demuxer
, id
, 0) < 1;
1759 ebml_read_skip(s
, NULL
);
1764 display_create_tracks(demuxer
);
1766 /* select video track */
1768 if (demuxer
->video
->id
== -1) { /* automatically select a video track */
1769 /* search for a video track that has the 'default' flag set */
1770 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1771 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_VIDEO
1772 && mkv_d
->tracks
[i
]->default_track
) {
1773 track
= mkv_d
->tracks
[i
];
1778 /* no track has the 'default' flag set */
1779 /* let's take the first video track */
1780 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1781 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_VIDEO
) {
1782 track
= mkv_d
->tracks
[i
];
1785 } else if (demuxer
->video
->id
!= -2) /* -2 = no video at all */
1787 demux_mkv_find_track_by_num(mkv_d
, demuxer
->video
->id
,
1788 MATROSKA_TRACK_VIDEO
);
1790 if (track
&& demuxer
->v_streams
[track
->tnum
]) {
1791 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] Will play video track %u.\n",
1793 demuxer
->video
->id
= track
->tnum
;
1794 demuxer
->video
->sh
= demuxer
->v_streams
[track
->tnum
];
1796 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] No video track found/wanted.\n");
1797 demuxer
->video
->id
= -2;
1800 /* select audio track */
1803 /* search for an audio track that has the 'default' flag set */
1804 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1805 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_AUDIO
1806 && mkv_d
->tracks
[i
]->default_track
) {
1807 track
= mkv_d
->tracks
[i
];
1812 /* no track has the 'default' flag set */
1813 /* let's take the first audio track */
1814 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1815 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_AUDIO
) {
1816 track
= mkv_d
->tracks
[i
];
1820 if (track
&& demuxer
->a_streams
[track
->tnum
]) {
1821 demuxer
->audio
->id
= track
->tnum
;
1822 demuxer
->audio
->sh
= demuxer
->a_streams
[track
->tnum
];
1824 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] No audio track found/wanted.\n");
1825 demuxer
->audio
->id
= -2;
1829 if (demuxer
->audio
->id
!= -2)
1830 for (i
= 0; i
< mkv_d
->num_tracks
; i
++) {
1831 if (mkv_d
->tracks
[i
]->type
!= MATROSKA_TRACK_AUDIO
)
1833 if (demuxer
->a_streams
[track
->tnum
]) {
1835 if (mkv_d
->last_aid
== MAX_A_STREAMS
)
1840 if (s
->end_pos
== 0 || (mkv_d
->indexes
== NULL
&& index_mode
< 0))
1841 demuxer
->seekable
= 0;
1843 demuxer
->movi_start
= s
->start_pos
;
1844 demuxer
->movi_end
= s
->end_pos
;
1845 demuxer
->seekable
= 1;
1848 demuxer
->accurate_seek
= true;
1850 return DEMUXER_TYPE_MATROSKA
;
1853 static void demux_close_mkv(demuxer_t
*demuxer
)
1855 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1859 free_cached_dps(demuxer
);
1860 if (mkv_d
->tracks
) {
1861 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
1862 demux_mkv_free_trackentry(mkv_d
->tracks
[i
]);
1863 free(mkv_d
->tracks
);
1865 free(mkv_d
->indexes
);
1866 free(mkv_d
->cluster_positions
);
1870 static int demux_mkv_read_block_lacing(uint8_t *buffer
, uint64_t *size
,
1872 uint32_t **all_lace_sizes
)
1874 uint32_t total
= 0, *lace_size
;
1878 *all_lace_sizes
= NULL
;
1884 switch ((flags
& 0x06) >> 1) {
1885 case 0: /* no lacing */
1887 lace_size
= calloc(*laces
, sizeof(uint32_t));
1888 lace_size
[0] = *size
;
1891 case 1: /* xiph lacing */
1892 case 2: /* fixed-size lacing */
1893 case 3: /* EBML lacing */
1897 lace_size
= calloc(*laces
, sizeof(uint32_t));
1899 switch ((flags
& 0x06) >> 1) {
1900 case 1: /* xiph lacing */
1901 for (i
= 0; i
< *laces
- 1; i
++) {
1904 lace_size
[i
] += *buffer
;
1906 } while (*buffer
++ == 0xFF);
1907 total
+= lace_size
[i
];
1909 lace_size
[i
] = *size
- total
;
1912 case 2: /* fixed-size lacing */
1913 for (i
= 0; i
< *laces
; i
++)
1914 lace_size
[i
] = *size
/ *laces
;
1917 case 3:; /* EBML lacing */
1919 uint64_t num
= ebml_read_vlen_uint(buffer
, &l
);
1920 if (num
== EBML_UINT_INVALID
) {
1927 total
= lace_size
[0] = num
;
1928 for (i
= 1; i
< *laces
- 1; i
++) {
1930 snum
= ebml_read_vlen_int(buffer
, &l
);
1931 if (snum
== EBML_INT_INVALID
) {
1937 lace_size
[i
] = lace_size
[i
- 1] + snum
;
1938 total
+= lace_size
[i
];
1940 lace_size
[i
] = *size
- total
;
1945 *all_lace_sizes
= lace_size
;
1949 static void handle_subtitles(demuxer_t
*demuxer
, mkv_track_t
*track
,
1950 char *block
, int64_t size
,
1951 uint64_t block_duration
, uint64_t timecode
)
1955 if (block_duration
== 0) {
1956 mp_msg(MSGT_DEMUX
, MSGL_WARN
,
1957 "[mkv] Warning: No BlockDuration for subtitle track found.\n");
1962 dp
= new_demux_packet(size
);
1963 memcpy(dp
->buffer
, block
, size
);
1964 dp
->pts
= timecode
/ 1000.0;
1965 dp
->endpts
= (timecode
+ block_duration
) / 1000.0;
1966 ds_add_packet(demuxer
->sub
, dp
);
1969 double real_fix_timestamp(unsigned char *buf
, unsigned int timestamp
,
1970 unsigned int format
, int64_t *kf_base
, int *kf_pts
,
1973 static void handle_realvideo(demuxer_t
*demuxer
, mkv_track_t
*track
,
1974 uint8_t *buffer
, uint32_t size
, int block_bref
)
1976 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1978 uint32_t timestamp
= mkv_d
->last_pts
* 1000;
1980 dp
= new_demux_packet(size
);
1981 memcpy(dp
->buffer
, buffer
, size
);
1983 if (mkv_d
->v_skip_to_keyframe
) {
1984 dp
->pts
= mkv_d
->last_pts
;
1985 track
->rv_kf_base
= 0;
1986 track
->rv_kf_pts
= timestamp
;
1989 real_fix_timestamp(dp
->buffer
, timestamp
,
1990 ((sh_video_t
*) demuxer
->video
->sh
)->bih
->
1991 biCompression
, &track
->rv_kf_base
,
1992 &track
->rv_kf_pts
, NULL
);
1993 dp
->pos
= demuxer
->filepos
;
1994 dp
->flags
= block_bref
? 0 : 0x10;
1996 ds_add_packet(demuxer
->video
, dp
);
1999 static void handle_realaudio(demuxer_t
*demuxer
, mkv_track_t
*track
,
2000 uint8_t *buffer
, uint32_t size
, int block_bref
)
2002 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2003 int sps
= track
->sub_packet_size
;
2004 int sph
= track
->sub_packet_h
;
2005 int cfs
= track
->coded_framesize
;
2006 int w
= track
->audiopk_size
;
2007 int spc
= track
->sub_packet_cnt
;
2011 if ((track
->a_formattag
== mmioFOURCC('2', '8', '_', '8'))
2012 || (track
->a_formattag
== mmioFOURCC('c', 'o', 'o', 'k'))
2013 || (track
->a_formattag
== mmioFOURCC('a', 't', 'r', 'c'))
2014 || (track
->a_formattag
== mmioFOURCC('s', 'i', 'p', 'r'))) {
2016 // spc = track->sub_packet_cnt = 0;
2017 switch (track
->a_formattag
) {
2018 case mmioFOURCC('2', '8', '_', '8'):
2019 for (x
= 0; x
< sph
/ 2; x
++)
2020 memcpy(track
->audio_buf
+ x
* 2 * w
+ spc
* cfs
,
2021 buffer
+ cfs
* x
, cfs
);
2023 case mmioFOURCC('c', 'o', 'o', 'k'):
2024 case mmioFOURCC('a', 't', 'r', 'c'):
2025 for (x
= 0; x
< w
/ sps
; x
++)
2026 memcpy(track
->audio_buf
+
2027 sps
* (sph
* x
+ ((sph
+ 1) / 2) * (spc
& 1) +
2028 (spc
>> 1)), buffer
+ sps
* x
, sps
);
2030 case mmioFOURCC('s', 'i', 'p', 'r'):
2031 memcpy(track
->audio_buf
+ spc
* w
, buffer
, w
);
2032 if (spc
== sph
- 1) {
2034 int bs
= sph
* w
* 2 / 96; // nibbles per subpacket
2035 // Perform reordering
2036 for (n
= 0; n
< 38; n
++) {
2038 int i
= bs
* sipr_swaps
[n
][0];
2039 int o
= bs
* sipr_swaps
[n
][1];
2040 // swap nibbles of block 'i' with 'o' TODO: optimize
2041 for (j
= 0; j
< bs
; j
++) {
2043 (track
->audio_buf
[i
>> 1] >> 4) :
2044 (track
->audio_buf
[i
>> 1] & 0x0F);
2046 (track
->audio_buf
[o
>> 1] >> 4) :
2047 (track
->audio_buf
[o
>> 1] & 0x0F);
2049 track
->audio_buf
[o
>> 1] =
2050 (track
->audio_buf
[o
>> 1] & 0x0F) | (x
<< 4);
2052 track
->audio_buf
[o
>> 1] =
2053 (track
->audio_buf
[o
>> 1] & 0xF0) | x
;
2055 track
->audio_buf
[i
>> 1] =
2056 (track
->audio_buf
[i
>> 1] & 0x0F) | (y
<< 4);
2058 track
->audio_buf
[i
>> 1] =
2059 (track
->audio_buf
[i
>> 1] & 0xF0) | y
;
2067 track
->audio_timestamp
[track
->sub_packet_cnt
] =
2068 (track
->ra_pts
== mkv_d
->last_pts
) ? 0 : (mkv_d
->last_pts
);
2069 track
->ra_pts
= mkv_d
->last_pts
;
2070 if (track
->sub_packet_cnt
== 0)
2071 track
->audio_filepos
= demuxer
->filepos
;
2072 if (++(track
->sub_packet_cnt
) == sph
) {
2074 ((WAVEFORMATEX
*) ((sh_audio_t
*) demuxer
->audio
->sh
)->wf
)->
2076 track
->sub_packet_cnt
= 0;
2077 // Release all the audio packets
2078 for (x
= 0; x
< sph
* w
/ apk_usize
; x
++) {
2079 dp
= new_demux_packet(apk_usize
);
2080 memcpy(dp
->buffer
, track
->audio_buf
+ x
* apk_usize
,
2082 /* Put timestamp only on packets that correspond to original
2083 * audio packets in file */
2084 dp
->pts
= (x
* apk_usize
% w
) ? 0 :
2085 track
->audio_timestamp
[x
* apk_usize
/ w
];
2086 dp
->pos
= track
->audio_filepos
; // all equal
2087 dp
->flags
= x
? 0 : 0x10; // Mark first packet as keyframe
2088 ds_add_packet(demuxer
->audio
, dp
);
2091 } else { // Not a codec that require reordering
2092 dp
= new_demux_packet(size
);
2093 memcpy(dp
->buffer
, buffer
, size
);
2094 if (track
->ra_pts
== mkv_d
->last_pts
&& !mkv_d
->a_skip_to_keyframe
)
2097 dp
->pts
= mkv_d
->last_pts
;
2098 track
->ra_pts
= mkv_d
->last_pts
;
2100 dp
->pos
= demuxer
->filepos
;
2101 dp
->flags
= block_bref
? 0 : 0x10;
2102 ds_add_packet(demuxer
->audio
, dp
);
2106 /** Reorder timecodes and add cached demux packets to the queues.
2108 * Timecode reordering is needed if a video track contains B frames that
2109 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2110 * MPlayer doesn't like timestamps in display order. This function adjusts
2111 * the timestamp of cached frames (which are exactly one I/P frame followed
2112 * by one or more B frames) so that they are in coding order again.
2114 * Example: The track with 25 FPS contains four frames with the timecodes
2115 * I at 0ms, P at 120ms, B at 40ms and B at 80ms. As soon as the next I
2116 * or P frame arrives these timecodes can be changed to I at 0ms, P at 40ms,
2117 * B at 80ms and B at 120ms.
2119 * This works for simple H.264 B-frame pyramids, but not for arbitrary orders.
2121 * \param demuxer The Matroska demuxer struct for this instance.
2122 * \param track The track structure whose cache should be handled.
2124 static void flush_cached_dps(demuxer_t
*demuxer
, mkv_track_t
*track
)
2128 if (track
->num_cached_dps
== 0)
2133 for (i
= 1; i
< track
->num_cached_dps
; i
++)
2134 if (track
->cached_dps
[i
- 1]->pts
> track
->cached_dps
[i
]->pts
) {
2135 double tmp_pts
= track
->cached_dps
[i
- 1]->pts
;
2136 track
->cached_dps
[i
- 1]->pts
= track
->cached_dps
[i
]->pts
;
2137 track
->cached_dps
[i
]->pts
= tmp_pts
;
2142 for (i
= 0; i
< track
->num_cached_dps
; i
++)
2143 ds_add_packet(demuxer
->video
, track
->cached_dps
[i
]);
2144 track
->num_cached_dps
= 0;
2147 /** Cache video frames if timecodes have to be reordered.
2149 * Timecode reordering is needed if a video track contains B frames that
2150 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2151 * This function takes in a Matroska block read from the file, allocates a
2152 * demux packet for it, fills in its values, allocates space for storing
2153 * pointers to the cached demux packets and adds the packet to it. If
2154 * the packet contains an I or a P frame then ::flush_cached_dps is called
2155 * in order to send the old cached frames downstream.
2157 * \param demuxer The Matroska demuxer struct for this instance.
2158 * \param track The packet is meant for this track.
2159 * \param buffer The actual frame contents.
2160 * \param size The frame size in bytes.
2161 * \param block_bref A relative timecode (backward reference). If it is \c 0
2162 * then the frame is an I frame.
2163 * \param block_fref A relative timecode (forward reference). If it is \c 0
2164 * then the frame is either an I frame or a P frame depending on the value
2165 * of \a block_bref. Otherwise it's a B frame.
2167 static void handle_video_bframes(demuxer_t
*demuxer
, mkv_track_t
*track
,
2168 uint8_t *buffer
, uint32_t size
,
2169 int block_bref
, int block_fref
)
2171 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2174 dp
= new_demux_packet(size
);
2175 memcpy(dp
->buffer
, buffer
, size
);
2176 dp
->pos
= demuxer
->filepos
;
2177 dp
->pts
= mkv_d
->last_pts
;
2178 if ((track
->num_cached_dps
> 0) && (dp
->pts
< track
->max_pts
))
2180 if (block_fref
== 0) /* I or P frame */
2181 flush_cached_dps(demuxer
, track
);
2182 if (block_bref
!= 0) /* I frame, don't cache it */
2184 if ((track
->num_cached_dps
+ 1) > track
->num_allocated_dps
) {
2185 track
->cached_dps
= (demux_packet_t
**)
2186 realloc(track
->cached_dps
,
2187 (track
->num_cached_dps
+ 10) * sizeof(demux_packet_t
*));
2188 track
->num_allocated_dps
+= 10;
2190 track
->cached_dps
[track
->num_cached_dps
] = dp
;
2191 track
->num_cached_dps
++;
2192 if (dp
->pts
> track
->max_pts
)
2193 track
->max_pts
= dp
->pts
;
2196 static int handle_block(demuxer_t
*demuxer
, uint8_t *block
, uint64_t length
,
2197 uint64_t block_duration
, int64_t block_bref
,
2198 int64_t block_fref
, uint8_t simpleblock
)
2200 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2201 mkv_track_t
*track
= NULL
;
2202 demux_stream_t
*ds
= NULL
;
2203 uint64_t old_length
;
2205 uint32_t *lace_size
;
2206 uint8_t laces
, flags
;
2207 int i
, num
, tmp
, use_this_block
= 1;
2211 /* first byte(s): track num */
2212 num
= ebml_read_vlen_uint(block
, &tmp
);
2214 /* time (relative to cluster time) */
2215 time
= block
[0] << 8 | block
[1];
2218 old_length
= length
;
2220 if (demux_mkv_read_block_lacing(block
, &length
, &laces
, &lace_size
))
2222 block
+= old_length
- length
;
2224 tc
= (time
* mkv_d
->tc_scale
+ mkv_d
->cluster_tc
) / 1000000.0 + 0.5;
2227 current_pts
= tc
/ 1000.0;
2229 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2230 if (mkv_d
->tracks
[i
]->tnum
== num
) {
2231 track
= mkv_d
->tracks
[i
];
2234 if (track
== NULL
) {
2238 if (num
== demuxer
->audio
->id
) {
2239 ds
= demuxer
->audio
;
2241 if (mkv_d
->a_skip_to_keyframe
) {
2243 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2245 } else if (block_bref
!= 0)
2247 } else if (mkv_d
->v_skip_to_keyframe
)
2250 if (track
->fix_i_bps
&& use_this_block
) {
2251 sh_audio_t
*sh
= (sh_audio_t
*) ds
->sh
;
2253 if (block_duration
!= 0) {
2254 sh
->i_bps
= length
* 1000 / block_duration
;
2255 track
->fix_i_bps
= 0;
2256 } else if (track
->qt_last_a_pts
== 0.0)
2257 track
->qt_last_a_pts
= current_pts
;
2258 else if (track
->qt_last_a_pts
!= current_pts
) {
2259 sh
->i_bps
= length
/ (current_pts
- track
->qt_last_a_pts
);
2260 track
->fix_i_bps
= 0;
2263 } else if (tc
< mkv_d
->skip_to_timecode
)
2265 else if (num
== demuxer
->video
->id
) {
2266 ds
= demuxer
->video
;
2267 if (mkv_d
->v_skip_to_keyframe
) {
2269 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2271 } else if (block_bref
!= 0 || block_fref
!= 0)
2274 } else if (num
== demuxer
->sub
->id
) {
2276 if (track
->subtitle_type
!= MATROSKA_SUBTYPE_VOBSUB
) {
2277 if (!mkv_d
->v_skip_to_keyframe
)
2278 handle_subtitles(demuxer
, track
, block
, length
, block_duration
,
2285 if (use_this_block
) {
2286 mkv_d
->last_pts
= current_pts
;
2287 mkv_d
->last_filepos
= demuxer
->filepos
;
2289 for (i
= 0; i
< laces
; i
++) {
2290 if (ds
== demuxer
->video
&& track
->realmedia
)
2291 handle_realvideo(demuxer
, track
, block
, lace_size
[i
],
2293 else if (ds
== demuxer
->audio
&& track
->realmedia
)
2294 handle_realaudio(demuxer
, track
, block
, lace_size
[i
],
2296 else if (ds
== demuxer
->video
&& track
->reorder_timecodes
)
2297 handle_video_bframes(demuxer
, track
, block
, lace_size
[i
],
2298 block_bref
, block_fref
);
2300 int modified
, size
= lace_size
[i
];
2303 modified
= demux_mkv_decode(track
, block
, &buffer
, &size
, 1);
2305 dp
= new_demux_packet(size
);
2306 memcpy(dp
->buffer
, buffer
, size
);
2309 dp
->flags
= (block_bref
== 0
2310 && block_fref
== 0) ? 0x10 : 0;
2311 /* If default_duration is 0, assume no pts value is known
2312 * for packets after the first one (rather than all pts
2313 * values being the same) */
2314 if (i
== 0 || track
->default_duration
)
2316 mkv_d
->last_pts
+ i
* track
->default_duration
;
2317 ds_add_packet(ds
, dp
);
2320 block
+= lace_size
[i
];
2323 if (ds
== demuxer
->video
) {
2324 mkv_d
->v_skip_to_keyframe
= 0;
2325 mkv_d
->skip_to_timecode
= 0;
2326 } else if (ds
== demuxer
->audio
)
2327 mkv_d
->a_skip_to_keyframe
= 0;
2337 static int demux_mkv_fill_buffer(demuxer_t
*demuxer
, demux_stream_t
*ds
)
2339 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2340 stream_t
*s
= demuxer
->stream
;
2345 while (mkv_d
->cluster_size
> 0) {
2346 uint64_t block_duration
= 0, block_length
= 0;
2347 int64_t block_bref
= 0, block_fref
= 0;
2348 uint8_t *block
= NULL
;
2350 while (mkv_d
->blockgroup_size
> 0) {
2351 switch (ebml_read_id(s
, &il
)) {
2352 case MATROSKA_ID_BLOCKDURATION
:
2353 block_duration
= ebml_read_uint(s
, &l
);
2354 if (block_duration
== EBML_UINT_INVALID
) {
2359 block_duration
* mkv_d
->tc_scale
/ 1000000.0 + 0.5;
2362 case MATROSKA_ID_BLOCK
:
2363 block_length
= ebml_read_length(s
, &tmp
);
2365 if (block_length
> SIZE_MAX
- AV_LZO_INPUT_PADDING
)
2367 block
= malloc(block_length
+ AV_LZO_INPUT_PADDING
);
2368 demuxer
->filepos
= stream_tell(s
);
2369 if (stream_read(s
, block
, block_length
) !=
2370 (int) block_length
) {
2374 l
= tmp
+ block_length
;
2377 case MATROSKA_ID_REFERENCEBLOCK
:;
2378 int64_t num
= ebml_read_int(s
, &l
);
2379 if (num
== EBML_INT_INVALID
) {
2389 case EBML_ID_INVALID
:
2394 ebml_read_skip(s
, &l
);
2397 mkv_d
->blockgroup_size
-= l
+ il
;
2398 mkv_d
->cluster_size
-= l
+ il
;
2402 int res
= handle_block(demuxer
, block
, block_length
,
2403 block_duration
, block_bref
, block_fref
,
2412 if (mkv_d
->cluster_size
> 0) {
2413 switch (ebml_read_id(s
, &il
)) {
2414 case MATROSKA_ID_TIMECODE
:;
2415 uint64_t num
= ebml_read_uint(s
, &l
);
2416 if (num
== EBML_UINT_INVALID
)
2418 mkv_d
->cluster_tc
= num
* mkv_d
->tc_scale
;
2419 add_cluster_position(mkv_d
, mkv_d
->cluster_start
,
2423 case MATROSKA_ID_BLOCKGROUP
:
2424 mkv_d
->blockgroup_size
= ebml_read_length(s
, &tmp
);
2428 case MATROSKA_ID_SIMPLEBLOCK
:;
2430 block_length
= ebml_read_length(s
, &tmp
);
2431 block
= malloc(block_length
);
2432 demuxer
->filepos
= stream_tell(s
);
2433 if (stream_read(s
, block
, block_length
) !=
2434 (int) block_length
) {
2438 l
= tmp
+ block_length
;
2439 res
= handle_block(demuxer
, block
, block_length
,
2440 block_duration
, block_bref
,
2443 mkv_d
->cluster_size
-= l
+ il
;
2449 mkv_d
->cluster_size
+= l
+ il
;
2452 case EBML_ID_INVALID
:
2456 ebml_read_skip(s
, &l
);
2459 mkv_d
->cluster_size
-= l
+ il
;
2463 while (ebml_read_id(s
, &il
) != MATROSKA_ID_CLUSTER
) {
2464 ebml_read_skip(s
, NULL
);
2468 mkv_d
->cluster_start
= stream_tell(s
) - il
;
2469 mkv_d
->cluster_size
= ebml_read_length(s
, NULL
);
2475 static void demux_mkv_seek(demuxer_t
*demuxer
, float rel_seek_secs
,
2476 float audio_delay
, int flags
)
2478 if (!(flags
& (SEEK_BACKWARD
| SEEK_FORWARD
))) {
2479 if (flags
& SEEK_ABSOLUTE
|| rel_seek_secs
< 0)
2480 flags
|= SEEK_BACKWARD
;
2482 flags
|= SEEK_FORWARD
;
2484 // Adjust the target a little bit to catch cases where the target position
2485 // specifies a keyframe with high, but not perfect, precision.
2486 rel_seek_secs
+= flags
& SEEK_FORWARD
? -0.005 : 0.005;
2488 free_cached_dps(demuxer
);
2489 if (!(flags
& SEEK_FACTOR
)) { /* time in secs */
2490 mkv_index_t
*index
= NULL
;
2491 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2492 stream_t
*s
= demuxer
->stream
;
2493 int64_t target_timecode
= 0, diff
, min_diff
= 0xFFFFFFFFFFFFFFFLL
;
2496 if (!(flags
& SEEK_ABSOLUTE
)) /* relative seek */
2497 target_timecode
= (int64_t) (mkv_d
->last_pts
* 1000.0);
2498 target_timecode
+= (int64_t) (rel_seek_secs
* 1000.0);
2499 if (target_timecode
< 0)
2500 target_timecode
= 0;
2502 if (mkv_d
->indexes
== NULL
) { /* no index was found */
2503 int64_t target_tc_ns
= (int64_t) (rel_seek_secs
* 1e9
);
2504 if (target_tc_ns
< 0)
2506 uint64_t max_filepos
= 0;
2507 int64_t max_tc
= -1;
2508 int n
= mkv_d
->num_cluster_pos
;
2510 max_filepos
= mkv_d
->cluster_positions
[n
- 1].filepos
;
2511 max_tc
= mkv_d
->cluster_positions
[n
- 1].timecode
;
2514 if (target_tc_ns
> max_tc
) {
2515 if ((off_t
) max_filepos
> stream_tell(s
))
2516 stream_seek(s
, max_filepos
);
2518 stream_seek(s
, stream_tell(s
) + mkv_d
->cluster_size
);
2519 /* parse all the clusters upto target_filepos */
2521 uint64_t start
= stream_tell(s
);
2522 uint32_t type
= ebml_read_id(s
, NULL
);
2523 uint64_t len
= ebml_read_length(s
, NULL
);
2524 uint64_t end
= stream_tell(s
) + len
;
2525 if (type
== MATROSKA_ID_CLUSTER
) {
2526 while (!s
->eof
&& stream_tell(s
) < end
) {
2527 if (ebml_read_id(s
, NULL
)
2528 == MATROSKA_ID_TIMECODE
) {
2529 uint64_t tc
= ebml_read_uint(s
, NULL
);
2530 tc
*= mkv_d
->tc_scale
;
2531 add_cluster_position(mkv_d
, start
, tc
);
2532 if (tc
>= target_tc_ns
)
2538 stream_seek(s
, end
);
2544 if (!mkv_d
->num_cluster_pos
) {
2545 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] no target for seek found\n");
2548 uint64_t cluster_pos
= mkv_d
->cluster_positions
[0].filepos
;
2549 /* Let's find the nearest cluster */
2550 for (i
= 0; i
< mkv_d
->num_cluster_pos
; i
++) {
2551 diff
= mkv_d
->cluster_positions
[i
].timecode
- target_tc_ns
;
2552 if (flags
& SEEK_BACKWARD
&& diff
< 0 && -diff
< min_diff
) {
2553 cluster_pos
= mkv_d
->cluster_positions
[i
].filepos
;
2555 } else if (flags
& SEEK_FORWARD
2556 && (diff
< 0 ? -1 * diff
: diff
) < min_diff
) {
2557 cluster_pos
= mkv_d
->cluster_positions
[i
].filepos
;
2558 min_diff
= diff
< 0 ? -1 * diff
: diff
;
2561 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2562 stream_seek(s
, cluster_pos
);
2564 int seek_id
= (demuxer
->video
->id
< 0) ?
2565 demuxer
->audio
->id
: demuxer
->video
->id
;
2567 /* let's find the entry in the indexes with the smallest */
2568 /* difference to the wanted timecode. */
2569 for (i
= 0; i
< mkv_d
->num_indexes
; i
++)
2570 if (mkv_d
->indexes
[i
].tnum
== seek_id
) {
2573 (int64_t) (mkv_d
->indexes
[i
].timecode
*
2574 mkv_d
->tc_scale
/ 1000000.0 + 0.5);
2576 if (flags
& SEEK_BACKWARD
) {
2577 // Seek backward: find the last index position
2578 // before target time
2579 if (diff
< 0 || diff
>= min_diff
)
2582 // Seek forward: find the first index position
2583 // after target time. If no such index exists, find last
2584 // position between current position and target time.
2586 if (min_diff
<= 0 && diff
<= min_diff
)
2589 FFMIN(target_timecode
- mkv_d
->last_pts
,
2594 index
= mkv_d
->indexes
+ i
;
2597 if (index
) { /* We've found an entry. */
2598 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2599 stream_seek(s
, index
->filepos
);
2603 if (demuxer
->video
->id
>= 0)
2604 mkv_d
->v_skip_to_keyframe
= 1;
2605 if (flags
& SEEK_FORWARD
)
2606 mkv_d
->skip_to_timecode
= target_timecode
;
2608 mkv_d
->skip_to_timecode
= index
? index
->timecode
: 0;
2609 mkv_d
->a_skip_to_keyframe
= 1;
2611 demux_mkv_fill_buffer(demuxer
, NULL
);
2612 } else if ((demuxer
->movi_end
<= 0) || !(flags
& SEEK_ABSOLUTE
))
2613 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
2615 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2616 stream_t
*s
= demuxer
->stream
;
2617 uint64_t target_filepos
;
2618 mkv_index_t
*index
= NULL
;
2621 if (mkv_d
->indexes
== NULL
) { /* not implemented without index */
2622 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
2626 target_filepos
= (uint64_t) (demuxer
->movi_end
* rel_seek_secs
);
2627 for (i
= 0; i
< mkv_d
->num_indexes
; i
++)
2628 if (mkv_d
->indexes
[i
].tnum
== demuxer
->video
->id
)
2630 || ((mkv_d
->indexes
[i
].filepos
>= target_filepos
)
2631 && ((index
->filepos
< target_filepos
)
2632 || (mkv_d
->indexes
[i
].filepos
< index
->filepos
))))
2633 index
= &mkv_d
->indexes
[i
];
2638 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2639 stream_seek(s
, index
->filepos
);
2641 if (demuxer
->video
->id
>= 0)
2642 mkv_d
->v_skip_to_keyframe
= 1;
2643 mkv_d
->skip_to_timecode
= index
->timecode
;
2644 mkv_d
->a_skip_to_keyframe
= 1;
2646 demux_mkv_fill_buffer(demuxer
, NULL
);
2650 static int demux_mkv_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
2652 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2655 case DEMUXER_CTRL_CORRECT_PTS
:
2656 return DEMUXER_CTRL_OK
;
2657 case DEMUXER_CTRL_GET_TIME_LENGTH
:
2658 if (mkv_d
->duration
== 0)
2659 return DEMUXER_CTRL_DONTKNOW
;
2661 *((double *) arg
) = (double) mkv_d
->duration
;
2662 return DEMUXER_CTRL_OK
;
2664 case DEMUXER_CTRL_GET_PERCENT_POS
:
2665 if (mkv_d
->duration
== 0) {
2666 return DEMUXER_CTRL_DONTKNOW
;
2669 *((int *) arg
) = (int) (100 * mkv_d
->last_pts
/ mkv_d
->duration
);
2670 return DEMUXER_CTRL_OK
;
2672 case DEMUXER_CTRL_SWITCH_AUDIO
:
2673 if (demuxer
->audio
&& demuxer
->audio
->sh
) {
2674 sh_audio_t
*sh
= demuxer
->a_streams
[demuxer
->audio
->id
];
2675 int aid
= *(int *) arg
;
2677 aid
= (sh
->aid
+ 1) % mkv_d
->last_aid
;
2678 if (aid
!= sh
->aid
) {
2679 mkv_track_t
*track
=
2680 demux_mkv_find_track_by_num(mkv_d
, aid
,
2681 MATROSKA_TRACK_AUDIO
);
2683 demuxer
->audio
->id
= track
->tnum
;
2684 sh
= demuxer
->a_streams
[demuxer
->audio
->id
];
2685 ds_free_packs(demuxer
->audio
);
2688 *(int *) arg
= sh
->aid
;
2691 return DEMUXER_CTRL_OK
;
2694 return DEMUXER_CTRL_NOTIMPL
;
2698 const demuxer_desc_t demuxer_desc_matroska
= {
2704 DEMUXER_TYPE_MATROSKA
,
2705 1, // safe autodetect
2707 demux_mkv_fill_buffer
,