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
86 uint32_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
;
180 off_t
*parsed_seekhead
;
181 int parsed_seekhead_num
;
186 } *cluster_positions
;
189 int64_t skip_to_timecode
;
190 int v_skip_to_keyframe
, a_skip_to_keyframe
;
193 int audio_tracks
[MAX_A_STREAMS
];
196 #define REALHEADER_SIZE 16
197 #define RVPROPERTIES_SIZE 34
198 #define RAPROPERTIES4_SIZE 56
199 #define RAPROPERTIES5_SIZE 70
202 * \brief ensures there is space for at least one additional element
203 * \param array array to grow
204 * \param nelem current number of elements in array
205 * \param elsize size of one array element
207 static void *grow_array(void *array
, int nelem
, size_t elsize
)
210 array
= realloc(array
, (nelem
+ 32) * elsize
);
214 static mkv_track_t
*demux_mkv_find_track_by_num(mkv_demuxer_t
*d
, int n
,
219 for (i
= 0, id
= 0; i
< d
->num_tracks
; i
++)
220 if (d
->tracks
[i
] != NULL
&& d
->tracks
[i
]->type
== type
)
227 static void add_cluster_position(mkv_demuxer_t
*mkv_d
, uint64_t filepos
,
233 int n
= mkv_d
->num_cluster_pos
;
234 if (n
> 0 && mkv_d
->cluster_positions
[n
-1].filepos
>= filepos
)
237 mkv_d
->cluster_positions
=
238 grow_array(mkv_d
->cluster_positions
, mkv_d
->num_cluster_pos
,
239 sizeof(*mkv_d
->cluster_positions
));
240 mkv_d
->cluster_positions
[mkv_d
->num_cluster_pos
++] = (struct cluster_pos
){
242 .timecode
= timecode
,
247 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
248 static int aac_get_sample_rate_index(uint32_t sample_rate
)
250 static const int srates
[] = {
251 92017, 75132, 55426, 46009, 37566, 27713,
252 23004, 18783, 13856, 11502, 9391, 0
255 while (sample_rate
< srates
[i
])
260 /** \brief Free cached demux packets
262 * Reordering the timecodes requires caching of demux packets. This function
263 * frees all these cached packets and the memory for the cached pointers
266 * \param demuxer The demuxer for which the cache is to be freed.
268 static void free_cached_dps(demuxer_t
*demuxer
)
270 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
274 for (k
= 0; k
< mkv_d
->num_tracks
; k
++) {
275 track
= mkv_d
->tracks
[k
];
276 for (i
= 0; i
< track
->num_cached_dps
; i
++)
277 free_demux_packet(track
->cached_dps
[i
]);
278 free(track
->cached_dps
);
279 track
->cached_dps
= NULL
;
280 track
->num_cached_dps
= 0;
281 track
->num_allocated_dps
= 0;
286 static int demux_mkv_decode(mkv_track_t
*track
, uint8_t *src
,
287 uint8_t **dest
, uint32_t *size
, uint32_t type
)
293 if (track
->num_encodings
<= 0)
296 for (i
= 0; i
< track
->num_encodings
; i
++) {
297 if (!(track
->encodings
[i
].scope
& type
))
301 if (track
->encodings
[i
].comp_algo
== 0) {
302 /* zlib encoded track */
305 zstream
.zalloc
= (alloc_func
) 0;
306 zstream
.zfree
= (free_func
) 0;
307 zstream
.opaque
= (voidpf
) 0;
308 if (inflateInit(&zstream
) != Z_OK
) {
309 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
310 "[mkv] zlib initialization failed.\n");
313 zstream
.next_in
= (Bytef
*) src
;
314 zstream
.avail_in
= *size
;
318 zstream
.avail_out
= *size
;
321 *dest
= realloc(*dest
, *size
);
322 zstream
.next_out
= (Bytef
*) (*dest
+ zstream
.total_out
);
323 result
= inflate(&zstream
, Z_NO_FLUSH
);
324 if (result
!= Z_OK
&& result
!= Z_STREAM_END
) {
325 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
326 "[mkv] zlib decompression failed.\n");
329 inflateEnd(&zstream
);
332 zstream
.avail_out
+= 4000;
333 } while (zstream
.avail_out
== 4000 && zstream
.avail_in
!= 0
334 && result
!= Z_STREAM_END
);
336 *size
= zstream
.total_out
;
337 inflateEnd(&zstream
);
340 if (track
->encodings
[i
].comp_algo
== 2) {
341 /* lzo encoded track */
342 int dstlen
= *size
* 3;
347 if (dstlen
> SIZE_MAX
- AV_LZO_OUTPUT_PADDING
)
349 *dest
= realloc(*dest
, dstlen
+ AV_LZO_OUTPUT_PADDING
);
350 result
= av_lzo1x_decode(*dest
, &dstlen
, src
, &srclen
);
353 if (!(result
& AV_LZO_OUTPUT_FULL
)) {
355 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
356 "[mkv] lzo decompression failed.\n");
361 mp_msg(MSGT_DEMUX
, MSGL_DBG2
,
362 "[mkv] lzo decompression buffer too small.\n");
373 static int demux_mkv_read_info(demuxer_t
*demuxer
)
375 mkv_demuxer_t
*mkv_d
= demuxer
->priv
;
376 stream_t
*s
= demuxer
->stream
;
379 uint64_t tc_scale
= 1000000;
380 long double duration
= 0.;
382 length
= ebml_read_length(s
, NULL
);
384 uint32_t id
= ebml_read_id(s
, &i
);
387 case MATROSKA_ID_TIMECODESCALE
:
388 tc_scale
= ebml_read_uint(s
, &l
);
390 if (tc_scale
== EBML_UINT_INVALID
)
392 mp_msg(MSGT_DEMUX
, MSGL_V
,
393 "[mkv] | + timecode scale: %" PRIu64
"\n", tc_scale
);
396 case MATROSKA_ID_DURATION
:
397 duration
= ebml_read_float(s
, &l
);
399 if (duration
== EBML_FLOAT_INVALID
)
403 case MATROSKA_ID_SEGMENTUID
:;
404 l
= ebml_read_length(s
, &i
);
406 if (l
!= sizeof(demuxer
->matroska_data
.segment_uid
)) {
407 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
408 "[mkv] segment uid invalid length %" PRIu64
"\n", l
);
411 stream_read(s
, demuxer
->matroska_data
.segment_uid
, l
);
412 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + segment uid");
413 for (int i
= 0; i
< l
; i
++)
414 mp_msg(MSGT_DEMUX
, MSGL_V
, " %02x",
415 demuxer
->matroska_data
.segment_uid
[i
]);
416 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
422 ebml_read_skip(s
, &l
);
427 mkv_d
->tc_scale
= tc_scale
;
428 mkv_d
->duration
= duration
* tc_scale
/ 1000000000.0;
430 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + duration: %.3fs\n",
437 * \brief free array of kv_content_encoding_t
438 * \param encodings pointer to array
439 * \param numencodings number of encodings in array
441 static void demux_mkv_free_encodings(mkv_content_encoding_t
*encodings
,
444 while (numencodings
-- > 0)
445 free(encodings
[numencodings
].comp_settings
);
449 static int demux_mkv_read_trackencodings(demuxer_t
*demuxer
,
452 stream_t
*s
= demuxer
->stream
;
453 mkv_content_encoding_t
*ce
, e
;
454 uint64_t len1
, len2
, length
, l
;
457 ce
= malloc(sizeof(*ce
));
460 len1
= length
= ebml_read_length(s
, &il
);
463 switch (ebml_read_id(s
, &il
)) {
464 case MATROSKA_ID_CONTENTENCODING
:
465 memset(&e
, 0, sizeof(e
));
468 len2
= ebml_read_length(s
, &i
);
475 switch (ebml_read_id(s
, &il
)) {
476 case MATROSKA_ID_CONTENTENCODINGORDER
:
477 num
= ebml_read_uint(s
, &l
);
478 if (num
== EBML_UINT_INVALID
)
483 case MATROSKA_ID_CONTENTENCODINGSCOPE
:
484 num
= ebml_read_uint(s
, &l
);
485 if (num
== EBML_UINT_INVALID
)
490 case MATROSKA_ID_CONTENTENCODINGTYPE
:
491 num
= ebml_read_uint(s
, &l
);
492 if (num
== EBML_UINT_INVALID
)
497 case MATROSKA_ID_CONTENTCOMPRESSION
:;
500 le
= ebml_read_length(s
, &i
);
507 switch (ebml_read_id(s
, &il
)) {
508 case MATROSKA_ID_CONTENTCOMPALGO
:
509 num
= ebml_read_uint(s
, &l
);
510 if (num
== EBML_UINT_INVALID
)
515 case MATROSKA_ID_CONTENTCOMPSETTINGS
:
516 l
= ebml_read_length(s
, &i
);
517 e
.comp_settings
= malloc(l
);
518 stream_read(s
, e
.comp_settings
, l
);
519 e
.comp_settings_len
= l
;
524 ebml_read_skip(s
, &l
);
531 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Track "
532 "number %u has been encrypted and "
533 "decryption has not yet been\n"
534 "[mkv] implemented. Skipping track.\n",
536 } else if (e
.type
!= 0) {
537 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
538 "[mkv] Unknown content encoding type for "
539 "track %u. Skipping track.\n",
543 if (e
.comp_algo
!= 0 && e
.comp_algo
!= 2) {
544 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
545 "[mkv] Track %u has been compressed with "
546 "an unknown/unsupported compression\n"
547 "[mkv] algorithm (%u). Skipping track.\n",
548 track
->tnum
, e
.comp_algo
);
551 else if (e
.comp_algo
== 0) {
552 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
553 "[mkv] Track %u was compressed with zlib "
554 "but mplayer has not been compiled\n"
555 "[mkv] with support for zlib compression. "
564 ebml_read_skip(s
, &l
);
569 for (i
= 0; i
< n
; i
++)
570 if (e
.order
<= ce
[i
].order
)
572 ce
= realloc(ce
, (n
+ 1) * sizeof(*ce
));
573 memmove(ce
+ i
+ 1, ce
+ i
, (n
- i
) * sizeof(*ce
));
574 memcpy(ce
+ i
, &e
, sizeof(e
));
579 ebml_read_skip(s
, &l
);
586 track
->encodings
= ce
;
587 track
->num_encodings
= n
;
591 demux_mkv_free_encodings(ce
, n
);
595 static int demux_mkv_read_trackaudio(demuxer_t
*demuxer
, mkv_track_t
*track
)
597 stream_t
*s
= demuxer
->stream
;
598 uint64_t len
, length
, l
;
603 track
->a_sfreq
= 8000.0;
604 track
->a_channels
= 1;
606 len
= length
= ebml_read_length(s
, &il
);
609 switch (ebml_read_id(s
, &il
)) {
610 case MATROSKA_ID_AUDIOSAMPLINGFREQ
:
611 fnum
= ebml_read_float(s
, &l
);
612 if (fnum
== EBML_FLOAT_INVALID
)
614 track
->a_sfreq
= fnum
;
615 mp_msg(MSGT_DEMUX
, MSGL_V
,
616 "[mkv] | + Sampling frequency: %f\n", track
->a_sfreq
);
619 case MATROSKA_ID_AUDIOBITDEPTH
:
620 num
= ebml_read_uint(s
, &l
);
621 if (num
== EBML_UINT_INVALID
)
624 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Bit depth: %u\n",
628 case MATROSKA_ID_AUDIOCHANNELS
:
629 num
= ebml_read_uint(s
, &l
);
630 if (num
== EBML_UINT_INVALID
)
632 track
->a_channels
= num
;
633 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Channels: %u\n",
638 ebml_read_skip(s
, &l
);
646 static int demux_mkv_read_trackvideo(demuxer_t
*demuxer
, mkv_track_t
*track
)
648 stream_t
*s
= demuxer
->stream
;
649 uint64_t len
, length
, l
;
654 len
= length
= ebml_read_length(s
, &il
);
657 switch (ebml_read_id(s
, &il
)) {
658 case MATROSKA_ID_VIDEOFRAMERATE
:
659 fnum
= ebml_read_float(s
, &l
);
660 if (fnum
== EBML_FLOAT_INVALID
)
662 track
->v_frate
= fnum
;
663 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Frame rate: %f\n",
665 if (track
->v_frate
> 0)
666 track
->default_duration
= 1 / track
->v_frate
;
669 case MATROSKA_ID_VIDEODISPLAYWIDTH
:
670 num
= ebml_read_uint(s
, &l
);
671 if (num
== EBML_UINT_INVALID
)
673 track
->v_dwidth
= num
;
674 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display width: %u\n",
678 case MATROSKA_ID_VIDEODISPLAYHEIGHT
:
679 num
= ebml_read_uint(s
, &l
);
680 if (num
== EBML_UINT_INVALID
)
682 track
->v_dheight
= num
;
683 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display height: %u\n",
687 case MATROSKA_ID_VIDEOPIXELWIDTH
:
688 num
= ebml_read_uint(s
, &l
);
689 if (num
== EBML_UINT_INVALID
)
691 track
->v_width
= num
;
692 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel width: %u\n",
696 case MATROSKA_ID_VIDEOPIXELHEIGHT
:
697 num
= ebml_read_uint(s
, &l
);
698 if (num
== EBML_UINT_INVALID
)
700 track
->v_height
= num
;
701 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel height: %u\n",
706 ebml_read_skip(s
, &l
);
715 * \brief free any data associated with given track
716 * \param track track of which to free data
718 static void demux_mkv_free_trackentry(mkv_track_t
*track
)
721 free(track
->codec_id
);
722 free(track
->language
);
723 free(track
->private_data
);
724 free(track
->audio_buf
);
725 free(track
->audio_timestamp
);
726 demux_mkv_free_encodings(track
->encodings
, track
->num_encodings
);
730 static int demux_mkv_read_trackentry(demuxer_t
*demuxer
)
732 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
733 stream_t
*s
= demuxer
->stream
;
735 uint64_t len
, length
, l
;
739 track
= calloc(1, sizeof(*track
));
740 /* set default values */
741 track
->default_track
= 1;
743 track
->language
= strdup("eng");
745 len
= length
= ebml_read_length(s
, &il
);
748 switch (ebml_read_id(s
, &il
)) {
749 case MATROSKA_ID_TRACKNUMBER
:
750 num
= ebml_read_uint(s
, &l
);
751 if (num
== EBML_UINT_INVALID
)
754 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track number: %u\n",
758 case MATROSKA_ID_TRACKNAME
:
759 track
->name
= ebml_read_utf8(s
, &l
);
760 if (track
->name
== NULL
)
762 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Name: %s\n",
766 case MATROSKA_ID_TRACKTYPE
:
767 num
= ebml_read_uint(s
, &l
);
768 if (num
== EBML_UINT_INVALID
)
771 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track type: ");
772 switch (track
->type
) {
773 case MATROSKA_TRACK_AUDIO
:
774 mp_msg(MSGT_DEMUX
, MSGL_V
, "Audio\n");
776 case MATROSKA_TRACK_VIDEO
:
777 mp_msg(MSGT_DEMUX
, MSGL_V
, "Video\n");
779 case MATROSKA_TRACK_SUBTITLE
:
780 mp_msg(MSGT_DEMUX
, MSGL_V
, "Subtitle\n");
783 mp_msg(MSGT_DEMUX
, MSGL_V
, "unknown\n");
788 case MATROSKA_ID_TRACKAUDIO
:
789 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Audio track\n");
790 l
= demux_mkv_read_trackaudio(demuxer
, track
);
795 case MATROSKA_ID_TRACKVIDEO
:
796 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Video track\n");
797 l
= demux_mkv_read_trackvideo(demuxer
, track
);
802 case MATROSKA_ID_CODECID
:
803 track
->codec_id
= ebml_read_ascii(s
, &l
);
804 if (track
->codec_id
== NULL
)
806 if (!strcmp(track
->codec_id
, MKV_V_MSCOMP
)
807 || !strcmp(track
->codec_id
, MKV_A_ACM
))
808 track
->ms_compat
= 1;
809 else if (!strcmp(track
->codec_id
, MKV_S_VOBSUB
))
810 track
->subtitle_type
= MATROSKA_SUBTYPE_VOBSUB
;
811 else if (!strcmp(track
->codec_id
, MKV_S_TEXTSSA
)
812 || !strcmp(track
->codec_id
, MKV_S_TEXTASS
)
813 || !strcmp(track
->codec_id
, MKV_S_SSA
)
814 || !strcmp(track
->codec_id
, MKV_S_ASS
)) {
815 track
->subtitle_type
= MATROSKA_SUBTYPE_SSA
;
816 } else if (!strcmp(track
->codec_id
, MKV_S_TEXTASCII
))
817 track
->subtitle_type
= MATROSKA_SUBTYPE_TEXT
;
818 if (!strcmp(track
->codec_id
, MKV_S_TEXTUTF8
)) {
819 track
->subtitle_type
= MATROSKA_SUBTYPE_TEXT
;
821 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Codec ID: %s\n",
825 case MATROSKA_ID_CODECPRIVATE
:;
827 num
= ebml_read_length(s
, &x
);
828 // audit: cheap guard against overflows later..
829 if (num
> SIZE_MAX
- 1000)
832 track
->private_data
= malloc(num
+ AV_LZO_INPUT_PADDING
);
833 if (stream_read(s
, track
->private_data
, num
) != (int) num
)
835 track
->private_size
= num
;
836 mp_msg(MSGT_DEMUX
, MSGL_V
,
837 "[mkv] | + CodecPrivate, length " "%u\n",
838 track
->private_size
);
841 case MATROSKA_ID_TRACKLANGUAGE
:
842 free(track
->language
);
843 track
->language
= ebml_read_utf8(s
, &l
);
844 if (track
->language
== NULL
)
846 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Language: %s\n",
850 case MATROSKA_ID_TRACKFLAGDEFAULT
:
851 num
= ebml_read_uint(s
, &l
);
852 if (num
== EBML_UINT_INVALID
)
854 track
->default_track
= num
;
855 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default flag: %u\n",
856 track
->default_track
);
859 case MATROSKA_ID_TRACKDEFAULTDURATION
:
860 num
= ebml_read_uint(s
, &l
);
861 if (num
== EBML_UINT_INVALID
)
864 mp_msg(MSGT_DEMUX
, MSGL_V
,
865 "[mkv] | + Default duration: 0");
867 track
->v_frate
= 1000000000.0 / num
;
868 track
->default_duration
= num
/ 1000000000.0;
869 mp_msg(MSGT_DEMUX
, MSGL_V
,
870 "[mkv] | + Default duration: "
871 "%.3fms ( = %.3f fps)\n", num
/ 1000000.0,
876 case MATROSKA_ID_TRACKENCODINGS
:
877 l
= demux_mkv_read_trackencodings(demuxer
, track
);
883 ebml_read_skip(s
, &l
);
889 mkv_d
->tracks
[mkv_d
->num_tracks
++] = track
;
893 demux_mkv_free_trackentry(track
);
897 static int demux_mkv_read_tracks(demuxer_t
*demuxer
)
899 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
900 stream_t
*s
= demuxer
->stream
;
904 mkv_d
->tracks
= malloc(sizeof(*mkv_d
->tracks
));
905 mkv_d
->num_tracks
= 0;
907 length
= ebml_read_length(s
, NULL
);
909 switch (ebml_read_id(s
, &il
)) {
910 case MATROSKA_ID_TRACKENTRY
:
911 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + a track...\n");
912 mkv_d
->tracks
= realloc(mkv_d
->tracks
, (mkv_d
->num_tracks
+ 1)
913 * sizeof(*mkv_d
->tracks
));
914 l
= demux_mkv_read_trackentry(demuxer
);
920 ebml_read_skip(s
, &l
);
928 static int demux_mkv_read_cues(demuxer_t
*demuxer
)
930 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
931 stream_t
*s
= demuxer
->stream
;
932 uint64_t length
, l
, time
, track
, pos
;
936 if (index_mode
== 0 || index_mode
== 2) {
937 ebml_read_skip(s
, NULL
);
940 off
= stream_tell(s
);
941 for (i
= 0; i
< mkv_d
->parsed_cues_num
; i
++)
942 if (mkv_d
->parsed_cues
[i
] == off
) {
943 ebml_read_skip(s
, NULL
);
947 realloc(mkv_d
->parsed_cues
, (mkv_d
->parsed_cues_num
+ 1)
949 mkv_d
->parsed_cues
[mkv_d
->parsed_cues_num
++] = off
;
951 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing cues ] -----------\n");
952 length
= ebml_read_length(s
, NULL
);
955 time
= track
= pos
= EBML_UINT_INVALID
;
957 switch (ebml_read_id(s
, &il
)) {
958 case MATROSKA_ID_POINTENTRY
:;
961 len
= ebml_read_length(s
, &i
);
968 switch (ebml_read_id(s
, &il
)) {
969 case MATROSKA_ID_CUETIME
:
970 time
= ebml_read_uint(s
, &l
);
973 case MATROSKA_ID_CUETRACKPOSITION
:;
974 uint64_t le
= ebml_read_length(s
, &i
);
981 switch (ebml_read_id(s
, &il
)) {
982 case MATROSKA_ID_CUETRACK
:
983 track
= ebml_read_uint(s
, &l
);
986 case MATROSKA_ID_CUECLUSTERPOSITION
:
987 pos
= ebml_read_uint(s
, &l
);
991 ebml_read_skip(s
, &l
);
999 ebml_read_skip(s
, &l
);
1007 ebml_read_skip(s
, &l
);
1013 if (time
!= EBML_UINT_INVALID
&& track
!= EBML_UINT_INVALID
1014 && pos
!= EBML_UINT_INVALID
) {
1016 grow_array(mkv_d
->indexes
, mkv_d
->num_indexes
,
1017 sizeof(mkv_index_t
));
1018 mkv_d
->indexes
[mkv_d
->num_indexes
].tnum
= track
;
1019 mkv_d
->indexes
[mkv_d
->num_indexes
].timecode
= time
;
1020 mkv_d
->indexes
[mkv_d
->num_indexes
].filepos
=
1021 mkv_d
->segment_start
+ pos
;
1022 mp_msg(MSGT_DEMUX
, MSGL_DBG2
,
1023 "[mkv] |+ found cue point " "for track %" PRIu64
1024 ": timecode %" PRIu64
", filepos: %" PRIu64
"\n", track
,
1025 time
, mkv_d
->segment_start
+ pos
);
1026 mkv_d
->num_indexes
++;
1030 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] \\---- [ parsing cues ] -----------\n");
1034 static uint64_t read_one_chapter(struct demuxer
*demuxer
, stream_t
*s
,
1035 struct matroska_chapter
*chapters
,
1039 uint64_t start
= 0, end
= 0;
1040 struct matroska_chapter chapter
= { };
1044 bool badchapter
= false;
1046 len
= ebml_read_length(s
, &i
);
1047 uint64_t bytes_read
= len
+ i
;
1050 id
= ebml_read_id(s
, &i
);
1053 case MATROSKA_ID_CHAPTERTIMESTART
:
1054 start
= ebml_read_uint(s
, &l
) / 1000000;
1058 case MATROSKA_ID_CHAPTERTIMEEND
:
1059 end
= ebml_read_uint(s
, &l
) / 1000000;
1063 case MATROSKA_ID_CHAPTERDISPLAY
:;
1064 uint64_t displaylen
= ebml_read_length(s
, &i
);
1065 len
-= displaylen
+ i
;
1066 while (displaylen
> 0) {
1067 id
= ebml_read_id(s
, &i
);
1070 case MATROSKA_ID_CHAPSTRING
:
1071 name
= ebml_read_utf8(s
, &l
);
1074 ebml_read_skip(s
, &l
);
1081 case MATROSKA_ID_CHAPTERSEGMENTUID
:
1082 l
= ebml_read_length(s
, &i
);
1084 if (l
!= sizeof(chapter
.segment_uid
)) {
1085 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
1086 "[mkv] chapter segment uid invalid length %" PRIu64
1090 stream_read(s
, chapter
.segment_uid
, l
);
1091 chapter
.has_segment_uid
= true;
1092 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Chapter segment uid ");
1093 for (int i
= 0; i
< l
; i
++)
1094 mp_msg(MSGT_DEMUX
, MSGL_V
, "%02x ",
1095 chapter
.segment_uid
[i
]);
1096 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
1100 case MATROSKA_ID_CHAPTERSEGMENTEDITIONUID
:
1101 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
1102 "[mkv] Warning: unsupported edition recursion in chapter; "
1103 "will skip on playback!\n");
1104 ebml_read_skip(s
, &l
);
1110 ebml_read_skip(s
, &l
);
1117 name
= strdup("(unnamed)");
1119 chapter
.start
= start
;
1121 chapter
.name
= talloc_strdup(chapters
, name
);
1122 chapters
[chapter_num
] = chapter
;
1125 memset(&chapter
.segment_uid
, 0, sizeof(chapter
.segment_uid
));
1129 mp_msg(MSGT_DEMUX
, MSGL_V
,
1130 "[mkv] Chapter %u from %02d:%02d:%02d."
1131 "%03d to %02d:%02d:%02d.%03d, %s\n", chapter_num
,
1132 (int) (start
/ 60 / 60 / 1000), (int) ((start
/ 60 / 1000) % 60),
1133 (int) ((start
/ 1000) % 60), (int) (start
% 1000),
1134 (int) (end
/ 60 / 60 / 1000), (int) ((end
/ 60 / 1000) % 60),
1135 (int) ((end
/ 1000) % 60), (int) (end
% 1000), name
);
1142 static int demux_mkv_read_chapters(struct demuxer
*demuxer
)
1144 struct MPOpts
*opts
= demuxer
->opts
;
1145 stream_t
*s
= demuxer
->stream
;
1150 if (demuxer
->chapters
) {
1151 ebml_read_skip(s
, NULL
);
1155 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing chapters ] ---------\n");
1156 length
= ebml_read_length(s
, NULL
);
1158 struct matroska_chapter
*selected_chapters
= NULL
;
1159 int num_selected_chapters
= 0;
1160 bool have_default
= false;
1161 bool have_user_specified
= false;
1162 int selected_edition
= -1;
1163 bool se_is_ordered
= false;
1165 while (length
> 0) {
1166 id
= ebml_read_id(s
, &i
);
1169 case MATROSKA_ID_EDITIONENTRY
:
1171 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] New edition %d\n", cur_idx
);
1172 uint64_t editionlen
= ebml_read_length(s
, &i
);
1173 length
-= editionlen
+ i
;
1174 bool defaultflag
= false;
1175 bool ordered
= false;
1176 struct matroska_chapter
*chapters
= NULL
;
1177 int num_chapters
= 0;
1178 while (editionlen
> 0) {
1179 id
= ebml_read_id(s
, &i
);
1182 case MATROSKA_ID_CHAPTERATOM
:
1184 talloc_realloc(demuxer
, chapters
,
1185 struct matroska_chapter
,
1187 l
= read_one_chapter(demuxer
, s
, chapters
, num_chapters
++);
1189 case MATROSKA_ID_EDITIONFLAGDEFAULT
:
1190 defaultflag
= ebml_read_uint(s
, &l
);
1191 mp_msg(MSGT_DEMUX
, MSGL_V
,
1192 "[mkv] Default edition flag: %d\n", defaultflag
);
1194 case MATROSKA_ID_EDITIONFLAGORDERED
:
1195 ordered
= ebml_read_uint(s
, &l
);
1196 mp_msg(MSGT_DEMUX
, MSGL_V
,
1197 "[mkv] Ordered chapter flag: %d\n", ordered
);
1201 ebml_read_skip(s
, &l
);
1206 if (cur_idx
== opts
->edition_id
) {
1207 have_user_specified
= true;
1208 mp_msg(MSGT_DEMUX
, MSGL_V
,
1209 "[mkv] Found user-selected edition\n");
1210 } else if (!have_user_specified
&& !have_default
&& defaultflag
) {
1211 have_default
= true;
1212 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Default edition: %d\n",
1214 } else if (selected_edition
< 0) {
1217 talloc_free(chapters
);
1220 selected_edition
= cur_idx
;
1221 talloc_free(selected_chapters
);
1222 selected_chapters
= chapters
;
1223 num_selected_chapters
= num_chapters
;
1224 se_is_ordered
= ordered
;
1228 ebml_read_skip(s
, &l
);
1234 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
1235 "[mkv] Found %d editions, will play #%d (first is 0).\n",
1236 cur_idx
+ 1, selected_edition
);
1238 for (i
= 0; i
< num_selected_chapters
; i
++)
1239 demuxer_add_chapter(demuxer
, selected_chapters
[i
].name
,
1240 selected_chapters
[i
].start
,
1241 selected_chapters
[i
].end
);
1242 struct matroska_data
*m
= &demuxer
->matroska_data
;
1243 talloc_free(m
->ordered_chapters
);
1244 if (se_is_ordered
) {
1245 m
->ordered_chapters
= selected_chapters
;
1246 m
->num_ordered_chapters
= num_selected_chapters
;
1248 m
->ordered_chapters
= NULL
;
1249 m
->num_ordered_chapters
= 0;
1250 talloc_free(selected_chapters
);
1253 mp_msg(MSGT_DEMUX
, MSGL_V
,
1254 "[mkv] \\---- [ parsing chapters ] ---------\n");
1258 static int demux_mkv_read_tags(demuxer_t
*demuxer
)
1260 ebml_read_skip(demuxer
->stream
, NULL
);
1264 static int demux_mkv_read_attachments(demuxer_t
*demuxer
)
1266 stream_t
*s
= demuxer
->stream
;
1270 mp_msg(MSGT_DEMUX
, MSGL_V
,
1271 "[mkv] /---- [ parsing attachments ] ---------\n");
1272 length
= ebml_read_length(s
, NULL
);
1274 while (length
> 0) {
1275 switch (ebml_read_id(s
, &il
)) {
1276 case MATROSKA_ID_ATTACHEDFILE
:;
1284 len
= ebml_read_length(s
, &i
);
1287 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + an attachment...\n");
1293 switch (ebml_read_id(s
, &il
)) {
1294 case MATROSKA_ID_FILENAME
:
1296 name
= ebml_read_utf8(s
, &l
);
1299 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + FileName: %s\n",
1303 case MATROSKA_ID_FILEMIMETYPE
:
1305 mime
= ebml_read_ascii(s
, &l
);
1308 mp_msg(MSGT_DEMUX
, MSGL_V
,
1309 "[mkv] | + FileMimeType: %s\n", mime
);
1312 case MATROSKA_ID_FILEDATA
:;
1314 uint64_t num
= ebml_read_length(s
, &x
);
1318 if (stream_read(s
, data
, num
) != (int) num
) {
1326 mp_msg(MSGT_DEMUX
, MSGL_V
,
1327 "[mkv] | + FileData, length " "%u\n",
1332 ebml_read_skip(s
, &l
);
1338 demuxer_add_attachment(demuxer
, name
, mime
, data
, data_size
);
1342 mp_msg(MSGT_DEMUX
, MSGL_V
,
1343 "[mkv] Attachment: %s, %s, %u bytes\n", name
, mime
,
1348 ebml_read_skip(s
, &l
);
1354 mp_msg(MSGT_DEMUX
, MSGL_V
,
1355 "[mkv] \\---- [ parsing attachments ] ---------\n");
1359 static int demux_mkv_read_seekhead(demuxer_t
*demuxer
)
1361 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1362 stream_t
*s
= demuxer
->stream
;
1363 uint64_t length
, l
, seek_pos
, saved_pos
, num
;
1368 off
= stream_tell(s
);
1369 for (i
= 0; i
< mkv_d
->parsed_seekhead_num
; i
++)
1370 if (mkv_d
->parsed_seekhead
[i
] == off
) {
1371 ebml_read_skip(s
, NULL
);
1374 mkv_d
->parsed_seekhead
= realloc(mkv_d
->parsed_seekhead
,
1375 (mkv_d
->parsed_seekhead_num
+ 1) * sizeof(off_t
));
1376 mkv_d
->parsed_seekhead
[mkv_d
->parsed_seekhead_num
++] = off
;
1378 mp_msg(MSGT_DEMUX
, MSGL_V
,
1379 "[mkv] /---- [ parsing seek head ] ---------\n");
1380 length
= ebml_read_length(s
, NULL
);
1381 /* off now holds the position of the next element after the seek head. */
1382 off
= stream_tell(s
) + length
;
1383 while (length
> 0 && !res
) {
1386 seek_pos
= EBML_UINT_INVALID
;
1388 switch (ebml_read_id(s
, &il
)) {
1389 case MATROSKA_ID_SEEKENTRY
:;
1390 uint64_t len
= ebml_read_length(s
, &i
);
1397 switch (ebml_read_id(s
, &il
)) {
1398 case MATROSKA_ID_SEEKID
:
1399 num
= ebml_read_uint(s
, &l
);
1400 if (num
!= EBML_UINT_INVALID
)
1404 case MATROSKA_ID_SEEKPOSITION
:
1405 seek_pos
= ebml_read_uint(s
, &l
);
1409 ebml_read_skip(s
, &l
);
1418 ebml_read_skip(s
, &l
);
1423 if (seek_id
== 0 || seek_id
== MATROSKA_ID_CLUSTER
1424 || seek_pos
== EBML_UINT_INVALID
1425 || ((mkv_d
->segment_start
+ seek_pos
) >=
1426 (uint64_t) demuxer
->movi_end
))
1429 saved_pos
= stream_tell(s
);
1430 if (!stream_seek(s
, mkv_d
->segment_start
+ seek_pos
))
1433 if (ebml_read_id(s
, &il
) != seek_id
)
1437 case MATROSKA_ID_CUES
:
1438 if (demux_mkv_read_cues(demuxer
))
1442 case MATROSKA_ID_TAGS
:
1443 if (demux_mkv_read_tags(demuxer
))
1447 case MATROSKA_ID_SEEKHEAD
:
1448 if (demux_mkv_read_seekhead(demuxer
))
1452 case MATROSKA_ID_CHAPTERS
:
1453 if (demux_mkv_read_chapters(demuxer
))
1459 stream_seek(s
, saved_pos
);
1462 /* If there was an error then try to skip this seek head. */
1463 if (stream_seek(s
, off
))
1465 } else if (length
> 0)
1466 stream_seek(s
, stream_tell(s
) + length
);
1467 mp_msg(MSGT_DEMUX
, MSGL_V
,
1468 "[mkv] \\---- [ parsing seek head ] ---------\n");
1472 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1474 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1476 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1479 static void display_create_tracks(demuxer_t
*demuxer
)
1481 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1482 int i
, vid
= 0, aid
= 0, sid
= 0;
1484 for (i
= 0; i
< mkv_d
->num_tracks
; i
++) {
1485 char *type
= "unknown", str
[32];
1487 switch (mkv_d
->tracks
[i
]->type
) {
1488 case MATROSKA_TRACK_VIDEO
:
1490 demux_mkv_open_video(demuxer
, mkv_d
->tracks
[i
], vid
);
1491 if (mkv_d
->tracks
[i
]->name
)
1492 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VID_%d_NAME=%s\n", vid
,
1493 mkv_d
->tracks
[i
]->name
);
1494 sprintf(str
, "-vid %u", vid
++);
1496 case MATROSKA_TRACK_AUDIO
:
1498 demux_mkv_open_audio(demuxer
, mkv_d
->tracks
[i
], aid
);
1499 if (mkv_d
->tracks
[i
]->name
)
1500 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_NAME=%s\n", aid
,
1501 mkv_d
->tracks
[i
]->name
);
1502 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_LANG=%s\n", aid
,
1503 mkv_d
->tracks
[i
]->language
);
1504 sprintf(str
, "-aid %u, -alang %.5s", aid
++,
1505 mkv_d
->tracks
[i
]->language
);
1507 case MATROSKA_TRACK_SUBTITLE
:
1509 demux_mkv_open_sub(demuxer
, mkv_d
->tracks
[i
], sid
);
1510 if (mkv_d
->tracks
[i
]->name
)
1511 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_NAME=%s\n", sid
,
1512 mkv_d
->tracks
[i
]->name
);
1513 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", sid
,
1514 mkv_d
->tracks
[i
]->language
);
1515 sprintf(str
, "-sid %u, -slang %.5s", sid
++,
1516 mkv_d
->tracks
[i
]->language
);
1519 if (mkv_d
->tracks
[i
]->name
)
1520 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
,
1521 "[mkv] Track ID %u: %s (%s) \"%s\", %s\n",
1522 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
,
1523 mkv_d
->tracks
[i
]->name
, str
);
1525 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] Track ID %u: %s (%s), %s\n",
1526 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
,
1535 } videocodec_info_t
;
1537 static const videocodec_info_t vinfo
[] = {
1538 {MKV_V_MPEG1
, mmioFOURCC('m', 'p', 'g', '1'), 0},
1539 {MKV_V_MPEG2
, mmioFOURCC('m', 'p', 'g', '2'), 0},
1540 {MKV_V_MPEG4_SP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1541 {MKV_V_MPEG4_ASP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1542 {MKV_V_MPEG4_AP
, mmioFOURCC('m', 'p', '4', 'v'), 1},
1543 {MKV_V_MPEG4_AVC
, mmioFOURCC('a', 'v', 'c', '1'), 1},
1544 {MKV_V_THEORA
, mmioFOURCC('t', 'h', 'e', 'o'), 1},
1548 static int demux_mkv_open_video(demuxer_t
*demuxer
, mkv_track_t
*track
,
1551 struct MPOpts
*opts
= demuxer
->opts
;
1552 BITMAPINFOHEADER
*bih
;
1553 void *ImageDesc
= NULL
;
1556 if (track
->ms_compat
) { /* MS compatibility mode */
1557 BITMAPINFOHEADER
*src
;
1559 if (track
->private_data
== NULL
1560 || track
->private_size
< sizeof(BITMAPINFOHEADER
))
1563 src
= (BITMAPINFOHEADER
*) track
->private_data
;
1564 bih
= calloc(1, track
->private_size
);
1565 bih
->biSize
= le2me_32(src
->biSize
);
1566 bih
->biWidth
= le2me_32(src
->biWidth
);
1567 bih
->biHeight
= le2me_32(src
->biHeight
);
1568 bih
->biPlanes
= le2me_16(src
->biPlanes
);
1569 bih
->biBitCount
= le2me_16(src
->biBitCount
);
1570 bih
->biCompression
= le2me_32(src
->biCompression
);
1571 bih
->biSizeImage
= le2me_32(src
->biSizeImage
);
1572 bih
->biXPelsPerMeter
= le2me_32(src
->biXPelsPerMeter
);
1573 bih
->biYPelsPerMeter
= le2me_32(src
->biYPelsPerMeter
);
1574 bih
->biClrUsed
= le2me_32(src
->biClrUsed
);
1575 bih
->biClrImportant
= le2me_32(src
->biClrImportant
);
1576 memcpy((char *) bih
+ sizeof(BITMAPINFOHEADER
),
1577 (char *) src
+ sizeof(BITMAPINFOHEADER
),
1578 track
->private_size
- sizeof(BITMAPINFOHEADER
));
1580 if (track
->v_width
== 0)
1581 track
->v_width
= bih
->biWidth
;
1582 if (track
->v_height
== 0)
1583 track
->v_height
= bih
->biHeight
;
1585 bih
= calloc(1, sizeof(BITMAPINFOHEADER
));
1586 bih
->biSize
= sizeof(BITMAPINFOHEADER
);
1587 bih
->biWidth
= track
->v_width
;
1588 bih
->biHeight
= track
->v_height
;
1589 bih
->biBitCount
= 24;
1590 bih
->biSizeImage
= bih
->biWidth
* bih
->biHeight
* bih
->biBitCount
/ 8;
1592 if (track
->private_size
>= RVPROPERTIES_SIZE
1593 && (!strcmp(track
->codec_id
, MKV_V_REALV10
)
1594 || !strcmp(track
->codec_id
, MKV_V_REALV20
)
1595 || !strcmp(track
->codec_id
, MKV_V_REALV30
)
1596 || !strcmp(track
->codec_id
, MKV_V_REALV40
))) {
1597 unsigned char *dst
, *src
;
1601 src
= (uint8_t *) track
->private_data
+ RVPROPERTIES_SIZE
;
1603 cnt
= track
->private_size
- RVPROPERTIES_SIZE
;
1604 bih
= realloc(bih
, sizeof(BITMAPINFOHEADER
) + 8 + cnt
);
1605 bih
->biSize
= 48 + cnt
;
1607 type2
= AV_RB32(src
- 4);
1608 if (type2
== 0x10003000 || type2
== 0x10003001)
1609 bih
->biCompression
= mmioFOURCC('R', 'V', '1', '3');
1611 bih
->biCompression
=
1612 mmioFOURCC('R', 'V', track
->codec_id
[9], '0');
1613 dst
= (unsigned char *) (bih
+ 1);
1614 // copy type1 and type2 info from rv properties
1615 memcpy(dst
, src
- 8, 8);
1616 stream_read(demuxer
->stream
, dst
+ 8, cnt
);
1617 track
->realmedia
= 1;
1619 #ifdef CONFIG_QTX_CODECS
1620 } else if (track
->private_size
>= sizeof(ImageDescription
)
1621 && !strcmp(track
->codec_id
, MKV_V_QUICKTIME
)) {
1622 ImageDescriptionPtr idesc
;
1624 idesc
= (ImageDescriptionPtr
) track
->private_data
;
1625 idesc
->idSize
= be2me_32(idesc
->idSize
);
1626 idesc
->cType
= be2me_32(idesc
->cType
);
1627 idesc
->version
= be2me_16(idesc
->version
);
1628 idesc
->revisionLevel
= be2me_16(idesc
->revisionLevel
);
1629 idesc
->vendor
= be2me_32(idesc
->vendor
);
1630 idesc
->temporalQuality
= be2me_32(idesc
->temporalQuality
);
1631 idesc
->spatialQuality
= be2me_32(idesc
->spatialQuality
);
1632 idesc
->width
= be2me_16(idesc
->width
);
1633 idesc
->height
= be2me_16(idesc
->height
);
1634 idesc
->hRes
= be2me_32(idesc
->hRes
);
1635 idesc
->vRes
= be2me_32(idesc
->vRes
);
1636 idesc
->dataSize
= be2me_32(idesc
->dataSize
);
1637 idesc
->frameCount
= be2me_16(idesc
->frameCount
);
1638 idesc
->depth
= be2me_16(idesc
->depth
);
1639 idesc
->clutID
= be2me_16(idesc
->clutID
);
1641 bih
->biCompression
= idesc
->cType
;
1643 #endif /* CONFIG_QTX_CODECS */
1646 const videocodec_info_t
*vi
= vinfo
;
1647 while (vi
->id
&& strcmp(vi
->id
, track
->codec_id
))
1649 bih
->biCompression
= vi
->fourcc
;
1650 if (vi
->extradata
&& track
->private_data
1651 && (track
->private_size
> 0)) {
1652 bih
->biSize
+= track
->private_size
;
1653 bih
= realloc(bih
, bih
->biSize
);
1654 memcpy(bih
+ 1, track
->private_data
, track
->private_size
);
1656 track
->reorder_timecodes
= opts
->user_correct_pts
== 0;
1658 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Unknown/unsupported "
1659 "CodecID (%s) or missing/bad CodecPrivate\n"
1660 "[mkv] data (track %u).\n",
1661 track
->codec_id
, track
->tnum
);
1668 sh_v
= new_sh_video_vid(demuxer
, track
->tnum
, vid
);
1670 sh_v
->format
= sh_v
->bih
->biCompression
;
1671 if (track
->v_frate
== 0.0)
1672 track
->v_frate
= 25.0;
1673 sh_v
->fps
= track
->v_frate
;
1674 sh_v
->frametime
= 1 / track
->v_frate
;
1676 if (!track
->realmedia
) {
1677 sh_v
->disp_w
= track
->v_width
;
1678 sh_v
->disp_h
= track
->v_height
;
1679 if (track
->v_dheight
)
1680 sh_v
->aspect
= (double) track
->v_dwidth
/ track
->v_dheight
;
1682 // vd_realvid.c will set aspect to disp_w/disp_h and rederive
1683 // disp_w and disp_h from the RealVideo stream contents returned
1684 // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
1685 // the Matroska file then it has already been set to PixelWidth/Height
1686 // by check_track_information.
1687 sh_v
->disp_w
= track
->v_dwidth
;
1688 sh_v
->disp_h
= track
->v_dheight
;
1690 sh_v
->ImageDesc
= ImageDesc
;
1691 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Aspect: %f\n", sh_v
->aspect
);
1693 sh_v
->ds
= demuxer
->video
;
1697 static int demux_mkv_open_audio(demuxer_t
*demuxer
, mkv_track_t
*track
,
1700 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1701 sh_audio_t
*sh_a
= new_sh_audio_aid(demuxer
, track
->tnum
, aid
);
1704 mkv_d
->audio_tracks
[mkv_d
->last_aid
] = track
->tnum
;
1706 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
1707 sh_a
->lang
= strdup(track
->language
);
1708 sh_a
->default_track
= track
->default_track
;
1709 sh_a
->ds
= demuxer
->audio
;
1710 sh_a
->wf
= malloc(sizeof(WAVEFORMATEX
));
1711 if (track
->ms_compat
&& (track
->private_size
>= sizeof(WAVEFORMATEX
))) {
1712 WAVEFORMATEX
*wf
= (WAVEFORMATEX
*) track
->private_data
;
1713 sh_a
->wf
= realloc(sh_a
->wf
, track
->private_size
);
1714 sh_a
->wf
->wFormatTag
= le2me_16(wf
->wFormatTag
);
1715 sh_a
->wf
->nChannels
= le2me_16(wf
->nChannels
);
1716 sh_a
->wf
->nSamplesPerSec
= le2me_32(wf
->nSamplesPerSec
);
1717 sh_a
->wf
->nAvgBytesPerSec
= le2me_32(wf
->nAvgBytesPerSec
);
1718 sh_a
->wf
->nBlockAlign
= le2me_16(wf
->nBlockAlign
);
1719 sh_a
->wf
->wBitsPerSample
= le2me_16(wf
->wBitsPerSample
);
1720 sh_a
->wf
->cbSize
= track
->private_size
- sizeof(WAVEFORMATEX
);
1721 memcpy(sh_a
->wf
+ 1, wf
+ 1,
1722 track
->private_size
- sizeof(WAVEFORMATEX
));
1723 if (track
->a_sfreq
== 0.0)
1724 track
->a_sfreq
= sh_a
->wf
->nSamplesPerSec
;
1725 if (track
->a_channels
== 0)
1726 track
->a_channels
= sh_a
->wf
->nChannels
;
1727 if (track
->a_bps
== 0)
1728 track
->a_bps
= sh_a
->wf
->wBitsPerSample
;
1729 track
->a_formattag
= sh_a
->wf
->wFormatTag
;
1731 memset(sh_a
->wf
, 0, sizeof(WAVEFORMATEX
));
1732 if (!strcmp(track
->codec_id
, MKV_A_MP3
)
1733 || !strcmp(track
->codec_id
, MKV_A_MP2
))
1734 track
->a_formattag
= 0x0055;
1735 else if (!strncmp(track
->codec_id
, MKV_A_AC3
, strlen(MKV_A_AC3
)))
1736 track
->a_formattag
= 0x2000;
1737 else if (!strcmp(track
->codec_id
, MKV_A_DTS
))
1738 track
->a_formattag
= 0x2001;
1739 else if (!strcmp(track
->codec_id
, MKV_A_PCM
)
1740 || !strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1741 track
->a_formattag
= 0x0001;
1742 else if (!strcmp(track
->codec_id
, MKV_A_AAC_2MAIN
)
1743 || !strncmp(track
->codec_id
, MKV_A_AAC_2LC
,
1744 strlen(MKV_A_AAC_2LC
))
1745 || !strcmp(track
->codec_id
, MKV_A_AAC_2SSR
)
1746 || !strcmp(track
->codec_id
, MKV_A_AAC_4MAIN
)
1747 || !strncmp(track
->codec_id
, MKV_A_AAC_4LC
,
1748 strlen(MKV_A_AAC_4LC
))
1749 || !strcmp(track
->codec_id
, MKV_A_AAC_4SSR
)
1750 || !strcmp(track
->codec_id
, MKV_A_AAC_4LTP
)
1751 || !strcmp(track
->codec_id
, MKV_A_AAC
))
1752 track
->a_formattag
= mmioFOURCC('M', 'P', '4', 'A');
1753 else if (!strcmp(track
->codec_id
, MKV_A_VORBIS
)) {
1754 if (track
->private_data
== NULL
)
1756 track
->a_formattag
= mmioFOURCC('v', 'r', 'b', 's');
1757 } else if (!strcmp(track
->codec_id
, MKV_A_QDMC
))
1758 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', 'C');
1759 else if (!strcmp(track
->codec_id
, MKV_A_QDMC2
))
1760 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', '2');
1761 else if (!strcmp(track
->codec_id
, MKV_A_WAVPACK
))
1762 track
->a_formattag
= mmioFOURCC('W', 'V', 'P', 'K');
1763 else if (!strcmp(track
->codec_id
, MKV_A_TRUEHD
))
1764 track
->a_formattag
= mmioFOURCC('T', 'R', 'H', 'D');
1765 else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)) {
1766 if (track
->private_data
== NULL
|| track
->private_size
== 0) {
1767 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
,
1768 "[mkv] FLAC track does not contain valid headers.\n");
1771 track
->a_formattag
= mmioFOURCC('f', 'L', 'a', 'C');
1772 } else if (track
->private_size
>= RAPROPERTIES4_SIZE
) {
1773 if (!strcmp(track
->codec_id
, MKV_A_REAL28
))
1774 track
->a_formattag
= mmioFOURCC('2', '8', '_', '8');
1775 else if (!strcmp(track
->codec_id
, MKV_A_REALATRC
))
1776 track
->a_formattag
= mmioFOURCC('a', 't', 'r', 'c');
1777 else if (!strcmp(track
->codec_id
, MKV_A_REALCOOK
))
1778 track
->a_formattag
= mmioFOURCC('c', 'o', 'o', 'k');
1779 else if (!strcmp(track
->codec_id
, MKV_A_REALDNET
))
1780 track
->a_formattag
= mmioFOURCC('d', 'n', 'e', 't');
1781 else if (!strcmp(track
->codec_id
, MKV_A_REALSIPR
))
1782 track
->a_formattag
= mmioFOURCC('s', 'i', 'p', 'r');
1784 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Unknown/unsupported audio "
1785 "codec ID '%s' for track %u or missing/faulty\n[mkv] "
1786 "private codec data.\n", track
->codec_id
, track
->tnum
);
1787 free_sh_audio(demuxer
, track
->tnum
);
1792 sh_a
->format
= track
->a_formattag
;
1793 sh_a
->wf
->wFormatTag
= track
->a_formattag
;
1794 sh_a
->channels
= track
->a_channels
;
1795 sh_a
->wf
->nChannels
= track
->a_channels
;
1796 sh_a
->samplerate
= (uint32_t) track
->a_sfreq
;
1797 sh_a
->wf
->nSamplesPerSec
= (uint32_t) track
->a_sfreq
;
1798 if (track
->a_bps
== 0) {
1799 sh_a
->samplesize
= 2;
1800 sh_a
->wf
->wBitsPerSample
= 16;
1802 sh_a
->samplesize
= track
->a_bps
/ 8;
1803 sh_a
->wf
->wBitsPerSample
= track
->a_bps
;
1805 if (track
->a_formattag
== 0x0055) { /* MP3 || MP2 */
1806 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1807 sh_a
->wf
->nBlockAlign
= 1152;
1808 } else if ((track
->a_formattag
== 0x2000) /* AC3 */
1809 || (track
->a_formattag
== 0x2001)) { /* DTS */
1812 } else if (track
->a_formattag
== 0x0001) { /* PCM || PCM_BE */
1813 sh_a
->wf
->nAvgBytesPerSec
= sh_a
->channels
* sh_a
->samplerate
* 2;
1814 sh_a
->wf
->nBlockAlign
= sh_a
->wf
->nAvgBytesPerSec
;
1815 if (!strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1816 sh_a
->format
= mmioFOURCC('t', 'w', 'o', 's');
1817 } else if (!strcmp(track
->codec_id
, MKV_A_QDMC
)
1818 || !strcmp(track
->codec_id
, MKV_A_QDMC2
)) {
1819 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1820 sh_a
->wf
->nBlockAlign
= 1486;
1821 track
->fix_i_bps
= 1;
1822 track
->qt_last_a_pts
= 0.0;
1823 if (track
->private_data
!= NULL
) {
1824 sh_a
->codecdata
= malloc(track
->private_size
);
1825 memcpy(sh_a
->codecdata
, track
->private_data
, track
->private_size
);
1826 sh_a
->codecdata_len
= track
->private_size
;
1828 } else if (track
->a_formattag
== mmioFOURCC('M', 'P', '4', 'A')) {
1829 int profile
, srate_idx
;
1831 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1832 sh_a
->wf
->nBlockAlign
= 1024;
1834 if (!strcmp(track
->codec_id
, MKV_A_AAC
)
1835 && (NULL
!= track
->private_data
)) {
1836 sh_a
->codecdata
= malloc(track
->private_size
);
1837 memcpy(sh_a
->codecdata
, track
->private_data
, track
->private_size
);
1838 sh_a
->codecdata_len
= track
->private_size
;
1842 /* Recreate the 'private data' */
1843 /* which faad2 uses in its initialization */
1844 srate_idx
= aac_get_sample_rate_index(sh_a
->samplerate
);
1845 if (!strncmp(&track
->codec_id
[12], "MAIN", 4))
1847 else if (!strncmp(&track
->codec_id
[12], "LC", 2))
1849 else if (!strncmp(&track
->codec_id
[12], "SSR", 3))
1853 sh_a
->codecdata
= malloc(5);
1854 sh_a
->codecdata
[0] = ((profile
+ 1) << 3) | ((srate_idx
& 0xE) >> 1);
1855 sh_a
->codecdata
[1] =
1856 ((srate_idx
& 0x1) << 7) | (track
->a_channels
<< 3);
1858 if (strstr(track
->codec_id
, "SBR") != NULL
) {
1859 /* HE-AAC (aka SBR AAC) */
1860 sh_a
->codecdata_len
= 5;
1862 sh_a
->samplerate
*= 2;
1863 sh_a
->wf
->nSamplesPerSec
*= 2;
1864 srate_idx
= aac_get_sample_rate_index(sh_a
->samplerate
);
1865 sh_a
->codecdata
[2] = AAC_SYNC_EXTENSION_TYPE
>> 3;
1866 sh_a
->codecdata
[3] = ((AAC_SYNC_EXTENSION_TYPE
& 0x07) << 5) | 5;
1867 sh_a
->codecdata
[4] = (1 << 7) | (srate_idx
<< 3);
1868 track
->default_duration
= 1024.0 / (sh_a
->samplerate
/ 2);
1870 sh_a
->codecdata_len
= 2;
1871 track
->default_duration
= 1024.0 / sh_a
->samplerate
;
1873 } else if (track
->a_formattag
== mmioFOURCC('v', 'r', 'b', 's')) { /* VORBIS */
1874 sh_a
->wf
->cbSize
= track
->private_size
;
1875 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(WAVEFORMATEX
) + sh_a
->wf
->cbSize
);
1876 memcpy((unsigned char *) (sh_a
->wf
+ 1), track
->private_data
,
1878 } else if (track
->private_size
>= RAPROPERTIES4_SIZE
1879 && !strncmp(track
->codec_id
, MKV_A_REALATRC
, 7)) {
1880 /* Common initialization for all RealAudio codecs */
1881 unsigned char *src
= track
->private_data
;
1882 int codecdata_length
, version
;
1885 sh_a
->wf
->nAvgBytesPerSec
= 0; /* FIXME !? */
1887 version
= AV_RB16(src
+ 4);
1888 flavor
= AV_RB16(src
+ 22);
1889 track
->coded_framesize
= AV_RB32(src
+ 24);
1890 track
->sub_packet_h
= AV_RB16(src
+ 40);
1891 sh_a
->wf
->nBlockAlign
= track
->audiopk_size
= AV_RB16(src
+ 42);
1892 track
->sub_packet_size
= AV_RB16(src
+ 44);
1894 src
+= RAPROPERTIES4_SIZE
;
1898 src
+= RAPROPERTIES5_SIZE
;
1903 codecdata_length
= AV_RB32(src
);
1905 sh_a
->wf
->cbSize
= codecdata_length
;
1906 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(WAVEFORMATEX
) + sh_a
->wf
->cbSize
);
1907 memcpy(((char *) (sh_a
->wf
+ 1)), src
, codecdata_length
);
1909 switch (track
->a_formattag
) {
1910 case mmioFOURCC('a', 't', 'r', 'c'):
1911 sh_a
->wf
->nAvgBytesPerSec
= atrc_fl2bps
[flavor
];
1912 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1914 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1915 track
->audio_timestamp
=
1916 malloc(track
->sub_packet_h
* sizeof(double));
1918 case mmioFOURCC('c', 'o', 'o', 'k'):
1919 sh_a
->wf
->nAvgBytesPerSec
= cook_fl2bps
[flavor
];
1920 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1922 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1923 track
->audio_timestamp
=
1924 malloc(track
->sub_packet_h
* sizeof(double));
1926 case mmioFOURCC('s', 'i', 'p', 'r'):
1927 sh_a
->wf
->nAvgBytesPerSec
= sipr_fl2bps
[flavor
];
1928 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1930 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1931 track
->audio_timestamp
=
1932 malloc(track
->sub_packet_h
* sizeof(double));
1934 case mmioFOURCC('2', '8', '_', '8'):
1935 sh_a
->wf
->nAvgBytesPerSec
= 3600;
1936 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1938 malloc(track
->sub_packet_h
* track
->audiopk_size
);
1939 track
->audio_timestamp
=
1940 malloc(track
->sub_packet_h
* sizeof(double));
1944 track
->realmedia
= 1;
1945 } else if (!strcmp(track
->codec_id
, MKV_A_FLAC
)
1946 || (track
->a_formattag
== 0xf1ac)) {
1952 if (track
->a_formattag
== mmioFOURCC('f', 'L', 'a', 'C')) {
1953 ptr
= track
->private_data
;
1954 size
= track
->private_size
;
1956 sh_a
->format
= mmioFOURCC('f', 'L', 'a', 'C');
1957 ptr
= track
->private_data
+ sizeof(WAVEFORMATEX
);
1958 size
= track
->private_size
- sizeof(WAVEFORMATEX
);
1960 if (size
< 4 || ptr
[0] != 'f' || ptr
[1] != 'L' || ptr
[2] != 'a'
1962 sh_a
->codecdata
= malloc(4);
1963 sh_a
->codecdata_len
= 4;
1964 memcpy(sh_a
->codecdata
, "fLaC", 4);
1966 sh_a
->codecdata
= malloc(size
);
1967 sh_a
->codecdata_len
= size
;
1968 memcpy(sh_a
->codecdata
, ptr
, size
);
1970 } else if (track
->a_formattag
== mmioFOURCC('W', 'V', 'P', 'K') || track
->a_formattag
== mmioFOURCC('T', 'R', 'H', 'D')) { /* do nothing, still works */
1971 } else if (!track
->ms_compat
1972 || (track
->private_size
< sizeof(WAVEFORMATEX
))) {
1973 free_sh_audio(demuxer
, track
->tnum
);
1980 static int demux_mkv_open_sub(demuxer_t
*demuxer
, mkv_track_t
*track
,
1983 if (track
->subtitle_type
!= MATROSKA_SUBTYPE_UNKNOWN
) {
1986 sh_sub_t
*sh
= new_sh_sub_sid(demuxer
, track
->tnum
, sid
);
1989 if (track
->subtitle_type
== MATROSKA_SUBTYPE_VOBSUB
)
1991 if (track
->subtitle_type
== MATROSKA_SUBTYPE_SSA
)
1993 size
= track
->private_size
;
1994 m
= demux_mkv_decode(track
, track
->private_data
, &buffer
, &size
, 2);
1996 free(track
->private_data
);
1997 track
->private_data
= buffer
;
1998 track
->private_size
= size
;
2000 sh
->extradata
= malloc(track
->private_size
);
2001 memcpy(sh
->extradata
, track
->private_data
, track
->private_size
);
2002 sh
->extradata_len
= track
->private_size
;
2003 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
2004 sh
->lang
= strdup(track
->language
);
2005 sh
->default_track
= track
->default_track
;
2007 mp_tmsg(MSGT_DEMUX
, MSGL_ERR
,
2008 "[mkv] Subtitle type '%s' is not supported.\n",
2016 static int demux_mkv_open(demuxer_t
*demuxer
)
2018 stream_t
*s
= demuxer
->stream
;
2019 mkv_demuxer_t
*mkv_d
;
2021 int i
, version
, cont
= 0;
2024 stream_seek(s
, s
->start_pos
);
2025 str
= ebml_read_header(s
, &version
);
2026 if (str
== NULL
|| strcmp(str
, "matroska") || version
> 2) {
2027 mp_msg(MSGT_DEMUX
, MSGL_DBG2
, "[mkv] no head found\n");
2032 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Found the head...\n");
2034 if (ebml_read_id(s
, NULL
) != MATROSKA_ID_SEGMENT
) {
2035 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] but no segment :(\n");
2038 ebml_read_length(s
, NULL
); /* return bytes number until EOF */
2040 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] + a segment...\n");
2042 mkv_d
= calloc(1, sizeof(mkv_demuxer_t
));
2043 demuxer
->priv
= mkv_d
;
2044 mkv_d
->tc_scale
= 1000000;
2045 mkv_d
->segment_start
= stream_tell(s
);
2046 mkv_d
->parsed_cues
= malloc(sizeof(off_t
));
2047 mkv_d
->parsed_seekhead
= malloc(sizeof(off_t
));
2050 switch (ebml_read_id(s
, NULL
)) {
2051 case MATROSKA_ID_INFO
:
2052 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment information...\n");
2053 cont
= demux_mkv_read_info(demuxer
);
2056 case MATROSKA_ID_TRACKS
:
2057 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment tracks...\n");
2058 cont
= demux_mkv_read_tracks(demuxer
);
2061 case MATROSKA_ID_CUES
:
2062 cont
= demux_mkv_read_cues(demuxer
);
2065 case MATROSKA_ID_TAGS
:
2066 cont
= demux_mkv_read_tags(demuxer
);
2069 case MATROSKA_ID_SEEKHEAD
:
2070 cont
= demux_mkv_read_seekhead(demuxer
);
2073 case MATROSKA_ID_CHAPTERS
:
2074 cont
= demux_mkv_read_chapters(demuxer
);
2077 case MATROSKA_ID_ATTACHMENTS
:
2078 cont
= demux_mkv_read_attachments(demuxer
);
2081 case MATROSKA_ID_CLUSTER
:
2082 mp_msg(MSGT_DEMUX
, MSGL_V
,
2083 "[mkv] |+ found cluster, headers are "
2084 "parsed completely :)\n");
2085 stream_seek(s
, stream_tell(s
) - 4);
2092 ebml_read_skip(s
, NULL
);
2097 display_create_tracks(demuxer
);
2099 /* select video track */
2101 if (demuxer
->video
->id
== -1) { /* automatically select a video track */
2102 /* search for a video track that has the 'default' flag set */
2103 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2104 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_VIDEO
2105 && mkv_d
->tracks
[i
]->default_track
) {
2106 track
= mkv_d
->tracks
[i
];
2111 /* no track has the 'default' flag set */
2112 /* let's take the first video track */
2113 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2114 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_VIDEO
) {
2115 track
= mkv_d
->tracks
[i
];
2118 } else if (demuxer
->video
->id
!= -2) /* -2 = no video at all */
2120 demux_mkv_find_track_by_num(mkv_d
, demuxer
->video
->id
,
2121 MATROSKA_TRACK_VIDEO
);
2123 if (track
&& demuxer
->v_streams
[track
->tnum
]) {
2124 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] Will play video track %u.\n",
2126 demuxer
->video
->id
= track
->tnum
;
2127 demuxer
->video
->sh
= demuxer
->v_streams
[track
->tnum
];
2129 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] No video track found/wanted.\n");
2130 demuxer
->video
->id
= -2;
2133 /* select audio track */
2136 /* search for an audio track that has the 'default' flag set */
2137 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2138 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_AUDIO
2139 && mkv_d
->tracks
[i
]->default_track
) {
2140 track
= mkv_d
->tracks
[i
];
2145 /* no track has the 'default' flag set */
2146 /* let's take the first audio track */
2147 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2148 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_AUDIO
) {
2149 track
= mkv_d
->tracks
[i
];
2153 if (track
&& demuxer
->a_streams
[track
->tnum
]) {
2154 demuxer
->audio
->id
= track
->tnum
;
2155 demuxer
->audio
->sh
= demuxer
->a_streams
[track
->tnum
];
2157 mp_tmsg(MSGT_DEMUX
, MSGL_INFO
, "[mkv] No audio track found/wanted.\n");
2158 demuxer
->audio
->id
= -2;
2162 if (demuxer
->audio
->id
!= -2)
2163 for (i
= 0; i
< mkv_d
->num_tracks
; i
++) {
2164 if (mkv_d
->tracks
[i
]->type
!= MATROSKA_TRACK_AUDIO
)
2166 if (demuxer
->a_streams
[track
->tnum
]) {
2168 if (mkv_d
->last_aid
== MAX_A_STREAMS
)
2173 if (s
->end_pos
== 0 || (mkv_d
->indexes
== NULL
&& index_mode
< 0))
2174 demuxer
->seekable
= 0;
2176 demuxer
->movi_start
= s
->start_pos
;
2177 demuxer
->movi_end
= s
->end_pos
;
2178 demuxer
->seekable
= 1;
2181 demuxer
->accurate_seek
= true;
2183 return DEMUXER_TYPE_MATROSKA
;
2186 static void demux_close_mkv(demuxer_t
*demuxer
)
2188 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2192 free_cached_dps(demuxer
);
2193 if (mkv_d
->tracks
) {
2194 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2195 demux_mkv_free_trackentry(mkv_d
->tracks
[i
]);
2196 free(mkv_d
->tracks
);
2198 free(mkv_d
->indexes
);
2199 free(mkv_d
->cluster_positions
);
2200 free(mkv_d
->parsed_cues
);
2201 free(mkv_d
->parsed_seekhead
);
2206 static int demux_mkv_read_block_lacing(uint8_t *buffer
, uint64_t *size
,
2208 uint32_t **all_lace_sizes
)
2210 uint32_t total
= 0, *lace_size
;
2214 *all_lace_sizes
= NULL
;
2220 switch ((flags
& 0x06) >> 1) {
2221 case 0: /* no lacing */
2223 lace_size
= calloc(*laces
, sizeof(uint32_t));
2224 lace_size
[0] = *size
;
2227 case 1: /* xiph lacing */
2228 case 2: /* fixed-size lacing */
2229 case 3: /* EBML lacing */
2233 lace_size
= calloc(*laces
, sizeof(uint32_t));
2235 switch ((flags
& 0x06) >> 1) {
2236 case 1: /* xiph lacing */
2237 for (i
= 0; i
< *laces
- 1; i
++) {
2240 lace_size
[i
] += *buffer
;
2242 } while (*buffer
++ == 0xFF);
2243 total
+= lace_size
[i
];
2245 lace_size
[i
] = *size
- total
;
2248 case 2: /* fixed-size lacing */
2249 for (i
= 0; i
< *laces
; i
++)
2250 lace_size
[i
] = *size
/ *laces
;
2253 case 3:; /* EBML lacing */
2255 uint64_t num
= ebml_read_vlen_uint(buffer
, &l
);
2256 if (num
== EBML_UINT_INVALID
) {
2263 total
= lace_size
[0] = num
;
2264 for (i
= 1; i
< *laces
- 1; i
++) {
2266 snum
= ebml_read_vlen_int(buffer
, &l
);
2267 if (snum
== EBML_INT_INVALID
) {
2273 lace_size
[i
] = lace_size
[i
- 1] + snum
;
2274 total
+= lace_size
[i
];
2276 lace_size
[i
] = *size
- total
;
2281 *all_lace_sizes
= lace_size
;
2285 static void handle_subtitles(demuxer_t
*demuxer
, mkv_track_t
*track
,
2286 char *block
, int64_t size
,
2287 uint64_t block_duration
, uint64_t timecode
)
2291 if (block_duration
== 0) {
2292 mp_msg(MSGT_DEMUX
, MSGL_WARN
,
2293 "[mkv] Warning: No BlockDuration for subtitle track found.\n");
2298 dp
= new_demux_packet(size
);
2299 memcpy(dp
->buffer
, block
, size
);
2300 dp
->pts
= timecode
/ 1000.0;
2301 dp
->endpts
= (timecode
+ block_duration
) / 1000.0;
2302 ds_add_packet(demuxer
->sub
, dp
);
2305 double real_fix_timestamp(unsigned char *buf
, unsigned int timestamp
,
2306 unsigned int format
, int64_t *kf_base
, int *kf_pts
,
2309 static void handle_realvideo(demuxer_t
*demuxer
, mkv_track_t
*track
,
2310 uint8_t *buffer
, uint32_t size
, int block_bref
)
2312 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2314 uint32_t timestamp
= mkv_d
->last_pts
* 1000;
2316 dp
= new_demux_packet(size
);
2317 memcpy(dp
->buffer
, buffer
, size
);
2319 if (mkv_d
->v_skip_to_keyframe
) {
2320 dp
->pts
= mkv_d
->last_pts
;
2321 track
->rv_kf_base
= 0;
2322 track
->rv_kf_pts
= timestamp
;
2325 real_fix_timestamp(dp
->buffer
, timestamp
,
2326 ((sh_video_t
*) demuxer
->video
->sh
)->bih
->
2327 biCompression
, &track
->rv_kf_base
,
2328 &track
->rv_kf_pts
, NULL
);
2329 dp
->pos
= demuxer
->filepos
;
2330 dp
->flags
= block_bref
? 0 : 0x10;
2332 ds_add_packet(demuxer
->video
, dp
);
2335 static void handle_realaudio(demuxer_t
*demuxer
, mkv_track_t
*track
,
2336 uint8_t *buffer
, uint32_t size
, int block_bref
)
2338 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2339 int sps
= track
->sub_packet_size
;
2340 int sph
= track
->sub_packet_h
;
2341 int cfs
= track
->coded_framesize
;
2342 int w
= track
->audiopk_size
;
2343 int spc
= track
->sub_packet_cnt
;
2347 if ((track
->a_formattag
== mmioFOURCC('2', '8', '_', '8'))
2348 || (track
->a_formattag
== mmioFOURCC('c', 'o', 'o', 'k'))
2349 || (track
->a_formattag
== mmioFOURCC('a', 't', 'r', 'c'))
2350 || (track
->a_formattag
== mmioFOURCC('s', 'i', 'p', 'r'))) {
2352 // spc = track->sub_packet_cnt = 0;
2353 switch (track
->a_formattag
) {
2354 case mmioFOURCC('2', '8', '_', '8'):
2355 for (x
= 0; x
< sph
/ 2; x
++)
2356 memcpy(track
->audio_buf
+ x
* 2 * w
+ spc
* cfs
,
2357 buffer
+ cfs
* x
, cfs
);
2359 case mmioFOURCC('c', 'o', 'o', 'k'):
2360 case mmioFOURCC('a', 't', 'r', 'c'):
2361 for (x
= 0; x
< w
/ sps
; x
++)
2362 memcpy(track
->audio_buf
+
2363 sps
* (sph
* x
+ ((sph
+ 1) / 2) * (spc
& 1) +
2364 (spc
>> 1)), buffer
+ sps
* x
, sps
);
2366 case mmioFOURCC('s', 'i', 'p', 'r'):
2367 memcpy(track
->audio_buf
+ spc
* w
, buffer
, w
);
2368 if (spc
== sph
- 1) {
2370 int bs
= sph
* w
* 2 / 96; // nibbles per subpacket
2371 // Perform reordering
2372 for (n
= 0; n
< 38; n
++) {
2374 int i
= bs
* sipr_swaps
[n
][0];
2375 int o
= bs
* sipr_swaps
[n
][1];
2376 // swap nibbles of block 'i' with 'o' TODO: optimize
2377 for (j
= 0; j
< bs
; j
++) {
2379 (track
->audio_buf
[i
>> 1] >> 4) :
2380 (track
->audio_buf
[i
>> 1] & 0x0F);
2382 (track
->audio_buf
[o
>> 1] >> 4) :
2383 (track
->audio_buf
[o
>> 1] & 0x0F);
2385 track
->audio_buf
[o
>> 1] =
2386 (track
->audio_buf
[o
>> 1] & 0x0F) | (x
<< 4);
2388 track
->audio_buf
[o
>> 1] =
2389 (track
->audio_buf
[o
>> 1] & 0xF0) | x
;
2391 track
->audio_buf
[i
>> 1] =
2392 (track
->audio_buf
[i
>> 1] & 0x0F) | (y
<< 4);
2394 track
->audio_buf
[i
>> 1] =
2395 (track
->audio_buf
[i
>> 1] & 0xF0) | y
;
2403 track
->audio_timestamp
[track
->sub_packet_cnt
] =
2404 (track
->ra_pts
== mkv_d
->last_pts
) ? 0 : (mkv_d
->last_pts
);
2405 track
->ra_pts
= mkv_d
->last_pts
;
2406 if (track
->sub_packet_cnt
== 0)
2407 track
->audio_filepos
= demuxer
->filepos
;
2408 if (++(track
->sub_packet_cnt
) == sph
) {
2410 ((WAVEFORMATEX
*) ((sh_audio_t
*) demuxer
->audio
->sh
)->wf
)->
2412 track
->sub_packet_cnt
= 0;
2413 // Release all the audio packets
2414 for (x
= 0; x
< sph
* w
/ apk_usize
; x
++) {
2415 dp
= new_demux_packet(apk_usize
);
2416 memcpy(dp
->buffer
, track
->audio_buf
+ x
* apk_usize
,
2418 /* Put timestamp only on packets that correspond to original
2419 * audio packets in file */
2420 dp
->pts
= (x
* apk_usize
% w
) ? 0 :
2421 track
->audio_timestamp
[x
* apk_usize
/ w
];
2422 dp
->pos
= track
->audio_filepos
; // all equal
2423 dp
->flags
= x
? 0 : 0x10; // Mark first packet as keyframe
2424 ds_add_packet(demuxer
->audio
, dp
);
2427 } else { // Not a codec that require reordering
2428 dp
= new_demux_packet(size
);
2429 memcpy(dp
->buffer
, buffer
, size
);
2430 if (track
->ra_pts
== mkv_d
->last_pts
&& !mkv_d
->a_skip_to_keyframe
)
2433 dp
->pts
= mkv_d
->last_pts
;
2434 track
->ra_pts
= mkv_d
->last_pts
;
2436 dp
->pos
= demuxer
->filepos
;
2437 dp
->flags
= block_bref
? 0 : 0x10;
2438 ds_add_packet(demuxer
->audio
, dp
);
2442 /** Reorder timecodes and add cached demux packets to the queues.
2444 * Timecode reordering is needed if a video track contains B frames that
2445 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2446 * MPlayer doesn't like timestamps in display order. This function adjusts
2447 * the timestamp of cached frames (which are exactly one I/P frame followed
2448 * by one or more B frames) so that they are in coding order again.
2450 * Example: The track with 25 FPS contains four frames with the timecodes
2451 * I at 0ms, P at 120ms, B at 40ms and B at 80ms. As soon as the next I
2452 * or P frame arrives these timecodes can be changed to I at 0ms, P at 40ms,
2453 * B at 80ms and B at 120ms.
2455 * This works for simple H.264 B-frame pyramids, but not for arbitrary orders.
2457 * \param demuxer The Matroska demuxer struct for this instance.
2458 * \param track The track structure whose cache should be handled.
2460 static void flush_cached_dps(demuxer_t
*demuxer
, mkv_track_t
*track
)
2464 if (track
->num_cached_dps
== 0)
2469 for (i
= 1; i
< track
->num_cached_dps
; i
++)
2470 if (track
->cached_dps
[i
- 1]->pts
> track
->cached_dps
[i
]->pts
) {
2471 double tmp_pts
= track
->cached_dps
[i
- 1]->pts
;
2472 track
->cached_dps
[i
- 1]->pts
= track
->cached_dps
[i
]->pts
;
2473 track
->cached_dps
[i
]->pts
= tmp_pts
;
2478 for (i
= 0; i
< track
->num_cached_dps
; i
++)
2479 ds_add_packet(demuxer
->video
, track
->cached_dps
[i
]);
2480 track
->num_cached_dps
= 0;
2483 /** Cache video frames if timecodes have to be reordered.
2485 * Timecode reordering is needed if a video track contains B frames that
2486 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2487 * This function takes in a Matroska block read from the file, allocates a
2488 * demux packet for it, fills in its values, allocates space for storing
2489 * pointers to the cached demux packets and adds the packet to it. If
2490 * the packet contains an I or a P frame then ::flush_cached_dps is called
2491 * in order to send the old cached frames downstream.
2493 * \param demuxer The Matroska demuxer struct for this instance.
2494 * \param track The packet is meant for this track.
2495 * \param buffer The actual frame contents.
2496 * \param size The frame size in bytes.
2497 * \param block_bref A relative timecode (backward reference). If it is \c 0
2498 * then the frame is an I frame.
2499 * \param block_fref A relative timecode (forward reference). If it is \c 0
2500 * then the frame is either an I frame or a P frame depending on the value
2501 * of \a block_bref. Otherwise it's a B frame.
2503 static void handle_video_bframes(demuxer_t
*demuxer
, mkv_track_t
*track
,
2504 uint8_t *buffer
, uint32_t size
,
2505 int block_bref
, int block_fref
)
2507 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2510 dp
= new_demux_packet(size
);
2511 memcpy(dp
->buffer
, buffer
, size
);
2512 dp
->pos
= demuxer
->filepos
;
2513 dp
->pts
= mkv_d
->last_pts
;
2514 if ((track
->num_cached_dps
> 0) && (dp
->pts
< track
->max_pts
))
2516 if (block_fref
== 0) /* I or P frame */
2517 flush_cached_dps(demuxer
, track
);
2518 if (block_bref
!= 0) /* I frame, don't cache it */
2520 if ((track
->num_cached_dps
+ 1) > track
->num_allocated_dps
) {
2521 track
->cached_dps
= (demux_packet_t
**)
2522 realloc(track
->cached_dps
,
2523 (track
->num_cached_dps
+ 10) * sizeof(demux_packet_t
*));
2524 track
->num_allocated_dps
+= 10;
2526 track
->cached_dps
[track
->num_cached_dps
] = dp
;
2527 track
->num_cached_dps
++;
2528 if (dp
->pts
> track
->max_pts
)
2529 track
->max_pts
= dp
->pts
;
2532 static int handle_block(demuxer_t
*demuxer
, uint8_t *block
, uint64_t length
,
2533 uint64_t block_duration
, int64_t block_bref
,
2534 int64_t block_fref
, uint8_t simpleblock
)
2536 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2537 mkv_track_t
*track
= NULL
;
2538 demux_stream_t
*ds
= NULL
;
2539 uint64_t old_length
;
2541 uint32_t *lace_size
;
2542 uint8_t laces
, flags
;
2543 int i
, num
, tmp
, use_this_block
= 1;
2547 /* first byte(s): track num */
2548 num
= ebml_read_vlen_uint(block
, &tmp
);
2550 /* time (relative to cluster time) */
2551 time
= block
[0] << 8 | block
[1];
2554 old_length
= length
;
2556 if (demux_mkv_read_block_lacing(block
, &length
, &laces
, &lace_size
))
2558 block
+= old_length
- length
;
2560 tc
= (time
* mkv_d
->tc_scale
+ mkv_d
->cluster_tc
) / 1000000.0 + 0.5;
2563 current_pts
= tc
/ 1000.0;
2565 for (i
= 0; i
< mkv_d
->num_tracks
; i
++)
2566 if (mkv_d
->tracks
[i
]->tnum
== num
) {
2567 track
= mkv_d
->tracks
[i
];
2570 if (track
== NULL
) {
2574 if (num
== demuxer
->audio
->id
) {
2575 ds
= demuxer
->audio
;
2577 if (mkv_d
->a_skip_to_keyframe
) {
2579 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2581 } else if (block_bref
!= 0)
2583 } else if (mkv_d
->v_skip_to_keyframe
)
2586 if (track
->fix_i_bps
&& use_this_block
) {
2587 sh_audio_t
*sh
= (sh_audio_t
*) ds
->sh
;
2589 if (block_duration
!= 0) {
2590 sh
->i_bps
= length
* 1000 / block_duration
;
2591 track
->fix_i_bps
= 0;
2592 } else if (track
->qt_last_a_pts
== 0.0)
2593 track
->qt_last_a_pts
= current_pts
;
2594 else if (track
->qt_last_a_pts
!= current_pts
) {
2595 sh
->i_bps
= length
/ (current_pts
- track
->qt_last_a_pts
);
2596 track
->fix_i_bps
= 0;
2599 } else if (tc
< mkv_d
->skip_to_timecode
)
2601 else if (num
== demuxer
->video
->id
) {
2602 ds
= demuxer
->video
;
2603 if (mkv_d
->v_skip_to_keyframe
) {
2605 if (!(flags
& 0x80)) /*current frame isn't a keyframe */
2607 } else if (block_bref
!= 0 || block_fref
!= 0)
2610 } else if (num
== demuxer
->sub
->id
) {
2612 if (track
->subtitle_type
!= MATROSKA_SUBTYPE_VOBSUB
) {
2613 if (!mkv_d
->v_skip_to_keyframe
)
2614 handle_subtitles(demuxer
, track
, block
, length
, block_duration
,
2621 if (use_this_block
) {
2622 mkv_d
->last_pts
= current_pts
;
2623 mkv_d
->last_filepos
= demuxer
->filepos
;
2625 for (i
= 0; i
< laces
; i
++) {
2626 if (ds
== demuxer
->video
&& track
->realmedia
)
2627 handle_realvideo(demuxer
, track
, block
, lace_size
[i
],
2629 else if (ds
== demuxer
->audio
&& track
->realmedia
)
2630 handle_realaudio(demuxer
, track
, block
, lace_size
[i
],
2632 else if (ds
== demuxer
->video
&& track
->reorder_timecodes
)
2633 handle_video_bframes(demuxer
, track
, block
, lace_size
[i
],
2634 block_bref
, block_fref
);
2636 int modified
, size
= lace_size
[i
];
2639 modified
= demux_mkv_decode(track
, block
, &buffer
, &size
, 1);
2641 dp
= new_demux_packet(size
);
2642 memcpy(dp
->buffer
, buffer
, size
);
2645 dp
->flags
= (block_bref
== 0
2646 && block_fref
== 0) ? 0x10 : 0;
2647 /* If default_duration is 0, assume no pts value is known
2648 * for packets after the first one (rather than all pts
2649 * values being the same) */
2650 if (i
== 0 || track
->default_duration
)
2652 mkv_d
->last_pts
+ i
* track
->default_duration
;
2653 ds_add_packet(ds
, dp
);
2656 block
+= lace_size
[i
];
2659 if (ds
== demuxer
->video
) {
2660 mkv_d
->v_skip_to_keyframe
= 0;
2661 mkv_d
->skip_to_timecode
= 0;
2662 } else if (ds
== demuxer
->audio
)
2663 mkv_d
->a_skip_to_keyframe
= 0;
2673 static int demux_mkv_fill_buffer(demuxer_t
*demuxer
, demux_stream_t
*ds
)
2675 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2676 stream_t
*s
= demuxer
->stream
;
2681 while (mkv_d
->cluster_size
> 0) {
2682 uint64_t block_duration
= 0, block_length
= 0;
2683 int64_t block_bref
= 0, block_fref
= 0;
2684 uint8_t *block
= NULL
;
2686 while (mkv_d
->blockgroup_size
> 0) {
2687 switch (ebml_read_id(s
, &il
)) {
2688 case MATROSKA_ID_BLOCKDURATION
:
2689 block_duration
= ebml_read_uint(s
, &l
);
2690 if (block_duration
== EBML_UINT_INVALID
) {
2695 block_duration
* mkv_d
->tc_scale
/ 1000000.0 + 0.5;
2698 case MATROSKA_ID_BLOCK
:
2699 block_length
= ebml_read_length(s
, &tmp
);
2701 if (block_length
> SIZE_MAX
- AV_LZO_INPUT_PADDING
)
2703 block
= malloc(block_length
+ AV_LZO_INPUT_PADDING
);
2704 demuxer
->filepos
= stream_tell(s
);
2705 if (stream_read(s
, block
, block_length
) !=
2706 (int) block_length
) {
2710 l
= tmp
+ block_length
;
2713 case MATROSKA_ID_REFERENCEBLOCK
:;
2714 int64_t num
= ebml_read_int(s
, &l
);
2715 if (num
== EBML_INT_INVALID
) {
2725 case EBML_ID_INVALID
:
2730 ebml_read_skip(s
, &l
);
2733 mkv_d
->blockgroup_size
-= l
+ il
;
2734 mkv_d
->cluster_size
-= l
+ il
;
2738 int res
= handle_block(demuxer
, block
, block_length
,
2739 block_duration
, block_bref
, block_fref
,
2748 if (mkv_d
->cluster_size
> 0) {
2749 switch (ebml_read_id(s
, &il
)) {
2750 case MATROSKA_ID_CLUSTERTIMECODE
:;
2751 uint64_t num
= ebml_read_uint(s
, &l
);
2752 if (num
== EBML_UINT_INVALID
)
2754 mkv_d
->cluster_tc
= num
* mkv_d
->tc_scale
;
2755 add_cluster_position(mkv_d
, mkv_d
->cluster_start
,
2759 case MATROSKA_ID_BLOCKGROUP
:
2760 mkv_d
->blockgroup_size
= ebml_read_length(s
, &tmp
);
2764 case MATROSKA_ID_SIMPLEBLOCK
:;
2766 block_length
= ebml_read_length(s
, &tmp
);
2767 block
= malloc(block_length
);
2768 demuxer
->filepos
= stream_tell(s
);
2769 if (stream_read(s
, block
, block_length
) !=
2770 (int) block_length
) {
2774 l
= tmp
+ block_length
;
2775 res
= handle_block(demuxer
, block
, block_length
,
2776 block_duration
, block_bref
,
2779 mkv_d
->cluster_size
-= l
+ il
;
2785 mkv_d
->cluster_size
+= l
+ il
;
2788 case EBML_ID_INVALID
:
2792 ebml_read_skip(s
, &l
);
2795 mkv_d
->cluster_size
-= l
+ il
;
2799 if (ebml_read_id(s
, &il
) != MATROSKA_ID_CLUSTER
)
2801 mkv_d
->cluster_start
= stream_tell(s
) - il
;
2802 mkv_d
->cluster_size
= ebml_read_length(s
, NULL
);
2808 static void demux_mkv_seek(demuxer_t
*demuxer
, float rel_seek_secs
,
2809 float audio_delay
, int flags
)
2811 if (!(flags
& (SEEK_BACKWARD
| SEEK_FORWARD
))) {
2812 if (flags
& SEEK_ABSOLUTE
|| rel_seek_secs
< 0)
2813 flags
|= SEEK_BACKWARD
;
2815 flags
|= SEEK_FORWARD
;
2817 // Adjust the target a little bit to catch cases where the target position
2818 // specifies a keyframe with high, but not perfect, precision.
2819 rel_seek_secs
+= flags
& SEEK_FORWARD
? -0.005 : 0.005;
2821 free_cached_dps(demuxer
);
2822 if (!(flags
& SEEK_FACTOR
)) { /* time in secs */
2823 mkv_index_t
*index
= NULL
;
2824 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2825 stream_t
*s
= demuxer
->stream
;
2826 int64_t target_timecode
= 0, diff
, min_diff
= 0xFFFFFFFFFFFFFFFLL
;
2829 if (!(flags
& SEEK_ABSOLUTE
)) /* relative seek */
2830 target_timecode
= (int64_t) (mkv_d
->last_pts
* 1000.0);
2831 target_timecode
+= (int64_t) (rel_seek_secs
* 1000.0);
2832 if (target_timecode
< 0)
2833 target_timecode
= 0;
2835 if (mkv_d
->indexes
== NULL
) { /* no index was found */
2836 int64_t target_tc_ns
= (int64_t) (rel_seek_secs
* 1e9
);
2837 if (target_tc_ns
< 0)
2839 uint64_t max_filepos
= 0;
2840 int64_t max_tc
= -1;
2841 int n
= mkv_d
->num_cluster_pos
;
2843 max_filepos
= mkv_d
->cluster_positions
[n
- 1].filepos
;
2844 max_tc
= mkv_d
->cluster_positions
[n
- 1].timecode
;
2847 if (target_tc_ns
> max_tc
) {
2848 if ((off_t
) max_filepos
> stream_tell(s
))
2849 stream_seek(s
, max_filepos
);
2851 stream_seek(s
, stream_tell(s
) + mkv_d
->cluster_size
);
2852 /* parse all the clusters upto target_filepos */
2854 uint64_t start
= stream_tell(s
);
2855 uint32_t type
= ebml_read_id(s
, NULL
);
2856 uint64_t len
= ebml_read_length(s
, NULL
);
2857 uint64_t end
= stream_tell(s
) + len
;
2858 if (type
== MATROSKA_ID_CLUSTER
) {
2859 while (!s
->eof
&& stream_tell(s
) < end
) {
2860 if (ebml_read_id(s
, NULL
)
2861 == MATROSKA_ID_CLUSTERTIMECODE
) {
2862 uint64_t tc
= ebml_read_uint(s
, NULL
);
2863 tc
*= mkv_d
->tc_scale
;
2864 add_cluster_position(mkv_d
, start
, tc
);
2865 if (tc
>= target_tc_ns
)
2871 stream_seek(s
, end
);
2877 if (!mkv_d
->num_cluster_pos
) {
2878 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] no target for seek found\n");
2881 uint64_t cluster_pos
= mkv_d
->cluster_positions
[0].filepos
;
2882 /* Let's find the nearest cluster */
2883 for (i
= 0; i
< mkv_d
->num_cluster_pos
; i
++) {
2884 diff
= mkv_d
->cluster_positions
[i
].timecode
- target_tc_ns
;
2885 if (flags
& SEEK_BACKWARD
&& diff
< 0 && -diff
< min_diff
) {
2886 cluster_pos
= mkv_d
->cluster_positions
[i
].filepos
;
2888 } else if (flags
& SEEK_FORWARD
2889 && (diff
< 0 ? -1 * diff
: diff
) < min_diff
) {
2890 cluster_pos
= mkv_d
->cluster_positions
[i
].filepos
;
2891 min_diff
= diff
< 0 ? -1 * diff
: diff
;
2894 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2895 stream_seek(s
, cluster_pos
);
2897 int seek_id
= (demuxer
->video
->id
< 0) ?
2898 demuxer
->audio
->id
: demuxer
->video
->id
;
2900 /* let's find the entry in the indexes with the smallest */
2901 /* difference to the wanted timecode. */
2902 for (i
= 0; i
< mkv_d
->num_indexes
; i
++)
2903 if (mkv_d
->indexes
[i
].tnum
== seek_id
) {
2906 (int64_t) (mkv_d
->indexes
[i
].timecode
*
2907 mkv_d
->tc_scale
/ 1000000.0 + 0.5);
2909 if (flags
& SEEK_BACKWARD
) {
2910 // Seek backward: find the last index position
2911 // before target time
2912 if (diff
< 0 || diff
>= min_diff
)
2915 // Seek forward: find the first index position
2916 // after target time. If no such index exists, find last
2917 // position between current position and target time.
2919 if (min_diff
<= 0 && diff
<= min_diff
)
2922 FFMIN(target_timecode
- mkv_d
->last_pts
,
2927 index
= mkv_d
->indexes
+ i
;
2930 if (index
) { /* We've found an entry. */
2931 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2932 stream_seek(s
, index
->filepos
);
2936 if (demuxer
->video
->id
>= 0)
2937 mkv_d
->v_skip_to_keyframe
= 1;
2938 if (flags
& SEEK_FORWARD
)
2939 mkv_d
->skip_to_timecode
= target_timecode
;
2941 mkv_d
->skip_to_timecode
= index
? index
->timecode
: 0;
2942 mkv_d
->a_skip_to_keyframe
= 1;
2944 demux_mkv_fill_buffer(demuxer
, NULL
);
2945 } else if ((demuxer
->movi_end
<= 0) || !(flags
& SEEK_ABSOLUTE
))
2946 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
2948 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2949 stream_t
*s
= demuxer
->stream
;
2950 uint64_t target_filepos
;
2951 mkv_index_t
*index
= NULL
;
2954 if (mkv_d
->indexes
== NULL
) { /* not implemented without index */
2955 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
2959 target_filepos
= (uint64_t) (demuxer
->movi_end
* rel_seek_secs
);
2960 for (i
= 0; i
< mkv_d
->num_indexes
; i
++)
2961 if (mkv_d
->indexes
[i
].tnum
== demuxer
->video
->id
)
2963 || ((mkv_d
->indexes
[i
].filepos
>= target_filepos
)
2964 && ((index
->filepos
< target_filepos
)
2965 || (mkv_d
->indexes
[i
].filepos
< index
->filepos
))))
2966 index
= &mkv_d
->indexes
[i
];
2971 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
2972 stream_seek(s
, index
->filepos
);
2974 if (demuxer
->video
->id
>= 0)
2975 mkv_d
->v_skip_to_keyframe
= 1;
2976 mkv_d
->skip_to_timecode
= index
->timecode
;
2977 mkv_d
->a_skip_to_keyframe
= 1;
2979 demux_mkv_fill_buffer(demuxer
, NULL
);
2983 static int demux_mkv_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
2985 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2988 case DEMUXER_CTRL_CORRECT_PTS
:
2989 return DEMUXER_CTRL_OK
;
2990 case DEMUXER_CTRL_GET_TIME_LENGTH
:
2991 if (mkv_d
->duration
== 0)
2992 return DEMUXER_CTRL_DONTKNOW
;
2994 *((double *) arg
) = (double) mkv_d
->duration
;
2995 return DEMUXER_CTRL_OK
;
2997 case DEMUXER_CTRL_GET_PERCENT_POS
:
2998 if (mkv_d
->duration
== 0) {
2999 return DEMUXER_CTRL_DONTKNOW
;
3002 *((int *) arg
) = (int) (100 * mkv_d
->last_pts
/ mkv_d
->duration
);
3003 return DEMUXER_CTRL_OK
;
3005 case DEMUXER_CTRL_SWITCH_AUDIO
:
3006 if (demuxer
->audio
&& demuxer
->audio
->sh
) {
3007 sh_audio_t
*sh
= demuxer
->a_streams
[demuxer
->audio
->id
];
3008 int aid
= *(int *) arg
;
3010 aid
= (sh
->aid
+ 1) % mkv_d
->last_aid
;
3011 if (aid
!= sh
->aid
) {
3012 mkv_track_t
*track
=
3013 demux_mkv_find_track_by_num(mkv_d
, aid
,
3014 MATROSKA_TRACK_AUDIO
);
3016 demuxer
->audio
->id
= track
->tnum
;
3017 sh
= demuxer
->a_streams
[demuxer
->audio
->id
];
3018 ds_free_packs(demuxer
->audio
);
3021 *(int *) arg
= sh
->aid
;
3024 return DEMUXER_CTRL_OK
;
3027 return DEMUXER_CTRL_NOTIMPL
;
3031 const demuxer_desc_t demuxer_desc_matroska
= {
3037 DEMUXER_TYPE_MATROSKA
,
3038 1, // safe autodetect
3040 demux_mkv_fill_buffer
,