2 * native Matroska demuxer
3 * Written by 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.
19 #include "stream/stream.h"
29 #include "subreader.h"
30 #include "libvo/sub.h"
32 #include "libass/ass.h"
33 #include "libass/ass_mp.h"
35 #include "libavutil/common.h"
37 #ifdef CONFIG_QTX_CODECS
38 #include "loader/qtx/qtxsdk/components.h"
45 #include "libavutil/lzo.h"
46 #include "libavutil/intreadwrite.h"
47 #include "libavutil/avstring.h"
49 static const unsigned char sipr_swaps
[38][2]={
50 {0,63},{1,22},{2,44},{3,90},{5,81},{7,31},{8,86},{9,58},{10,36},{12,68},
51 {13,39},{14,73},{15,53},{16,69},{17,57},{19,88},{20,34},{21,71},{24,46},
52 {25,94},{26,54},{28,75},{29,50},{32,70},{33,92},{35,74},{38,85},{40,56},
53 {42,87},{43,65},{45,59},{48,79},{49,93},{51,89},{55,95},{61,76},{67,83},
56 // Map flavour to bytes per second
57 #define SIPR_FLAVORS 4
58 #define ATRC_FLAVORS 8
59 #define COOK_FLAVORS 34
60 static const int sipr_fl2bps
[SIPR_FLAVORS
] = {813, 1062, 625, 2000};
61 static const int atrc_fl2bps
[ATRC_FLAVORS
] = {8269, 11714, 13092, 16538, 18260, 22050, 33075, 44100};
62 static const int cook_fl2bps
[COOK_FLAVORS
] = {
63 1000, 1378, 2024, 2584, 4005, 5513, 8010, 4005, 750, 2498,
64 4048, 5513, 8010, 11973, 8010, 2584, 4005, 2067, 2584, 2584,
65 4005, 4005, 5513, 5513, 8010, 12059, 1550, 8010, 12059, 5513,
66 12016, 16408, 22911, 33506};
70 uint32_t order
, type
, scope
;
72 uint8_t *comp_settings
;
73 int comp_settings_len
;
74 } mkv_content_encoding_t
;
76 typedef struct mkv_track
87 uint32_t v_width
, v_height
, v_dwidth
, v_dheight
;
91 uint32_t a_channels
, a_bps
;
94 float default_duration
;
98 unsigned char *private_data
;
99 unsigned int private_size
;
101 /* stuff for realmedia */
105 float rv_pts
; /* previous video timestamp */
106 float ra_pts
; /* previous audio timestamp */
108 /** realaudio descrambling */
109 int sub_packet_size
; ///< sub packet size, per stream
110 int sub_packet_h
; ///< number of coded frames per block
111 int coded_framesize
; ///< coded frame size, per stream
112 int audiopk_size
; ///< audio packet size
113 unsigned char *audio_buf
; ///< place to store reordered audio data
114 float *audio_timestamp
; ///< timestamp for each audio packet
115 int sub_packet_cnt
; ///< number of subpacket already received
116 int audio_filepos
; ///< file position of first audio packet in block
118 /* stuff for quicktime */
124 /* The timecodes of video frames might have to be reordered if they're
125 in display order (the timecodes, not the frames themselves!). In this
126 case demux packets have to be cached with the help of these variables. */
127 int reorder_timecodes
;
128 demux_packet_t
**cached_dps
;
129 int num_cached_dps
, num_allocated_dps
;
132 /* generic content encoding support */
133 mkv_content_encoding_t
*encodings
;
136 /* For VobSubs and SSA/ASS */
140 typedef struct mkv_index
143 uint64_t timecode
, filepos
;
146 typedef struct mkv_demuxer
150 float duration
, last_pts
;
151 uint64_t last_filepos
;
153 mkv_track_t
**tracks
;
156 uint64_t tc_scale
, cluster_tc
;
158 uint64_t cluster_size
;
159 uint64_t blockgroup_size
;
161 mkv_index_t
*indexes
;
166 off_t
*parsed_seekhead
;
167 int parsed_seekhead_num
;
169 uint64_t *cluster_positions
;
172 int64_t skip_to_timecode
;
173 int v_skip_to_keyframe
, a_skip_to_keyframe
;
176 int audio_tracks
[MAX_A_STREAMS
];
179 #define REALHEADER_SIZE 16
180 #define RVPROPERTIES_SIZE 34
181 #define RAPROPERTIES4_SIZE 56
182 #define RAPROPERTIES5_SIZE 70
185 * \brief ensures there is space for at least one additional element
186 * \param array array to grow
187 * \param nelem current number of elements in array
188 * \param elsize size of one array element
190 static void *grow_array(void *array
, int nelem
, size_t elsize
) {
192 array
= realloc(array
, (nelem
+ 32) * elsize
);
197 demux_mkv_find_track_by_num (mkv_demuxer_t
*d
, int n
, int type
)
201 for (i
=0, id
=0; i
< d
->num_tracks
; i
++)
202 if (d
->tracks
[i
] != NULL
&& d
->tracks
[i
]->type
== type
)
210 add_cluster_position (mkv_demuxer_t
*mkv_d
, uint64_t position
)
212 int i
= mkv_d
->num_cluster_pos
;
215 if (mkv_d
->cluster_positions
[i
] == position
)
218 mkv_d
->cluster_positions
= grow_array(mkv_d
->cluster_positions
,
219 mkv_d
->num_cluster_pos
,
221 mkv_d
->cluster_positions
[mkv_d
->num_cluster_pos
++] = position
;
225 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
227 aac_get_sample_rate_index (uint32_t sample_rate
)
229 if (92017 <= sample_rate
)
231 else if (75132 <= sample_rate
)
233 else if (55426 <= sample_rate
)
235 else if (46009 <= sample_rate
)
237 else if (37566 <= sample_rate
)
239 else if (27713 <= sample_rate
)
241 else if (23004 <= sample_rate
)
243 else if (18783 <= sample_rate
)
245 else if (13856 <= sample_rate
)
247 else if (11502 <= sample_rate
)
249 else if (9391 <= sample_rate
)
255 /** \brief Free cached demux packets
257 * Reordering the timecodes requires caching of demux packets. This function
258 * frees all these cached packets and the memory for the cached pointers
261 * \param demuxer The demuxer for which the cache is to be freed.
264 free_cached_dps (demuxer_t
*demuxer
)
266 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
270 for (k
= 0; k
< mkv_d
->num_tracks
; k
++)
272 track
= mkv_d
->tracks
[k
];
273 for (i
= 0; i
< track
->num_cached_dps
; i
++)
274 free_demux_packet (track
->cached_dps
[i
]);
275 free(track
->cached_dps
);
276 track
->cached_dps
= NULL
;
277 track
->num_cached_dps
= 0;
278 track
->num_allocated_dps
= 0;
284 demux_mkv_decode (mkv_track_t
*track
, uint8_t *src
, uint8_t **dest
,
285 uint32_t *size
, uint32_t type
)
291 if (track
->num_encodings
<= 0)
294 for (i
=0; i
<track
->num_encodings
; i
++)
296 if (!(track
->encodings
[i
].scope
& type
))
300 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
)
310 mp_msg (MSGT_DEMUX
, MSGL_WARN
,
311 MSGTR_MPDEMUX_MKV_ZlibInitializationFailed
);
314 zstream
.next_in
= (Bytef
*) src
;
315 zstream
.avail_in
= *size
;
319 zstream
.avail_out
= *size
;
322 *dest
= realloc (*dest
, *size
);
323 zstream
.next_out
= (Bytef
*) (*dest
+ zstream
.total_out
);
324 result
= inflate (&zstream
, Z_NO_FLUSH
);
325 if (result
!= Z_OK
&& result
!= Z_STREAM_END
)
327 mp_msg (MSGT_DEMUX
, MSGL_WARN
,
328 MSGTR_MPDEMUX_MKV_ZlibDecompressionFailed
);
331 inflateEnd (&zstream
);
334 zstream
.avail_out
+= 4000;
335 } while (zstream
.avail_out
== 4000 &&
336 zstream
.avail_in
!= 0 && result
!= Z_STREAM_END
);
338 *size
= zstream
.total_out
;
339 inflateEnd (&zstream
);
342 if (track
->encodings
[i
].comp_algo
== 2)
344 /* lzo encoded track */
345 int dstlen
= *size
* 3;
351 if (dstlen
> SIZE_MAX
- AV_LZO_OUTPUT_PADDING
) goto lzo_fail
;
352 *dest
= realloc (*dest
, dstlen
+ AV_LZO_OUTPUT_PADDING
);
353 result
= av_lzo1x_decode (*dest
, &dstlen
, src
, &srclen
);
356 if (!(result
& AV_LZO_OUTPUT_FULL
))
359 mp_msg (MSGT_DEMUX
, MSGL_WARN
,
360 MSGTR_MPDEMUX_MKV_LzoDecompressionFailed
);
365 mp_msg (MSGT_DEMUX
, MSGL_DBG2
,
366 "[mkv] lzo decompression buffer too small.\n");
377 static int demux_mkv_read_info(demuxer_t
*demuxer
)
379 mkv_demuxer_t
*mkv_d
= demuxer
->priv
;
380 stream_t
*s
= demuxer
->stream
;
383 uint64_t tc_scale
= 1000000;
384 long double duration
= 0.;
386 length
= ebml_read_length(s
, NULL
);
388 uint32_t id
= ebml_read_id(s
, &i
);
391 case MATROSKA_ID_TIMECODESCALE
:
392 tc_scale
= ebml_read_uint(s
, &l
);
394 if (tc_scale
== EBML_UINT_INVALID
)
396 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + timecode scale: %"PRIu64
"\n",
400 case MATROSKA_ID_DURATION
:
401 duration
= ebml_read_float(s
, &l
);
403 if (duration
== EBML_FLOAT_INVALID
)
407 case MATROSKA_ID_SEGMENTUID
:;
408 l
= ebml_read_length(s
, &i
);
410 if (l
!= sizeof(demuxer
->matroska_data
.segment_uid
)) {
411 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
412 "[mkv] segment uid invalid length %"PRIu64
"\n", l
);
415 stream_read(s
, demuxer
->matroska_data
.segment_uid
, l
);
416 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + segment uid");
417 for (int i
= 0; i
< l
; i
++)
418 mp_msg(MSGT_DEMUX
, MSGL_V
, " %02x",
419 demuxer
->matroska_data
.segment_uid
[i
]);
420 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
426 ebml_read_skip(s
, &l
);
431 mkv_d
->tc_scale
= tc_scale
;
432 mkv_d
->duration
= duration
* tc_scale
/ 1000000000.0;
434 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] | + duration: %.3fs\n",
441 * \brief free array of kv_content_encoding_t
442 * \param encodings pointer to array
443 * \param numencodings number of encodings in array
446 demux_mkv_free_encodings(mkv_content_encoding_t
*encodings
, int numencodings
)
448 while (numencodings
-- > 0)
449 free(encodings
[numencodings
].comp_settings
);
454 demux_mkv_read_trackencodings (demuxer_t
*demuxer
, mkv_track_t
*track
)
456 stream_t
*s
= demuxer
->stream
;
457 mkv_content_encoding_t
*ce
, e
;
458 uint64_t len
, length
, l
;
461 ce
= malloc (sizeof (*ce
));
464 len
= length
= ebml_read_length (s
, &il
);
468 switch (ebml_read_id (s
, &il
))
470 case MATROSKA_ID_CONTENTENCODING
:
475 memset (&e
, 0, sizeof (e
));
478 len
= ebml_read_length (s
, &i
);
486 switch (ebml_read_id (s
, &il
))
488 case MATROSKA_ID_CONTENTENCODINGORDER
:
489 num
= ebml_read_uint (s
, &l
);
490 if (num
== EBML_UINT_INVALID
)
495 case MATROSKA_ID_CONTENTENCODINGSCOPE
:
496 num
= ebml_read_uint (s
, &l
);
497 if (num
== EBML_UINT_INVALID
)
502 case MATROSKA_ID_CONTENTENCODINGTYPE
:
503 num
= ebml_read_uint (s
, &l
);
504 if (num
== EBML_UINT_INVALID
)
509 case MATROSKA_ID_CONTENTCOMPRESSION
:
513 le
= ebml_read_length (s
, &i
);
521 switch (ebml_read_id (s
, &il
))
523 case MATROSKA_ID_CONTENTCOMPALGO
:
524 num
= ebml_read_uint (s
, &l
);
525 if (num
== EBML_UINT_INVALID
)
530 case MATROSKA_ID_CONTENTCOMPSETTINGS
:
531 l
= ebml_read_length (s
, &i
);
532 e
.comp_settings
= malloc (l
);
533 stream_read (s
, e
.comp_settings
, l
);
534 e
.comp_settings_len
= l
;
539 ebml_read_skip (s
, &l
);
547 mp_msg(MSGT_DEMUX
, MSGL_WARN
,
548 MSGTR_MPDEMUX_MKV_TrackEncrypted
, track
->tnum
);
550 else if (e
.type
!= 0)
552 mp_msg(MSGT_DEMUX
, MSGL_WARN
,
553 MSGTR_MPDEMUX_MKV_UnknownContentEncoding
, track
->tnum
);
556 if (e
.comp_algo
!= 0 && e
.comp_algo
!= 2)
558 mp_msg (MSGT_DEMUX
, MSGL_WARN
,
559 MSGTR_MPDEMUX_MKV_UnknownCompression
,
560 track
->tnum
, e
.comp_algo
);
563 else if (e
.comp_algo
== 0)
565 mp_msg (MSGT_DEMUX
, MSGL_WARN
,
566 MSGTR_MPDEMUX_MKV_ZlibCompressionUnsupported
,
575 ebml_read_skip (s
, &l
);
581 if (e
.order
<= ce
[i
].order
)
583 ce
= realloc (ce
, (n
+1) *sizeof (*ce
));
584 memmove (ce
+i
+1, ce
+i
, (n
-i
) * sizeof (*ce
));
585 memcpy (ce
+i
, &e
, sizeof (e
));
591 ebml_read_skip (s
, &l
);
598 track
->encodings
= ce
;
599 track
->num_encodings
= n
;
603 demux_mkv_free_encodings(ce
, n
);
608 demux_mkv_read_trackaudio (demuxer_t
*demuxer
, mkv_track_t
*track
)
610 stream_t
*s
= demuxer
->stream
;
611 uint64_t len
, length
, l
;
614 track
->a_sfreq
= 8000.0;
615 track
->a_channels
= 1;
617 len
= length
= ebml_read_length (s
, &il
);
621 switch (ebml_read_id (s
, &il
))
623 case MATROSKA_ID_AUDIOSAMPLINGFREQ
:
625 long double num
= ebml_read_float (s
, &l
);
626 if (num
== EBML_FLOAT_INVALID
)
628 track
->a_sfreq
= num
;
629 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Sampling frequency: %f\n",
634 case MATROSKA_ID_AUDIOBITDEPTH
:
636 uint64_t num
= ebml_read_uint (s
, &l
);
637 if (num
== EBML_UINT_INVALID
)
640 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Bit depth: %u\n",
645 case MATROSKA_ID_AUDIOCHANNELS
:
647 uint64_t num
= ebml_read_uint (s
, &l
);
648 if (num
== EBML_UINT_INVALID
)
650 track
->a_channels
= num
;
651 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Channels: %u\n",
657 ebml_read_skip (s
, &l
);
666 demux_mkv_read_trackvideo (demuxer_t
*demuxer
, mkv_track_t
*track
)
668 stream_t
*s
= demuxer
->stream
;
669 uint64_t len
, length
, l
;
672 len
= length
= ebml_read_length (s
, &il
);
676 switch (ebml_read_id (s
, &il
))
678 case MATROSKA_ID_VIDEOFRAMERATE
:
680 long double num
= ebml_read_float (s
, &l
);
681 if (num
== EBML_FLOAT_INVALID
)
683 track
->v_frate
= num
;
684 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Frame rate: %f\n",
686 if (track
->v_frate
> 0)
687 track
->default_duration
= 1 / track
->v_frate
;
691 case MATROSKA_ID_VIDEODISPLAYWIDTH
:
693 uint64_t num
= ebml_read_uint (s
, &l
);
694 if (num
== EBML_UINT_INVALID
)
696 track
->v_dwidth
= num
;
697 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display width: %u\n",
702 case MATROSKA_ID_VIDEODISPLAYHEIGHT
:
704 uint64_t num
= ebml_read_uint (s
, &l
);
705 if (num
== EBML_UINT_INVALID
)
707 track
->v_dheight
= num
;
708 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Display height: %u\n",
713 case MATROSKA_ID_VIDEOPIXELWIDTH
:
715 uint64_t num
= ebml_read_uint (s
, &l
);
716 if (num
== EBML_UINT_INVALID
)
718 track
->v_width
= num
;
719 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel width: %u\n",
724 case MATROSKA_ID_VIDEOPIXELHEIGHT
:
726 uint64_t num
= ebml_read_uint (s
, &l
);
727 if (num
== EBML_UINT_INVALID
)
729 track
->v_height
= num
;
730 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Pixel height: %u\n",
736 ebml_read_skip (s
, &l
);
745 * \brief free any data associated with given track
746 * \param track track of which to free data
749 demux_mkv_free_trackentry(mkv_track_t
*track
) {
751 free (track
->codec_id
);
752 free (track
->language
);
753 free (track
->private_data
);
754 free (track
->audio_buf
);
755 free (track
->audio_timestamp
);
756 demux_mkv_free_encodings(track
->encodings
, track
->num_encodings
);
761 demux_mkv_read_trackentry (demuxer_t
*demuxer
)
763 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
764 stream_t
*s
= demuxer
->stream
;
766 uint64_t len
, length
, l
;
769 track
= calloc (1, sizeof (*track
));
770 /* set default values */
771 track
->default_track
= 1;
773 track
->language
= strdup("eng");
775 len
= length
= ebml_read_length (s
, &il
);
779 switch (ebml_read_id (s
, &il
))
781 case MATROSKA_ID_TRACKNUMBER
:
783 uint64_t num
= ebml_read_uint (s
, &l
);
784 if (num
== EBML_UINT_INVALID
)
787 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track number: %u\n",
792 case MATROSKA_ID_TRACKNAME
:
794 track
->name
= ebml_read_utf8 (s
, &l
);
795 if (track
->name
== NULL
)
797 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Name: %s\n",
802 case MATROSKA_ID_TRACKTYPE
:
804 uint64_t num
= ebml_read_uint (s
, &l
);
805 if (num
== EBML_UINT_INVALID
)
808 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Track type: ");
811 case MATROSKA_TRACK_AUDIO
:
812 mp_msg (MSGT_DEMUX
, MSGL_V
, "Audio\n");
814 case MATROSKA_TRACK_VIDEO
:
815 mp_msg (MSGT_DEMUX
, MSGL_V
, "Video\n");
817 case MATROSKA_TRACK_SUBTITLE
:
818 mp_msg (MSGT_DEMUX
, MSGL_V
, "Subtitle\n");
821 mp_msg (MSGT_DEMUX
, MSGL_V
, "unknown\n");
827 case MATROSKA_ID_TRACKAUDIO
:
828 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Audio track\n");
829 l
= demux_mkv_read_trackaudio (demuxer
, track
);
834 case MATROSKA_ID_TRACKVIDEO
:
835 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Video track\n");
836 l
= demux_mkv_read_trackvideo (demuxer
, track
);
841 case MATROSKA_ID_CODECID
:
842 track
->codec_id
= ebml_read_ascii (s
, &l
);
843 if (track
->codec_id
== NULL
)
845 if (!strcmp (track
->codec_id
, MKV_V_MSCOMP
) ||
846 !strcmp (track
->codec_id
, MKV_A_ACM
))
847 track
->ms_compat
= 1;
848 else if (!strcmp (track
->codec_id
, MKV_S_VOBSUB
))
849 track
->subtitle_type
= MATROSKA_SUBTYPE_VOBSUB
;
850 else if (!strcmp (track
->codec_id
, MKV_S_TEXTSSA
)
851 || !strcmp (track
->codec_id
, MKV_S_TEXTASS
)
852 || !strcmp (track
->codec_id
, MKV_S_SSA
)
853 || !strcmp (track
->codec_id
, MKV_S_ASS
))
855 track
->subtitle_type
= MATROSKA_SUBTYPE_SSA
;
857 else if (!strcmp (track
->codec_id
, MKV_S_TEXTASCII
))
858 track
->subtitle_type
= MATROSKA_SUBTYPE_TEXT
;
859 if (!strcmp (track
->codec_id
, MKV_S_TEXTUTF8
))
861 track
->subtitle_type
= MATROSKA_SUBTYPE_TEXT
;
863 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Codec ID: %s\n",
867 case MATROSKA_ID_CODECPRIVATE
:
870 uint64_t num
= ebml_read_length (s
, &x
);
871 // audit: cheap guard against overflows later..
872 if (num
> SIZE_MAX
- 1000) return 0;
874 track
->private_data
= malloc (num
+ AV_LZO_INPUT_PADDING
);
875 if (stream_read(s
, track
->private_data
, num
) != (int) num
)
877 track
->private_size
= num
;
878 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + CodecPrivate, length "
879 "%u\n", track
->private_size
);
883 case MATROSKA_ID_TRACKLANGUAGE
:
884 free(track
->language
);
885 track
->language
= ebml_read_utf8 (s
, &l
);
886 if (track
->language
== NULL
)
888 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Language: %s\n",
892 case MATROSKA_ID_TRACKFLAGDEFAULT
:
894 uint64_t num
= ebml_read_uint (s
, &l
);
895 if (num
== EBML_UINT_INVALID
)
897 track
->default_track
= num
;
898 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default flag: %u\n",
899 track
->default_track
);
903 case MATROSKA_ID_TRACKDEFAULTDURATION
:
905 uint64_t num
= ebml_read_uint (s
, &l
);
906 if (num
== EBML_UINT_INVALID
)
909 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default duration: 0");
912 track
->v_frate
= 1000000000.0 / num
;
913 track
->default_duration
= num
/ 1000000000.0;
914 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + Default duration: "
915 "%.3fms ( = %.3f fps)\n",num
/1000000.0,track
->v_frate
);
920 case MATROSKA_ID_TRACKENCODINGS
:
921 l
= demux_mkv_read_trackencodings (demuxer
, track
);
927 ebml_read_skip (s
, &l
);
933 mkv_d
->tracks
[mkv_d
->num_tracks
++] = track
;
937 demux_mkv_free_trackentry(track
);
942 demux_mkv_read_tracks (demuxer_t
*demuxer
)
944 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
945 stream_t
*s
= demuxer
->stream
;
949 mkv_d
->tracks
= malloc (sizeof (*mkv_d
->tracks
));
950 mkv_d
->num_tracks
= 0;
952 length
= ebml_read_length (s
, NULL
);
955 switch (ebml_read_id (s
, &il
))
957 case MATROSKA_ID_TRACKENTRY
:
958 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + a track...\n");
959 mkv_d
->tracks
= realloc (mkv_d
->tracks
,
960 (mkv_d
->num_tracks
+1)
961 *sizeof (*mkv_d
->tracks
));
962 l
= demux_mkv_read_trackentry (demuxer
);
968 ebml_read_skip (s
, &l
);
977 demux_mkv_read_cues (demuxer_t
*demuxer
)
979 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
980 stream_t
*s
= demuxer
->stream
;
981 uint64_t length
, l
, time
, track
, pos
;
985 if (index_mode
== 0) {
986 ebml_read_skip (s
, NULL
);
989 off
= stream_tell (s
);
990 for (i
=0; i
<mkv_d
->parsed_cues_num
; i
++)
991 if (mkv_d
->parsed_cues
[i
] == off
)
993 ebml_read_skip (s
, NULL
);
996 mkv_d
->parsed_cues
= realloc (mkv_d
->parsed_cues
,
997 (mkv_d
->parsed_cues_num
+1)
999 mkv_d
->parsed_cues
[mkv_d
->parsed_cues_num
++] = off
;
1001 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing cues ] -----------\n");
1002 length
= ebml_read_length (s
, NULL
);
1006 time
= track
= pos
= EBML_UINT_INVALID
;
1008 switch (ebml_read_id (s
, &il
))
1010 case MATROSKA_ID_POINTENTRY
:
1014 len
= ebml_read_length (s
, &i
);
1022 switch (ebml_read_id (s
, &il
))
1024 case MATROSKA_ID_CUETIME
:
1025 time
= ebml_read_uint (s
, &l
);
1028 case MATROSKA_ID_CUETRACKPOSITION
:
1032 le
= ebml_read_length (s
, &i
);
1040 switch (ebml_read_id (s
, &il
))
1042 case MATROSKA_ID_CUETRACK
:
1043 track
= ebml_read_uint (s
, &l
);
1046 case MATROSKA_ID_CUECLUSTERPOSITION
:
1047 pos
= ebml_read_uint (s
, &l
);
1051 ebml_read_skip (s
, &l
);
1060 ebml_read_skip (s
, &l
);
1069 ebml_read_skip (s
, &l
);
1075 if (time
!= EBML_UINT_INVALID
&& track
!= EBML_UINT_INVALID
1076 && pos
!= EBML_UINT_INVALID
)
1078 mkv_d
->indexes
= grow_array(mkv_d
->indexes
, mkv_d
->num_indexes
,
1079 sizeof(mkv_index_t
));
1080 mkv_d
->indexes
[mkv_d
->num_indexes
].tnum
= track
;
1081 mkv_d
->indexes
[mkv_d
->num_indexes
].timecode
= time
;
1082 mkv_d
->indexes
[mkv_d
->num_indexes
].filepos
=mkv_d
->segment_start
+pos
;
1083 mp_msg (MSGT_DEMUX
, MSGL_DBG2
, "[mkv] |+ found cue point "
1084 "for track %"PRIu64
": timecode %"PRIu64
", filepos: %"PRIu64
"\n",
1085 track
, time
, mkv_d
->segment_start
+ pos
);
1086 mkv_d
->num_indexes
++;
1090 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] \\---- [ parsing cues ] -----------\n");
1094 static uint64_t read_one_chapter(struct demuxer
*demuxer
, stream_t
*s
)
1097 uint64_t start
= 0, end
= 0;
1098 struct matroska_chapter chapter
= {};
1103 len
= ebml_read_length(s
, &i
);
1104 uint64_t bytes_read
= len
+ i
;
1107 id
= ebml_read_id(s
, &i
);
1110 case MATROSKA_ID_CHAPTERTIMESTART
:
1111 start
= ebml_read_uint(s
, &l
) / 1000000;
1115 case MATROSKA_ID_CHAPTERTIMEEND
:
1116 end
= ebml_read_uint(s
, &l
) / 1000000;
1120 case MATROSKA_ID_CHAPTERDISPLAY
:;
1121 uint64_t displaylen
= ebml_read_length(s
, &i
);
1122 len
-= displaylen
+ i
;
1123 while (displaylen
> 0) {
1124 id
= ebml_read_id(s
, &i
);
1127 case MATROSKA_ID_CHAPSTRING
:
1128 name
= ebml_read_utf8(s
, &l
);
1131 ebml_read_skip(s
, &l
);
1138 case MATROSKA_ID_CHAPTERSEGMENTUID
:
1139 l
= ebml_read_length(s
, &i
);
1141 if (l
!= sizeof(chapter
.segment_uid
)) {
1142 mp_msg(MSGT_DEMUX
, MSGL_INFO
,
1143 "[mkv] chapter segment uid invalid length %"PRIu64
"\n",
1147 stream_read(s
, chapter
.segment_uid
, l
);
1148 chapter
.has_segment_uid
= true;
1149 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Chapter segment uid ");
1150 for (int i
= 0; i
< l
; i
++)
1151 mp_msg(MSGT_DEMUX
, MSGL_V
, "%02x ", chapter
.segment_uid
[i
]);
1152 mp_msg(MSGT_DEMUX
, MSGL_V
, "\n");
1157 ebml_read_skip(s
, &l
);
1164 name
= strdup("(unnamed)");
1166 int cid
= demuxer_add_chapter(demuxer
, name
, start
, end
);
1167 struct matroska_data
*m
= &demuxer
->matroska_data
;
1168 m
->ordered_chapters
= talloc_realloc(demuxer
, m
->ordered_chapters
,
1169 struct matroska_chapter
,
1170 m
->num_ordered_chapters
+ 1);
1171 chapter
.start
= start
;
1173 chapter
.name
= talloc_strdup(m
->ordered_chapters
, name
);
1174 // Will be undone later if this is a normal chapter rather than ordered
1175 m
->ordered_chapters
[m
->num_ordered_chapters
] = chapter
;
1176 m
->num_ordered_chapters
++;
1178 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] Chapter %u from %02d:%02d:%02d."
1179 "%03d to %02d:%02d:%02d.%03d, %s\n",
1181 (int) (start
/ 60 / 60 / 1000),
1182 (int) ((start
/ 60 / 1000) % 60),
1183 (int) ((start
/ 1000) % 60),
1184 (int) (start
% 1000),
1185 (int) (end
/ 60 / 60 / 1000),
1186 (int) ((end
/ 60 / 1000) % 60),
1187 (int) ((end
/ 1000) % 60),
1188 (int) (end
% 1000), name
);
1194 static int demux_mkv_read_chapters(struct demuxer
*demuxer
)
1196 stream_t
*s
= demuxer
->stream
;
1201 if (demuxer
->chapters
) {
1202 ebml_read_skip(s
, NULL
);
1206 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing chapters ] ---------\n");
1207 length
= ebml_read_length(s
, NULL
);
1209 bool have_edition
= false;
1210 while (length
> 0) {
1211 id
= ebml_read_id(s
, &i
);
1214 case MATROSKA_ID_EDITIONENTRY
:
1216 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "[mkv] Multiple edition entries"
1217 " - ignoring all but first!\n");
1218 ebml_read_skip(s
, &l
);
1222 have_edition
= true;
1223 uint64_t editionlen
= ebml_read_length(s
, &i
);
1224 length
-= editionlen
+ i
;
1225 bool ordered
= false;
1226 while (editionlen
> 0) {
1227 id
= ebml_read_id(s
, &i
);
1230 case MATROSKA_ID_CHAPTERATOM
:
1231 l
= read_one_chapter(demuxer
, s
);
1233 case MATROSKA_ID_EDITIONFLAGORDERED
:
1234 ordered
= ebml_read_uint(s
, &l
);
1235 mp_msg(MSGT_DEMUX
, MSGL_V
,
1236 "[mkv] Ordered chapter flag: %d\n", ordered
);
1240 ebml_read_skip(s
, &l
);
1246 // The chapters should be interpreted as normal ones,
1247 // so undo the addition of this information.
1248 talloc_free(demuxer
->matroska_data
.ordered_chapters
);
1249 demuxer
->matroska_data
.ordered_chapters
= NULL
;
1250 demuxer
->matroska_data
.num_ordered_chapters
= 0;
1255 ebml_read_skip(s
, &l
);
1261 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] \\---- [ parsing chapters ] ---------\n");
1266 demux_mkv_read_tags (demuxer_t
*demuxer
)
1268 ebml_read_skip (demuxer
->stream
, NULL
);
1273 demux_mkv_read_attachments (demuxer_t
*demuxer
)
1275 stream_t
*s
= demuxer
->stream
;
1279 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing attachments ] ---------\n");
1280 length
= ebml_read_length (s
, NULL
);
1284 switch (ebml_read_id (s
, &il
))
1286 case MATROSKA_ID_ATTACHEDFILE
:
1295 len
= ebml_read_length (s
, &i
);
1298 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + an attachment...\n");
1305 switch (ebml_read_id (s
, &il
))
1307 case MATROSKA_ID_FILENAME
:
1308 name
= ebml_read_utf8 (s
, &l
);
1311 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + FileName: %s\n",
1315 case MATROSKA_ID_FILEMIMETYPE
:
1316 mime
= ebml_read_ascii (s
, &l
);
1319 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + FileMimeType: %s\n",
1323 case MATROSKA_ID_FILEDATA
:
1326 uint64_t num
= ebml_read_length (s
, &x
);
1329 data
= malloc (num
);
1330 if (stream_read(s
, data
, num
) != (int) num
)
1336 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] | + FileData, length "
1342 ebml_read_skip (s
, &l
);
1348 demuxer_add_attachment(demuxer
, name
, mime
, data
, data_size
);
1349 mp_msg(MSGT_DEMUX
, MSGL_V
,
1350 "[mkv] Attachment: %s, %s, %u bytes\n",
1351 name
, mime
, data_size
);
1356 ebml_read_skip (s
, &l
);
1362 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] \\---- [ parsing attachments ] ---------\n");
1367 demux_mkv_read_seekhead (demuxer_t
*demuxer
)
1369 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1370 stream_t
*s
= demuxer
->stream
;
1371 uint64_t length
, l
, seek_pos
, saved_pos
, num
;
1376 off
= stream_tell (s
);
1377 for (i
=0; i
<mkv_d
->parsed_seekhead_num
; i
++)
1378 if (mkv_d
->parsed_seekhead
[i
] == off
)
1380 ebml_read_skip (s
, NULL
);
1383 mkv_d
->parsed_seekhead
= realloc (mkv_d
->parsed_seekhead
,
1384 (mkv_d
->parsed_seekhead_num
+1)
1386 mkv_d
->parsed_seekhead
[mkv_d
->parsed_seekhead_num
++] = off
;
1388 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] /---- [ parsing seek head ] ---------\n");
1389 length
= ebml_read_length (s
, NULL
);
1390 /* off now holds the position of the next element after the seek head. */
1391 off
= stream_tell (s
) + length
;
1392 while (length
> 0 && !res
)
1396 seek_pos
= EBML_UINT_INVALID
;
1398 switch (ebml_read_id (s
, &il
))
1400 case MATROSKA_ID_SEEKENTRY
:
1404 len
= ebml_read_length (s
, &i
);
1412 switch (ebml_read_id (s
, &il
))
1414 case MATROSKA_ID_SEEKID
:
1415 num
= ebml_read_uint (s
, &l
);
1416 if (num
!= EBML_UINT_INVALID
)
1420 case MATROSKA_ID_SEEKPOSITION
:
1421 seek_pos
= ebml_read_uint (s
, &l
);
1425 ebml_read_skip (s
, &l
);
1435 ebml_read_skip (s
, &l
);
1440 if (seek_id
== 0 || seek_id
== MATROSKA_ID_CLUSTER
1441 || seek_pos
== EBML_UINT_INVALID
||
1442 ((mkv_d
->segment_start
+ seek_pos
) >= (uint64_t)demuxer
->movi_end
))
1445 saved_pos
= stream_tell (s
);
1446 if (!stream_seek (s
, mkv_d
->segment_start
+ seek_pos
))
1450 if (ebml_read_id (s
, &il
) != seek_id
)
1455 case MATROSKA_ID_CUES
:
1456 if (demux_mkv_read_cues (demuxer
))
1460 case MATROSKA_ID_TAGS
:
1461 if (demux_mkv_read_tags (demuxer
))
1465 case MATROSKA_ID_SEEKHEAD
:
1466 if (demux_mkv_read_seekhead (demuxer
))
1470 case MATROSKA_ID_CHAPTERS
:
1471 if (demux_mkv_read_chapters (demuxer
))
1477 stream_seek (s
, saved_pos
);
1481 /* If there was an error then try to skip this seek head. */
1482 if (stream_seek (s
, off
))
1487 stream_seek (s
, stream_tell (s
) + length
);
1488 mp_msg(MSGT_DEMUX
, MSGL_V
, "[mkv] \\---- [ parsing seek head ] ---------\n");
1493 demux_mkv_open_video (demuxer_t
*demuxer
, mkv_track_t
*track
, int vid
);
1495 demux_mkv_open_audio (demuxer_t
*demuxer
, mkv_track_t
*track
, int aid
);
1497 demux_mkv_open_sub (demuxer_t
*demuxer
, mkv_track_t
*track
, int sid
);
1500 display_create_tracks (demuxer_t
*demuxer
)
1502 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*)demuxer
->priv
;
1503 int i
, vid
=0, aid
=0, sid
=0;
1505 for (i
=0; i
<mkv_d
->num_tracks
; i
++)
1507 char *type
= "unknown", str
[32];
1509 switch (mkv_d
->tracks
[i
]->type
)
1511 case MATROSKA_TRACK_VIDEO
:
1513 demux_mkv_open_video(demuxer
, mkv_d
->tracks
[i
], vid
);
1514 if (mkv_d
->tracks
[i
]->name
)
1515 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VID_%d_NAME=%s\n", vid
, mkv_d
->tracks
[i
]->name
);
1516 sprintf (str
, "-vid %u", vid
++);
1518 case MATROSKA_TRACK_AUDIO
:
1520 demux_mkv_open_audio(demuxer
, mkv_d
->tracks
[i
], aid
);
1521 if (mkv_d
->tracks
[i
]->name
)
1522 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_NAME=%s\n", aid
, mkv_d
->tracks
[i
]->name
);
1523 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_LANG=%s\n", aid
, mkv_d
->tracks
[i
]->language
);
1524 sprintf (str
, "-aid %u, -alang %.5s",aid
++,mkv_d
->tracks
[i
]->language
);
1526 case MATROSKA_TRACK_SUBTITLE
:
1528 demux_mkv_open_sub(demuxer
, mkv_d
->tracks
[i
], sid
);
1529 if (mkv_d
->tracks
[i
]->name
)
1530 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_NAME=%s\n", sid
, mkv_d
->tracks
[i
]->name
);
1531 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", sid
, mkv_d
->tracks
[i
]->language
);
1532 sprintf (str
, "-sid %u, -slang %.5s",sid
++,mkv_d
->tracks
[i
]->language
);
1535 if (mkv_d
->tracks
[i
]->name
)
1536 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_MPDEMUX_MKV_TrackIDName
,
1537 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
, mkv_d
->tracks
[i
]->name
, str
);
1539 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_MPDEMUX_MKV_TrackID
,
1540 mkv_d
->tracks
[i
]->tnum
, type
, mkv_d
->tracks
[i
]->codec_id
, str
);
1548 } videocodec_info_t
;
1550 static const videocodec_info_t vinfo
[] = {
1551 { MKV_V_MPEG1
, mmioFOURCC('m', 'p', 'g', '1'), 0 },
1552 { MKV_V_MPEG2
, mmioFOURCC('m', 'p', 'g', '2'), 0 },
1553 { MKV_V_MPEG4_SP
, mmioFOURCC('m', 'p', '4', 'v'), 1 },
1554 { MKV_V_MPEG4_ASP
, mmioFOURCC('m', 'p', '4', 'v'), 1 },
1555 { MKV_V_MPEG4_AP
, mmioFOURCC('m', 'p', '4', 'v'), 1 },
1556 { MKV_V_MPEG4_AVC
, mmioFOURCC('a', 'v', 'c', '1'), 1 },
1557 { MKV_V_THEORA
, mmioFOURCC('t', 'h', 'e', 'o'), 1 },
1562 demux_mkv_open_video (demuxer_t
*demuxer
, mkv_track_t
*track
, int vid
)
1564 struct MPOpts
*opts
= demuxer
->opts
;
1565 BITMAPINFOHEADER
*bih
;
1566 void *ImageDesc
= NULL
;
1569 if (track
->ms_compat
) /* MS compatibility mode */
1571 BITMAPINFOHEADER
*src
;
1573 if (track
->private_data
== NULL
1574 || track
->private_size
< sizeof (BITMAPINFOHEADER
))
1577 src
= (BITMAPINFOHEADER
*) track
->private_data
;
1578 bih
= calloc (1, track
->private_size
);
1579 bih
->biSize
= le2me_32 (src
->biSize
);
1580 bih
->biWidth
= le2me_32 (src
->biWidth
);
1581 bih
->biHeight
= le2me_32 (src
->biHeight
);
1582 bih
->biPlanes
= le2me_16 (src
->biPlanes
);
1583 bih
->biBitCount
= le2me_16 (src
->biBitCount
);
1584 bih
->biCompression
= le2me_32 (src
->biCompression
);
1585 bih
->biSizeImage
= le2me_32 (src
->biSizeImage
);
1586 bih
->biXPelsPerMeter
= le2me_32 (src
->biXPelsPerMeter
);
1587 bih
->biYPelsPerMeter
= le2me_32 (src
->biYPelsPerMeter
);
1588 bih
->biClrUsed
= le2me_32 (src
->biClrUsed
);
1589 bih
->biClrImportant
= le2me_32 (src
->biClrImportant
);
1590 memcpy((char *) bih
+ sizeof (BITMAPINFOHEADER
),
1591 (char *) src
+ sizeof (BITMAPINFOHEADER
),
1592 track
->private_size
- sizeof (BITMAPINFOHEADER
));
1594 if (track
->v_width
== 0)
1595 track
->v_width
= bih
->biWidth
;
1596 if (track
->v_height
== 0)
1597 track
->v_height
= bih
->biHeight
;
1601 bih
= calloc (1, sizeof (BITMAPINFOHEADER
));
1602 bih
->biSize
= sizeof (BITMAPINFOHEADER
);
1603 bih
->biWidth
= track
->v_width
;
1604 bih
->biHeight
= track
->v_height
;
1605 bih
->biBitCount
= 24;
1606 bih
->biSizeImage
= bih
->biWidth
* bih
->biHeight
* bih
->biBitCount
/8;
1608 if (track
->private_size
>= RVPROPERTIES_SIZE
1609 && (!strcmp (track
->codec_id
, MKV_V_REALV10
)
1610 || !strcmp (track
->codec_id
, MKV_V_REALV20
)
1611 || !strcmp (track
->codec_id
, MKV_V_REALV30
)
1612 || !strcmp (track
->codec_id
, MKV_V_REALV40
)))
1614 unsigned char *dst
, *src
;
1618 src
= track
->private_data
+ RVPROPERTIES_SIZE
;
1620 cnt
= track
->private_size
- RVPROPERTIES_SIZE
;
1621 bih
= realloc(bih
, sizeof (BITMAPINFOHEADER
)+8+cnt
);
1622 bih
->biSize
= 48+cnt
;
1624 type2
= AV_RB32(src
- 4);
1625 if (type2
== 0x10003000 || type2
== 0x10003001)
1626 bih
->biCompression
=mmioFOURCC('R','V','1','3');
1628 bih
->biCompression
=mmioFOURCC('R','V',track
->codec_id
[9],'0');
1629 dst
= (unsigned char *) (bih
+ 1);
1630 // copy type1 and type2 info from rv properties
1631 memcpy(dst
, src
- 8, 8);
1632 stream_read(demuxer
->stream
, dst
+8, cnt
);
1633 track
->realmedia
= 1;
1635 #ifdef CONFIG_QTX_CODECS
1637 else if (track
->private_size
>= sizeof (ImageDescription
)
1638 && !strcmp(track
->codec_id
, MKV_V_QUICKTIME
))
1640 ImageDescriptionPtr idesc
;
1642 idesc
= (ImageDescriptionPtr
) track
->private_data
;
1643 idesc
->idSize
= be2me_32 (idesc
->idSize
);
1644 idesc
->cType
= be2me_32 (idesc
->cType
);
1645 idesc
->version
= be2me_16 (idesc
->version
);
1646 idesc
->revisionLevel
= be2me_16 (idesc
->revisionLevel
);
1647 idesc
->vendor
= be2me_32 (idesc
->vendor
);
1648 idesc
->temporalQuality
= be2me_32 (idesc
->temporalQuality
);
1649 idesc
->spatialQuality
= be2me_32 (idesc
->spatialQuality
);
1650 idesc
->width
= be2me_16 (idesc
->width
);
1651 idesc
->height
= be2me_16 (idesc
->height
);
1652 idesc
->hRes
= be2me_32 (idesc
->hRes
);
1653 idesc
->vRes
= be2me_32 (idesc
->vRes
);
1654 idesc
->dataSize
= be2me_32 (idesc
->dataSize
);
1655 idesc
->frameCount
= be2me_16 (idesc
->frameCount
);
1656 idesc
->depth
= be2me_16 (idesc
->depth
);
1657 idesc
->clutID
= be2me_16 (idesc
->clutID
);
1659 bih
->biCompression
= idesc
->cType
;
1661 #endif /* CONFIG_QTX_CODECS */
1666 const videocodec_info_t
*vi
= vinfo
;
1667 while (vi
->id
&& strcmp(vi
->id
, track
->codec_id
)) vi
++;
1668 bih
->biCompression
= vi
->fourcc
;
1669 if (vi
->extradata
&& track
->private_data
&& (track
->private_size
> 0))
1671 bih
->biSize
+= track
->private_size
;
1672 bih
= realloc (bih
, bih
->biSize
);
1673 memcpy (bih
+ 1, track
->private_data
, track
->private_size
);
1675 track
->reorder_timecodes
= opts
->user_correct_pts
== 0;
1677 mp_msg (MSGT_DEMUX
,MSGL_WARN
, MSGTR_MPDEMUX_MKV_UnknownCodecID
,
1678 track
->codec_id
, track
->tnum
);
1685 sh_v
= new_sh_video_vid (demuxer
, track
->tnum
, vid
);
1687 sh_v
->format
= sh_v
->bih
->biCompression
;
1688 if (track
->v_frate
== 0.0)
1689 track
->v_frate
= 25.0;
1690 sh_v
->fps
= track
->v_frate
;
1691 sh_v
->frametime
= 1 / track
->v_frate
;
1693 if (!track
->realmedia
)
1695 sh_v
->disp_w
= track
->v_width
;
1696 sh_v
->disp_h
= track
->v_height
;
1697 if (track
->v_dheight
)
1698 sh_v
->aspect
= (float)track
->v_dwidth
/ (float)track
->v_dheight
;
1702 // vd_realvid.c will set aspect to disp_w/disp_h and rederive
1703 // disp_w and disp_h from the RealVideo stream contents returned
1704 // by the Real DLLs. If DisplayWidth/DisplayHeight was not set in
1705 // the Matroska file then it has already been set to PixelWidth/Height
1706 // by check_track_information.
1707 sh_v
->disp_w
= track
->v_dwidth
;
1708 sh_v
->disp_h
= track
->v_dheight
;
1710 sh_v
->ImageDesc
= ImageDesc
;
1711 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] Aspect: %f\n", sh_v
->aspect
);
1713 sh_v
->ds
= demuxer
->video
;
1718 demux_mkv_open_audio (demuxer_t
*demuxer
, mkv_track_t
*track
, int aid
)
1720 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
1721 sh_audio_t
*sh_a
= new_sh_audio_aid(demuxer
, track
->tnum
, aid
);
1724 mkv_d
->audio_tracks
[mkv_d
->last_aid
] = track
->tnum
;
1726 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
1727 sh_a
->lang
= strdup(track
->language
);
1728 sh_a
->default_track
= track
->default_track
;
1729 sh_a
->ds
= demuxer
->audio
;
1730 sh_a
->wf
= malloc (sizeof (WAVEFORMATEX
));
1731 if (track
->ms_compat
&& (track
->private_size
>= sizeof(WAVEFORMATEX
)))
1733 WAVEFORMATEX
*wf
= (WAVEFORMATEX
*)track
->private_data
;
1734 sh_a
->wf
= realloc(sh_a
->wf
, track
->private_size
);
1735 sh_a
->wf
->wFormatTag
= le2me_16 (wf
->wFormatTag
);
1736 sh_a
->wf
->nChannels
= le2me_16 (wf
->nChannels
);
1737 sh_a
->wf
->nSamplesPerSec
= le2me_32 (wf
->nSamplesPerSec
);
1738 sh_a
->wf
->nAvgBytesPerSec
= le2me_32 (wf
->nAvgBytesPerSec
);
1739 sh_a
->wf
->nBlockAlign
= le2me_16 (wf
->nBlockAlign
);
1740 sh_a
->wf
->wBitsPerSample
= le2me_16 (wf
->wBitsPerSample
);
1741 sh_a
->wf
->cbSize
= track
->private_size
- sizeof(WAVEFORMATEX
);
1742 memcpy(sh_a
->wf
+ 1, wf
+ 1, track
->private_size
- sizeof(WAVEFORMATEX
));
1743 if (track
->a_sfreq
== 0.0)
1744 track
->a_sfreq
= sh_a
->wf
->nSamplesPerSec
;
1745 if (track
->a_channels
== 0)
1746 track
->a_channels
= sh_a
->wf
->nChannels
;
1747 if (track
->a_bps
== 0)
1748 track
->a_bps
= sh_a
->wf
->wBitsPerSample
;
1749 track
->a_formattag
= sh_a
->wf
->wFormatTag
;
1753 memset(sh_a
->wf
, 0, sizeof (WAVEFORMATEX
));
1754 if (!strcmp(track
->codec_id
, MKV_A_MP3
) ||
1755 !strcmp(track
->codec_id
, MKV_A_MP2
))
1756 track
->a_formattag
= 0x0055;
1757 else if (!strncmp(track
->codec_id
, MKV_A_AC3
, strlen(MKV_A_AC3
)))
1758 track
->a_formattag
= 0x2000;
1759 else if (!strcmp(track
->codec_id
, MKV_A_DTS
))
1760 track
->a_formattag
= 0x2001;
1761 else if (!strcmp(track
->codec_id
, MKV_A_PCM
) ||
1762 !strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1763 track
->a_formattag
= 0x0001;
1764 else if (!strcmp(track
->codec_id
, MKV_A_AAC_2MAIN
) ||
1765 !strncmp(track
->codec_id
, MKV_A_AAC_2LC
,
1766 strlen(MKV_A_AAC_2LC
)) ||
1767 !strcmp(track
->codec_id
, MKV_A_AAC_2SSR
) ||
1768 !strcmp(track
->codec_id
, MKV_A_AAC_4MAIN
) ||
1769 !strncmp(track
->codec_id
, MKV_A_AAC_4LC
,
1770 strlen(MKV_A_AAC_4LC
)) ||
1771 !strcmp(track
->codec_id
, MKV_A_AAC_4SSR
) ||
1772 !strcmp(track
->codec_id
, MKV_A_AAC_4LTP
) ||
1773 !strcmp(track
->codec_id
, MKV_A_AAC
))
1774 track
->a_formattag
= mmioFOURCC('M', 'P', '4', 'A');
1775 else if (!strcmp(track
->codec_id
, MKV_A_VORBIS
))
1777 if (track
->private_data
== NULL
)
1779 track
->a_formattag
= mmioFOURCC('v', 'r', 'b', 's');
1781 else if (!strcmp(track
->codec_id
, MKV_A_QDMC
))
1782 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', 'C');
1783 else if (!strcmp(track
->codec_id
, MKV_A_QDMC2
))
1784 track
->a_formattag
= mmioFOURCC('Q', 'D', 'M', '2');
1785 else if (!strcmp(track
->codec_id
, MKV_A_WAVPACK
))
1786 track
->a_formattag
= mmioFOURCC('W', 'V', 'P', 'K');
1787 else if (!strcmp(track
->codec_id
, MKV_A_FLAC
))
1789 if (track
->private_data
== NULL
|| track
->private_size
== 0)
1791 mp_msg (MSGT_DEMUX
, MSGL_WARN
,
1792 MSGTR_MPDEMUX_MKV_FlacTrackDoesNotContainValidHeaders
);
1795 track
->a_formattag
= mmioFOURCC ('f', 'L', 'a', 'C');
1797 else if (track
->private_size
>= RAPROPERTIES4_SIZE
)
1799 if (!strcmp(track
->codec_id
, MKV_A_REAL28
))
1800 track
->a_formattag
= mmioFOURCC('2', '8', '_', '8');
1801 else if (!strcmp(track
->codec_id
, MKV_A_REALATRC
))
1802 track
->a_formattag
= mmioFOURCC('a', 't', 'r', 'c');
1803 else if (!strcmp(track
->codec_id
, MKV_A_REALCOOK
))
1804 track
->a_formattag
= mmioFOURCC('c', 'o', 'o', 'k');
1805 else if (!strcmp(track
->codec_id
, MKV_A_REALDNET
))
1806 track
->a_formattag
= mmioFOURCC('d', 'n', 'e', 't');
1807 else if (!strcmp(track
->codec_id
, MKV_A_REALSIPR
))
1808 track
->a_formattag
= mmioFOURCC('s', 'i', 'p', 'r');
1812 mp_msg (MSGT_DEMUX
, MSGL_WARN
, MSGTR_MPDEMUX_MKV_UnknownAudioCodec
,
1813 track
->codec_id
, track
->tnum
);
1814 free_sh_audio(demuxer
, track
->tnum
);
1819 sh_a
->format
= track
->a_formattag
;
1820 sh_a
->wf
->wFormatTag
= track
->a_formattag
;
1821 sh_a
->channels
= track
->a_channels
;
1822 sh_a
->wf
->nChannels
= track
->a_channels
;
1823 sh_a
->samplerate
= (uint32_t) track
->a_sfreq
;
1824 sh_a
->wf
->nSamplesPerSec
= (uint32_t) track
->a_sfreq
;
1825 if (track
->a_bps
== 0)
1827 sh_a
->samplesize
= 2;
1828 sh_a
->wf
->wBitsPerSample
= 16;
1832 sh_a
->samplesize
= track
->a_bps
/ 8;
1833 sh_a
->wf
->wBitsPerSample
= track
->a_bps
;
1835 if (track
->a_formattag
== 0x0055) /* MP3 || MP2 */
1837 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1838 sh_a
->wf
->nBlockAlign
= 1152;
1840 else if ((track
->a_formattag
== 0x2000) || /* AC3 */
1841 (track
->a_formattag
== 0x2001)) /* DTS */
1846 else if (track
->a_formattag
== 0x0001) /* PCM || PCM_BE */
1848 sh_a
->wf
->nAvgBytesPerSec
= sh_a
->channels
* sh_a
->samplerate
*2;
1849 sh_a
->wf
->nBlockAlign
= sh_a
->wf
->nAvgBytesPerSec
;
1850 if (!strcmp(track
->codec_id
, MKV_A_PCM_BE
))
1851 sh_a
->format
= mmioFOURCC('t', 'w', 'o', 's');
1853 else if (!strcmp(track
->codec_id
, MKV_A_QDMC
) ||
1854 !strcmp(track
->codec_id
, MKV_A_QDMC2
))
1856 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1857 sh_a
->wf
->nBlockAlign
= 1486;
1858 track
->fix_i_bps
= 1;
1859 track
->qt_last_a_pts
= 0.0;
1860 if (track
->private_data
!= NULL
)
1862 sh_a
->codecdata
=malloc(track
->private_size
);
1863 memcpy (sh_a
->codecdata
, track
->private_data
,
1864 track
->private_size
);
1865 sh_a
->codecdata_len
= track
->private_size
;
1868 else if (track
->a_formattag
== mmioFOURCC('M', 'P', '4', 'A'))
1870 int profile
, srate_idx
;
1872 sh_a
->wf
->nAvgBytesPerSec
= 16000;
1873 sh_a
->wf
->nBlockAlign
= 1024;
1875 if (!strcmp (track
->codec_id
, MKV_A_AAC
) &&
1876 (NULL
!= track
->private_data
))
1878 sh_a
->codecdata
=malloc(track
->private_size
);
1879 memcpy (sh_a
->codecdata
, track
->private_data
,
1880 track
->private_size
);
1881 sh_a
->codecdata_len
= track
->private_size
;
1885 /* Recreate the 'private data' */
1886 /* which faad2 uses in its initialization */
1887 srate_idx
= aac_get_sample_rate_index (sh_a
->samplerate
);
1888 if (!strncmp (&track
->codec_id
[12], "MAIN", 4))
1890 else if (!strncmp (&track
->codec_id
[12], "LC", 2))
1892 else if (!strncmp (&track
->codec_id
[12], "SSR", 3))
1896 sh_a
->codecdata
= malloc (5);
1897 sh_a
->codecdata
[0] = ((profile
+1) << 3) | ((srate_idx
&0xE) >> 1);
1898 sh_a
->codecdata
[1] = ((srate_idx
&0x1)<<7)|(track
->a_channels
<<3);
1900 if (strstr(track
->codec_id
, "SBR") != NULL
)
1902 /* HE-AAC (aka SBR AAC) */
1903 sh_a
->codecdata_len
= 5;
1905 sh_a
->samplerate
*= 2;
1906 sh_a
->wf
->nSamplesPerSec
*= 2;
1907 srate_idx
= aac_get_sample_rate_index(sh_a
->samplerate
);
1908 sh_a
->codecdata
[2] = AAC_SYNC_EXTENSION_TYPE
>> 3;
1909 sh_a
->codecdata
[3] = ((AAC_SYNC_EXTENSION_TYPE
&0x07)<<5) | 5;
1910 sh_a
->codecdata
[4] = (1 << 7) | (srate_idx
<< 3);
1911 track
->default_duration
= 1024.0 / (sh_a
->samplerate
/ 2);
1915 sh_a
->codecdata_len
= 2;
1916 track
->default_duration
= 1024.0 / (float)sh_a
->samplerate
;
1919 else if (track
->a_formattag
== mmioFOURCC('v', 'r', 'b', 's')) /* VORBIS */
1921 sh_a
->wf
->cbSize
= track
->private_size
;
1922 sh_a
->wf
= realloc(sh_a
->wf
, sizeof(WAVEFORMATEX
) + sh_a
->wf
->cbSize
);
1923 memcpy((unsigned char *) (sh_a
->wf
+1), track
->private_data
, sh_a
->wf
->cbSize
);
1925 else if (track
->private_size
>= RAPROPERTIES4_SIZE
1926 && !strncmp (track
->codec_id
, MKV_A_REALATRC
, 7))
1928 /* Common initialization for all RealAudio codecs */
1929 unsigned char *src
= track
->private_data
;
1930 int codecdata_length
, version
;
1933 sh_a
->wf
->nAvgBytesPerSec
= 0; /* FIXME !? */
1935 version
= AV_RB16(src
+ 4);
1936 flavor
= AV_RB16(src
+ 22);
1937 track
->coded_framesize
= AV_RB32(src
+ 24);
1938 track
->sub_packet_h
= AV_RB16(src
+ 40);
1939 sh_a
->wf
->nBlockAlign
=
1940 track
->audiopk_size
= AV_RB16(src
+ 42);
1941 track
->sub_packet_size
= AV_RB16(src
+ 44);
1944 src
+= RAPROPERTIES4_SIZE
;
1949 src
+= RAPROPERTIES5_SIZE
;
1954 codecdata_length
= AV_RB32(src
);
1956 sh_a
->wf
->cbSize
= codecdata_length
;
1957 sh_a
->wf
= realloc (sh_a
->wf
,
1958 sizeof (WAVEFORMATEX
) +
1960 memcpy(((char *)(sh_a
->wf
+ 1)), src
, codecdata_length
);
1962 switch (track
->a_formattag
) {
1963 case mmioFOURCC('a', 't', 'r', 'c'):
1964 sh_a
->wf
->nAvgBytesPerSec
= atrc_fl2bps
[flavor
];
1965 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1966 track
->audio_buf
= malloc(track
->sub_packet_h
* track
->audiopk_size
);
1967 track
->audio_timestamp
= malloc(track
->sub_packet_h
* sizeof(float));
1969 case mmioFOURCC('c', 'o', 'o', 'k'):
1970 sh_a
->wf
->nAvgBytesPerSec
= cook_fl2bps
[flavor
];
1971 sh_a
->wf
->nBlockAlign
= track
->sub_packet_size
;
1972 track
->audio_buf
= malloc(track
->sub_packet_h
* track
->audiopk_size
);
1973 track
->audio_timestamp
= malloc(track
->sub_packet_h
* sizeof(float));
1975 case mmioFOURCC('s', 'i', 'p', 'r'):
1976 sh_a
->wf
->nAvgBytesPerSec
= sipr_fl2bps
[flavor
];
1977 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1978 track
->audio_buf
= malloc(track
->sub_packet_h
* track
->audiopk_size
);
1979 track
->audio_timestamp
= malloc(track
->sub_packet_h
* sizeof(float));
1981 case mmioFOURCC('2', '8', '_', '8'):
1982 sh_a
->wf
->nAvgBytesPerSec
= 3600;
1983 sh_a
->wf
->nBlockAlign
= track
->coded_framesize
;
1984 track
->audio_buf
= malloc(track
->sub_packet_h
* track
->audiopk_size
);
1985 track
->audio_timestamp
= malloc(track
->sub_packet_h
* sizeof(float));
1989 track
->realmedia
= 1;
1991 else if (!strcmp(track
->codec_id
, MKV_A_FLAC
) ||
1992 (track
->a_formattag
== 0xf1ac))
1999 if (track
->a_formattag
== mmioFOURCC('f', 'L', 'a', 'C'))
2001 ptr
= track
->private_data
;
2002 size
= track
->private_size
;
2006 sh_a
->format
= mmioFOURCC('f', 'L', 'a', 'C');
2007 ptr
= track
->private_data
2008 + sizeof (WAVEFORMATEX
);
2009 size
= track
->private_size
- sizeof (WAVEFORMATEX
);
2011 if (size
< 4 || ptr
[0] != 'f' || ptr
[1] != 'L' ||
2012 ptr
[2] != 'a' || ptr
[3] != 'C')
2014 dp
= new_demux_packet (4);
2015 memcpy (dp
->buffer
, "fLaC", 4);
2019 dp
= new_demux_packet (size
);
2020 memcpy (dp
->buffer
, ptr
, size
);
2024 ds_add_packet (demuxer
->audio
, dp
);
2026 else if (track
->a_formattag
== mmioFOURCC('W', 'V', 'P', 'K'))
2027 { /* do nothing, still works */ }
2028 else if (!track
->ms_compat
|| (track
->private_size
< sizeof(WAVEFORMATEX
)))
2030 free_sh_audio(demuxer
, track
->tnum
);
2038 demux_mkv_open_sub (demuxer_t
*demuxer
, mkv_track_t
*track
, int sid
)
2040 if (track
->subtitle_type
!= MATROSKA_SUBTYPE_UNKNOWN
)
2044 sh_sub_t
*sh
= new_sh_sub_sid(demuxer
, track
->tnum
, sid
);
2047 if (track
->subtitle_type
== MATROSKA_SUBTYPE_VOBSUB
)
2049 if (track
->subtitle_type
== MATROSKA_SUBTYPE_SSA
)
2051 size
= track
->private_size
;
2052 m
= demux_mkv_decode (track
,track
->private_data
,&buffer
,&size
,2);
2055 free (track
->private_data
);
2056 track
->private_data
= buffer
;
2057 track
->private_size
= size
;
2059 sh
->extradata
=malloc(track
->private_size
);
2060 memcpy (sh
->extradata
, track
->private_data
,
2061 track
->private_size
);
2062 sh
->extradata_len
= track
->private_size
;
2063 if (track
->language
&& (strcmp(track
->language
, "und") != 0))
2064 sh
->lang
= strdup(track
->language
);
2065 sh
->default_track
= track
->default_track
;
2069 mp_msg (MSGT_DEMUX
, MSGL_ERR
, MSGTR_MPDEMUX_MKV_SubtitleTypeNotSupported
,
2078 demux_mkv_open (demuxer_t
*demuxer
)
2080 stream_t
*s
= demuxer
->stream
;
2081 mkv_demuxer_t
*mkv_d
;
2083 int i
, version
, cont
= 0;
2086 stream_seek(s
, s
->start_pos
);
2087 str
= ebml_read_header (s
, &version
);
2088 if (str
== NULL
|| strcmp (str
, "matroska") || version
> 2)
2090 mp_msg (MSGT_DEMUX
, MSGL_DBG2
, "[mkv] no head found\n");
2095 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] Found the head...\n");
2097 if (ebml_read_id (s
, NULL
) != MATROSKA_ID_SEGMENT
)
2099 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] but no segment :(\n");
2102 ebml_read_length (s
, NULL
); /* return bytes number until EOF */
2104 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] + a segment...\n");
2106 mkv_d
= calloc (1, sizeof (mkv_demuxer_t
));
2107 demuxer
->priv
= mkv_d
;
2108 mkv_d
->tc_scale
= 1000000;
2109 mkv_d
->segment_start
= stream_tell (s
);
2110 mkv_d
->parsed_cues
= malloc (sizeof (off_t
));
2111 mkv_d
->parsed_seekhead
= malloc (sizeof (off_t
));
2115 switch (ebml_read_id (s
, NULL
))
2117 case MATROSKA_ID_INFO
:
2118 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment information...\n");
2119 cont
= demux_mkv_read_info (demuxer
);
2122 case MATROSKA_ID_TRACKS
:
2123 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] |+ segment tracks...\n");
2124 cont
= demux_mkv_read_tracks (demuxer
);
2127 case MATROSKA_ID_CUES
:
2128 cont
= demux_mkv_read_cues (demuxer
);
2131 case MATROSKA_ID_TAGS
:
2132 cont
= demux_mkv_read_tags (demuxer
);
2135 case MATROSKA_ID_SEEKHEAD
:
2136 cont
= demux_mkv_read_seekhead (demuxer
);
2139 case MATROSKA_ID_CHAPTERS
:
2140 cont
= demux_mkv_read_chapters (demuxer
);
2143 case MATROSKA_ID_ATTACHMENTS
:
2144 cont
= demux_mkv_read_attachments (demuxer
);
2147 case MATROSKA_ID_CLUSTER
:
2150 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] |+ found cluster, headers are "
2151 "parsed completely :)\n");
2152 /* get the first cluster timecode */
2154 l
= ebml_read_length (s
, NULL
);
2155 while (ebml_read_id (s
, NULL
) != MATROSKA_ID_CLUSTERTIMECODE
)
2157 ebml_read_skip (s
, NULL
);
2158 if (stream_tell (s
) >= p
+ l
)
2161 if (stream_tell (s
) < p
+ l
)
2163 uint64_t num
= ebml_read_uint (s
, NULL
);
2164 if (num
== EBML_UINT_INVALID
)
2167 stream_seek (s
, p
- 4);
2175 ebml_read_skip (s
, NULL
);
2180 display_create_tracks (demuxer
);
2182 /* select video track */
2184 if (demuxer
->video
->id
== -1) /* automatically select a video track */
2186 /* search for a video track that has the 'default' flag set */
2187 for (i
=0; i
<mkv_d
->num_tracks
; i
++)
2188 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_VIDEO
2189 && mkv_d
->tracks
[i
]->default_track
)
2191 track
= mkv_d
->tracks
[i
];
2196 /* no track has the 'default' flag set */
2197 /* let's take the first video track */
2198 for (i
=0; i
<mkv_d
->num_tracks
; i
++)
2199 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_VIDEO
)
2201 track
= mkv_d
->tracks
[i
];
2205 else if (demuxer
->video
->id
!= -2) /* -2 = no video at all */
2206 track
= demux_mkv_find_track_by_num (mkv_d
, demuxer
->video
->id
,
2207 MATROSKA_TRACK_VIDEO
);
2209 if (track
&& demuxer
->v_streams
[track
->tnum
])
2211 mp_msg (MSGT_DEMUX
, MSGL_INFO
,
2212 MSGTR_MPDEMUX_MKV_WillPlayVideoTrack
, track
->tnum
);
2213 demuxer
->video
->id
= track
->tnum
;
2214 demuxer
->video
->sh
= demuxer
->v_streams
[track
->tnum
];
2218 mp_msg (MSGT_DEMUX
, MSGL_INFO
, MSGTR_MPDEMUX_MKV_NoVideoTrackFound
);
2219 demuxer
->video
->id
= -2;
2222 /* select audio track */
2225 /* search for an audio track that has the 'default' flag set */
2226 for (i
=0; i
< mkv_d
->num_tracks
; i
++)
2227 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_AUDIO
2228 && mkv_d
->tracks
[i
]->default_track
)
2230 track
= mkv_d
->tracks
[i
];
2235 /* no track has the 'default' flag set */
2236 /* let's take the first audio track */
2237 for (i
=0; i
< mkv_d
->num_tracks
; i
++)
2238 if (mkv_d
->tracks
[i
]->type
== MATROSKA_TRACK_AUDIO
)
2240 track
= mkv_d
->tracks
[i
];
2244 if (track
&& demuxer
->a_streams
[track
->tnum
])
2246 demuxer
->audio
->id
= track
->tnum
;
2247 demuxer
->audio
->sh
= demuxer
->a_streams
[track
->tnum
];
2251 mp_msg (MSGT_DEMUX
, MSGL_INFO
, MSGTR_MPDEMUX_MKV_NoAudioTrackFound
);
2252 demuxer
->audio
->id
= -2;
2256 if(demuxer
->audio
->id
!= -2)
2257 for (i
=0; i
< mkv_d
->num_tracks
; i
++)
2259 if(mkv_d
->tracks
[i
]->type
!= MATROSKA_TRACK_AUDIO
)
2261 if(demuxer
->a_streams
[track
->tnum
])
2264 if(mkv_d
->last_aid
== MAX_A_STREAMS
)
2269 if (s
->end_pos
== 0 || (mkv_d
->indexes
== NULL
&& index_mode
< 0))
2270 demuxer
->seekable
= 0;
2273 demuxer
->movi_start
= s
->start_pos
;
2274 demuxer
->movi_end
= s
->end_pos
;
2275 demuxer
->seekable
= 1;
2278 demuxer
->accurate_seek
= true;
2280 return DEMUXER_TYPE_MATROSKA
;
2284 demux_close_mkv (demuxer_t
*demuxer
)
2286 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2291 free_cached_dps (demuxer
);
2294 for (i
=0; i
<mkv_d
->num_tracks
; i
++)
2295 demux_mkv_free_trackentry(mkv_d
->tracks
[i
]);
2296 free (mkv_d
->tracks
);
2298 free (mkv_d
->indexes
);
2299 free (mkv_d
->cluster_positions
);
2300 free (mkv_d
->parsed_cues
);
2301 free (mkv_d
->parsed_seekhead
);
2307 demux_mkv_read_block_lacing (uint8_t *buffer
, uint64_t *size
,
2308 uint8_t *laces
, uint32_t **all_lace_sizes
)
2310 uint32_t total
= 0, *lace_size
;
2314 *all_lace_sizes
= NULL
;
2320 switch ((flags
& 0x06) >> 1)
2322 case 0: /* no lacing */
2324 lace_size
= calloc(*laces
, sizeof(uint32_t));
2325 lace_size
[0] = *size
;
2328 case 1: /* xiph lacing */
2329 case 2: /* fixed-size lacing */
2330 case 3: /* EBML lacing */
2334 lace_size
= calloc(*laces
, sizeof(uint32_t));
2336 switch ((flags
& 0x06) >> 1)
2338 case 1: /* xiph lacing */
2339 for (i
=0; i
< *laces
-1; i
++)
2344 lace_size
[i
] += *buffer
;
2346 } while (*buffer
++ == 0xFF);
2347 total
+= lace_size
[i
];
2349 lace_size
[i
] = *size
- total
;
2352 case 2: /* fixed-size lacing */
2353 for (i
=0; i
< *laces
; i
++)
2354 lace_size
[i
] = *size
/ *laces
;
2357 case 3: /* EBML lacing */
2360 uint64_t num
= ebml_read_vlen_uint (buffer
, &l
);
2361 if (num
== EBML_UINT_INVALID
) {
2368 total
= lace_size
[0] = num
;
2369 for (i
=1; i
< *laces
-1; i
++)
2372 snum
= ebml_read_vlen_int (buffer
, &l
);
2373 if (snum
== EBML_INT_INVALID
) {
2379 lace_size
[i
] = lace_size
[i
-1] + snum
;
2380 total
+= lace_size
[i
];
2382 lace_size
[i
] = *size
- total
;
2388 *all_lace_sizes
= lace_size
;
2393 handle_subtitles(demuxer_t
*demuxer
, mkv_track_t
*track
, char *block
,
2394 int64_t size
, uint64_t block_duration
, uint64_t timecode
)
2398 if (block_duration
== 0)
2400 mp_msg (MSGT_DEMUX
, MSGL_WARN
,
2401 MSGTR_MPDEMUX_MKV_NoBlockDurationForSubtitleTrackFound
);
2406 dp
= new_demux_packet(size
);
2407 memcpy(dp
->buffer
, block
, size
);
2408 dp
->pts
= timecode
/ 1000.0f
;
2409 dp
->endpts
= (timecode
+ block_duration
) / 1000.0f
;
2410 ds_add_packet(demuxer
->sub
, dp
);
2413 double real_fix_timestamp(unsigned char *buf
, unsigned int timestamp
, unsigned int format
, int64_t *kf_base
, int *kf_pts
, double *pts
);
2416 handle_realvideo (demuxer_t
*demuxer
, mkv_track_t
*track
, uint8_t *buffer
,
2417 uint32_t size
, int block_bref
)
2419 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2421 uint32_t timestamp
= mkv_d
->last_pts
* 1000;
2423 dp
= new_demux_packet (size
);
2424 memcpy (dp
->buffer
, buffer
, size
);
2426 if (mkv_d
->v_skip_to_keyframe
)
2428 dp
->pts
= mkv_d
->last_pts
;
2429 track
->rv_kf_base
= 0;
2430 track
->rv_kf_pts
= timestamp
;
2433 dp
->pts
= real_fix_timestamp (dp
->buffer
, timestamp
,
2434 ((sh_video_t
*)demuxer
->video
->sh
)->bih
->biCompression
,
2435 &track
->rv_kf_base
, &track
->rv_kf_pts
, NULL
);
2436 dp
->pos
= demuxer
->filepos
;
2437 dp
->flags
= block_bref
? 0 : 0x10;
2439 ds_add_packet(demuxer
->video
, dp
);
2443 handle_realaudio (demuxer_t
*demuxer
, mkv_track_t
*track
, uint8_t *buffer
,
2444 uint32_t size
, int block_bref
)
2446 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2447 int sps
= track
->sub_packet_size
;
2448 int sph
= track
->sub_packet_h
;
2449 int cfs
= track
->coded_framesize
;
2450 int w
= track
->audiopk_size
;
2451 int spc
= track
->sub_packet_cnt
;
2455 if ((track
->a_formattag
== mmioFOURCC('2', '8', '_', '8')) ||
2456 (track
->a_formattag
== mmioFOURCC('c', 'o', 'o', 'k')) ||
2457 (track
->a_formattag
== mmioFOURCC('a', 't', 'r', 'c')) ||
2458 (track
->a_formattag
== mmioFOURCC('s', 'i', 'p', 'r')))
2461 // spc = track->sub_packet_cnt = 0;
2462 switch (track
->a_formattag
) {
2463 case mmioFOURCC('2', '8', '_', '8'):
2464 for (x
= 0; x
< sph
/ 2; x
++)
2465 memcpy(track
->audio_buf
+ x
* 2 * w
+ spc
* cfs
, buffer
+ cfs
* x
, cfs
);
2467 case mmioFOURCC('c', 'o', 'o', 'k'):
2468 case mmioFOURCC('a', 't', 'r', 'c'):
2469 for (x
= 0; x
< w
/ sps
; x
++)
2470 memcpy(track
->audio_buf
+ sps
* (sph
* x
+ ((sph
+ 1) / 2) * (spc
& 1) + (spc
>> 1)), buffer
+ sps
* x
, sps
);
2472 case mmioFOURCC('s', 'i', 'p', 'r'):
2473 memcpy(track
->audio_buf
+ spc
* w
, buffer
, w
);
2477 int bs
= sph
* w
* 2 / 96; // nibbles per subpacket
2478 // Perform reordering
2479 for(n
=0; n
< 38; n
++)
2482 int i
= bs
* sipr_swaps
[n
][0];
2483 int o
= bs
* sipr_swaps
[n
][1];
2484 // swap nibbles of block 'i' with 'o' TODO: optimize
2485 for(j
= 0;j
< bs
; j
++)
2487 int x
= (i
& 1) ? (track
->audio_buf
[i
>> 1] >> 4) : (track
->audio_buf
[i
>> 1] & 0x0F);
2488 int y
= (o
& 1) ? (track
->audio_buf
[o
>> 1] >> 4) : (track
->audio_buf
[o
>> 1] & 0x0F);
2490 track
->audio_buf
[o
>> 1] = (track
->audio_buf
[o
>> 1] & 0x0F) | (x
<< 4);
2492 track
->audio_buf
[o
>> 1] = (track
->audio_buf
[o
>> 1] & 0xF0) | x
;
2494 track
->audio_buf
[i
>> 1] = (track
->audio_buf
[i
>> 1] & 0x0F) | (y
<< 4);
2496 track
->audio_buf
[i
>> 1] = (track
->audio_buf
[i
>> 1] & 0xF0) | y
;
2503 track
->audio_timestamp
[track
->sub_packet_cnt
] = (track
->ra_pts
== mkv_d
->last_pts
) ? 0 : (mkv_d
->last_pts
);
2504 track
->ra_pts
= mkv_d
->last_pts
;
2505 if (track
->sub_packet_cnt
== 0)
2506 track
->audio_filepos
= demuxer
->filepos
;
2507 if (++(track
->sub_packet_cnt
) == sph
)
2509 int apk_usize
= ((WAVEFORMATEX
*)((sh_audio_t
*)demuxer
->audio
->sh
)->wf
)->nBlockAlign
;
2510 track
->sub_packet_cnt
= 0;
2511 // Release all the audio packets
2512 for (x
= 0; x
< sph
*w
/apk_usize
; x
++)
2514 dp
= new_demux_packet(apk_usize
);
2515 memcpy(dp
->buffer
, track
->audio_buf
+ x
* apk_usize
, apk_usize
);
2516 /* Put timestamp only on packets that correspond to original audio packets in file */
2517 dp
->pts
= (x
* apk_usize
% w
) ? 0 : track
->audio_timestamp
[x
* apk_usize
/ w
];
2518 dp
->pos
= track
->audio_filepos
; // all equal
2519 dp
->flags
= x
? 0 : 0x10; // Mark first packet as keyframe
2520 ds_add_packet(demuxer
->audio
, dp
);
2523 } else { // Not a codec that require reordering
2524 dp
= new_demux_packet (size
);
2525 memcpy(dp
->buffer
, buffer
, size
);
2526 if (track
->ra_pts
== mkv_d
->last_pts
&& !mkv_d
->a_skip_to_keyframe
)
2529 dp
->pts
= mkv_d
->last_pts
;
2530 track
->ra_pts
= mkv_d
->last_pts
;
2532 dp
->pos
= demuxer
->filepos
;
2533 dp
->flags
= block_bref
? 0 : 0x10;
2534 ds_add_packet (demuxer
->audio
, dp
);
2538 /** Reorder timecodes and add cached demux packets to the queues.
2540 * Timecode reordering is needed if a video track contains B frames that
2541 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2542 * MPlayer doesn't like timestamps in display order. This function adjusts
2543 * the timestamp of cached frames (which are exactly one I/P frame followed
2544 * by one or more B frames) so that they are in coding order again.
2546 * Example: The track with 25 FPS contains four frames with the timecodes
2547 * I at 0ms, P at 120ms, B at 40ms and B at 80ms. As soon as the next I
2548 * or P frame arrives these timecodes can be changed to I at 0ms, P at 40ms,
2549 * B at 80ms and B at 120ms.
2551 * This works for simple H.264 B-frame pyramids, but not for arbitrary orders.
2553 * \param demuxer The Matroska demuxer struct for this instance.
2554 * \param track The track structure whose cache should be handled.
2557 flush_cached_dps (demuxer_t
*demuxer
, mkv_track_t
*track
)
2561 if (track
->num_cached_dps
== 0)
2566 for (i
= 1; i
< track
->num_cached_dps
; i
++)
2567 if (track
->cached_dps
[i
- 1]->pts
> track
->cached_dps
[i
]->pts
) {
2568 float tmp_pts
= track
->cached_dps
[i
- 1]->pts
;
2569 track
->cached_dps
[i
- 1]->pts
= track
->cached_dps
[i
]->pts
;
2570 track
->cached_dps
[i
]->pts
= tmp_pts
;
2575 for (i
= 0; i
< track
->num_cached_dps
; i
++)
2576 ds_add_packet (demuxer
->video
, track
->cached_dps
[i
]);
2577 track
->num_cached_dps
= 0;
2580 /** Cache video frames if timecodes have to be reordered.
2582 * Timecode reordering is needed if a video track contains B frames that
2583 * are timestamped in display order (e.g. MPEG-1, MPEG-2 or "native" MPEG-4).
2584 * This function takes in a Matroska block read from the file, allocates a
2585 * demux packet for it, fills in its values, allocates space for storing
2586 * pointers to the cached demux packets and adds the packet to it. If
2587 * the packet contains an I or a P frame then ::flush_cached_dps is called
2588 * in order to send the old cached frames downstream.
2590 * \param demuxer The Matroska demuxer struct for this instance.
2591 * \param track The packet is meant for this track.
2592 * \param buffer The actual frame contents.
2593 * \param size The frame size in bytes.
2594 * \param block_bref A relative timecode (backward reference). If it is \c 0
2595 * then the frame is an I frame.
2596 * \param block_fref A relative timecode (forward reference). If it is \c 0
2597 * then the frame is either an I frame or a P frame depending on the value
2598 * of \a block_bref. Otherwise it's a B frame.
2601 handle_video_bframes (demuxer_t
*demuxer
, mkv_track_t
*track
, uint8_t *buffer
,
2602 uint32_t size
, int block_bref
, int block_fref
)
2604 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2607 dp
= new_demux_packet (size
);
2608 memcpy(dp
->buffer
, buffer
, size
);
2609 dp
->pos
= demuxer
->filepos
;
2610 dp
->pts
= mkv_d
->last_pts
;
2611 if ((track
->num_cached_dps
> 0) && (dp
->pts
< track
->max_pts
))
2613 if (block_fref
== 0) /* I or P frame */
2614 flush_cached_dps (demuxer
, track
);
2615 if (block_bref
!= 0) /* I frame, don't cache it */
2617 if ((track
->num_cached_dps
+ 1) > track
->num_allocated_dps
)
2619 track
->cached_dps
= (demux_packet_t
**)
2620 realloc(track
->cached_dps
, (track
->num_cached_dps
+ 10) *
2621 sizeof(demux_packet_t
*));
2622 track
->num_allocated_dps
+= 10;
2624 track
->cached_dps
[track
->num_cached_dps
] = dp
;
2625 track
->num_cached_dps
++;
2626 if (dp
->pts
> track
->max_pts
)
2627 track
->max_pts
= dp
->pts
;
2631 handle_block (demuxer_t
*demuxer
, uint8_t *block
, uint64_t length
,
2632 uint64_t block_duration
, int64_t block_bref
, int64_t block_fref
, uint8_t simpleblock
)
2634 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2635 mkv_track_t
*track
= NULL
;
2636 demux_stream_t
*ds
= NULL
;
2637 uint64_t old_length
;
2639 uint32_t *lace_size
;
2640 uint8_t laces
, flags
;
2641 int i
, num
, tmp
, use_this_block
= 1;
2645 /* first byte(s): track num */
2646 num
= ebml_read_vlen_uint (block
, &tmp
);
2648 /* time (relative to cluster time) */
2649 time
= block
[0] << 8 | block
[1];
2652 old_length
= length
;
2654 if (demux_mkv_read_block_lacing (block
, &length
, &laces
, &lace_size
))
2656 block
+= old_length
- length
;
2658 tc
= ((time
*mkv_d
->tc_scale
+mkv_d
->cluster_tc
) /1000000.0);
2661 current_pts
= tc
/ 1000.0;
2663 for (i
=0; i
<mkv_d
->num_tracks
; i
++)
2664 if (mkv_d
->tracks
[i
]->tnum
== num
) {
2665 track
= mkv_d
->tracks
[i
];
2673 if (num
== demuxer
->audio
->id
)
2675 ds
= demuxer
->audio
;
2677 if (mkv_d
->a_skip_to_keyframe
)
2681 if (!(flags
&0x80)) /*current frame isn't a keyframe*/
2684 else if (block_bref
!= 0)
2687 else if (mkv_d
->v_skip_to_keyframe
)
2690 if (track
->fix_i_bps
&& use_this_block
)
2692 sh_audio_t
*sh
= (sh_audio_t
*) ds
->sh
;
2694 if (block_duration
!= 0)
2696 sh
->i_bps
= length
* 1000 / block_duration
;
2697 track
->fix_i_bps
= 0;
2699 else if (track
->qt_last_a_pts
== 0.0)
2700 track
->qt_last_a_pts
= current_pts
;
2701 else if(track
->qt_last_a_pts
!= current_pts
)
2703 sh
->i_bps
= length
/ (current_pts
- track
->qt_last_a_pts
);
2704 track
->fix_i_bps
= 0;
2708 else if (tc
< mkv_d
->skip_to_timecode
)
2710 else if (num
== demuxer
->video
->id
)
2712 ds
= demuxer
->video
;
2713 if (mkv_d
->v_skip_to_keyframe
)
2717 if (!(flags
&0x80)) /*current frame isn't a keyframe*/
2720 else if (block_bref
!= 0 || block_fref
!= 0)
2724 else if (num
== demuxer
->sub
->id
)
2727 if (track
->subtitle_type
!= MATROSKA_SUBTYPE_VOBSUB
)
2729 if (!mkv_d
->v_skip_to_keyframe
)
2730 handle_subtitles (demuxer
, track
, block
, length
,
2731 block_duration
, tc
);
2740 mkv_d
->last_pts
= current_pts
;
2741 mkv_d
->last_filepos
= demuxer
->filepos
;
2743 for (i
=0; i
< laces
; i
++)
2745 if (ds
== demuxer
->video
&& track
->realmedia
)
2746 handle_realvideo (demuxer
, track
, block
, lace_size
[i
], block_bref
);
2747 else if (ds
== demuxer
->audio
&& track
->realmedia
)
2748 handle_realaudio (demuxer
, track
, block
, lace_size
[i
], block_bref
);
2749 else if (ds
== demuxer
->video
&& track
->reorder_timecodes
)
2750 handle_video_bframes (demuxer
, track
, block
, lace_size
[i
],
2751 block_bref
, block_fref
);
2754 int modified
, size
= lace_size
[i
];
2757 modified
= demux_mkv_decode (track
, block
, &buffer
, &size
, 1);
2760 dp
= new_demux_packet (size
);
2761 memcpy (dp
->buffer
, buffer
, size
);
2764 dp
->flags
= (block_bref
== 0 && block_fref
== 0) ? 0x10 : 0;
2765 /* If default_duration is 0, assume no pts value is known
2766 * for packets after the first one (rather than all pts
2767 * values being the same) */
2768 if (i
== 0 || track
->default_duration
)
2769 dp
->pts
= mkv_d
->last_pts
+ i
* track
->default_duration
;
2770 ds_add_packet (ds
, dp
);
2773 block
+= lace_size
[i
];
2776 if (ds
== demuxer
->video
)
2778 mkv_d
->v_skip_to_keyframe
= 0;
2779 mkv_d
->skip_to_timecode
= 0;
2781 else if (ds
== demuxer
->audio
)
2782 mkv_d
->a_skip_to_keyframe
= 0;
2793 demux_mkv_fill_buffer (demuxer_t
*demuxer
, demux_stream_t
*ds
)
2795 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2796 stream_t
*s
= demuxer
->stream
;
2802 while (mkv_d
->cluster_size
> 0)
2804 uint64_t block_duration
= 0, block_length
= 0;
2805 int64_t block_bref
= 0, block_fref
= 0;
2806 uint8_t *block
= NULL
;
2808 while (mkv_d
->blockgroup_size
> 0)
2810 switch (ebml_read_id (s
, &il
))
2812 case MATROSKA_ID_BLOCKDURATION
:
2814 block_duration
= ebml_read_uint (s
, &l
);
2815 if (block_duration
== EBML_UINT_INVALID
) {
2819 block_duration
*= mkv_d
->tc_scale
/ 1000000.0;
2823 case MATROSKA_ID_BLOCK
:
2824 block_length
= ebml_read_length (s
, &tmp
);
2826 if (block_length
> SIZE_MAX
- AV_LZO_INPUT_PADDING
) return 0;
2827 block
= malloc (block_length
+ AV_LZO_INPUT_PADDING
);
2828 demuxer
->filepos
= stream_tell (s
);
2829 if (stream_read (s
,block
,block_length
) != (int) block_length
)
2834 l
= tmp
+ block_length
;
2837 case MATROSKA_ID_REFERENCEBLOCK
:
2839 int64_t num
= ebml_read_int (s
, &l
);
2840 if (num
== EBML_INT_INVALID
) {
2851 case EBML_ID_INVALID
:
2856 ebml_read_skip (s
, &l
);
2859 mkv_d
->blockgroup_size
-= l
+ il
;
2860 mkv_d
->cluster_size
-= l
+ il
;
2865 int res
= handle_block (demuxer
, block
, block_length
,
2866 block_duration
, block_bref
, block_fref
, 0);
2874 if (mkv_d
->cluster_size
> 0)
2876 switch (ebml_read_id (s
, &il
))
2878 case MATROSKA_ID_CLUSTERTIMECODE
:
2880 uint64_t num
= ebml_read_uint (s
, &l
);
2881 if (num
== EBML_UINT_INVALID
)
2883 mkv_d
->cluster_tc
= num
* mkv_d
->tc_scale
;
2887 case MATROSKA_ID_BLOCKGROUP
:
2888 mkv_d
->blockgroup_size
= ebml_read_length (s
, &tmp
);
2892 case MATROSKA_ID_SIMPLEBLOCK
:
2895 block_length
= ebml_read_length (s
, &tmp
);
2896 block
= malloc (block_length
);
2897 demuxer
->filepos
= stream_tell (s
);
2898 if (stream_read (s
,block
,block_length
) != (int) block_length
)
2903 l
= tmp
+ block_length
;
2904 res
= handle_block (demuxer
, block
, block_length
,
2905 block_duration
, block_bref
, block_fref
, 1);
2907 mkv_d
->cluster_size
-= l
+ il
;
2912 else mkv_d
->cluster_size
+= l
+ il
;
2915 case EBML_ID_INVALID
:
2919 ebml_read_skip (s
, &l
);
2922 mkv_d
->cluster_size
-= l
+ il
;
2926 if (ebml_read_id (s
, &il
) != MATROSKA_ID_CLUSTER
)
2928 add_cluster_position(mkv_d
, stream_tell(s
)-il
);
2929 mkv_d
->cluster_size
= ebml_read_length (s
, NULL
);
2936 demux_mkv_seek (demuxer_t
*demuxer
, float rel_seek_secs
, float audio_delay
, int flags
)
2938 if (!(flags
& (SEEK_BACKWARD
| SEEK_FORWARD
))) {
2939 if (flags
& SEEK_ABSOLUTE
|| rel_seek_secs
< 0)
2940 flags
|= SEEK_BACKWARD
;
2942 flags
|= SEEK_FORWARD
;
2944 // Adjust the target a little bit to catch cases where the target position
2945 // specifies a keyframe with high, but not perfect, precision.
2946 rel_seek_secs
+= flags
& SEEK_FORWARD
? -0.001 : 0.001;
2948 free_cached_dps (demuxer
);
2949 if (!(flags
& SEEK_FACTOR
)) /* time in secs */
2951 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
2952 stream_t
*s
= demuxer
->stream
;
2953 int64_t target_timecode
= 0, diff
, min_diff
=0xFFFFFFFFFFFFFFFLL
;
2956 if (!(flags
& SEEK_ABSOLUTE
)) /* relative seek */
2957 target_timecode
= (int64_t) (mkv_d
->last_pts
* 1000.0);
2958 target_timecode
+= (int64_t)(rel_seek_secs
* 1000.0);
2959 if (target_timecode
< 0)
2960 target_timecode
= 0;
2962 if (mkv_d
->indexes
== NULL
) /* no index was found */
2964 uint64_t target_filepos
, cluster_pos
, max_pos
;
2966 target_filepos
= (uint64_t) (target_timecode
* mkv_d
->last_filepos
2967 / (mkv_d
->last_pts
* 1000.0));
2969 max_pos
= mkv_d
->cluster_positions
[mkv_d
->num_cluster_pos
-1];
2970 if (target_filepos
> max_pos
)
2972 if ((off_t
) max_pos
> stream_tell (s
))
2973 stream_seek (s
, max_pos
);
2975 stream_seek (s
, stream_tell (s
) + mkv_d
->cluster_size
);
2976 /* parse all the clusters upto target_filepos */
2977 while (!s
->eof
&& stream_tell(s
) < (off_t
) target_filepos
)
2979 switch (ebml_read_id (s
, &i
))
2981 case MATROSKA_ID_CLUSTER
:
2982 add_cluster_position(mkv_d
, (uint64_t) stream_tell(s
)-i
);
2985 case MATROSKA_ID_CUES
:
2986 demux_mkv_read_cues (demuxer
);
2989 ebml_read_skip (s
, NULL
);
2995 if (mkv_d
->indexes
== NULL
)
2997 cluster_pos
= mkv_d
->cluster_positions
[0];
2998 /* Let's find the nearest cluster */
2999 for (i
=0; i
< mkv_d
->num_cluster_pos
; i
++)
3001 diff
= mkv_d
->cluster_positions
[i
] - target_filepos
;
3002 if (flags
& SEEK_BACKWARD
&& diff
< 0 && -diff
< min_diff
)
3004 cluster_pos
= mkv_d
->cluster_positions
[i
];
3007 else if (flags
& SEEK_FORWARD
3008 && (diff
< 0 ? -1 * diff
: diff
) < min_diff
)
3010 cluster_pos
= mkv_d
->cluster_positions
[i
];
3011 min_diff
= diff
< 0 ? -1 * diff
: diff
;
3014 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
3015 stream_seek (s
, cluster_pos
);
3020 mkv_index_t
*index
= NULL
;
3021 int seek_id
= (demuxer
->video
->id
< 0) ? demuxer
->audio
->id
: demuxer
->video
->id
;
3023 /* let's find the entry in the indexes with the smallest */
3024 /* difference to the wanted timecode. */
3025 for (i
=0; i
< mkv_d
->num_indexes
; i
++)
3026 if (mkv_d
->indexes
[i
].tnum
== seek_id
)
3028 diff
= target_timecode
-
3029 (int64_t) mkv_d
->indexes
[i
].timecode
* mkv_d
->tc_scale
/ 1000000.0;
3031 if (flags
& SEEK_BACKWARD
) {
3032 // Seek backward: find the last index position
3033 // before target time
3034 if (diff
< 0 || diff
>= min_diff
)
3038 // Seek forward: find the first index position
3039 // after target time. If no such index exists, find last
3040 // position between current position and target time.
3042 if (min_diff
<= 0 && diff
<= min_diff
)
3045 else if (diff
>= FFMIN(target_timecode
- mkv_d
->last_pts
,
3050 index
= mkv_d
->indexes
+ i
;
3053 if (index
) /* We've found an entry. */
3055 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
3056 stream_seek (s
, index
->filepos
);
3060 if (demuxer
->video
->id
>= 0)
3061 mkv_d
->v_skip_to_keyframe
= 1;
3062 if (flags
& SEEK_FORWARD
)
3063 mkv_d
->skip_to_timecode
= target_timecode
;
3065 mkv_d
->skip_to_timecode
= 0;
3066 mkv_d
->a_skip_to_keyframe
= 1;
3068 demux_mkv_fill_buffer(demuxer
, NULL
);
3070 else if ((demuxer
->movi_end
<= 0) || !(flags
& SEEK_ABSOLUTE
))
3071 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
3074 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
3075 stream_t
*s
= demuxer
->stream
;
3076 uint64_t target_filepos
;
3077 mkv_index_t
*index
= NULL
;
3080 if (mkv_d
->indexes
== NULL
) /* no index was found */
3082 mp_msg (MSGT_DEMUX
, MSGL_V
, "[mkv] seek unsupported flags\n");
3086 target_filepos
= (uint64_t)(demuxer
->movi_end
* rel_seek_secs
);
3087 for (i
=0; i
< mkv_d
->num_indexes
; i
++)
3088 if (mkv_d
->indexes
[i
].tnum
== demuxer
->video
->id
)
3089 if ((index
== NULL
) ||
3090 ((mkv_d
->indexes
[i
].filepos
>= target_filepos
) &&
3091 ((index
->filepos
< target_filepos
) ||
3092 (mkv_d
->indexes
[i
].filepos
< index
->filepos
))))
3093 index
= &mkv_d
->indexes
[i
];
3098 mkv_d
->cluster_size
= mkv_d
->blockgroup_size
= 0;
3099 stream_seek (s
, index
->filepos
);
3101 if (demuxer
->video
->id
>= 0)
3102 mkv_d
->v_skip_to_keyframe
= 1;
3103 mkv_d
->skip_to_timecode
= index
->timecode
;
3104 mkv_d
->a_skip_to_keyframe
= 1;
3106 demux_mkv_fill_buffer(demuxer
, NULL
);
3111 demux_mkv_control (demuxer_t
*demuxer
, int cmd
, void *arg
)
3113 mkv_demuxer_t
*mkv_d
= (mkv_demuxer_t
*) demuxer
->priv
;
3117 case DEMUXER_CTRL_CORRECT_PTS
:
3118 return DEMUXER_CTRL_OK
;
3119 case DEMUXER_CTRL_GET_TIME_LENGTH
:
3120 if (mkv_d
->duration
== 0)
3121 return DEMUXER_CTRL_DONTKNOW
;
3123 *((double *)arg
) = (double)mkv_d
->duration
;
3124 return DEMUXER_CTRL_OK
;
3126 case DEMUXER_CTRL_GET_PERCENT_POS
:
3127 if (mkv_d
->duration
== 0)
3129 return DEMUXER_CTRL_DONTKNOW
;
3132 *((int *) arg
) = (int) (100 * mkv_d
->last_pts
/ mkv_d
->duration
);
3133 return DEMUXER_CTRL_OK
;
3135 case DEMUXER_CTRL_SWITCH_AUDIO
:
3136 if (demuxer
->audio
&& demuxer
->audio
->sh
) {
3137 sh_audio_t
*sh
= demuxer
->a_streams
[demuxer
->audio
->id
];
3138 int aid
= *(int*)arg
;
3140 aid
= (sh
->aid
+ 1) % mkv_d
->last_aid
;
3141 if (aid
!= sh
->aid
) {
3142 mkv_track_t
*track
= demux_mkv_find_track_by_num (mkv_d
, aid
, MATROSKA_TRACK_AUDIO
);
3144 demuxer
->audio
->id
= track
->tnum
;
3145 sh
= demuxer
->a_streams
[demuxer
->audio
->id
];
3146 ds_free_packs(demuxer
->audio
);
3149 *(int*)arg
= sh
->aid
;
3152 return DEMUXER_CTRL_OK
;
3155 return DEMUXER_CTRL_NOTIMPL
;
3159 const demuxer_desc_t demuxer_desc_matroska
= {
3165 DEMUXER_TYPE_MATROSKA
,
3166 1, // safe autodetect
3168 demux_mkv_fill_buffer
,