1 /*****************************************************************************
2 * mkv.cpp : matroska demuxer
3 *****************************************************************************
4 * Copyright (C) 2003-2004 the VideoLAN team
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Steve Lhomme <steve.lhomme@free.fr>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
28 #include <stdlib.h> /* malloc(), free() */
33 # include <time.h> /* time() */
36 #include <vlc/input.h>
38 #include <codecs.h> /* BITMAPINFOHEADER, WAVEFORMATEX */
53 /* libebml and matroska */
54 #include "ebml/EbmlHead.h"
55 #include "ebml/EbmlSubHead.h"
56 #include "ebml/EbmlStream.h"
57 #include "ebml/EbmlContexts.h"
58 #include "ebml/EbmlVoid.h"
59 #include "ebml/EbmlVersion.h"
60 #include "ebml/StdIOCallback.h"
62 #include "matroska/KaxAttachments.h"
63 #include "matroska/KaxBlock.h"
64 #include "matroska/KaxBlockData.h"
65 #include "matroska/KaxChapters.h"
66 #include "matroska/KaxCluster.h"
67 #include "matroska/KaxClusterData.h"
68 #include "matroska/KaxContexts.h"
69 #include "matroska/KaxCues.h"
70 #include "matroska/KaxCuesData.h"
71 #include "matroska/KaxInfo.h"
72 #include "matroska/KaxInfoData.h"
73 #include "matroska/KaxSeekHead.h"
74 #include "matroska/KaxSegment.h"
75 #include "matroska/KaxTag.h"
76 #include "matroska/KaxTags.h"
77 #include "matroska/KaxTagMulti.h"
78 #include "matroska/KaxTracks.h"
79 #include "matroska/KaxTrackAudio.h"
80 #include "matroska/KaxTrackVideo.h"
81 #include "matroska/KaxTrackEntryData.h"
82 #include "matroska/KaxContentEncoding.h"
83 #include "matroska/KaxVersion.h"
85 #include "ebml/StdIOCallback.h"
87 #if LIBMATROSKA_VERSION < 0x000706
88 START_LIBMATROSKA_NAMESPACE
89 extern const EbmlSemanticContext MATROSKA_DLL_API KaxMatroska_Context
;
90 END_LIBMATROSKA_NAMESPACE
96 #include "mp4/libmp4.h"
102 #define MATROSKA_COMPRESSION_NONE -1
103 #define MATROSKA_COMPRESSION_ZLIB 0
104 #define MATROSKA_COMPRESSION_BLIB 1
105 #define MATROSKA_COMPRESSION_LZOX 2
106 #define MATROSKA_COMPRESSION_HEADER 3
108 #define MKVD_TIMECODESCALE 1000000
110 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
111 #undef ATTRIBUTE_PACKED
112 #undef PRAGMA_PACK_BEGIN
113 #undef PRAGMA_PACK_END
115 #if defined(__GNUC__)
116 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
117 #define ATTRIBUTE_PACKED __attribute__ ((packed))
118 #define PRAGMA_PACK 0
122 #if !defined(ATTRIBUTE_PACKED)
123 #define ATTRIBUTE_PACKED
124 #define PRAGMA_PACK 1
131 /*************************************
132 * taken from libdvdnav / libdvdread
133 **************************************/
136 * DVD Time Information.
142 uint8_t frame_u
; /* The two high bits are the frame rate. */
143 } ATTRIBUTE_PACKED dvd_time_t
;
149 #ifdef WORDS_BIGENDIAN
150 unsigned char zero
: 7; /* 25-31 */
151 unsigned char video_pres_mode_change
: 1; /* 24 */
153 unsigned char karaoke_audio_pres_mode_change
: 1; /* 23 */
154 unsigned char angle_change
: 1;
155 unsigned char subpic_stream_change
: 1;
156 unsigned char audio_stream_change
: 1;
157 unsigned char pause_on
: 1;
158 unsigned char still_off
: 1;
159 unsigned char button_select_or_activate
: 1;
160 unsigned char resume
: 1; /* 16 */
162 unsigned char chapter_menu_call
: 1; /* 15 */
163 unsigned char angle_menu_call
: 1;
164 unsigned char audio_menu_call
: 1;
165 unsigned char subpic_menu_call
: 1;
166 unsigned char root_menu_call
: 1;
167 unsigned char title_menu_call
: 1;
168 unsigned char backward_scan
: 1;
169 unsigned char forward_scan
: 1; /* 8 */
171 unsigned char next_pg_search
: 1; /* 7 */
172 unsigned char prev_or_top_pg_search
: 1;
173 unsigned char time_or_chapter_search
: 1;
174 unsigned char go_up
: 1;
175 unsigned char stop
: 1;
176 unsigned char title_play
: 1;
177 unsigned char chapter_search_or_play
: 1;
178 unsigned char title_or_time_play
: 1; /* 0 */
180 unsigned char video_pres_mode_change
: 1; /* 24 */
181 unsigned char zero
: 7; /* 25-31 */
183 unsigned char resume
: 1; /* 16 */
184 unsigned char button_select_or_activate
: 1;
185 unsigned char still_off
: 1;
186 unsigned char pause_on
: 1;
187 unsigned char audio_stream_change
: 1;
188 unsigned char subpic_stream_change
: 1;
189 unsigned char angle_change
: 1;
190 unsigned char karaoke_audio_pres_mode_change
: 1; /* 23 */
192 unsigned char forward_scan
: 1; /* 8 */
193 unsigned char backward_scan
: 1;
194 unsigned char title_menu_call
: 1;
195 unsigned char root_menu_call
: 1;
196 unsigned char subpic_menu_call
: 1;
197 unsigned char audio_menu_call
: 1;
198 unsigned char angle_menu_call
: 1;
199 unsigned char chapter_menu_call
: 1; /* 15 */
201 unsigned char title_or_time_play
: 1; /* 0 */
202 unsigned char chapter_search_or_play
: 1;
203 unsigned char title_play
: 1;
204 unsigned char stop
: 1;
205 unsigned char go_up
: 1;
206 unsigned char time_or_chapter_search
: 1;
207 unsigned char prev_or_top_pg_search
: 1;
208 unsigned char next_pg_search
: 1; /* 7 */
210 } ATTRIBUTE_PACKED user_ops_t
;
213 * Type to store per-command data.
217 } ATTRIBUTE_PACKED vm_cmd_t
;
218 #define COMMAND_DATA_SIZE 8
221 * PCI General Information
224 uint32_t nv_pck_lbn
; /**< sector address of this nav pack */
225 uint16_t vobu_cat
; /**< 'category' of vobu */
226 uint16_t zero1
; /**< reserved */
227 user_ops_t vobu_uop_ctl
; /**< UOP of vobu */
228 uint32_t vobu_s_ptm
; /**< start presentation time of vobu */
229 uint32_t vobu_e_ptm
; /**< end presentation time of vobu */
230 uint32_t vobu_se_e_ptm
; /**< end ptm of sequence end in vobu */
231 dvd_time_t e_eltm
; /**< Cell elapsed time */
233 } ATTRIBUTE_PACKED pci_gi_t
;
236 * Non Seamless Angle Information
239 uint32_t nsml_agl_dsta
[9]; /**< address of destination vobu in AGL_C#n */
240 } ATTRIBUTE_PACKED nsml_agli_t
;
243 * Highlight General Information
245 * For btngrX_dsp_ty the bits have the following meaning:
246 * 000b: normal 4/3 only buttons
247 * XX1b: wide (16/9) buttons
248 * X1Xb: letterbox buttons
249 * 1XXb: pan&scan buttons
252 uint16_t hli_ss
; /**< status, only low 2 bits 0: no buttons, 1: different 2: equal 3: eual except for button cmds */
253 uint32_t hli_s_ptm
; /**< start ptm of hli */
254 uint32_t hli_e_ptm
; /**< end ptm of hli */
255 uint32_t btn_se_e_ptm
; /**< end ptm of button select */
256 #ifdef WORDS_BIGENDIAN
257 unsigned char zero1
: 2; /**< reserved */
258 unsigned char btngr_ns
: 2; /**< number of button groups 1, 2 or 3 with 36/18/12 buttons */
259 unsigned char zero2
: 1; /**< reserved */
260 unsigned char btngr1_dsp_ty
: 3; /**< display type of subpic stream for button group 1 */
261 unsigned char zero3
: 1; /**< reserved */
262 unsigned char btngr2_dsp_ty
: 3; /**< display type of subpic stream for button group 2 */
263 unsigned char zero4
: 1; /**< reserved */
264 unsigned char btngr3_dsp_ty
: 3; /**< display type of subpic stream for button group 3 */
266 unsigned char btngr1_dsp_ty
: 3;
267 unsigned char zero2
: 1;
268 unsigned char btngr_ns
: 2;
269 unsigned char zero1
: 2;
270 unsigned char btngr3_dsp_ty
: 3;
271 unsigned char zero4
: 1;
272 unsigned char btngr2_dsp_ty
: 3;
273 unsigned char zero3
: 1;
275 uint8_t btn_ofn
; /**< button offset number range 0-255 */
276 uint8_t btn_ns
; /**< number of valid buttons <= 36/18/12 (low 6 bits) */
277 uint8_t nsl_btn_ns
; /**< number of buttons selectable by U_BTNNi (low 6 bits) nsl_btn_ns <= btn_ns */
278 uint8_t zero5
; /**< reserved */
279 uint8_t fosl_btnn
; /**< forcedly selected button (low 6 bits) */
280 uint8_t foac_btnn
; /**< forcedly activated button (low 6 bits) */
281 } ATTRIBUTE_PACKED hl_gi_t
;
285 * Button Color Information Table
286 * Each entry beeing a 32bit word that contains the color indexs and alpha
287 * values to use. They are all represented by 4 bit number and stored
288 * like this [Ci3, Ci2, Ci1, Ci0, A3, A2, A1, A0]. The actual palette
289 * that the indexes reference is in the PGC.
290 * \todo split the uint32_t into a struct
293 uint32_t btn_coli
[3][2]; /**< [button color number-1][select:0/action:1] */
294 } ATTRIBUTE_PACKED btn_colit_t
;
299 * NOTE: I've had to change the structure from the disk layout to get
300 * the packing to work with Sun's Forte C compiler.
301 * The 4 and 7 bytes are 'rotated' was: ABC DEF GHIJ is: ABCG DEFH IJ
304 #ifdef WORDS_BIGENDIAN
305 uint32 btn_coln
: 2; /**< button color number */
306 uint32 x_start
: 10; /**< x start offset within the overlay */
307 uint32 zero1
: 2; /**< reserved */
308 uint32 x_end
: 10; /**< x end offset within the overlay */
310 uint32 zero3
: 2; /**< reserved */
311 uint32 up
: 6; /**< button index when pressing up */
313 uint32 auto_action_mode
: 2; /**< 0: no, 1: activated if selected */
314 uint32 y_start
: 10; /**< y start offset within the overlay */
315 uint32 zero2
: 2; /**< reserved */
316 uint32 y_end
: 10; /**< y end offset within the overlay */
318 uint32 zero4
: 2; /**< reserved */
319 uint32 down
: 6; /**< button index when pressing down */
320 unsigned char zero5
: 2; /**< reserved */
321 unsigned char left
: 6; /**< button index when pressing left */
322 unsigned char zero6
: 2; /**< reserved */
323 unsigned char right
: 6; /**< button index when pressing right */
336 uint32 auto_action_mode
: 2;
340 unsigned char left
: 6;
341 unsigned char zero5
: 2;
342 unsigned char right
: 6;
343 unsigned char zero6
: 2;
346 } ATTRIBUTE_PACKED btni_t
;
349 * Highlight Information
353 btn_colit_t btn_colit
;
355 } ATTRIBUTE_PACKED hli_t
;
362 nsml_agli_t nsml_agli
;
365 } ATTRIBUTE_PACKED pci_t
;
371 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
375 * What's between a directory and a filename?
378 #define DIRECTORY_SEPARATOR '\\'
380 #define DIRECTORY_SEPARATOR '/'
383 using namespace LIBMATROSKA_NAMESPACE
;
386 /*****************************************************************************
388 *****************************************************************************/
389 static int Open ( vlc_object_t
* );
390 static void Close( vlc_object_t
* );
393 set_shortname( "Matroska" );
394 set_description( _("Matroska stream demuxer" ) );
395 set_capability( "demux2", 50 );
396 set_callbacks( Open
, Close
);
397 set_category( CAT_INPUT
);
398 set_subcategory( SUBCAT_INPUT_DEMUX
);
400 add_bool( "mkv-use-ordered-chapters", 1, NULL
,
401 N_("Ordered chapters"),
402 N_("Play ordered chapters as specified in the segment."), VLC_TRUE
);
404 add_bool( "mkv-use-chapter-codec", 1, NULL
,
405 N_("Chapter codecs"),
406 N_("Use chapter codecs found in the segment."), VLC_TRUE
);
408 add_bool( "mkv-preload-local-dir", 1, NULL
,
409 N_("Preload Directory"),
410 N_("Preload matroska files from the same family in the same directory (not good for broken files)."), VLC_TRUE
);
412 add_bool( "mkv-seek-percent", 0, NULL
,
413 N_("Seek based on percent not time"),
414 N_("Seek based on percent not time."), VLC_TRUE
);
416 add_bool( "mkv-use-dummy", 0, NULL
,
417 N_("Dummy Elements"),
418 N_("Read and discard unknown EBML elements (not good for broken files)."), VLC_TRUE
);
420 add_shortcut( "mka" );
421 add_shortcut( "mkv" );
424 /*****************************************************************************
426 *****************************************************************************/
428 block_t
*block_zlib_decompress( vlc_object_t
*p_this
, block_t
*p_in_block
) {
429 int result
, dstsize
, n
;
434 d_stream
.zalloc
= (alloc_func
)0;
435 d_stream
.zfree
= (free_func
)0;
436 d_stream
.opaque
= (voidpf
)0;
437 result
= inflateInit(&d_stream
);
440 msg_Dbg( p_this
, "inflateInit() failed. Result: %d", result
);
444 d_stream
.next_in
= (Bytef
*)p_in_block
->p_buffer
;
445 d_stream
.avail_in
= p_in_block
->i_buffer
;
447 p_block
= block_New( p_this
, 0 );
452 p_block
= block_Realloc( p_block
, 0, n
* 1000 );
453 dst
= (unsigned char *)p_block
->p_buffer
;
454 d_stream
.next_out
= (Bytef
*)&dst
[(n
- 1) * 1000];
455 d_stream
.avail_out
= 1000;
456 result
= inflate(&d_stream
, Z_NO_FLUSH
);
457 if( ( result
!= Z_OK
) && ( result
!= Z_STREAM_END
) )
459 msg_Dbg( p_this
, "Zlib decompression failed. Result: %d", result
);
463 while( ( d_stream
.avail_out
== 0 ) && ( d_stream
.avail_in
!= 0 ) &&
464 ( result
!= Z_STREAM_END
) );
466 dstsize
= d_stream
.total_out
;
467 inflateEnd( &d_stream
);
469 p_block
= block_Realloc( p_block
, 0, dstsize
);
470 p_block
->i_buffer
= dstsize
;
471 block_Release( p_in_block
);
478 * Helper function to print the mkv parse tree
480 static void MkvTree( demux_t
& demuxer
, int i_level
, char *psz_format
, ... )
485 msg_Err( &demuxer
, "too deep tree" );
488 va_start( args
, psz_format
);
489 static char *psz_foo
= "| | | | | | | | | |";
490 char *psz_foo2
= (char*)malloc( ( i_level
* 4 + 3 + strlen( psz_format
) ) * sizeof(char) );
491 strncpy( psz_foo2
, psz_foo
, 4 * i_level
);
492 psz_foo2
[ 4 * i_level
] = '+';
493 psz_foo2
[ 4 * i_level
+ 1 ] = ' ';
494 strcpy( &psz_foo2
[ 4 * i_level
+ 2 ], psz_format
);
495 __msg_GenericVa( VLC_OBJECT(&demuxer
), MSG_QUEUE_NORMAL
, VLC_MSG_DBG
, "mkv", psz_foo2
, args
);
500 /*****************************************************************************
502 *****************************************************************************/
503 class vlc_stream_io_callback
: public IOCallback
511 vlc_stream_io_callback( stream_t
*, vlc_bool_t
);
513 virtual ~vlc_stream_io_callback()
519 virtual uint32
read ( void *p_buffer
, size_t i_size
);
520 virtual void setFilePointer ( int64_t i_offset
, seek_mode mode
= seek_beginning
);
521 virtual size_t write ( const void *p_buffer
, size_t i_size
);
522 virtual uint64
getFilePointer ( void );
523 virtual void close ( void );
526 /*****************************************************************************
528 *****************************************************************************/
532 EbmlParser( EbmlStream
*es
, EbmlElement
*el_start
, demux_t
*p_demux
);
533 virtual ~EbmlParser( void );
537 void Reset( demux_t
*p_demux
);
538 EbmlElement
*Get( void );
540 EbmlElement
*UnGet( uint64 i_block_pos
, uint64 i_cluster_pos
);
542 int GetLevel( void );
547 EbmlElement
*m_el
[10];
548 int64_t mi_remain_size
[10];
558 /*****************************************************************************
559 * Some functions to manipulate memory
560 *****************************************************************************/
561 #define GetFOURCC( p ) __GetFOURCC( (uint8_t*)p )
562 static vlc_fourcc_t
__GetFOURCC( uint8_t *p
)
564 return VLC_FOURCC( p
[0], p
[1], p
[2], p
[3] );
567 /*****************************************************************************
568 * definitions of structures and functions used by this plugins
569 *****************************************************************************/
574 vlc_bool_t b_default
;
575 vlc_bool_t b_enabled
;
576 unsigned int i_number
;
579 uint8_t *p_extra_data
;
583 uint64_t i_default_duration
;
584 float f_timecodescale
;
593 unsigned int i_original_rate
;
596 /* data to be send first */
598 uint8_t *p_data_init
;
600 /* hack : it's for seek */
601 vlc_bool_t b_search_keyframe
;
605 char *psz_codec_name
;
606 char *psz_codec_settings
;
607 char *psz_codec_info_url
;
608 char *psz_codec_download_url
;
610 /* encryption/compression */
611 int i_compression_type
;
612 KaxContentCompSettings
*p_compression_data
;
629 const binary MATROSKA_DVD_LEVEL_SS
= 0x30;
630 const binary MATROSKA_DVD_LEVEL_LU
= 0x2A;
631 const binary MATROSKA_DVD_LEVEL_TT
= 0x28;
632 const binary MATROSKA_DVD_LEVEL_PGC
= 0x20;
633 const binary MATROSKA_DVD_LEVEL_PG
= 0x18;
634 const binary MATROSKA_DVD_LEVEL_PTT
= 0x10;
635 const binary MATROSKA_DVD_LEVEL_CN
= 0x08;
637 class chapter_codec_cmds_c
640 chapter_codec_cmds_c( demux_sys_t
& demuxer
, int codec_id
= -1)
641 :p_private_data(NULL
)
642 ,i_codec_id( codec_id
)
646 virtual ~chapter_codec_cmds_c()
648 delete p_private_data
;
649 std::vector
<KaxChapterProcessData
*>::iterator indexe
= enter_cmds
.begin();
650 while ( indexe
!= enter_cmds
.end() )
655 std::vector
<KaxChapterProcessData
*>::iterator indexl
= leave_cmds
.begin();
656 while ( indexl
!= leave_cmds
.end() )
661 std::vector
<KaxChapterProcessData
*>::iterator indexd
= during_cmds
.begin();
662 while ( indexd
!= during_cmds
.end() )
669 void SetPrivate( const KaxChapterProcessPrivate
& private_data
)
671 p_private_data
= new KaxChapterProcessPrivate( private_data
);
674 void AddCommand( const KaxChapterProcessCommand
& command
);
676 /// \return wether the codec has seeked in the files or not
677 virtual bool Enter() { return false; }
678 virtual bool Leave() { return false; }
679 virtual std::string
GetCodecName( bool f_for_title
= false ) const { return ""; }
680 virtual int16
GetTitleNumber() { return -1; }
682 KaxChapterProcessPrivate
*p_private_data
;
685 std::vector
<KaxChapterProcessData
*> enter_cmds
;
686 std::vector
<KaxChapterProcessData
*> during_cmds
;
687 std::vector
<KaxChapterProcessData
*> leave_cmds
;
693 class dvd_command_interpretor_c
696 dvd_command_interpretor_c( demux_sys_t
& demuxer
)
699 memset( p_PRMs
, 0, sizeof(p_PRMs
) );
700 p_PRMs
[ 0x80 + 1 ] = 15;
701 p_PRMs
[ 0x80 + 2 ] = 62;
702 p_PRMs
[ 0x80 + 3 ] = 1;
703 p_PRMs
[ 0x80 + 4 ] = 1;
704 p_PRMs
[ 0x80 + 7 ] = 1;
705 p_PRMs
[ 0x80 + 8 ] = 1;
706 p_PRMs
[ 0x80 + 16 ] = 0xFFFFu
;
707 p_PRMs
[ 0x80 + 18 ] = 0xFFFFu
;
710 bool Interpret( const binary
* p_command
, size_t i_size
= 8 );
712 uint16
GetPRM( size_t index
) const
715 return p_PRMs
[ index
];
719 uint16
GetGPRM( size_t index
) const
721 if ( index
>= 0 && index
< 16 )
722 return p_PRMs
[ index
];
726 uint16
GetSPRM( size_t index
) const
728 // 21,22,23 reserved for future use
729 if ( index
>= 0x80 && index
< 0x95 )
730 return p_PRMs
[ index
];
734 bool SetPRM( size_t index
, uint16 value
)
736 if ( index
>= 0 && index
< 16 )
738 p_PRMs
[ index
] = value
;
744 bool SetGPRM( size_t index
, uint16 value
)
746 if ( index
>= 0 && index
< 16 )
748 p_PRMs
[ index
] = value
;
754 bool SetSPRM( size_t index
, uint16 value
)
756 if ( index
> 0x80 && index
<= 0x8D && index
!= 0x8C )
758 p_PRMs
[ index
] = value
;
765 std::string
GetRegTypeName( bool b_value
, uint16 value
) const
768 char s_value
[6], s_reg_value
[6];
769 sprintf( s_value
, "%.5d", value
);
777 else if ( value
< 0x80 )
779 sprintf( s_reg_value
, "%.5d", GetPRM( value
) );
783 result
+= s_reg_value
;
788 sprintf( s_reg_value
, "%.5d", GetPRM( value
) );
792 result
+= s_reg_value
;
804 // wether it's a comparison on the value or register
805 static const uint16 CMD_DVD_TEST_VALUE
= 0x80;
806 static const uint16 CMD_DVD_IF_GPREG_AND
= (1 << 4);
807 static const uint16 CMD_DVD_IF_GPREG_EQUAL
= (2 << 4);
808 static const uint16 CMD_DVD_IF_GPREG_NOT_EQUAL
= (3 << 4);
809 static const uint16 CMD_DVD_IF_GPREG_SUP_EQUAL
= (4 << 4);
810 static const uint16 CMD_DVD_IF_GPREG_SUP
= (5 << 4);
811 static const uint16 CMD_DVD_IF_GPREG_INF_EQUAL
= (6 << 4);
812 static const uint16 CMD_DVD_IF_GPREG_INF
= (7 << 4);
814 static const uint16 CMD_DVD_NOP
= 0x0000;
815 static const uint16 CMD_DVD_GOTO_LINE
= 0x0001;
816 static const uint16 CMD_DVD_BREAK
= 0x0002;
818 static const uint16 CMD_DVD_NOP2
= 0x2001;
819 static const uint16 CMD_DVD_LINKPGCN
= 0x2004;
820 static const uint16 CMD_DVD_LINKPGN
= 0x2006;
821 static const uint16 CMD_DVD_LINKCN
= 0x2007;
822 static const uint16 CMD_DVD_JUMP_TT
= 0x3002;
823 static const uint16 CMD_DVD_JUMPVTS_TT
= 0x3003;
824 static const uint16 CMD_DVD_JUMPVTS_PTT
= 0x3005;
825 static const uint16 CMD_DVD_JUMP_SS
= 0x3006;
826 static const uint16 CMD_DVD_CALLSS_VTSM1
= 0x3008;
828 static const uint16 CMD_DVD_SET_HL_BTNN2
= 0x4600;
829 static const uint16 CMD_DVD_SET_HL_BTNN_LINKPGCN1
= 0x4604;
830 static const uint16 CMD_DVD_SET_STREAM
= 0x5100;
831 static const uint16 CMD_DVD_SET_GPRMMD
= 0x5300;
832 static const uint16 CMD_DVD_SET_HL_BTNN1
= 0x5600;
833 static const uint16 CMD_DVD_SET_HL_BTNN_LINKPGCN2
= 0x5604;
834 static const uint16 CMD_DVD_SET_HL_BTNN_LINKCN
= 0x5607;
836 static const uint16 CMD_DVD_MOV_SPREG_PREG
= 0x6100;
837 static const uint16 CMD_DVD_GPREG_MOV_VALUE
= 0x7100;
838 static const uint16 CMD_DVD_SUB_GPREG
= 0x7400;
839 static const uint16 CMD_DVD_MULT_GPREG
= 0x7500;
840 static const uint16 CMD_DVD_GPREG_DIV_VALUE
= 0x7600;
841 static const uint16 CMD_DVD_GPREG_AND_VALUE
= 0x7900;
843 // callbacks when browsing inside CodecPrivate
844 static bool MatchIsDomain ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
845 static bool MatchIsVMG ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
846 static bool MatchVTSNumber ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
847 static bool MatchVTSMNumber ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
848 static bool MatchTitleNumber ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
849 static bool MatchPgcType ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
850 static bool MatchPgcNumber ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
851 static bool MatchChapterNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
852 static bool MatchCellNumber ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
855 class dvd_chapter_codec_c
: public chapter_codec_cmds_c
858 dvd_chapter_codec_c( demux_sys_t
& sys
)
859 :chapter_codec_cmds_c( sys
, 1 )
864 std::string
GetCodecName( bool f_for_title
= false ) const;
865 int16
GetTitleNumber();
868 class matroska_script_interpretor_c
871 matroska_script_interpretor_c( demux_sys_t
& demuxer
)
875 bool Interpret( const binary
* p_command
, size_t i_size
);
878 static const std::string CMD_MS_GOTO_AND_PLAY
;
884 const std::string
matroska_script_interpretor_c::CMD_MS_GOTO_AND_PLAY
= "GotoAndPlay";
887 class matroska_script_codec_c
: public chapter_codec_cmds_c
890 matroska_script_codec_c( demux_sys_t
& sys
)
891 :chapter_codec_cmds_c( sys
, 0 )
899 matroska_script_interpretor_c interpretor
;
902 class chapter_translation_c
905 chapter_translation_c()
909 ~chapter_translation_c()
914 KaxChapterTranslateID
*p_translated
;
915 unsigned int codec_id
;
916 std::vector
<uint64_t> editions
;
925 ,i_user_start_time(-1)
928 ,b_display_seekpoint(true)
929 ,b_user_display(false)
934 virtual ~chapter_item_c()
936 std::vector
<chapter_codec_cmds_c
*>::iterator index
= codecs
.begin();
937 while ( index
!= codecs
.end() )
942 std::vector
<chapter_item_c
*>::iterator index_
= sub_chapters
.begin();
943 while ( index_
!= sub_chapters
.end() )
950 int64_t RefreshChapters( bool b_ordered
, int64_t i_prev_user_time
);
951 int PublishChapters( input_title_t
& title
, int & i_user_chapters
, int i_level
= 0 );
952 virtual chapter_item_c
* FindTimecode( mtime_t i_timecode
, const chapter_item_c
* p_current
, bool & b_found
);
953 void Append( const chapter_item_c
& edition
);
954 chapter_item_c
* FindChapter( int64_t i_find_uid
);
955 virtual chapter_item_c
*BrowseCodecPrivate( unsigned int codec_id
,
956 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
957 const void *p_cookie
,
958 size_t i_cookie_size
);
959 std::string
GetCodecName( bool f_for_title
= false ) const;
960 bool ParentOf( const chapter_item_c
& item
) const;
961 int16
GetTitleNumber( ) const;
963 int64_t i_start_time
, i_end_time
;
964 int64_t i_user_start_time
, i_user_end_time
; /* the time in the stream when an edition is ordered */
965 std::vector
<chapter_item_c
*> sub_chapters
;
968 bool b_display_seekpoint
;
970 std::string psz_name
;
971 chapter_item_c
*psz_parent
;
974 std::vector
<chapter_codec_cmds_c
*> codecs
;
976 static bool CompareTimecode( const chapter_item_c
* itemA
, const chapter_item_c
* itemB
)
978 return ( itemA
->i_user_start_time
< itemB
->i_user_start_time
|| (itemA
->i_user_start_time
== itemB
->i_user_start_time
&& itemA
->i_user_end_time
< itemB
->i_user_end_time
) );
981 bool Enter( bool b_do_subchapters
);
982 bool Leave( bool b_do_subchapters
);
983 bool EnterAndLeave( chapter_item_c
*p_item
, bool b_enter
= true );
986 class chapter_edition_c
: public chapter_item_c
993 void RefreshChapters( );
994 mtime_t
Duration() const;
995 std::string
GetMainName() const;
996 chapter_item_c
* FindTimecode( mtime_t i_timecode
, const chapter_item_c
* p_current
);
1001 class matroska_segment_c
1004 matroska_segment_c( demux_sys_t
& demuxer
, EbmlStream
& estream
)
1007 ,i_timescale(MKVD_TIMECODESCALE
)
1010 ,i_cues_position(-1)
1011 ,i_chapters_position(-1)
1012 ,i_tags_position(-1)
1017 ,p_segment_uid(NULL
)
1018 ,p_prev_segment_uid(NULL
)
1019 ,p_next_segment_uid(NULL
)
1023 ,psz_muxing_application(NULL
)
1024 ,psz_writing_application(NULL
)
1025 ,psz_segment_filename(NULL
)
1028 ,i_default_edition(0)
1033 p_indexes
= (mkv_index_t
*)malloc( sizeof( mkv_index_t
) * i_index_max
);
1036 virtual ~matroska_segment_c()
1038 for( size_t i_track
= 0; i_track
< tracks
.size(); i_track
++ )
1040 if ( tracks
[i_track
]->p_compression_data
)
1042 delete tracks
[i_track
]->p_compression_data
;
1044 es_format_Clean( &tracks
[i_track
]->fmt
);
1045 if( tracks
[i_track
]->p_extra_data
)
1046 free( tracks
[i_track
]->p_extra_data
);
1047 if( tracks
[i_track
]->psz_codec
)
1048 free( tracks
[i_track
]->psz_codec
);
1049 delete tracks
[i_track
];
1052 if( psz_writing_application
)
1054 free( psz_writing_application
);
1056 if( psz_muxing_application
)
1058 free( psz_muxing_application
);
1060 if( psz_segment_filename
)
1062 free( psz_segment_filename
);
1070 free( psz_date_utc
);
1077 delete p_segment_uid
;
1078 delete p_prev_segment_uid
;
1079 delete p_next_segment_uid
;
1081 std::vector
<chapter_edition_c
*>::iterator index
= stored_editions
.begin();
1082 while ( index
!= stored_editions
.end() )
1087 std::vector
<chapter_translation_c
*>::iterator indext
= translations
.begin();
1088 while ( indext
!= translations
.end() )
1093 std::vector
<KaxSegmentFamily
*>::iterator indexf
= families
.begin();
1094 while ( indexf
!= families
.end() )
1101 KaxSegment
*segment
;
1105 uint64_t i_timescale
;
1107 /* duration of the segment */
1109 mtime_t i_start_time
;
1112 std::vector
<mkv_track_t
*> tracks
;
1115 int64_t i_cues_position
;
1116 int64_t i_chapters_position
;
1117 int64_t i_tags_position
;
1119 KaxCluster
*cluster
;
1121 uint64 i_cluster_pos
;
1122 int64_t i_start_pos
;
1123 KaxSegmentUID
*p_segment_uid
;
1124 KaxPrevUID
*p_prev_segment_uid
;
1125 KaxNextUID
*p_next_segment_uid
;
1130 mkv_index_t
*p_indexes
;
1133 char *psz_muxing_application
;
1134 char *psz_writing_application
;
1135 char *psz_segment_filename
;
1139 /* !!!!! GCC 3.3 bug on Darwin !!!!! */
1140 /* when you remove this variable the compiler issues an atomicity error */
1141 /* this variable only works when using std::vector<chapter_edition_c> */
1142 std::vector
<chapter_edition_c
*> stored_editions
;
1143 int i_default_edition
;
1145 std::vector
<chapter_translation_c
*> translations
;
1146 std::vector
<KaxSegmentFamily
*> families
;
1153 bool PreloadFamily( const matroska_segment_c
& segment
);
1154 void ParseInfo( KaxInfo
*info
);
1155 void ParseChapters( KaxChapters
*chapters
);
1156 void ParseSeekHead( KaxSeekHead
*seekhead
);
1157 void ParseTracks( KaxTracks
*tracks
);
1158 void ParseChapterAtom( int i_level
, KaxChapterAtom
*ca
, chapter_item_c
& chapters
);
1159 void ParseTrackEntry( KaxTrackEntry
*m
);
1160 void ParseCluster( );
1161 void IndexAppendCluster( KaxCluster
*cluster
);
1164 void InformationCreate( );
1165 void Seek( mtime_t i_date
, mtime_t i_time_offset
);
1166 #if LIBMATROSKA_VERSION >= 0x000800
1167 int BlockGet( KaxBlock
* &, KaxSimpleBlock
* &, int64_t *, int64_t *, int64_t *);
1169 int BlockGet( KaxBlock
* &, int64_t *, int64_t *, int64_t *);
1171 bool Select( mtime_t i_start_time
);
1174 static bool CompareSegmentUIDs( const matroska_segment_c
* item_a
, const matroska_segment_c
* item_b
);
1177 // class holding hard-linked segment together in the playback order
1178 class virtual_segment_c
1181 virtual_segment_c( matroska_segment_c
*p_segment
)
1184 ,i_current_segment(0)
1185 ,i_current_edition(-1)
1186 ,psz_current_chapter(NULL
)
1188 linked_segments
.push_back( p_segment
);
1190 AppendUID( p_segment
->p_segment_uid
);
1191 AppendUID( p_segment
->p_prev_segment_uid
);
1192 AppendUID( p_segment
->p_next_segment_uid
);
1196 size_t AddSegment( matroska_segment_c
*p_segment
);
1197 void PreloadLinked( );
1198 mtime_t
Duration( ) const;
1200 void Seek( demux_t
& demuxer
, mtime_t i_date
, mtime_t i_time_offset
, chapter_item_c
*psz_chapter
);
1202 inline chapter_edition_c
*Edition()
1204 if ( i_current_edition
>= 0 && size_t(i_current_edition
) < p_editions
->size() )
1205 return (*p_editions
)[i_current_edition
];
1209 matroska_segment_c
* Segment() const
1211 if ( linked_segments
.size() == 0 || i_current_segment
>= linked_segments
.size() )
1213 return linked_segments
[i_current_segment
];
1216 inline chapter_item_c
*CurrentChapter() {
1217 return psz_current_chapter
;
1222 if ( i_current_segment
< linked_segments
.size()-1 )
1224 i_current_segment
++;
1230 bool FindUID( KaxSegmentUID
& uid
) const
1232 for ( size_t i
=0; i
<linked_uids
.size(); i
++ )
1234 if ( linked_uids
[i
] == uid
)
1240 bool UpdateCurrentToChapter( demux_t
& demux
);
1241 void PrepareChapters( );
1243 chapter_item_c
*BrowseCodecPrivate( unsigned int codec_id
,
1244 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
1245 const void *p_cookie
,
1246 size_t i_cookie_size
);
1247 chapter_item_c
*FindChapter( int64_t i_find_uid
);
1249 std::vector
<chapter_edition_c
*> *p_editions
;
1253 std::vector
<matroska_segment_c
*> linked_segments
;
1254 std::vector
<KaxSegmentUID
> linked_uids
;
1255 size_t i_current_segment
;
1257 int i_current_edition
;
1258 chapter_item_c
*psz_current_chapter
;
1260 void AppendUID( const EbmlBinary
* UID
);
1263 class matroska_stream_c
1266 matroska_stream_c( demux_sys_t
& demuxer
)
1272 virtual ~matroska_stream_c()
1281 std::vector
<matroska_segment_c
*> segments
;
1294 vlc_bool_t b_clicked
;
1302 demux_sys_t( demux_t
& demux
)
1309 ,p_current_segment(NULL
)
1310 ,dvd_interpretor( *this )
1314 ,b_pci_packet_set(false)
1317 vlc_mutex_init( &demuxer
, &lock_demuxer
);
1320 virtual ~demux_sys_t()
1324 for ( i
=0; i
<streams
.size(); i
++ )
1326 for ( i
=0; i
<opened_segments
.size(); i
++ )
1327 delete opened_segments
[i
];
1328 for ( i
=0; i
<used_segments
.size(); i
++ )
1329 delete used_segments
[i
];
1330 if( meta
) vlc_meta_Delete( meta
);
1332 while( titles
.size() )
1333 { vlc_input_title_Delete( titles
.back() ); titles
.pop_back();}
1335 vlc_mutex_destroy( &lock_demuxer
);
1342 mtime_t i_start_pts
;
1343 mtime_t i_chapter_time
;
1347 std::vector
<input_title_t
*> titles
; // matroska editions
1348 size_t i_current_title
;
1350 std::vector
<matroska_stream_c
*> streams
;
1351 std::vector
<matroska_segment_c
*> opened_segments
;
1352 std::vector
<virtual_segment_c
*> used_segments
;
1353 virtual_segment_c
*p_current_segment
;
1355 dvd_command_interpretor_c dvd_interpretor
;
1357 /* duration of the stream */
1360 matroska_segment_c
*FindSegment( const EbmlBinary
& uid
) const;
1361 chapter_item_c
*BrowseCodecPrivate( unsigned int codec_id
,
1362 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
1363 const void *p_cookie
,
1364 size_t i_cookie_size
,
1365 virtual_segment_c
* & p_segment_found
);
1366 chapter_item_c
*FindChapter( int64_t i_find_uid
, virtual_segment_c
* & p_segment_found
);
1368 void PreloadFamily( const matroska_segment_c
& of_segment
);
1369 void PreloadLinked( matroska_segment_c
*p_segment
);
1370 bool PreparePlayback( virtual_segment_c
*p_new_segment
);
1371 matroska_stream_c
*AnalyseAllSegmentsFound( demux_t
*p_demux
, EbmlStream
*p_estream
, bool b_initial
= false );
1372 void JumpTo( virtual_segment_c
& p_segment
, chapter_item_c
* p_chapter
);
1374 void StartUiThread();
1375 void StopUiThread();
1377 inline void SwapButtons();
1379 /* for spu variables */
1380 input_thread_t
*p_input
;
1382 bool b_pci_packet_set
;
1383 uint8_t palette
[4][4];
1384 vlc_mutex_t lock_demuxer
;
1387 event_thread_t
*p_ev
;
1388 static int EventThread( vlc_object_t
*p_this
);
1389 static int EventMouse( vlc_object_t
*p_this
, char const *psz_var
,
1390 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
);
1391 static int EventKey( vlc_object_t
*p_this
, char const *psz_var
,
1392 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
);
1397 virtual_segment_c
*VirtualFromSegments( matroska_segment_c
*p_segment
) const;
1398 bool IsUsedSegment( matroska_segment_c
&p_segment
) const;
1401 static int Demux ( demux_t
* );
1402 static int Control( demux_t
*, int, va_list );
1403 static void Seek ( demux_t
*, mtime_t i_date
, double f_percent
, chapter_item_c
*psz_chapter
);
1405 #define MKV_IS_ID( el, C ) ( EbmlId( (*el) ) == C::ClassInfos.GlobalId )
1407 static inline char * ToUTF8( const UTFstring
&u
)
1409 return strdup( u
.GetUTF8().c_str() );
1412 /*****************************************************************************
1413 * Open: initializes matroska demux structures
1414 *****************************************************************************/
1415 static int Open( vlc_object_t
* p_this
)
1417 demux_t
*p_demux
= (demux_t
*)p_this
;
1419 matroska_stream_c
*p_stream
;
1420 matroska_segment_c
*p_segment
;
1422 std::string s_path
, s_filename
;
1423 vlc_stream_io_callback
*p_io_callback
;
1424 EbmlStream
*p_io_stream
;
1426 /* peek the begining */
1427 if( stream_Peek( p_demux
->s
, &p_peek
, 4 ) < 4 ) return VLC_EGENERIC
;
1429 /* is a valid file */
1430 if( p_peek
[0] != 0x1a || p_peek
[1] != 0x45 ||
1431 p_peek
[2] != 0xdf || p_peek
[3] != 0xa3 ) return VLC_EGENERIC
;
1433 /* Set the demux function */
1434 p_demux
->pf_demux
= Demux
;
1435 p_demux
->pf_control
= Control
;
1436 p_demux
->p_sys
= p_sys
= new demux_sys_t( *p_demux
);
1438 p_io_callback
= new vlc_stream_io_callback( p_demux
->s
, VLC_FALSE
);
1439 p_io_stream
= new EbmlStream( *p_io_callback
);
1441 if( p_io_stream
== NULL
)
1443 msg_Err( p_demux
, "failed to create EbmlStream" );
1444 delete p_io_callback
;
1446 return VLC_EGENERIC
;
1449 p_stream
= p_sys
->AnalyseAllSegmentsFound( p_demux
, p_io_stream
, true );
1450 if( p_stream
== NULL
)
1452 msg_Err( p_demux
, "cannot find KaxSegment" );
1455 p_sys
->streams
.push_back( p_stream
);
1457 p_stream
->p_in
= p_io_callback
;
1458 p_stream
->p_es
= p_io_stream
;
1460 for (size_t i
=0; i
<p_stream
->segments
.size(); i
++)
1462 p_stream
->segments
[i
]->Preload();
1465 p_segment
= p_stream
->segments
[0];
1466 if( p_segment
->cluster
!= NULL
)
1468 msg_Warn( p_demux
, "cannot find any cluster, damaged file ?" );
1470 // reset the stream reading to the first cluster of the segment used
1471 p_stream
->p_in
->setFilePointer( p_segment
->cluster
->GetElementPosition() );
1474 if (config_GetInt( p_demux
, "mkv-preload-local-dir" ))
1476 /* get the files from the same dir from the same family (based on p_demux->psz_path) */
1477 if (p_demux
->psz_path
[0] != '\0' && !strcmp(p_demux
->psz_access
, ""))
1479 // assume it's a regular file
1480 // get the directory path
1481 s_path
= p_demux
->psz_path
;
1482 if (s_path
.at(s_path
.length() - 1) == DIRECTORY_SEPARATOR
)
1484 s_path
= s_path
.substr(0,s_path
.length()-1);
1488 if (s_path
.find_last_of(DIRECTORY_SEPARATOR
) > 0)
1490 s_path
= s_path
.substr(0,s_path
.find_last_of(DIRECTORY_SEPARATOR
));
1494 struct dirent
*p_file_item
;
1495 DIR *p_src_dir
= opendir(s_path
.c_str());
1497 if (p_src_dir
!= NULL
)
1499 while ((p_file_item
= (dirent
*) readdir(p_src_dir
)))
1501 if (strlen(p_file_item
->d_name
) > 4)
1503 s_filename
= s_path
+ DIRECTORY_SEPARATOR
+ p_file_item
->d_name
;
1506 if (!strcasecmp(s_filename
.c_str(), p_demux
->psz_path
))
1508 if (!s_filename
.compare(p_demux
->psz_path
))
1510 continue; // don't reuse the original opened file
1512 #if defined(__GNUC__) && (__GNUC__ < 3)
1513 if (!s_filename
.compare("mkv", s_filename
.length() - 3, 3) ||
1514 !s_filename
.compare("mka", s_filename
.length() - 3, 3))
1516 if (!s_filename
.compare(s_filename
.length() - 3, 3, "mkv") ||
1517 !s_filename
.compare(s_filename
.length() - 3, 3, "mka"))
1520 // test wether this file belongs to our family
1521 stream_t
*p_file_stream
= stream_UrlNew( p_demux
, s_filename
.c_str());
1522 if ( p_file_stream
!= NULL
)
1524 vlc_stream_io_callback
*p_file_io
= new vlc_stream_io_callback( p_file_stream
, VLC_TRUE
);
1525 EbmlStream
*p_estream
= new EbmlStream(*p_file_io
);
1527 p_stream
= p_sys
->AnalyseAllSegmentsFound( p_demux
, p_estream
);
1529 if ( p_stream
== NULL
)
1531 msg_Dbg( p_demux
, "the file '%s' will not be used", s_filename
.c_str() );
1537 p_stream
->p_in
= p_file_io
;
1538 p_stream
->p_es
= p_estream
;
1539 p_sys
->streams
.push_back( p_stream
);
1544 msg_Dbg( p_demux
, "the file '%s' cannot be opened", s_filename
.c_str() );
1549 closedir( p_src_dir
);
1553 p_sys
->PreloadFamily( *p_segment
);
1556 p_sys
->PreloadLinked( p_segment
);
1558 if ( !p_sys
->PreparePlayback( NULL
) )
1560 msg_Err( p_demux
, "cannot use the segment" );
1564 p_sys
->StartUiThread();
1570 return VLC_EGENERIC
;
1573 /*****************************************************************************
1574 * Close: frees unused data
1575 *****************************************************************************/
1576 static void Close( vlc_object_t
*p_this
)
1578 demux_t
*p_demux
= (demux_t
*)p_this
;
1579 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1584 /*****************************************************************************
1586 *****************************************************************************/
1587 static int Control( demux_t
*p_demux
, int i_query
, va_list args
)
1589 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1595 vlc_meta_t
**pp_meta
;
1599 case DEMUX_GET_META
:
1600 pp_meta
= (vlc_meta_t
**)va_arg( args
, vlc_meta_t
** );
1601 *pp_meta
= vlc_meta_Duplicate( p_sys
->meta
);
1604 case DEMUX_GET_LENGTH
:
1605 pi64
= (int64_t*)va_arg( args
, int64_t * );
1606 if( p_sys
->f_duration
> 0.0 )
1608 *pi64
= (int64_t)(p_sys
->f_duration
* 1000);
1611 return VLC_EGENERIC
;
1613 case DEMUX_GET_POSITION
:
1614 pf
= (double*)va_arg( args
, double * );
1615 if ( p_sys
->f_duration
> 0.0 )
1616 *pf
= (double)(p_sys
->i_pts
>= p_sys
->i_start_pts
? p_sys
->i_pts
: p_sys
->i_start_pts
) / (1000.0 * p_sys
->f_duration
);
1619 case DEMUX_SET_POSITION
:
1620 f
= (double)va_arg( args
, double );
1621 Seek( p_demux
, -1, f
, NULL
);
1624 case DEMUX_GET_TIME
:
1625 pi64
= (int64_t*)va_arg( args
, int64_t * );
1626 *pi64
= p_sys
->i_pts
;
1629 case DEMUX_GET_TITLE_INFO
:
1630 if( p_sys
->titles
.size() )
1632 input_title_t
***ppp_title
= (input_title_t
***)va_arg( args
, input_title_t
*** );
1633 int *pi_int
= (int*)va_arg( args
, int* );
1635 *pi_int
= p_sys
->titles
.size();
1636 *ppp_title
= (input_title_t
**)malloc( sizeof( input_title_t
**) * p_sys
->titles
.size() );
1638 for( size_t i
= 0; i
< p_sys
->titles
.size(); i
++ )
1640 (*ppp_title
)[i
] = vlc_input_title_Duplicate( p_sys
->titles
[i
] );
1645 return VLC_EGENERIC
;
1647 case DEMUX_SET_TITLE
:
1648 /* TODO handle editions as titles */
1649 i_idx
= (int)va_arg( args
, int );
1650 if( i_idx
< p_sys
->used_segments
.size() )
1652 p_sys
->JumpTo( *p_sys
->used_segments
[i_idx
], NULL
);
1655 return VLC_EGENERIC
;
1657 case DEMUX_SET_SEEKPOINT
:
1658 i_skp
= (int)va_arg( args
, int );
1660 // TODO change the way it works with the << & >> buttons on the UI (+1/-1 instead of a number)
1661 if( p_sys
->titles
.size() && i_skp
< p_sys
->titles
[p_sys
->i_current_title
]->i_seekpoint
)
1663 Seek( p_demux
, (int64_t)p_sys
->titles
[p_sys
->i_current_title
]->seekpoint
[i_skp
]->i_time_offset
, -1, NULL
);
1664 p_demux
->info
.i_seekpoint
|= INPUT_UPDATE_SEEKPOINT
;
1665 p_demux
->info
.i_seekpoint
= i_skp
;
1668 return VLC_EGENERIC
;
1670 case DEMUX_SET_TIME
:
1673 return VLC_EGENERIC
;
1677 #if LIBMATROSKA_VERSION >= 0x000800
1678 int matroska_segment_c::BlockGet( KaxBlock
* & pp_block
, KaxSimpleBlock
* & pp_simpleblock
, int64_t *pi_ref1
, int64_t *pi_ref2
, int64_t *pi_duration
)
1680 int matroska_segment_c::BlockGet( KaxBlock
* & pp_block
, int64_t *pi_ref1
, int64_t *pi_ref2
, int64_t *pi_duration
)
1683 #if LIBMATROSKA_VERSION >= 0x000800
1684 pp_simpleblock
= NULL
;
1692 EbmlElement
*el
= NULL
;
1696 return VLC_EGENERIC
;
1698 #if LIBMATROSKA_VERSION >= 0x000800
1699 if( pp_simpleblock
!= NULL
|| ((el
= ep
->Get()) == NULL
&& pp_block
!= NULL
) )
1701 if( (el
= ep
->Get()) == NULL
&& pp_block
!= NULL
)
1704 /* update the index */
1705 #define idx p_indexes[i_index - 1]
1706 if( i_index
> 0 && idx
.i_time
== -1 )
1708 #if LIBMATROSKA_VERSION >= 0x000800
1709 if ( pp_simpleblock
!= NULL
)
1710 idx
.i_time
= pp_simpleblock
->GlobalTimecode() / (mtime_t
)1000;
1713 idx
.i_time
= (*pp_block
).GlobalTimecode() / (mtime_t
)1000;
1714 idx
.b_key
= *pi_ref1
== 0 ? VLC_TRUE
: VLC_FALSE
;
1720 i_level
= ep
->GetLevel();
1729 msg_Warn( &sys
.demuxer
, "EOF" );
1730 return VLC_EGENERIC
;
1737 if( MKV_IS_ID( el
, KaxCluster
) )
1739 cluster
= (KaxCluster
*)el
;
1740 i_cluster_pos
= cluster
->GetElementPosition();
1742 /* add it to the index */
1744 ( i_index
> 0 && p_indexes
[i_index
- 1].i_position
< (int64_t)cluster
->GetElementPosition() ) )
1746 IndexAppendCluster( cluster
);
1749 // reset silent tracks
1750 for (size_t i
=0; i
<tracks
.size(); i
++)
1752 tracks
[i
]->b_silent
= VLC_FALSE
;
1757 else if( MKV_IS_ID( el
, KaxCues
) )
1759 msg_Warn( &sys
.demuxer
, "find KaxCues FIXME" );
1760 return VLC_EGENERIC
;
1764 msg_Dbg( &sys
.demuxer
, "unknown (%s)", typeid( el
).name() );
1768 if( MKV_IS_ID( el
, KaxClusterTimecode
) )
1770 KaxClusterTimecode
&ctc
= *(KaxClusterTimecode
*)el
;
1772 ctc
.ReadData( es
.I_O(), SCOPE_ALL_DATA
);
1773 cluster
->InitTimecode( uint64( ctc
), i_timescale
);
1775 else if( MKV_IS_ID( el
, KaxClusterSilentTracks
) )
1779 else if( MKV_IS_ID( el
, KaxBlockGroup
) )
1781 i_block_pos
= el
->GetElementPosition();
1784 #if LIBMATROSKA_VERSION >= 0x000800
1785 else if( MKV_IS_ID( el
, KaxSimpleBlock
) )
1787 pp_simpleblock
= (KaxSimpleBlock
*)el
;
1789 pp_simpleblock
->ReadData( es
.I_O() );
1790 pp_simpleblock
->SetParent( *cluster
);
1795 if( MKV_IS_ID( el
, KaxBlock
) )
1797 pp_block
= (KaxBlock
*)el
;
1799 pp_block
->ReadData( es
.I_O() );
1800 pp_block
->SetParent( *cluster
);
1804 else if( MKV_IS_ID( el
, KaxBlockDuration
) )
1806 KaxBlockDuration
&dur
= *(KaxBlockDuration
*)el
;
1808 dur
.ReadData( es
.I_O() );
1809 *pi_duration
= uint64( dur
);
1811 else if( MKV_IS_ID( el
, KaxReferenceBlock
) )
1813 KaxReferenceBlock
&ref
= *(KaxReferenceBlock
*)el
;
1815 ref
.ReadData( es
.I_O() );
1818 *pi_ref1
= int64( ref
) * cluster
->GlobalTimecodeScale();
1820 else if( *pi_ref2
== 0 )
1822 *pi_ref2
= int64( ref
) * cluster
->GlobalTimecodeScale();
1825 else if( MKV_IS_ID( el
, KaxClusterSilentTrackNumber
) )
1827 KaxClusterSilentTrackNumber
&track_num
= *(KaxClusterSilentTrackNumber
*)el
;
1828 track_num
.ReadData( es
.I_O() );
1830 for (size_t i
=0; i
<tracks
.size(); i
++)
1832 if ( tracks
[i
]->i_number
== uint32(track_num
))
1834 tracks
[i
]->b_silent
= VLC_TRUE
;
1841 msg_Err( &sys
.demuxer
, "invalid level = %d", i_level
);
1842 return VLC_EGENERIC
;
1847 static block_t
*MemToBlock( demux_t
*p_demux
, uint8_t *p_mem
, int i_mem
, size_t offset
)
1850 if( !(p_block
= block_New( p_demux
, i_mem
+ offset
) ) ) return NULL
;
1851 memcpy( p_block
->p_buffer
+ offset
, p_mem
, i_mem
);
1852 //p_block->i_rate = p_input->stream.control.i_rate;
1856 #if LIBMATROSKA_VERSION >= 0x000800
1857 static void BlockDecode( demux_t
*p_demux
, KaxBlock
*block
, KaxSimpleBlock
*simpleblock
,
1858 mtime_t i_pts
, mtime_t i_duration
, bool f_mandatory
)
1860 static void BlockDecode( demux_t
*p_demux
, KaxBlock
*block
, mtime_t i_pts
,
1861 mtime_t i_duration
, bool f_mandatory
)
1864 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1865 matroska_segment_c
*p_segment
= p_sys
->p_current_segment
->Segment();
1871 #define tk p_segment->tracks[i_track]
1872 for( i_track
= 0; i_track
< p_segment
->tracks
.size(); i_track
++ )
1874 #if LIBMATROSKA_VERSION >= 0x000800
1875 if( (block
!= NULL
&& tk
->i_number
== block
->TrackNum()) ||
1876 (simpleblock
!= NULL
&& tk
->i_number
== simpleblock
->TrackNum()))
1878 if( tk
->i_number
== block
->TrackNum() )
1885 if( i_track
>= p_segment
->tracks
.size() )
1887 msg_Err( p_demux
, "invalid track number=%d", block
->TrackNum() );
1890 if( tk
->fmt
.i_cat
!= NAV_ES
&& tk
->p_es
== NULL
)
1892 msg_Err( p_demux
, "unknown track number=%d", block
->TrackNum() );
1895 if( i_pts
+ i_duration
< p_sys
->i_start_pts
&& tk
->fmt
.i_cat
== AUDIO_ES
)
1897 return; /* discard audio packets that shouldn't be rendered */
1900 if ( tk
->fmt
.i_cat
!= NAV_ES
)
1902 es_out_Control( p_demux
->out
, ES_OUT_GET_ES_STATE
, tk
->p_es
, &b
);
1906 tk
->b_inited
= VLC_FALSE
;
1912 /* First send init data */
1913 if( !tk
->b_inited
&& tk
->i_data_init
> 0 )
1917 msg_Dbg( p_demux
, "sending header (%d bytes)", tk
->i_data_init
);
1918 p_init
= MemToBlock( p_demux
, tk
->p_data_init
, tk
->i_data_init
, 0 );
1919 if( p_init
) es_out_Send( p_demux
->out
, tk
->p_es
, p_init
);
1921 tk
->b_inited
= VLC_TRUE
;
1924 #if LIBMATROSKA_VERSION >= 0x000800
1926 (block
!= NULL
&& i
< block
->NumberFrames()) || (simpleblock
!= NULL
&& i
< simpleblock
->NumberFrames());
1929 for( i
= 0; i
< block
->NumberFrames(); i
++ )
1934 #if LIBMATROSKA_VERSION >= 0x000800
1935 if ( simpleblock
!= NULL
)
1937 data
= &simpleblock
->GetBuffer(i
);
1938 // condition when the DTS is correct (keyframe or B frame == NOT P frame)
1939 f_mandatory
= simpleblock
->IsDiscardable() || simpleblock
->IsKeyframe();
1943 data
= &block
->GetBuffer(i
);
1945 if( tk
->i_compression_type
== MATROSKA_COMPRESSION_HEADER
&& tk
->p_compression_data
!= NULL
)
1946 p_block
= MemToBlock( p_demux
, data
->Buffer(), data
->Size(), tk
->p_compression_data
->GetSize() );
1948 p_block
= MemToBlock( p_demux
, data
->Buffer(), data
->Size(), 0 );
1950 if( p_block
== NULL
)
1955 #if defined(HAVE_ZLIB_H)
1956 if( tk
->i_compression_type
== MATROSKA_COMPRESSION_ZLIB
)
1958 p_block
= block_zlib_decompress( VLC_OBJECT(p_demux
), p_block
);
1962 if( tk
->i_compression_type
== MATROSKA_COMPRESSION_HEADER
)
1964 memcpy( p_block
->p_buffer
, tk
->p_compression_data
->GetBuffer(), tk
->p_compression_data
->GetSize() );
1967 if ( tk
->fmt
.i_cat
== NAV_ES
)
1969 // TODO handle the start/stop times of this packet
1970 if ( p_sys
->b_ui_hooked
)
1972 vlc_mutex_lock( &p_sys
->p_ev
->lock
);
1973 memcpy( &p_sys
->pci_packet
, &p_block
->p_buffer
[1], sizeof(pci_t
) );
1974 p_sys
->SwapButtons();
1975 p_sys
->b_pci_packet_set
= true;
1976 vlc_mutex_unlock( &p_sys
->p_ev
->lock
);
1977 block_Release( p_block
);
1981 // correct timestamping when B frames are used
1982 if( tk
->fmt
.i_cat
!= VIDEO_ES
)
1984 p_block
->i_dts
= p_block
->i_pts
= i_pts
;
1988 if( !strcmp( tk
->psz_codec
, "V_MS/VFW/FOURCC" ) )
1990 // in VFW we have no idea about B frames
1992 p_block
->i_dts
= i_pts
;
1996 p_block
->i_pts
= i_pts
;
1998 p_block
->i_dts
= p_block
->i_pts
;
2000 p_block
->i_dts
= min( i_pts
, tk
->i_last_dts
+ (tk
->i_default_duration
>> 10));
2001 p_sys
->i_pts
= p_block
->i_dts
;
2004 tk
->i_last_dts
= p_block
->i_dts
;
2007 msg_Dbg( p_demux
, "block i_dts: "I64Fd
" / i_pts: "I64Fd
, p_block
->i_dts
, p_block
->i_pts
);
2009 if( strcmp( tk
->psz_codec
, "S_VOBSUB" ) )
2011 p_block
->i_length
= i_duration
* 1000;
2014 es_out_Send( p_demux
->out
, tk
->p_es
, p_block
);
2016 /* use time stamp only for first block */
2023 matroska_stream_c
*demux_sys_t::AnalyseAllSegmentsFound( demux_t
*p_demux
, EbmlStream
*p_estream
, bool b_initial
)
2025 int i_upper_lvl
= 0;
2027 EbmlElement
*p_l0
, *p_l1
, *p_l2
;
2028 bool b_keep_stream
= false, b_keep_segment
;
2030 // verify the EBML Header
2031 p_l0
= p_estream
->FindNextID(EbmlHead::ClassInfos
, 0xFFFFFFFFL
);
2034 msg_Err( p_demux
, "No EBML header found" );
2038 // verify we can read this Segment, we only support Matroska version 1 for now
2039 p_l0
->Read(*p_estream
, EbmlHead::ClassInfos
.Context
, i_upper_lvl
, p_l0
, true);
2041 EDocType doc_type
= GetChild
<EDocType
>(*static_cast<EbmlHead
*>(p_l0
));
2042 if (std::string(doc_type
) != "matroska")
2044 msg_Err( p_demux
, "Not a Matroska file : DocType = %s ", std::string(doc_type
).c_str());
2048 EDocTypeReadVersion doc_read_version
= GetChild
<EDocTypeReadVersion
>(*static_cast<EbmlHead
*>(p_l0
));
2049 #if LIBMATROSKA_VERSION >= 0x000800
2050 if (uint64(doc_read_version
) > 2)
2052 msg_Err( p_demux
, "This matroska file is needs version "I64Fd
" and this VLC only supports version 1 & 2", uint64(doc_read_version
));
2056 if (uint64(doc_read_version
) != 1)
2058 msg_Err( p_demux
, "This matroska file is needs version "I64Fd
" and this VLC only supports version 1", uint64(doc_read_version
));
2066 // find all segments in this file
2067 p_l0
= p_estream
->FindNextID(KaxSegment::ClassInfos
, 0xFFFFFFFFFLL
);
2073 matroska_stream_c
*p_stream1
= new matroska_stream_c( *this );
2077 if (EbmlId(*p_l0
) == KaxSegment::ClassInfos
.GlobalId
)
2080 matroska_segment_c
*p_segment1
= new matroska_segment_c( *this, *p_estream
);
2081 b_keep_segment
= b_initial
;
2083 ep
= new EbmlParser(p_estream
, p_l0
, &demuxer
);
2084 p_segment1
->ep
= ep
;
2085 p_segment1
->segment
= (KaxSegment
*)p_l0
;
2087 while ((p_l1
= ep
->Get()))
2089 if (MKV_IS_ID(p_l1
, KaxInfo
))
2091 // find the families of this segment
2092 KaxInfo
*p_info
= static_cast<KaxInfo
*>(p_l1
);
2094 p_info
->Read(*p_estream
, KaxInfo::ClassInfos
.Context
, i_upper_lvl
, p_l2
, true);
2095 for( i
= 0; i
< p_info
->ListSize(); i
++ )
2097 EbmlElement
*l
= (*p_info
)[i
];
2099 if( MKV_IS_ID( l
, KaxSegmentUID
) )
2101 KaxSegmentUID
*p_uid
= static_cast<KaxSegmentUID
*>(l
);
2102 b_keep_segment
= (FindSegment( *p_uid
) == NULL
);
2103 if ( !b_keep_segment
)
2104 break; // this segment is already known
2105 opened_segments
.push_back( p_segment1
);
2106 delete p_segment1
->p_segment_uid
;
2107 p_segment1
->p_segment_uid
= new KaxSegmentUID(*p_uid
);
2109 else if( MKV_IS_ID( l
, KaxPrevUID
) )
2111 p_segment1
->p_prev_segment_uid
= new KaxPrevUID( *static_cast<KaxPrevUID
*>(l
) );
2113 else if( MKV_IS_ID( l
, KaxNextUID
) )
2115 p_segment1
->p_next_segment_uid
= new KaxNextUID( *static_cast<KaxNextUID
*>(l
) );
2117 else if( MKV_IS_ID( l
, KaxSegmentFamily
) )
2119 KaxSegmentFamily
*p_fam
= new KaxSegmentFamily( *static_cast<KaxSegmentFamily
*>(l
) );
2120 p_segment1
->families
.push_back( p_fam
);
2126 if ( b_keep_segment
)
2128 b_keep_stream
= true;
2129 p_stream1
->segments
.push_back( p_segment1
);
2134 if (p_l0
->IsFiniteSize() )
2136 p_l0
->SkipData(*p_estream
, KaxMatroska_Context
);
2137 p_l0
= p_estream
->FindNextID(KaxSegment::ClassInfos
, 0xFFFFFFFFL
);
2140 p_l0
= p_l0
->SkipData(*p_estream
, KaxSegment_Context
);
2143 if ( !b_keep_stream
)
2152 bool matroska_segment_c::Select( mtime_t i_start_time
)
2157 msg_Dbg( &sys
.demuxer
, "found %d es", (int)tracks
.size() );
2158 sys
.b_pci_packet_set
= false;
2160 for( i_track
= 0; i_track
< tracks
.size(); i_track
++ )
2162 if( tracks
[i_track
]->fmt
.i_cat
== UNKNOWN_ES
)
2164 msg_Warn( &sys
.demuxer
, "invalid track[%d, n=%d]", (int)i_track
, tracks
[i_track
]->i_number
);
2165 tracks
[i_track
]->p_es
= NULL
;
2169 if( !strcmp( tracks
[i_track
]->psz_codec
, "V_MS/VFW/FOURCC" ) )
2171 if( tracks
[i_track
]->i_extra_data
< (int)sizeof( BITMAPINFOHEADER
) )
2173 msg_Err( &sys
.demuxer
, "missing/invalid BITMAPINFOHEADER" );
2174 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'u', 'n', 'd', 'f' );
2178 BITMAPINFOHEADER
*p_bih
= (BITMAPINFOHEADER
*)tracks
[i_track
]->p_extra_data
;
2180 tracks
[i_track
]->fmt
.video
.i_width
= GetDWLE( &p_bih
->biWidth
);
2181 tracks
[i_track
]->fmt
.video
.i_height
= GetDWLE( &p_bih
->biHeight
);
2182 tracks
[i_track
]->fmt
.i_codec
= GetFOURCC( &p_bih
->biCompression
);
2184 tracks
[i_track
]->fmt
.i_extra
= GetDWLE( &p_bih
->biSize
) - sizeof( BITMAPINFOHEADER
);
2185 if( tracks
[i_track
]->fmt
.i_extra
> 0 )
2187 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->fmt
.i_extra
);
2188 memcpy( tracks
[i_track
]->fmt
.p_extra
, &p_bih
[1], tracks
[i_track
]->fmt
.i_extra
);
2192 else if( !strcmp( tracks
[i_track
]->psz_codec
, "V_MPEG1" ) ||
2193 !strcmp( tracks
[i_track
]->psz_codec
, "V_MPEG2" ) )
2195 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'm', 'p', 'g', 'v' );
2197 else if( !strncmp( tracks
[i_track
]->psz_codec
, "V_MPEG4", 7 ) )
2199 if( !strcmp( tracks
[i_track
]->psz_codec
, "V_MPEG4/MS/V3" ) )
2201 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'D', 'I', 'V', '3' );
2203 else if( !strcmp( tracks
[i_track
]->psz_codec
, "V_MPEG4/ISO/AVC" ) )
2205 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'a', 'v', 'c', '1' );
2206 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2207 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2208 memcpy( tracks
[i_track
]->fmt
.p_extra
,tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2212 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'm', 'p', '4', 'v' );
2215 else if( !strcmp( tracks
[i_track
]->psz_codec
, "V_QUICKTIME" ) )
2217 MP4_Box_t
*p_box
= (MP4_Box_t
*)malloc( sizeof( MP4_Box_t
) );
2218 stream_t
*p_mp4_stream
= stream_MemoryNew( VLC_OBJECT(&sys
.demuxer
),
2219 tracks
[i_track
]->p_extra_data
,
2220 tracks
[i_track
]->i_extra_data
,
2222 MP4_ReadBoxCommon( p_mp4_stream
, p_box
);
2223 MP4_ReadBox_sample_vide( p_mp4_stream
, p_box
);
2224 tracks
[i_track
]->fmt
.i_codec
= p_box
->i_type
;
2225 tracks
[i_track
]->fmt
.video
.i_width
= p_box
->data
.p_sample_vide
->i_width
;
2226 tracks
[i_track
]->fmt
.video
.i_height
= p_box
->data
.p_sample_vide
->i_height
;
2227 tracks
[i_track
]->fmt
.i_extra
= p_box
->data
.p_sample_vide
->i_qt_image_description
;
2228 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->fmt
.i_extra
);
2229 memcpy( tracks
[i_track
]->fmt
.p_extra
, p_box
->data
.p_sample_vide
->p_qt_image_description
, tracks
[i_track
]->fmt
.i_extra
);
2230 MP4_FreeBox_sample_vide( p_box
);
2231 stream_Delete( p_mp4_stream
);
2233 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_MS/ACM" ) )
2235 if( tracks
[i_track
]->i_extra_data
< (int)sizeof( WAVEFORMATEX
) )
2237 msg_Err( &sys
.demuxer
, "missing/invalid WAVEFORMATEX" );
2238 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'u', 'n', 'd', 'f' );
2242 WAVEFORMATEX
*p_wf
= (WAVEFORMATEX
*)tracks
[i_track
]->p_extra_data
;
2244 wf_tag_to_fourcc( GetWLE( &p_wf
->wFormatTag
), &tracks
[i_track
]->fmt
.i_codec
, NULL
);
2246 tracks
[i_track
]->fmt
.audio
.i_channels
= GetWLE( &p_wf
->nChannels
);
2247 tracks
[i_track
]->fmt
.audio
.i_rate
= GetDWLE( &p_wf
->nSamplesPerSec
);
2248 tracks
[i_track
]->fmt
.i_bitrate
= GetDWLE( &p_wf
->nAvgBytesPerSec
) * 8;
2249 tracks
[i_track
]->fmt
.audio
.i_blockalign
= GetWLE( &p_wf
->nBlockAlign
);;
2250 tracks
[i_track
]->fmt
.audio
.i_bitspersample
= GetWLE( &p_wf
->wBitsPerSample
);
2252 tracks
[i_track
]->fmt
.i_extra
= GetWLE( &p_wf
->cbSize
);
2253 if( tracks
[i_track
]->fmt
.i_extra
> 0 )
2255 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->fmt
.i_extra
);
2256 memcpy( tracks
[i_track
]->fmt
.p_extra
, &p_wf
[1], tracks
[i_track
]->fmt
.i_extra
);
2260 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_MPEG/L3" ) ||
2261 !strcmp( tracks
[i_track
]->psz_codec
, "A_MPEG/L2" ) ||
2262 !strcmp( tracks
[i_track
]->psz_codec
, "A_MPEG/L1" ) )
2264 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'm', 'p', 'g', 'a' );
2266 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_AC3" ) )
2268 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'a', '5', '2', ' ' );
2270 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_DTS" ) )
2272 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'd', 't', 's', ' ' );
2274 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_FLAC" ) )
2276 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'f', 'l', 'a', 'c' );
2277 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2278 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2279 memcpy( tracks
[i_track
]->fmt
.p_extra
,tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2281 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_VORBIS" ) )
2283 int i
, i_offset
= 1, i_size
[3], i_extra
;
2286 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'v', 'o', 'r', 'b' );
2288 /* Split the 3 headers */
2289 if( tracks
[i_track
]->p_extra_data
[0] != 0x02 )
2290 msg_Err( &sys
.demuxer
, "invalid vorbis header" );
2292 for( i
= 0; i
< 2; i
++ )
2295 while( i_offset
< tracks
[i_track
]->i_extra_data
)
2297 i_size
[i
] += tracks
[i_track
]->p_extra_data
[i_offset
];
2298 if( tracks
[i_track
]->p_extra_data
[i_offset
++] != 0xff ) break;
2302 i_size
[0] = __MIN(i_size
[0], tracks
[i_track
]->i_extra_data
- i_offset
);
2303 i_size
[1] = __MIN(i_size
[1], tracks
[i_track
]->i_extra_data
-i_offset
-i_size
[0]);
2304 i_size
[2] = tracks
[i_track
]->i_extra_data
- i_offset
- i_size
[0] - i_size
[1];
2306 tracks
[i_track
]->fmt
.i_extra
= 3 * 2 + i_size
[0] + i_size
[1] + i_size
[2];
2307 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->fmt
.i_extra
);
2308 p_extra
= (uint8_t *)tracks
[i_track
]->fmt
.p_extra
; i_extra
= 0;
2309 for( i
= 0; i
< 3; i
++ )
2311 *(p_extra
++) = i_size
[i
] >> 8;
2312 *(p_extra
++) = i_size
[i
] & 0xFF;
2313 memcpy( p_extra
, tracks
[i_track
]->p_extra_data
+ i_offset
+ i_extra
,
2315 p_extra
+= i_size
[i
];
2316 i_extra
+= i_size
[i
];
2319 else if( !strncmp( tracks
[i_track
]->psz_codec
, "A_AAC/MPEG2/", strlen( "A_AAC/MPEG2/" ) ) ||
2320 !strncmp( tracks
[i_track
]->psz_codec
, "A_AAC/MPEG4/", strlen( "A_AAC/MPEG4/" ) ) )
2322 int i_profile
, i_srate
, sbr
= 0;
2323 static unsigned int i_sample_rates
[] =
2325 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
2326 16000, 12000, 11025, 8000, 7350, 0, 0, 0
2329 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'm', 'p', '4', 'a' );
2330 /* create data for faad (MP4DecSpecificDescrTag)*/
2332 if( !strcmp( &tracks
[i_track
]->psz_codec
[12], "MAIN" ) )
2336 else if( !strcmp( &tracks
[i_track
]->psz_codec
[12], "LC" ) )
2340 else if( !strcmp( &tracks
[i_track
]->psz_codec
[12], "SSR" ) )
2344 else if( !strcmp( &tracks
[i_track
]->psz_codec
[12], "LC/SBR" ) )
2354 for( i_srate
= 0; i_srate
< 13; i_srate
++ )
2356 if( i_sample_rates
[i_srate
] == tracks
[i_track
]->i_original_rate
)
2361 msg_Dbg( &sys
.demuxer
, "profile=%d srate=%d", i_profile
, i_srate
);
2363 tracks
[i_track
]->fmt
.i_extra
= sbr
? 5 : 2;
2364 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->fmt
.i_extra
);
2365 ((uint8_t*)tracks
[i_track
]->fmt
.p_extra
)[0] = ((i_profile
+ 1) << 3) | ((i_srate
&0xe) >> 1);
2366 ((uint8_t*)tracks
[i_track
]->fmt
.p_extra
)[1] = ((i_srate
& 0x1) << 7) | (tracks
[i_track
]->fmt
.audio
.i_channels
<< 3);
2369 int syncExtensionType
= 0x2B7;
2371 for (iDSRI
=0; iDSRI
<13; iDSRI
++)
2372 if( i_sample_rates
[iDSRI
] == tracks
[i_track
]->fmt
.audio
.i_rate
)
2374 ((uint8_t*)tracks
[i_track
]->fmt
.p_extra
)[2] = (syncExtensionType
>> 3) & 0xFF;
2375 ((uint8_t*)tracks
[i_track
]->fmt
.p_extra
)[3] = ((syncExtensionType
& 0x7) << 5) | 5;
2376 ((uint8_t*)tracks
[i_track
]->fmt
.p_extra
)[4] = ((1 & 0x1) << 7) | (iDSRI
<< 3);
2379 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_AAC" ) )
2381 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'm', 'p', '4', 'a' );
2382 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2383 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2384 memcpy( tracks
[i_track
]->fmt
.p_extra
, tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2386 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_PCM/INT/BIG" ) ||
2387 !strcmp( tracks
[i_track
]->psz_codec
, "A_PCM/INT/LIT" ) ||
2388 !strcmp( tracks
[i_track
]->psz_codec
, "A_PCM/FLOAT/IEEE" ) )
2390 if( !strcmp( tracks
[i_track
]->psz_codec
, "A_PCM/INT/BIG" ) )
2392 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 't', 'w', 'o', 's' );
2396 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'a', 'r', 'a', 'w' );
2398 tracks
[i_track
]->fmt
.audio
.i_blockalign
= ( tracks
[i_track
]->fmt
.audio
.i_bitspersample
+ 7 ) / 8 * tracks
[i_track
]->fmt
.audio
.i_channels
;
2400 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_TTA1" ) )
2402 /* FIXME: support this codec */
2403 msg_Err( &sys
.demuxer
, "TTA not supported yet[%d, n=%d]", (int)i_track
, tracks
[i_track
]->i_number
);
2404 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'u', 'n', 'd', 'f' );
2406 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_WAVPACK4" ) )
2408 /* FIXME: support this codec */
2409 msg_Err( &sys
.demuxer
, "Wavpack not supported yet[%d, n=%d]", (int)i_track
, tracks
[i_track
]->i_number
);
2410 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'u', 'n', 'd', 'f' );
2412 else if( !strcmp( tracks
[i_track
]->psz_codec
, "S_TEXT/UTF8" ) )
2414 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 's', 'u', 'b', 't' );
2415 tracks
[i_track
]->fmt
.subs
.psz_encoding
= strdup( "UTF-8" );
2417 else if( !strcmp( tracks
[i_track
]->psz_codec
, "S_TEXT/SSA" ) ||
2418 !strcmp( tracks
[i_track
]->psz_codec
, "S_TEXT/ASS" ) ||
2419 !strcmp( tracks
[i_track
]->psz_codec
, "S_SSA" ) ||
2420 !strcmp( tracks
[i_track
]->psz_codec
, "S_ASS" ))
2422 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 's', 's', 'a', ' ' );
2423 tracks
[i_track
]->fmt
.subs
.psz_encoding
= strdup( "UTF-8" );
2424 if( tracks
[i_track
]->i_extra_data
)
2426 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2427 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2428 memcpy( tracks
[i_track
]->fmt
.p_extra
, tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2431 else if( !strcmp( tracks
[i_track
]->psz_codec
, "S_VOBSUB" ) )
2433 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 's','p','u',' ' );
2434 if( tracks
[i_track
]->i_extra_data
)
2437 char *p_buf
= (char *)malloc( tracks
[i_track
]->i_extra_data
+ 1);
2438 memcpy( p_buf
, tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2439 p_buf
[tracks
[i_track
]->i_extra_data
] = '\0';
2441 p_start
= strstr( p_buf
, "size:" );
2442 if( sscanf( p_start
, "size: %dx%d",
2443 &tracks
[i_track
]->fmt
.subs
.spu
.i_original_frame_width
, &tracks
[i_track
]->fmt
.subs
.spu
.i_original_frame_height
) == 2 )
2445 msg_Dbg( &sys
.demuxer
, "original frame size vobsubs: %dx%d", tracks
[i_track
]->fmt
.subs
.spu
.i_original_frame_width
, tracks
[i_track
]->fmt
.subs
.spu
.i_original_frame_height
);
2449 msg_Warn( &sys
.demuxer
, "reading original frame size for vobsub failed" );
2454 else if( !strcmp( tracks
[i_track
]->psz_codec
, "B_VOBBTN" ) )
2456 tracks
[i_track
]->fmt
.i_cat
= NAV_ES
;
2461 msg_Err( &sys
.demuxer
, "unknow codec id=`%s'", tracks
[i_track
]->psz_codec
);
2462 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'u', 'n', 'd', 'f' );
2464 if( tracks
[i_track
]->b_default
)
2466 tracks
[i_track
]->fmt
.i_priority
= 1000;
2469 tracks
[i_track
]->p_es
= es_out_Add( sys
.demuxer
.out
, &tracks
[i_track
]->fmt
);
2471 es_out_Control( sys
.demuxer
.out
, ES_OUT_SET_NEXT_DISPLAY_TIME
, tracks
[i_track
]->p_es
, i_start_time
);
2474 sys
.i_start_pts
= i_start_time
;
2475 // reset the stream reading to the first cluster of the segment used
2476 es
.I_O().setFilePointer( i_start_pos
);
2479 ep
= new EbmlParser( &es
, segment
, &sys
.demuxer
);
2484 void demux_sys_t::StartUiThread()
2488 msg_Dbg( &demuxer
, "Starting the UI Hook" );
2490 /* FIXME hack hack hack hack FIXME */
2491 /* Get p_input and create variable */
2492 p_input
= (input_thread_t
*) vlc_object_find( &demuxer
, VLC_OBJECT_INPUT
, FIND_PARENT
);
2493 var_Create( p_input
, "x-start", VLC_VAR_INTEGER
);
2494 var_Create( p_input
, "y-start", VLC_VAR_INTEGER
);
2495 var_Create( p_input
, "x-end", VLC_VAR_INTEGER
);
2496 var_Create( p_input
, "y-end", VLC_VAR_INTEGER
);
2497 var_Create( p_input
, "color", VLC_VAR_ADDRESS
);
2498 var_Create( p_input
, "menu-palette", VLC_VAR_ADDRESS
);
2499 var_Create( p_input
, "highlight", VLC_VAR_BOOL
);
2500 var_Create( p_input
, "highlight-mutex", VLC_VAR_MUTEX
);
2502 /* Now create our event thread catcher */
2503 p_ev
= (event_thread_t
*) vlc_object_create( &demuxer
, sizeof( event_thread_t
) );
2504 p_ev
->p_demux
= &demuxer
;
2505 p_ev
->b_die
= VLC_FALSE
;
2506 vlc_mutex_init( p_ev
, &p_ev
->lock
);
2507 vlc_thread_create( p_ev
, "mkv event thread handler", EventThread
,
2508 VLC_THREAD_PRIORITY_LOW
, VLC_FALSE
);
2512 void demux_sys_t::StopUiThread()
2516 p_ev
->b_die
= VLC_TRUE
;
2518 vlc_thread_join( p_ev
);
2519 vlc_object_destroy( p_ev
);
2523 var_Destroy( p_input
, "highlight-mutex" );
2524 var_Destroy( p_input
, "highlight" );
2525 var_Destroy( p_input
, "x-start" );
2526 var_Destroy( p_input
, "x-end" );
2527 var_Destroy( p_input
, "y-start" );
2528 var_Destroy( p_input
, "y-end" );
2529 var_Destroy( p_input
, "color" );
2530 var_Destroy( p_input
, "menu-palette" );
2532 vlc_object_release( p_input
);
2534 msg_Dbg( &demuxer
, "Stopping the UI Hook" );
2536 b_ui_hooked
= false;
2539 int demux_sys_t::EventMouse( vlc_object_t
*p_this
, char const *psz_var
,
2540 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
)
2542 event_thread_t
*p_ev
= (event_thread_t
*) p_data
;
2543 vlc_mutex_lock( &p_ev
->lock
);
2544 if( psz_var
[6] == 'c' )
2546 p_ev
->b_clicked
= VLC_TRUE
;
2547 msg_Dbg( p_this
, "Event Mouse: clicked");
2549 else if( psz_var
[6] == 'm' )
2550 p_ev
->b_moved
= VLC_TRUE
;
2551 vlc_mutex_unlock( &p_ev
->lock
);
2556 int demux_sys_t::EventKey( vlc_object_t
*p_this
, char const *psz_var
,
2557 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
)
2559 event_thread_t
*p_ev
= (event_thread_t
*) p_data
;
2560 vlc_mutex_lock( &p_ev
->lock
);
2561 p_ev
->b_key
= VLC_TRUE
;
2562 vlc_mutex_unlock( &p_ev
->lock
);
2563 msg_Dbg( p_this
, "Event Key");
2568 int demux_sys_t::EventThread( vlc_object_t
*p_this
)
2570 event_thread_t
*p_ev
= (event_thread_t
*)p_this
;
2571 demux_sys_t
*p_sys
= p_ev
->p_demux
->p_sys
;
2572 vlc_object_t
*p_vout
= NULL
;
2574 p_ev
->b_moved
= VLC_FALSE
;
2575 p_ev
->b_clicked
= VLC_FALSE
;
2576 p_ev
->b_key
= VLC_FALSE
;
2578 /* catch all key event */
2579 var_AddCallback( p_ev
->p_vlc
, "key-pressed", EventKey
, p_ev
);
2582 while( !p_ev
->b_die
)
2584 if ( !p_sys
->b_pci_packet_set
)
2591 vlc_bool_t b_activated
= VLC_FALSE
;
2597 struct vlc_t::hotkey
*p_hotkeys
= p_ev
->p_vlc
->p_hotkeys
;
2598 int i
, i_action
= -1;
2600 msg_Dbg( p_ev
->p_demux
, "Handle Key Event");
2602 vlc_mutex_lock( &p_ev
->lock
);
2604 pci_t
*pci
= (pci_t
*) &p_sys
->pci_packet
;
2606 var_Get( p_ev
->p_vlc
, "key-pressed", &valk
);
2607 for( i
= 0; p_hotkeys
[i
].psz_action
!= NULL
; i
++ )
2609 if( p_hotkeys
[i
].i_key
== valk
.i_int
)
2611 i_action
= p_hotkeys
[i
].i_action
;
2615 uint16 i_curr_button
= p_sys
->dvd_interpretor
.GetSPRM( 0x88 );
2619 case ACTIONID_NAV_LEFT
:
2620 if ( i_curr_button
> 0 && i_curr_button
<= pci
->hli
.hl_gi
.btn_ns
)
2622 btni_t
*p_button_ptr
= &(pci
->hli
.btnit
[i_curr_button
-1]);
2623 if ( p_button_ptr
->left
> 0 && p_button_ptr
->left
<= pci
->hli
.hl_gi
.btn_ns
)
2625 i_curr_button
= p_button_ptr
->left
;
2626 p_sys
->dvd_interpretor
.SetSPRM( 0x88, i_curr_button
);
2627 btni_t button_ptr
= pci
->hli
.btnit
[i_curr_button
-1];
2628 if ( button_ptr
.auto_action_mode
)
2630 vlc_mutex_unlock( &p_ev
->lock
);
2631 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2633 // process the button action
2634 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2636 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2637 vlc_mutex_lock( &p_ev
->lock
);
2642 case ACTIONID_NAV_RIGHT
:
2643 if ( i_curr_button
> 0 && i_curr_button
<= pci
->hli
.hl_gi
.btn_ns
)
2645 btni_t
*p_button_ptr
= &(pci
->hli
.btnit
[i_curr_button
-1]);
2646 if ( p_button_ptr
->right
> 0 && p_button_ptr
->right
<= pci
->hli
.hl_gi
.btn_ns
)
2648 i_curr_button
= p_button_ptr
->right
;
2649 p_sys
->dvd_interpretor
.SetSPRM( 0x88, i_curr_button
);
2650 btni_t button_ptr
= pci
->hli
.btnit
[i_curr_button
-1];
2651 if ( button_ptr
.auto_action_mode
)
2653 vlc_mutex_unlock( &p_ev
->lock
);
2654 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2656 // process the button action
2657 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2659 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2660 vlc_mutex_lock( &p_ev
->lock
);
2665 case ACTIONID_NAV_UP
:
2666 if ( i_curr_button
> 0 && i_curr_button
<= pci
->hli
.hl_gi
.btn_ns
)
2668 btni_t
*p_button_ptr
= &(pci
->hli
.btnit
[i_curr_button
-1]);
2669 if ( p_button_ptr
->up
> 0 && p_button_ptr
->up
<= pci
->hli
.hl_gi
.btn_ns
)
2671 i_curr_button
= p_button_ptr
->up
;
2672 p_sys
->dvd_interpretor
.SetSPRM( 0x88, i_curr_button
);
2673 btni_t button_ptr
= pci
->hli
.btnit
[i_curr_button
-1];
2674 if ( button_ptr
.auto_action_mode
)
2676 vlc_mutex_unlock( &p_ev
->lock
);
2677 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2679 // process the button action
2680 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2682 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2683 vlc_mutex_lock( &p_ev
->lock
);
2688 case ACTIONID_NAV_DOWN
:
2689 if ( i_curr_button
> 0 && i_curr_button
<= pci
->hli
.hl_gi
.btn_ns
)
2691 btni_t
*p_button_ptr
= &(pci
->hli
.btnit
[i_curr_button
-1]);
2692 if ( p_button_ptr
->down
> 0 && p_button_ptr
->down
<= pci
->hli
.hl_gi
.btn_ns
)
2694 i_curr_button
= p_button_ptr
->down
;
2695 p_sys
->dvd_interpretor
.SetSPRM( 0x88, i_curr_button
);
2696 btni_t button_ptr
= pci
->hli
.btnit
[i_curr_button
-1];
2697 if ( button_ptr
.auto_action_mode
)
2699 vlc_mutex_unlock( &p_ev
->lock
);
2700 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2702 // process the button action
2703 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2705 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2706 vlc_mutex_lock( &p_ev
->lock
);
2711 case ACTIONID_NAV_ACTIVATE
:
2712 b_activated
= VLC_TRUE
;
2714 if ( i_curr_button
> 0 && i_curr_button
<= pci
->hli
.hl_gi
.btn_ns
)
2716 btni_t button_ptr
= pci
->hli
.btnit
[i_curr_button
-1];
2718 vlc_mutex_unlock( &p_ev
->lock
);
2719 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2721 // process the button action
2722 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2724 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2725 vlc_mutex_lock( &p_ev
->lock
);
2731 p_ev
->b_key
= VLC_FALSE
;
2732 vlc_mutex_unlock( &p_ev
->lock
);
2736 if( p_vout
&& ( p_ev
->b_moved
|| p_ev
->b_clicked
) )
2738 vlc_value_t valx
, valy
;
2740 vlc_mutex_lock( &p_ev
->lock
);
2741 pci_t
*pci
= (pci_t
*) &p_sys
->pci_packet
;
2742 var_Get( p_vout
, "mouse-x", &valx
);
2743 var_Get( p_vout
, "mouse-y", &valy
);
2745 if( p_ev
->b_clicked
)
2748 int32_t best
,dist
,d
;
2749 int32_t mx
,my
,dx
,dy
;
2751 msg_Dbg( p_ev
->p_demux
, "Handle Mouse Event: Mouse clicked x(%d)*y(%d)", (unsigned)valx
.i_int
, (unsigned)valy
.i_int
);
2753 b_activated
= VLC_TRUE
;
2754 // get current button
2756 dist
= 0x08000000; /* >> than (720*720)+(567*567); */
2757 for(button
= 1; button
<= pci
->hli
.hl_gi
.btn_ns
; button
++)
2759 btni_t
*button_ptr
= &(pci
->hli
.btnit
[button
-1]);
2761 if(((unsigned)valx
.i_int
>= button_ptr
->x_start
)
2762 && ((unsigned)valx
.i_int
<= button_ptr
->x_end
)
2763 && ((unsigned)valy
.i_int
>= button_ptr
->y_start
)
2764 && ((unsigned)valy
.i_int
<= button_ptr
->y_end
))
2766 mx
= (button_ptr
->x_start
+ button_ptr
->x_end
)/2;
2767 my
= (button_ptr
->y_start
+ button_ptr
->y_end
)/2;
2768 dx
= mx
- valx
.i_int
;
2769 dy
= my
- valy
.i_int
;
2770 d
= (dx
*dx
) + (dy
*dy
);
2771 /* If the mouse is within the button and the mouse is closer
2772 * to the center of this button then it is the best choice. */
2782 btni_t button_ptr
= pci
->hli
.btnit
[best
-1];
2783 uint16 i_curr_button
= p_sys
->dvd_interpretor
.GetSPRM( 0x88 );
2785 msg_Dbg( &p_sys
->demuxer
, "Clicked button %d", best
);
2786 vlc_mutex_unlock( &p_ev
->lock
);
2787 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2789 // process the button action
2790 p_sys
->dvd_interpretor
.SetSPRM( 0x88, best
);
2791 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2793 msg_Dbg( &p_sys
->demuxer
, "Processed button %d", best
);
2795 // select new button
2796 if ( best
!= i_curr_button
)
2800 if( var_Get( p_sys
->p_input
, "highlight-mutex", &val
) == VLC_SUCCESS
)
2802 vlc_mutex_t
*p_mutex
= (vlc_mutex_t
*) val
.p_address
;
2805 if(button_ptr
.btn_coln
!= 0) {
2806 i_palette
= pci
->hli
.btn_colit
.btn_coli
[button_ptr
.btn_coln
-1][1];
2811 for( int i
= 0; i
< 4; i
++ )
2813 uint32_t i_yuv
= 0xFF;//p_sys->clut[(hl.palette>>(16+i*4))&0x0f];
2814 uint8_t i_alpha
= (i_palette
>>(i
*4))&0x0f;
2815 i_alpha
= i_alpha
== 0xf ? 0xff : i_alpha
<< 4;
2817 p_sys
->palette
[i
][0] = (i_yuv
>> 16) & 0xff;
2818 p_sys
->palette
[i
][1] = (i_yuv
>> 0) & 0xff;
2819 p_sys
->palette
[i
][2] = (i_yuv
>> 8) & 0xff;
2820 p_sys
->palette
[i
][3] = i_alpha
;
2823 vlc_mutex_lock( p_mutex
);
2824 val
.i_int
= button_ptr
.x_start
; var_Set( p_sys
->p_input
, "x-start", val
);
2825 val
.i_int
= button_ptr
.x_end
; var_Set( p_sys
->p_input
, "x-end", val
);
2826 val
.i_int
= button_ptr
.y_start
; var_Set( p_sys
->p_input
, "y-start", val
);
2827 val
.i_int
= button_ptr
.y_end
; var_Set( p_sys
->p_input
, "y-end", val
);
2829 val
.p_address
= (void *)p_sys
->palette
;
2830 var_Set( p_sys
->p_input
, "menu-palette", val
);
2832 val
.b_bool
= VLC_TRUE
; var_Set( p_sys
->p_input
, "highlight", val
);
2833 vlc_mutex_unlock( p_mutex
);
2836 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2837 vlc_mutex_lock( &p_ev
->lock
);
2840 else if( p_ev
->b_moved
)
2842 // dvdnav_mouse_select( NULL, pci, valx.i_int, valy.i_int );
2845 p_ev
->b_moved
= VLC_FALSE
;
2846 p_ev
->b_clicked
= VLC_FALSE
;
2847 vlc_mutex_unlock( &p_ev
->lock
);
2851 if( p_vout
&& p_vout
->b_die
)
2853 var_DelCallback( p_vout
, "mouse-moved", EventMouse
, p_ev
);
2854 var_DelCallback( p_vout
, "mouse-clicked", EventMouse
, p_ev
);
2855 vlc_object_release( p_vout
);
2859 else if( p_vout
== NULL
)
2861 p_vout
= (vlc_object_t
*) vlc_object_find( p_sys
->p_input
, VLC_OBJECT_VOUT
,
2865 var_AddCallback( p_vout
, "mouse-moved", EventMouse
, p_ev
);
2866 var_AddCallback( p_vout
, "mouse-clicked", EventMouse
, p_ev
);
2870 /* Wait a bit, 10ms */
2874 /* Release callback */
2877 var_DelCallback( p_vout
, "mouse-moved", EventMouse
, p_ev
);
2878 var_DelCallback( p_vout
, "mouse-clicked", EventMouse
, p_ev
);
2879 vlc_object_release( p_vout
);
2881 var_DelCallback( p_ev
->p_vlc
, "key-pressed", EventKey
, p_ev
);
2883 vlc_mutex_destroy( &p_ev
->lock
);
2888 void matroska_segment_c::UnSelect( )
2892 for( i_track
= 0; i_track
< tracks
.size(); i_track
++ )
2894 if ( tracks
[i_track
]->p_es
!= NULL
)
2896 // es_format_Clean( &tracks[i_track]->fmt );
2897 es_out_Del( sys
.demuxer
.out
, tracks
[i_track
]->p_es
);
2898 tracks
[i_track
]->p_es
= NULL
;
2905 void virtual_segment_c::PrepareChapters( )
2907 if ( linked_segments
.size() == 0 )
2910 // !!! should be called only once !!!
2911 matroska_segment_c
*p_segment
;
2914 // copy editions from the first segment
2915 p_segment
= linked_segments
[0];
2916 p_editions
= &p_segment
->stored_editions
;
2918 for ( i
=1 ; i
<linked_segments
.size(); i
++ )
2920 p_segment
= linked_segments
[i
];
2921 // FIXME assume we have the same editions in all segments
2922 for (j
=0; j
<p_segment
->stored_editions
.size(); j
++)
2923 (*p_editions
)[j
]->Append( *p_segment
->stored_editions
[j
] );
2927 std::string
chapter_edition_c::GetMainName() const
2929 if ( sub_chapters
.size() )
2931 return sub_chapters
[0]->GetCodecName( true );
2936 int chapter_item_c::PublishChapters( input_title_t
& title
, int & i_user_chapters
, int i_level
)
2938 // add support for meta-elements from codec like DVD Titles
2939 if ( !b_display_seekpoint
|| psz_name
== "" )
2941 psz_name
= GetCodecName();
2942 if ( psz_name
!= "" )
2943 b_display_seekpoint
= true;
2946 if (b_display_seekpoint
)
2948 seekpoint_t
*sk
= vlc_seekpoint_New();
2950 sk
->i_level
= i_level
;
2951 sk
->i_time_offset
= i_start_time
;
2952 sk
->psz_name
= strdup( psz_name
.c_str() );
2954 // A start time of '0' is ok. A missing ChapterTime element is ok, too, because '0' is its default value.
2955 title
.i_seekpoint
++;
2956 title
.seekpoint
= (seekpoint_t
**)realloc( title
.seekpoint
, title
.i_seekpoint
* sizeof( seekpoint_t
* ) );
2957 title
.seekpoint
[title
.i_seekpoint
-1] = sk
;
2959 if ( b_user_display
)
2963 for ( size_t i
=0; i
<sub_chapters
.size() ; i
++)
2965 sub_chapters
[i
]->PublishChapters( title
, i_user_chapters
, i_level
+1 );
2968 i_seekpoint_num
= i_user_chapters
;
2970 return i_user_chapters
;
2973 bool virtual_segment_c::UpdateCurrentToChapter( demux_t
& demux
)
2975 demux_sys_t
& sys
= *demux
.p_sys
;
2976 chapter_item_c
*psz_curr_chapter
;
2977 bool b_has_seeked
= false;
2979 /* update current chapter/seekpoint */
2980 if ( p_editions
->size() )
2982 /* 1st, we need to know in which chapter we are */
2983 psz_curr_chapter
= (*p_editions
)[i_current_edition
]->FindTimecode( sys
.i_pts
, psz_current_chapter
);
2985 /* we have moved to a new chapter */
2986 if (psz_curr_chapter
!= NULL
&& psz_current_chapter
!= psz_curr_chapter
)
2988 if ( (*p_editions
)[i_current_edition
]->b_ordered
)
2990 // Leave/Enter up to the link point
2991 b_has_seeked
= psz_curr_chapter
->EnterAndLeave( psz_current_chapter
);
2992 if ( !b_has_seeked
)
2994 // only physically seek if necessary
2995 if ( psz_current_chapter
== NULL
|| (psz_current_chapter
->i_end_time
!= psz_curr_chapter
->i_start_time
) )
2996 Seek( demux
, sys
.i_pts
, 0, psz_curr_chapter
);
3000 if ( !b_has_seeked
)
3002 psz_current_chapter
= psz_curr_chapter
;
3003 if ( psz_curr_chapter
->i_seekpoint_num
> 0 )
3005 demux
.info
.i_update
|= INPUT_UPDATE_TITLE
| INPUT_UPDATE_SEEKPOINT
;
3006 demux
.info
.i_title
= sys
.i_current_title
= i_sys_title
;
3007 demux
.info
.i_seekpoint
= psz_curr_chapter
->i_seekpoint_num
- 1;
3013 else if (psz_curr_chapter
== NULL
)
3015 // out of the scope of the data described by chapters, leave the edition
3016 if ( (*p_editions
)[i_current_edition
]->b_ordered
&& psz_current_chapter
!= NULL
)
3018 if ( !(*p_editions
)[i_current_edition
]->EnterAndLeave( psz_current_chapter
, false ) )
3019 psz_current_chapter
= NULL
;
3028 chapter_item_c
*virtual_segment_c::BrowseCodecPrivate( unsigned int codec_id
,
3029 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
3030 const void *p_cookie
,
3031 size_t i_cookie_size
)
3033 // FIXME don't assume it is the first edition
3034 std::vector
<chapter_edition_c
*>::iterator index
= p_editions
->begin();
3035 if ( index
!= p_editions
->end() )
3037 chapter_item_c
*p_result
= (*index
)->BrowseCodecPrivate( codec_id
, match
, p_cookie
, i_cookie_size
);
3038 if ( p_result
!= NULL
)
3044 chapter_item_c
*virtual_segment_c::FindChapter( int64_t i_find_uid
)
3046 // FIXME don't assume it is the first edition
3047 std::vector
<chapter_edition_c
*>::iterator index
= p_editions
->begin();
3048 if ( index
!= p_editions
->end() )
3050 chapter_item_c
*p_result
= (*index
)->FindChapter( i_find_uid
);
3051 if ( p_result
!= NULL
)
3057 chapter_item_c
*chapter_item_c::BrowseCodecPrivate( unsigned int codec_id
,
3058 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
3059 const void *p_cookie
,
3060 size_t i_cookie_size
)
3063 std::vector
<chapter_codec_cmds_c
*>::const_iterator index
= codecs
.begin();
3064 while ( index
!= codecs
.end() )
3066 if ( match( **index
,p_cookie
, i_cookie_size
) )
3072 chapter_item_c
*p_result
= NULL
;
3073 std::vector
<chapter_item_c
*>::const_iterator index2
= sub_chapters
.begin();
3074 while ( index2
!= sub_chapters
.end() )
3076 p_result
= (*index2
)->BrowseCodecPrivate( codec_id
, match
, p_cookie
, i_cookie_size
);
3077 if ( p_result
!= NULL
)
3085 void chapter_item_c::Append( const chapter_item_c
& chapter
)
3087 // we are appending content for the same chapter UID
3089 chapter_item_c
*p_chapter
;
3091 for ( i
=0; i
<chapter
.sub_chapters
.size(); i
++ )
3093 p_chapter
= FindChapter( chapter
.sub_chapters
[i
]->i_uid
);
3094 if ( p_chapter
!= NULL
)
3096 p_chapter
->Append( *chapter
.sub_chapters
[i
] );
3100 sub_chapters
.push_back( chapter
.sub_chapters
[i
] );
3104 i_user_start_time
= min( i_user_start_time
, chapter
.i_user_start_time
);
3105 i_user_end_time
= max( i_user_end_time
, chapter
.i_user_end_time
);
3108 chapter_item_c
* chapter_item_c::FindChapter( int64_t i_find_uid
)
3111 chapter_item_c
*p_result
= NULL
;
3113 if ( i_uid
== i_find_uid
)
3116 for ( i
=0; i
<sub_chapters
.size(); i
++)
3118 p_result
= sub_chapters
[i
]->FindChapter( i_find_uid
);
3119 if ( p_result
!= NULL
)
3125 std::string
chapter_item_c::GetCodecName( bool f_for_title
) const
3129 std::vector
<chapter_codec_cmds_c
*>::const_iterator index
= codecs
.begin();
3130 while ( index
!= codecs
.end() )
3132 result
= (*index
)->GetCodecName( f_for_title
);
3141 std::string
dvd_chapter_codec_c::GetCodecName( bool f_for_title
) const
3144 if ( p_private_data
->GetSize() >= 3)
3146 const binary
* p_data
= p_private_data
->GetBuffer();
3147 /* if ( p_data[0] == MATROSKA_DVD_LEVEL_TT )
3149 uint16_t i_title = (p_data[1] << 8) + p_data[2];
3151 sprintf( psz_str, " %d ---", i_title );
3152 result = N_("--- DVD Title");
3155 else */ if ( p_data
[0] == MATROSKA_DVD_LEVEL_LU
)
3158 sprintf( psz_str
, " (%c%c) ---", p_data
[1], p_data
[2] );
3159 result
= N_("--- DVD Menu");
3162 else if ( p_data
[0] == MATROSKA_DVD_LEVEL_SS
&& f_for_title
)
3164 if ( p_data
[1] == 0x00 )
3165 result
= N_("First Played");
3166 else if ( p_data
[1] == 0xC0 )
3167 result
= N_("Video Manager");
3168 else if ( p_data
[1] == 0x80 )
3170 uint16_t i_title
= (p_data
[2] << 8) + p_data
[3];
3172 sprintf( psz_str
, " %d -----", i_title
);
3173 result
= N_("----- Title");
3182 int16
chapter_item_c::GetTitleNumber( ) const
3186 std::vector
<chapter_codec_cmds_c
*>::const_iterator index
= codecs
.begin();
3187 while ( index
!= codecs
.end() )
3189 result
= (*index
)->GetTitleNumber( );
3198 int16
dvd_chapter_codec_c::GetTitleNumber()
3200 if ( p_private_data
->GetSize() >= 3)
3202 const binary
* p_data
= p_private_data
->GetBuffer();
3203 if ( p_data
[0] == MATROSKA_DVD_LEVEL_SS
)
3205 return int16( (p_data
[2] << 8) + p_data
[3] );
3211 static void Seek( demux_t
*p_demux
, mtime_t i_date
, double f_percent
, chapter_item_c
*psz_chapter
)
3213 demux_sys_t
*p_sys
= p_demux
->p_sys
;
3214 virtual_segment_c
*p_vsegment
= p_sys
->p_current_segment
;
3215 matroska_segment_c
*p_segment
= p_vsegment
->Segment();
3216 mtime_t i_time_offset
= 0;
3220 msg_Dbg( p_demux
, "seek request to "I64Fd
" (%f%%)", i_date
, f_percent
);
3221 if( i_date
< 0 && f_percent
< 0 )
3223 msg_Warn( p_demux
, "cannot seek nowhere !" );
3226 if( f_percent
> 1.0 )
3228 msg_Warn( p_demux
, "cannot seek so far !" );
3232 /* seek without index or without date */
3233 if( f_percent
>= 0 && (config_GetInt( p_demux
, "mkv-seek-percent" ) || !p_segment
->b_cues
|| i_date
< 0 ))
3235 if (p_sys
->f_duration
>= 0)
3237 i_date
= int64_t( f_percent
* p_sys
->f_duration
* 1000.0 );
3241 int64_t i_pos
= int64_t( f_percent
* stream_Size( p_demux
->s
) );
3243 msg_Dbg( p_demux
, "inacurate way of seeking" );
3244 for( i_index
= 0; i_index
< p_segment
->i_index
; i_index
++ )
3246 if( p_segment
->p_indexes
[i_index
].i_position
>= i_pos
)
3251 if( i_index
== p_segment
->i_index
)
3256 i_date
= p_segment
->p_indexes
[i_index
].i_time
;
3259 if( p_segment
->p_indexes
[i_index
].i_position
< i_pos
)
3263 msg_Warn( p_demux
, "searching for cluster, could take some time" );
3265 /* search a cluster */
3266 while( ( el
= p_sys
->ep
->Get() ) != NULL
)
3268 if( MKV_IS_ID( el
, KaxCluster
) )
3270 KaxCluster
*cluster
= (KaxCluster
*)el
;
3272 /* add it to the index */
3273 p_segment
->IndexAppendCluster( cluster
);
3275 if( (int64_t)cluster
->GetElementPosition() >= i_pos
)
3277 p_sys
->cluster
= cluster
;
3288 p_vsegment
->Seek( *p_demux
, i_date
, i_time_offset
, psz_chapter
);
3291 /*****************************************************************************
3292 * Demux: reads and demuxes data packets
3293 *****************************************************************************
3294 * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
3295 *****************************************************************************/
3296 static int Demux( demux_t
*p_demux
)
3298 demux_sys_t
*p_sys
= p_demux
->p_sys
;
3300 vlc_mutex_lock( &p_sys
->lock_demuxer
);
3302 virtual_segment_c
*p_vsegment
= p_sys
->p_current_segment
;
3303 matroska_segment_c
*p_segment
= p_vsegment
->Segment();
3304 if ( p_segment
== NULL
) return 0;
3305 int i_block_count
= 0;
3310 if ( p_sys
->demuxer
.b_die
)
3313 if( p_sys
->i_pts
>= p_sys
->i_start_pts
)
3314 if ( p_vsegment
->UpdateCurrentToChapter( *p_demux
) )
3320 if ( p_vsegment
->Edition() && p_vsegment
->Edition()->b_ordered
&& p_vsegment
->CurrentChapter() == NULL
)
3322 /* nothing left to read in this ordered edition */
3323 if ( !p_vsegment
->SelectNext() )
3325 p_segment
->UnSelect( );
3327 es_out_Control( p_demux
->out
, ES_OUT_RESET_PCR
);
3329 /* switch to the next segment */
3330 p_segment
= p_vsegment
->Segment();
3331 if ( !p_segment
->Select( 0 ) )
3333 msg_Err( p_demux
, "Failed to select new segment" );
3340 int64_t i_block_duration
= 0;
3341 int64_t i_block_ref1
;
3342 int64_t i_block_ref2
;
3344 #if LIBMATROSKA_VERSION >= 0x000800
3345 KaxSimpleBlock
*simpleblock
;
3347 if( p_segment
->BlockGet( block
, simpleblock
, &i_block_ref1
, &i_block_ref2
, &i_block_duration
) )
3349 if( p_segment
->BlockGet( block
, &i_block_ref1
, &i_block_ref2
, &i_block_duration
) )
3352 if ( p_vsegment
->Edition() && p_vsegment
->Edition()->b_ordered
)
3354 const chapter_item_c
*p_chap
= p_vsegment
->CurrentChapter();
3355 // check if there are more chapters to read
3356 if ( p_chap
!= NULL
)
3358 /* TODO handle successive chapters with the same user_start_time/user_end_time
3359 if ( p_chap->i_user_start_time == p_chap->i_user_start_time )
3360 p_vsegment->SelectNext();
3362 p_sys
->i_pts
= p_chap
->i_user_end_time
;
3363 p_sys
->i_pts
++; // trick to avoid staying on segments with no duration and no content
3372 msg_Warn( p_demux
, "cannot get block EOF?" );
3373 p_segment
->UnSelect( );
3375 es_out_Control( p_demux
->out
, ES_OUT_RESET_PCR
);
3377 /* switch to the next segment */
3378 if ( !p_vsegment
->SelectNext() )
3379 // no more segments in this stream
3381 p_segment
= p_vsegment
->Segment();
3382 if ( !p_segment
->Select( 0 ) )
3384 msg_Err( p_demux
, "Failed to select new segment" );
3392 #if LIBMATROSKA_VERSION >= 0x000800
3393 if ( simpleblock
!= NULL
)
3394 p_sys
->i_pts
= (p_sys
->i_chapter_time
+ simpleblock
->GlobalTimecode()) / (mtime_t
) 1000;
3397 p_sys
->i_pts
= (p_sys
->i_chapter_time
+ block
->GlobalTimecode()) / (mtime_t
) 1000;
3399 if( p_sys
->i_pts
>= p_sys
->i_start_pts
)
3401 es_out_Control( p_demux
->out
, ES_OUT_SET_PCR
, p_sys
->i_pts
);
3403 if ( p_vsegment
->UpdateCurrentToChapter( *p_demux
) )
3411 if ( p_vsegment
->Edition() && p_vsegment
->Edition()->b_ordered
&& p_vsegment
->CurrentChapter() == NULL
)
3413 /* nothing left to read in this ordered edition */
3414 if ( !p_vsegment
->SelectNext() )
3419 p_segment
->UnSelect( );
3421 es_out_Control( p_demux
->out
, ES_OUT_RESET_PCR
);
3423 /* switch to the next segment */
3424 p_segment
= p_vsegment
->Segment();
3425 if ( !p_segment
->Select( 0 ) )
3427 msg_Err( p_demux
, "Failed to select new segment" );
3435 #if LIBMATROSKA_VERSION >= 0x000800
3436 BlockDecode( p_demux
, block
, simpleblock
, p_sys
->i_pts
, i_block_duration
, i_block_ref1
>= 0 || i_block_ref2
> 0 );
3438 BlockDecode( p_demux
, block
, p_sys
->i_pts
, i_block_duration
, i_block_ref1
>= 0 || i_block_ref2
> 0 );
3444 // TODO optimize when there is need to leave or when seeking has been called
3445 if( i_block_count
> 5 )
3452 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
3459 /*****************************************************************************
3461 *****************************************************************************/
3462 vlc_stream_io_callback::vlc_stream_io_callback( stream_t
*s_
, vlc_bool_t b_owner_
)
3469 uint32
vlc_stream_io_callback::read( void *p_buffer
, size_t i_size
)
3471 if( i_size
<= 0 || mb_eof
)
3476 return stream_Read( s
, p_buffer
, i_size
);
3478 void vlc_stream_io_callback::setFilePointer(int64_t i_offset
, seek_mode mode
)
3484 case seek_beginning
:
3488 i_pos
= stream_Size( s
) - i_offset
;
3491 i_pos
= stream_Tell( s
) + i_offset
;
3495 if( i_pos
< 0 || i_pos
>= stream_Size( s
) )
3502 if( stream_Seek( s
, i_pos
) )
3508 size_t vlc_stream_io_callback::write( const void *p_buffer
, size_t i_size
)
3512 uint64
vlc_stream_io_callback::getFilePointer( void )
3516 return stream_Tell( s
);
3518 void vlc_stream_io_callback::close( void )
3524 /*****************************************************************************
3525 * Ebml Stream parser
3526 *****************************************************************************/
3527 EbmlParser::EbmlParser( EbmlStream
*es
, EbmlElement
*el_start
, demux_t
*p_demux
)
3534 mi_remain_size
[0] = el_start
->GetSize();
3536 for( i
= 1; i
< 6; i
++ )
3542 mb_keep
= VLC_FALSE
;
3543 mb_dummy
= config_GetInt( p_demux
, "mkv-use-dummy" );
3546 EbmlParser::~EbmlParser( void )
3550 for( i
= 1; i
< mi_level
; i
++ )
3556 mb_keep
= VLC_FALSE
;
3560 EbmlElement
* EbmlParser::UnGet( uint64 i_block_pos
, uint64 i_cluster_pos
)
3562 if ( mi_user_level
> mi_level
)
3564 while ( mi_user_level
!= mi_level
)
3566 delete m_el
[mi_user_level
];
3567 m_el
[mi_user_level
] = NULL
;
3572 mb_keep
= VLC_FALSE
;
3573 if ( m_el
[1]->GetElementPosition() == i_cluster_pos
)
3575 m_es
->I_O().setFilePointer( i_block_pos
, seek_beginning
);
3576 return (EbmlMaster
*) m_el
[1];
3580 // seek to the previous Cluster
3581 m_es
->I_O().setFilePointer( i_cluster_pos
, seek_beginning
);
3584 delete m_el
[mi_level
];
3585 m_el
[mi_level
] = NULL
;
3590 void EbmlParser::Up( void )
3592 if( mi_user_level
== mi_level
)
3594 fprintf( stderr
," arrrrrrrrrrrrrg Up cannot escape itself\n" );
3600 void EbmlParser::Down( void )
3606 void EbmlParser::Keep( void )
3611 int EbmlParser::GetLevel( void )
3613 return mi_user_level
;
3616 void EbmlParser::Reset( demux_t
*p_demux
)
3618 while ( mi_level
> 0)
3620 delete m_el
[mi_level
];
3621 m_el
[mi_level
] = NULL
;
3624 mi_user_level
= mi_level
= 1;
3625 #if LIBEBML_VERSION >= 0x000704
3626 // a little faster and cleaner
3627 m_es
->I_O().setFilePointer( static_cast<KaxSegment
*>(m_el
[0])->GetGlobalPosition(0) );
3629 m_es
->I_O().setFilePointer( m_el
[0]->GetElementPosition() + m_el
[0]->ElementSize(true) - m_el
[0]->GetSize() );
3631 mb_dummy
= config_GetInt( p_demux
, "mkv-use-dummy" );
3634 EbmlElement
*EbmlParser::Get( void )
3638 if( mi_user_level
!= mi_level
)
3644 EbmlElement
*ret
= m_got
;
3650 if( m_el
[mi_level
] )
3652 m_el
[mi_level
]->SkipData( *m_es
, m_el
[mi_level
]->Generic().Context
);
3655 delete m_el
[mi_level
];
3657 mb_keep
= VLC_FALSE
;
3660 m_el
[mi_level
] = m_es
->FindNextElement( m_el
[mi_level
- 1]->Generic().Context
, i_ulev
, 0xFFFFFFFFL
, mb_dummy
!= 0, 1 );
3661 // mi_remain_size[mi_level] = m_el[mi_level]->GetSize();
3672 delete m_el
[mi_level
- 1];
3673 m_got
= m_el
[mi_level
-1] = m_el
[mi_level
];
3674 m_el
[mi_level
] = NULL
;
3681 else if( m_el
[mi_level
] == NULL
)
3683 fprintf( stderr
," m_el[mi_level] == NULL\n" );
3686 return m_el
[mi_level
];
3690 /*****************************************************************************
3692 * * LoadCues : load the cues element and update index
3694 * * LoadTags : load ... the tags element
3696 * * InformationCreate : create all information, load tags if present
3698 *****************************************************************************/
3699 void matroska_segment_c::LoadCues( )
3701 int64_t i_sav_position
= es
.I_O().getFilePointer();
3703 EbmlElement
*el
, *cues
;
3705 /* *** Load the cue if found *** */
3706 if( i_cues_position
< 0 )
3708 msg_Warn( &sys
.demuxer
, "no cues/empty cues found->seek won't be precise" );
3710 // IndexAppendCluster( cluster );
3713 vlc_bool_t b_seekable
;
3715 stream_Control( sys
.demuxer
.s
, STREAM_CAN_FASTSEEK
, &b_seekable
);
3719 msg_Dbg( &sys
.demuxer
, "loading cues" );
3720 es
.I_O().setFilePointer( i_cues_position
, seek_beginning
);
3721 cues
= es
.FindNextID( KaxCues::ClassInfos
, 0xFFFFFFFFL
);
3725 msg_Err( &sys
.demuxer
, "cannot load cues (broken seekhead or file)" );
3726 es
.I_O().setFilePointer( i_sav_position
, seek_beginning
);
3730 ep
= new EbmlParser( &es
, cues
, &sys
.demuxer
);
3731 while( ( el
= ep
->Get() ) != NULL
)
3733 if( MKV_IS_ID( el
, KaxCuePoint
) )
3735 #define idx p_indexes[i_index]
3738 idx
.i_block_number
= -1;
3739 idx
.i_position
= -1;
3741 idx
.b_key
= VLC_TRUE
;
3744 while( ( el
= ep
->Get() ) != NULL
)
3746 if( MKV_IS_ID( el
, KaxCueTime
) )
3748 KaxCueTime
&ctime
= *(KaxCueTime
*)el
;
3750 ctime
.ReadData( es
.I_O() );
3752 idx
.i_time
= uint64( ctime
) * i_timescale
/ (mtime_t
)1000;
3754 else if( MKV_IS_ID( el
, KaxCueTrackPositions
) )
3757 while( ( el
= ep
->Get() ) != NULL
)
3759 if( MKV_IS_ID( el
, KaxCueTrack
) )
3761 KaxCueTrack
&ctrack
= *(KaxCueTrack
*)el
;
3763 ctrack
.ReadData( es
.I_O() );
3764 idx
.i_track
= uint16( ctrack
);
3766 else if( MKV_IS_ID( el
, KaxCueClusterPosition
) )
3768 KaxCueClusterPosition
&ccpos
= *(KaxCueClusterPosition
*)el
;
3770 ccpos
.ReadData( es
.I_O() );
3771 idx
.i_position
= segment
->GetGlobalPosition( uint64( ccpos
) );
3773 else if( MKV_IS_ID( el
, KaxCueBlockNumber
) )
3775 KaxCueBlockNumber
&cbnum
= *(KaxCueBlockNumber
*)el
;
3777 cbnum
.ReadData( es
.I_O() );
3778 idx
.i_block_number
= uint32( cbnum
);
3782 msg_Dbg( &sys
.demuxer
, " * Unknown (%s)", typeid(*el
).name() );
3789 msg_Dbg( &sys
.demuxer
, " * Unknown (%s)", typeid(*el
).name() );
3795 msg_Dbg( &sys
.demuxer
, " * added time="I64Fd
" pos="I64Fd
3796 " track=%d bnum=%d", idx
.i_time
, idx
.i_position
,
3797 idx
.i_track
, idx
.i_block_number
);
3801 if( i_index
>= i_index_max
)
3803 i_index_max
+= 1024;
3804 p_indexes
= (mkv_index_t
*)realloc( p_indexes
, sizeof( mkv_index_t
) * i_index_max
);
3810 msg_Dbg( &sys
.demuxer
, " * Unknown (%s)", typeid(*el
).name() );
3818 msg_Dbg( &sys
.demuxer
, "loading cues done." );
3819 es
.I_O().setFilePointer( i_sav_position
, seek_beginning
);
3822 void matroska_segment_c::LoadTags( )
3824 int64_t i_sav_position
= es
.I_O().getFilePointer();
3826 EbmlElement
*el
, *tags
;
3828 msg_Dbg( &sys
.demuxer
, "loading tags" );
3829 es
.I_O().setFilePointer( i_tags_position
, seek_beginning
);
3830 tags
= es
.FindNextID( KaxTags::ClassInfos
, 0xFFFFFFFFL
);
3834 msg_Err( &sys
.demuxer
, "cannot load tags (broken seekhead or file)" );
3835 es
.I_O().setFilePointer( i_sav_position
, seek_beginning
);
3839 msg_Dbg( &sys
.demuxer
, "Tags" );
3840 ep
= new EbmlParser( &es
, tags
, &sys
.demuxer
);
3841 while( ( el
= ep
->Get() ) != NULL
)
3843 if( MKV_IS_ID( el
, KaxTag
) )
3845 msg_Dbg( &sys
.demuxer
, "+ Tag" );
3847 while( ( el
= ep
->Get() ) != NULL
)
3849 if( MKV_IS_ID( el
, KaxTagTargets
) )
3851 msg_Dbg( &sys
.demuxer
, "| + Targets" );
3853 while( ( el
= ep
->Get() ) != NULL
)
3855 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid( *el
).name() );
3859 else if( MKV_IS_ID( el
, KaxTagGeneral
) )
3861 msg_Dbg( &sys
.demuxer
, "| + General" );
3863 while( ( el
= ep
->Get() ) != NULL
)
3865 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid( *el
).name() );
3869 else if( MKV_IS_ID( el
, KaxTagGenres
) )
3871 msg_Dbg( &sys
.demuxer
, "| + Genres" );
3873 while( ( el
= ep
->Get() ) != NULL
)
3875 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid( *el
).name() );
3879 else if( MKV_IS_ID( el
, KaxTagAudioSpecific
) )
3881 msg_Dbg( &sys
.demuxer
, "| + Audio Specific" );
3883 while( ( el
= ep
->Get() ) != NULL
)
3885 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid( *el
).name() );
3889 else if( MKV_IS_ID( el
, KaxTagImageSpecific
) )
3891 msg_Dbg( &sys
.demuxer
, "| + Images Specific" );
3893 while( ( el
= ep
->Get() ) != NULL
)
3895 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid( *el
).name() );
3899 else if( MKV_IS_ID( el
, KaxTagMultiComment
) )
3901 msg_Dbg( &sys
.demuxer
, "| + Multi Comment" );
3903 else if( MKV_IS_ID( el
, KaxTagMultiCommercial
) )
3905 msg_Dbg( &sys
.demuxer
, "| + Multi Commercial" );
3907 else if( MKV_IS_ID( el
, KaxTagMultiDate
) )
3909 msg_Dbg( &sys
.demuxer
, "| + Multi Date" );
3911 else if( MKV_IS_ID( el
, KaxTagMultiEntity
) )
3913 msg_Dbg( &sys
.demuxer
, "| + Multi Entity" );
3915 else if( MKV_IS_ID( el
, KaxTagMultiIdentifier
) )
3917 msg_Dbg( &sys
.demuxer
, "| + Multi Identifier" );
3919 else if( MKV_IS_ID( el
, KaxTagMultiLegal
) )
3921 msg_Dbg( &sys
.demuxer
, "| + Multi Legal" );
3923 else if( MKV_IS_ID( el
, KaxTagMultiTitle
) )
3925 msg_Dbg( &sys
.demuxer
, "| + Multi Title" );
3929 msg_Dbg( &sys
.demuxer
, "| + Unknown (%s)", typeid( *el
).name() );
3936 msg_Dbg( &sys
.demuxer
, "+ Unknown (%s)", typeid( *el
).name() );
3942 msg_Dbg( &sys
.demuxer
, "loading tags done." );
3943 es
.I_O().setFilePointer( i_sav_position
, seek_beginning
);
3946 /*****************************************************************************
3948 *****************************************************************************/
3949 void matroska_segment_c::ParseSeekHead( KaxSeekHead
*seekhead
)
3953 int i_upper_level
= 0;
3955 msg_Dbg( &sys
.demuxer
, "| + Seek head" );
3957 /* Master elements */
3958 seekhead
->Read( es
, seekhead
->Generic().Context
, i_upper_level
, el
, true );
3960 for( i
= 0; i
< seekhead
->ListSize(); i
++ )
3962 EbmlElement
*l
= (*seekhead
)[i
];
3964 if( MKV_IS_ID( l
, KaxSeek
) )
3966 EbmlMaster
*sk
= static_cast<EbmlMaster
*>(l
);
3967 EbmlId id
= EbmlVoid::ClassInfos
.GlobalId
;
3970 for( j
= 0; j
< sk
->ListSize(); j
++ )
3972 EbmlElement
*l
= (*sk
)[j
];
3974 if( MKV_IS_ID( l
, KaxSeekID
) )
3976 KaxSeekID
&sid
= *(KaxSeekID
*)l
;
3977 id
= EbmlId( sid
.GetBuffer(), sid
.GetSize() );
3979 else if( MKV_IS_ID( l
, KaxSeekPosition
) )
3981 KaxSeekPosition
&spos
= *(KaxSeekPosition
*)l
;
3982 i_pos
= uint64( spos
);
3986 msg_Dbg( &sys
.demuxer
, "| | | + Unknown (%s)", typeid(*l
).name() );
3992 if( id
== KaxCues::ClassInfos
.GlobalId
)
3994 msg_Dbg( &sys
.demuxer
, "| | | = cues at "I64Fd
, i_pos
);
3995 i_cues_position
= segment
->GetGlobalPosition( i_pos
);
3997 else if( id
== KaxChapters::ClassInfos
.GlobalId
)
3999 msg_Dbg( &sys
.demuxer
, "| | | = chapters at "I64Fd
, i_pos
);
4000 i_chapters_position
= segment
->GetGlobalPosition( i_pos
);
4002 else if( id
== KaxTags::ClassInfos
.GlobalId
)
4004 msg_Dbg( &sys
.demuxer
, "| | | = tags at "I64Fd
, i_pos
);
4005 i_tags_position
= segment
->GetGlobalPosition( i_pos
);
4011 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid(*l
).name() );
4016 /*****************************************************************************
4018 *****************************************************************************/
4019 void matroska_segment_c::ParseTrackEntry( KaxTrackEntry
*m
)
4022 bool bSupported
= true;
4026 msg_Dbg( &sys
.demuxer
, "| | + Track Entry" );
4028 tk
= new mkv_track_t();
4030 /* Init the track */
4031 memset( tk
, 0, sizeof( mkv_track_t
) );
4033 es_format_Init( &tk
->fmt
, UNKNOWN_ES
, 0 );
4034 tk
->fmt
.psz_language
= strdup("English");
4035 tk
->fmt
.psz_description
= NULL
;
4037 tk
->b_default
= VLC_TRUE
;
4038 tk
->b_enabled
= VLC_TRUE
;
4039 tk
->b_silent
= VLC_FALSE
;
4040 tk
->i_number
= tracks
.size() - 1;
4041 tk
->i_extra_data
= 0;
4042 tk
->p_extra_data
= NULL
;
4043 tk
->psz_codec
= NULL
;
4044 tk
->i_default_duration
= 0;
4045 tk
->f_timecodescale
= 1.0;
4047 tk
->b_inited
= VLC_FALSE
;
4048 tk
->i_data_init
= 0;
4049 tk
->p_data_init
= NULL
;
4051 tk
->psz_codec_name
= NULL
;
4052 tk
->psz_codec_settings
= NULL
;
4053 tk
->psz_codec_info_url
= NULL
;
4054 tk
->psz_codec_download_url
= NULL
;
4056 tk
->i_compression_type
= MATROSKA_COMPRESSION_NONE
;
4057 tk
->p_compression_data
= NULL
;
4059 for( i
= 0; i
< m
->ListSize(); i
++ )
4061 EbmlElement
*l
= (*m
)[i
];
4063 if( MKV_IS_ID( l
, KaxTrackNumber
) )
4065 KaxTrackNumber
&tnum
= *(KaxTrackNumber
*)l
;
4067 tk
->i_number
= uint32( tnum
);
4068 msg_Dbg( &sys
.demuxer
, "| | | + Track Number=%u", uint32( tnum
) );
4070 else if( MKV_IS_ID( l
, KaxTrackUID
) )
4072 KaxTrackUID
&tuid
= *(KaxTrackUID
*)l
;
4074 msg_Dbg( &sys
.demuxer
, "| | | + Track UID=%u", uint32( tuid
) );
4076 else if( MKV_IS_ID( l
, KaxTrackType
) )
4079 KaxTrackType
&ttype
= *(KaxTrackType
*)l
;
4081 switch( uint8(ttype
) )
4085 tk
->fmt
.i_cat
= AUDIO_ES
;
4089 tk
->fmt
.i_cat
= VIDEO_ES
;
4091 case track_subtitle
:
4092 psz_type
= "subtitle";
4093 tk
->fmt
.i_cat
= SPU_ES
;
4096 psz_type
= "buttons";
4097 tk
->fmt
.i_cat
= SPU_ES
;
4100 psz_type
= "unknown";
4101 tk
->fmt
.i_cat
= UNKNOWN_ES
;
4105 msg_Dbg( &sys
.demuxer
, "| | | + Track Type=%s", psz_type
);
4107 // else if( EbmlId( *l ) == KaxTrackFlagEnabled::ClassInfos.GlobalId )
4109 // KaxTrackFlagEnabled &fenb = *(KaxTrackFlagEnabled*)l;
4111 // tk->b_enabled = uint32( fenb );
4112 // msg_Dbg( &sys.demuxer, "| | | + Track Enabled=%u",
4113 // uint32( fenb ) );
4115 else if( MKV_IS_ID( l
, KaxTrackFlagDefault
) )
4117 KaxTrackFlagDefault
&fdef
= *(KaxTrackFlagDefault
*)l
;
4119 tk
->b_default
= uint32( fdef
);
4120 msg_Dbg( &sys
.demuxer
, "| | | + Track Default=%u", uint32( fdef
) );
4122 else if( MKV_IS_ID( l
, KaxTrackFlagLacing
) )
4124 KaxTrackFlagLacing
&lac
= *(KaxTrackFlagLacing
*)l
;
4126 msg_Dbg( &sys
.demuxer
, "| | | + Track Lacing=%d", uint32( lac
) );
4128 else if( MKV_IS_ID( l
, KaxTrackMinCache
) )
4130 KaxTrackMinCache
&cmin
= *(KaxTrackMinCache
*)l
;
4132 msg_Dbg( &sys
.demuxer
, "| | | + Track MinCache=%d", uint32( cmin
) );
4134 else if( MKV_IS_ID( l
, KaxTrackMaxCache
) )
4136 KaxTrackMaxCache
&cmax
= *(KaxTrackMaxCache
*)l
;
4138 msg_Dbg( &sys
.demuxer
, "| | | + Track MaxCache=%d", uint32( cmax
) );
4140 else if( MKV_IS_ID( l
, KaxTrackDefaultDuration
) )
4142 KaxTrackDefaultDuration
&defd
= *(KaxTrackDefaultDuration
*)l
;
4144 tk
->i_default_duration
= uint64(defd
);
4145 msg_Dbg( &sys
.demuxer
, "| | | + Track Default Duration="I64Fd
, uint64(defd
) );
4147 else if( MKV_IS_ID( l
, KaxTrackTimecodeScale
) )
4149 KaxTrackTimecodeScale
&ttcs
= *(KaxTrackTimecodeScale
*)l
;
4151 tk
->f_timecodescale
= float( ttcs
);
4152 msg_Dbg( &sys
.demuxer
, "| | | + Track TimeCodeScale=%f", tk
->f_timecodescale
);
4154 else if( MKV_IS_ID( l
, KaxTrackName
) )
4156 KaxTrackName
&tname
= *(KaxTrackName
*)l
;
4158 tk
->fmt
.psz_description
= ToUTF8( UTFstring( tname
) );
4159 msg_Dbg( &sys
.demuxer
, "| | | + Track Name=%s", tk
->fmt
.psz_description
);
4161 else if( MKV_IS_ID( l
, KaxTrackLanguage
) )
4163 KaxTrackLanguage
&lang
= *(KaxTrackLanguage
*)l
;
4165 if ( tk
->fmt
.psz_language
!= NULL
)
4166 free( tk
->fmt
.psz_language
);
4167 tk
->fmt
.psz_language
= strdup( string( lang
).c_str() );
4168 msg_Dbg( &sys
.demuxer
,
4169 "| | | + Track Language=`%s'", tk
->fmt
.psz_language
);
4171 else if( MKV_IS_ID( l
, KaxCodecID
) )
4173 KaxCodecID
&codecid
= *(KaxCodecID
*)l
;
4175 tk
->psz_codec
= strdup( string( codecid
).c_str() );
4176 msg_Dbg( &sys
.demuxer
, "| | | + Track CodecId=%s", string( codecid
).c_str() );
4178 else if( MKV_IS_ID( l
, KaxCodecPrivate
) )
4180 KaxCodecPrivate
&cpriv
= *(KaxCodecPrivate
*)l
;
4182 tk
->i_extra_data
= cpriv
.GetSize();
4183 if( tk
->i_extra_data
> 0 )
4185 tk
->p_extra_data
= (uint8_t*)malloc( tk
->i_extra_data
);
4186 memcpy( tk
->p_extra_data
, cpriv
.GetBuffer(), tk
->i_extra_data
);
4188 msg_Dbg( &sys
.demuxer
, "| | | + Track CodecPrivate size="I64Fd
, cpriv
.GetSize() );
4190 else if( MKV_IS_ID( l
, KaxCodecName
) )
4192 KaxCodecName
&cname
= *(KaxCodecName
*)l
;
4194 tk
->psz_codec_name
= ToUTF8( UTFstring( cname
) );
4195 msg_Dbg( &sys
.demuxer
, "| | | + Track Codec Name=%s", tk
->psz_codec_name
);
4197 else if( MKV_IS_ID( l
, KaxContentEncodings
) )
4199 EbmlMaster
*cencs
= static_cast<EbmlMaster
*>(l
);
4200 MkvTree( sys
.demuxer
, 3, "Content Encodings" );
4201 if ( cencs
->ListSize() > 1 )
4203 msg_Err( &sys
.demuxer
, "Multiple Compression method not supported" );
4206 for( j
= 0; j
< cencs
->ListSize(); j
++ )
4208 EbmlElement
*l2
= (*cencs
)[j
];
4209 if( MKV_IS_ID( l2
, KaxContentEncoding
) )
4211 MkvTree( sys
.demuxer
, 4, "Content Encoding" );
4212 EbmlMaster
*cenc
= static_cast<EbmlMaster
*>(l2
);
4213 for( k
= 0; k
< cenc
->ListSize(); k
++ )
4215 EbmlElement
*l3
= (*cenc
)[k
];
4216 if( MKV_IS_ID( l3
, KaxContentEncodingOrder
) )
4218 KaxContentEncodingOrder
&encord
= *(KaxContentEncodingOrder
*)l3
;
4219 MkvTree( sys
.demuxer
, 5, "Order: %i", uint32( encord
) );
4221 else if( MKV_IS_ID( l3
, KaxContentEncodingScope
) )
4223 KaxContentEncodingScope
&encscope
= *(KaxContentEncodingScope
*)l3
;
4224 MkvTree( sys
.demuxer
, 5, "Scope: %i", uint32( encscope
) );
4226 else if( MKV_IS_ID( l3
, KaxContentEncodingType
) )
4228 KaxContentEncodingType
&enctype
= *(KaxContentEncodingType
*)l3
;
4229 MkvTree( sys
.demuxer
, 5, "Type: %i", uint32( enctype
) );
4231 else if( MKV_IS_ID( l3
, KaxContentCompression
) )
4233 EbmlMaster
*compr
= static_cast<EbmlMaster
*>(l3
);
4234 MkvTree( sys
.demuxer
, 5, "Content Compression" );
4235 for( n
= 0; n
< compr
->ListSize(); n
++ )
4237 EbmlElement
*l4
= (*compr
)[n
];
4238 if( MKV_IS_ID( l4
, KaxContentCompAlgo
) )
4240 KaxContentCompAlgo
&compalg
= *(KaxContentCompAlgo
*)l4
;
4241 MkvTree( sys
.demuxer
, 6, "Compression Algorithm: %i", uint32(compalg
) );
4242 tk
->i_compression_type
= uint32( compalg
);
4243 if ( ( tk
->i_compression_type
!= MATROSKA_COMPRESSION_ZLIB
) &&
4244 ( tk
->i_compression_type
!= MATROSKA_COMPRESSION_HEADER
) )
4246 msg_Err( &sys
.demuxer
, "Track Compression method %d not supported", tk
->i_compression_type
);
4250 else if( MKV_IS_ID( l4
, KaxContentCompSettings
) )
4252 tk
->p_compression_data
= new KaxContentCompSettings( *(KaxContentCompSettings
*)l4
);
4256 MkvTree( sys
.demuxer
, 6, "Unknown (%s)", typeid(*l4
).name() );
4263 MkvTree( sys
.demuxer
, 5, "Unknown (%s)", typeid(*l3
).name() );
4270 MkvTree( sys
.demuxer
, 4, "Unknown (%s)", typeid(*l2
).name() );
4275 // else if( EbmlId( *l ) == KaxCodecSettings::ClassInfos.GlobalId )
4277 // KaxCodecSettings &cset = *(KaxCodecSettings*)l;
4279 // tk->psz_codec_settings = ToUTF8( UTFstring( cset ) );
4280 // msg_Dbg( &sys.demuxer, "| | | + Track Codec Settings=%s", tk->psz_codec_settings );
4282 // else if( EbmlId( *l ) == KaxCodecInfoURL::ClassInfos.GlobalId )
4284 // KaxCodecInfoURL &ciurl = *(KaxCodecInfoURL*)l;
4286 // tk->psz_codec_info_url = strdup( string( ciurl ).c_str() );
4287 // msg_Dbg( &sys.demuxer, "| | | + Track Codec Info URL=%s", tk->psz_codec_info_url );
4289 // else if( EbmlId( *l ) == KaxCodecDownloadURL::ClassInfos.GlobalId )
4291 // KaxCodecDownloadURL &cdurl = *(KaxCodecDownloadURL*)l;
4293 // tk->psz_codec_download_url = strdup( string( cdurl ).c_str() );
4294 // msg_Dbg( &sys.demuxer, "| | | + Track Codec Info URL=%s", tk->psz_codec_download_url );
4296 // else if( EbmlId( *l ) == KaxCodecDecodeAll::ClassInfos.GlobalId )
4298 // KaxCodecDecodeAll &cdall = *(KaxCodecDecodeAll*)l;
4300 // msg_Dbg( &sys.demuxer, "| | | + Track Codec Decode All=%u <== UNUSED", uint8( cdall ) );
4302 // else if( EbmlId( *l ) == KaxTrackOverlay::ClassInfos.GlobalId )
4304 // KaxTrackOverlay &tovr = *(KaxTrackOverlay*)l;
4306 // msg_Dbg( &sys.demuxer, "| | | + Track Overlay=%u <== UNUSED", uint32( tovr ) );
4308 else if( MKV_IS_ID( l
, KaxTrackVideo
) )
4310 EbmlMaster
*tkv
= static_cast<EbmlMaster
*>(l
);
4313 msg_Dbg( &sys
.demuxer
, "| | | + Track Video" );
4316 tk
->fmt
.video
.i_frame_rate_base
= (unsigned int)(tk
->i_default_duration
/ 1000);
4317 tk
->fmt
.video
.i_frame_rate
= 1000000;
4319 for( j
= 0; j
< tkv
->ListSize(); j
++ )
4321 EbmlElement
*l
= (*tkv
)[j
];
4322 // if( EbmlId( *el4 ) == KaxVideoFlagInterlaced::ClassInfos.GlobalId )
4324 // KaxVideoFlagInterlaced &fint = *(KaxVideoFlagInterlaced*)el4;
4326 // msg_Dbg( &sys.demuxer, "| | | | + Track Video Interlaced=%u", uint8( fint ) );
4328 // else if( EbmlId( *el4 ) == KaxVideoStereoMode::ClassInfos.GlobalId )
4330 // KaxVideoStereoMode &stereo = *(KaxVideoStereoMode*)el4;
4332 // msg_Dbg( &sys.demuxer, "| | | | + Track Video Stereo Mode=%u", uint8( stereo ) );
4335 if( MKV_IS_ID( l
, KaxVideoPixelWidth
) )
4337 KaxVideoPixelWidth
&vwidth
= *(KaxVideoPixelWidth
*)l
;
4339 tk
->fmt
.video
.i_width
+= uint16( vwidth
);
4340 msg_Dbg( &sys
.demuxer
, "| | | | + width=%d", uint16( vwidth
) );
4342 else if( MKV_IS_ID( l
, KaxVideoPixelHeight
) )
4344 KaxVideoPixelWidth
&vheight
= *(KaxVideoPixelWidth
*)l
;
4346 tk
->fmt
.video
.i_height
+= uint16( vheight
);
4347 msg_Dbg( &sys
.demuxer
, "| | | | + height=%d", uint16( vheight
) );
4349 else if( MKV_IS_ID( l
, KaxVideoDisplayWidth
) )
4351 KaxVideoDisplayWidth
&vwidth
= *(KaxVideoDisplayWidth
*)l
;
4353 tk
->fmt
.video
.i_visible_width
= uint16( vwidth
);
4354 msg_Dbg( &sys
.demuxer
, "| | | | + display width=%d", uint16( vwidth
) );
4356 else if( MKV_IS_ID( l
, KaxVideoDisplayHeight
) )
4358 KaxVideoDisplayWidth
&vheight
= *(KaxVideoDisplayWidth
*)l
;
4360 tk
->fmt
.video
.i_visible_height
= uint16( vheight
);
4361 msg_Dbg( &sys
.demuxer
, "| | | | + display height=%d", uint16( vheight
) );
4363 else if( MKV_IS_ID( l
, KaxVideoPixelCropBottom
) )
4365 KaxVideoPixelCropBottom
&cropval
= *(KaxVideoPixelCropBottom
*)l
;
4367 tk
->fmt
.video
.i_height
-= uint16( cropval
);
4368 msg_Dbg( &sys
.demuxer
, "| | | | + crop pixel bottom=%d", uint16( cropval
) );
4370 else if( MKV_IS_ID( l
, KaxVideoPixelCropTop
) )
4372 KaxVideoPixelCropTop
&cropval
= *(KaxVideoPixelCropTop
*)l
;
4374 tk
->fmt
.video
.i_height
-= uint16( cropval
);
4375 tk
->fmt
.video
.i_y_offset
+= uint16( cropval
);
4376 msg_Dbg( &sys
.demuxer
, "| | | | + crop pixel top=%d", uint16( cropval
) );
4378 else if( MKV_IS_ID( l
, KaxVideoPixelCropRight
) )
4380 KaxVideoPixelCropRight
&cropval
= *(KaxVideoPixelCropRight
*)l
;
4382 tk
->fmt
.video
.i_width
-= uint16( cropval
);
4383 msg_Dbg( &sys
.demuxer
, "| | | | + crop pixel right=%d", uint16( cropval
) );
4385 else if( MKV_IS_ID( l
, KaxVideoPixelCropLeft
) )
4387 KaxVideoPixelCropLeft
&cropval
= *(KaxVideoPixelCropLeft
*)l
;
4389 tk
->fmt
.video
.i_width
-= uint16( cropval
);
4390 tk
->fmt
.video
.i_x_offset
+= uint16( cropval
);
4391 msg_Dbg( &sys
.demuxer
, "| | | | + crop pixel left=%d", uint16( cropval
) );
4393 else if( MKV_IS_ID( l
, KaxVideoFrameRate
) )
4395 KaxVideoFrameRate
&vfps
= *(KaxVideoFrameRate
*)l
;
4397 tk
->f_fps
= float( vfps
);
4398 msg_Dbg( &sys
.demuxer
, " | | | + fps=%f", float( vfps
) );
4400 // else if( EbmlId( *l ) == KaxVideoDisplayUnit::ClassInfos.GlobalId )
4402 // KaxVideoDisplayUnit &vdmode = *(KaxVideoDisplayUnit*)l;
4404 // msg_Dbg( &sys.demuxer, "| | | | + Track Video Display Unit=%s",
4405 // uint8( vdmode ) == 0 ? "pixels" : ( uint8( vdmode ) == 1 ? "centimeters": "inches" ) );
4407 // else if( EbmlId( *l ) == KaxVideoAspectRatio::ClassInfos.GlobalId )
4409 // KaxVideoAspectRatio &ratio = *(KaxVideoAspectRatio*)l;
4411 // msg_Dbg( &sys.demuxer, " | | | + Track Video Aspect Ratio Type=%u", uint8( ratio ) );
4413 // else if( EbmlId( *l ) == KaxVideoGamma::ClassInfos.GlobalId )
4415 // KaxVideoGamma &gamma = *(KaxVideoGamma*)l;
4417 // msg_Dbg( &sys.demuxer, " | | | + fps=%f", float( gamma ) );
4421 msg_Dbg( &sys
.demuxer
, "| | | | + Unknown (%s)", typeid(*l
).name() );
4424 if ( tk
->fmt
.video
.i_visible_height
&& tk
->fmt
.video
.i_visible_width
)
4425 tk
->fmt
.video
.i_aspect
= VOUT_ASPECT_FACTOR
* tk
->fmt
.video
.i_visible_width
/ tk
->fmt
.video
.i_visible_height
;
4427 else if( MKV_IS_ID( l
, KaxTrackAudio
) )
4429 EbmlMaster
*tka
= static_cast<EbmlMaster
*>(l
);
4432 msg_Dbg( &sys
.demuxer
, "| | | + Track Audio" );
4434 for( j
= 0; j
< tka
->ListSize(); j
++ )
4436 EbmlElement
*l
= (*tka
)[j
];
4438 if( MKV_IS_ID( l
, KaxAudioSamplingFreq
) )
4440 KaxAudioSamplingFreq
&afreq
= *(KaxAudioSamplingFreq
*)l
;
4442 tk
->i_original_rate
= tk
->fmt
.audio
.i_rate
= (int)float( afreq
);
4443 msg_Dbg( &sys
.demuxer
, "| | | | + afreq=%d", tk
->fmt
.audio
.i_rate
);
4445 else if( MKV_IS_ID( l
, KaxAudioOutputSamplingFreq
) )
4447 KaxAudioOutputSamplingFreq
&afreq
= *(KaxAudioOutputSamplingFreq
*)l
;
4449 tk
->fmt
.audio
.i_rate
= (int)float( afreq
);
4450 msg_Dbg( &sys
.demuxer
, "| | | | + aoutfreq=%d", tk
->fmt
.audio
.i_rate
);
4452 else if( MKV_IS_ID( l
, KaxAudioChannels
) )
4454 KaxAudioChannels
&achan
= *(KaxAudioChannels
*)l
;
4456 tk
->fmt
.audio
.i_channels
= uint8( achan
);
4457 msg_Dbg( &sys
.demuxer
, "| | | | + achan=%u", uint8( achan
) );
4459 else if( MKV_IS_ID( l
, KaxAudioBitDepth
) )
4461 KaxAudioBitDepth
&abits
= *(KaxAudioBitDepth
*)l
;
4463 tk
->fmt
.audio
.i_bitspersample
= uint8( abits
);
4464 msg_Dbg( &sys
.demuxer
, "| | | | + abits=%u", uint8( abits
) );
4468 msg_Dbg( &sys
.demuxer
, "| | | | + Unknown (%s)", typeid(*l
).name() );
4474 msg_Dbg( &sys
.demuxer
, "| | | + Unknown (%s)",
4475 typeid(*l
).name() );
4481 tracks
.push_back( tk
);
4485 msg_Err( &sys
.demuxer
, "Track Entry %d not supported", tk
->i_number
);
4490 /*****************************************************************************
4492 *****************************************************************************/
4493 void matroska_segment_c::ParseTracks( KaxTracks
*tracks
)
4497 int i_upper_level
= 0;
4499 msg_Dbg( &sys
.demuxer
, "| + Tracks" );
4501 /* Master elements */
4502 tracks
->Read( es
, tracks
->Generic().Context
, i_upper_level
, el
, true );
4504 for( i
= 0; i
< tracks
->ListSize(); i
++ )
4506 EbmlElement
*l
= (*tracks
)[i
];
4508 if( MKV_IS_ID( l
, KaxTrackEntry
) )
4510 ParseTrackEntry( static_cast<KaxTrackEntry
*>(l
) );
4514 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid(*l
).name() );
4519 /*****************************************************************************
4521 *****************************************************************************/
4522 void matroska_segment_c::ParseInfo( KaxInfo
*info
)
4527 int i_upper_level
= 0;
4529 msg_Dbg( &sys
.demuxer
, "| + Information" );
4531 /* Master elements */
4532 m
= static_cast<EbmlMaster
*>(info
);
4533 m
->Read( es
, info
->Generic().Context
, i_upper_level
, el
, true );
4535 for( i
= 0; i
< m
->ListSize(); i
++ )
4537 EbmlElement
*l
= (*m
)[i
];
4539 if( MKV_IS_ID( l
, KaxSegmentUID
) )
4541 if ( p_segment_uid
== NULL
)
4542 p_segment_uid
= new KaxSegmentUID(*static_cast<KaxSegmentUID
*>(l
));
4544 msg_Dbg( &sys
.demuxer
, "| | + UID=%d", *(uint32
*)p_segment_uid
->GetBuffer() );
4546 else if( MKV_IS_ID( l
, KaxPrevUID
) )
4548 if ( p_prev_segment_uid
== NULL
)
4549 p_prev_segment_uid
= new KaxPrevUID(*static_cast<KaxPrevUID
*>(l
));
4551 msg_Dbg( &sys
.demuxer
, "| | + PrevUID=%d", *(uint32
*)p_prev_segment_uid
->GetBuffer() );
4553 else if( MKV_IS_ID( l
, KaxNextUID
) )
4555 if ( p_next_segment_uid
== NULL
)
4556 p_next_segment_uid
= new KaxNextUID(*static_cast<KaxNextUID
*>(l
));
4558 msg_Dbg( &sys
.demuxer
, "| | + NextUID=%d", *(uint32
*)p_next_segment_uid
->GetBuffer() );
4560 else if( MKV_IS_ID( l
, KaxTimecodeScale
) )
4562 KaxTimecodeScale
&tcs
= *(KaxTimecodeScale
*)l
;
4564 i_timescale
= uint64(tcs
);
4566 msg_Dbg( &sys
.demuxer
, "| | + TimecodeScale="I64Fd
,
4569 else if( MKV_IS_ID( l
, KaxDuration
) )
4571 KaxDuration
&dur
= *(KaxDuration
*)l
;
4573 i_duration
= mtime_t( double( dur
) );
4575 msg_Dbg( &sys
.demuxer
, "| | + Duration="I64Fd
,
4578 else if( MKV_IS_ID( l
, KaxMuxingApp
) )
4580 KaxMuxingApp
&mapp
= *(KaxMuxingApp
*)l
;
4582 psz_muxing_application
= ToUTF8( UTFstring( mapp
) );
4584 msg_Dbg( &sys
.demuxer
, "| | + Muxing Application=%s",
4585 psz_muxing_application
);
4587 else if( MKV_IS_ID( l
, KaxWritingApp
) )
4589 KaxWritingApp
&wapp
= *(KaxWritingApp
*)l
;
4591 psz_writing_application
= ToUTF8( UTFstring( wapp
) );
4593 msg_Dbg( &sys
.demuxer
, "| | + Writing Application=%s",
4594 psz_writing_application
);
4596 else if( MKV_IS_ID( l
, KaxSegmentFilename
) )
4598 KaxSegmentFilename
&sfn
= *(KaxSegmentFilename
*)l
;
4600 psz_segment_filename
= ToUTF8( UTFstring( sfn
) );
4602 msg_Dbg( &sys
.demuxer
, "| | + Segment Filename=%s",
4603 psz_segment_filename
);
4605 else if( MKV_IS_ID( l
, KaxTitle
) )
4607 KaxTitle
&title
= *(KaxTitle
*)l
;
4609 psz_title
= ToUTF8( UTFstring( title
) );
4611 msg_Dbg( &sys
.demuxer
, "| | + Title=%s", psz_title
);
4613 else if( MKV_IS_ID( l
, KaxSegmentFamily
) )
4615 KaxSegmentFamily
*uid
= static_cast<KaxSegmentFamily
*>(l
);
4617 families
.push_back( new KaxSegmentFamily(*uid
) );
4619 msg_Dbg( &sys
.demuxer
, "| | + family=%d", *(uint32
*)uid
->GetBuffer() );
4621 #if defined( HAVE_GMTIME_R ) && !defined( __APPLE__ )
4622 else if( MKV_IS_ID( l
, KaxDateUTC
) )
4624 KaxDateUTC
&date
= *(KaxDateUTC
*)l
;
4629 i_date
= date
.GetEpochDate();
4630 memset( buffer
, 0, 256 );
4631 if( gmtime_r( &i_date
, &tmres
) &&
4632 asctime_r( &tmres
, buffer
) )
4634 buffer
[strlen( buffer
)-1]= '\0';
4635 psz_date_utc
= strdup( buffer
);
4636 msg_Dbg( &sys
.demuxer
, "| | + Date=%s", psz_date_utc
);
4640 #if LIBMATROSKA_VERSION >= 0x000704
4641 else if( MKV_IS_ID( l
, KaxChapterTranslate
) )
4643 KaxChapterTranslate
*p_trans
= static_cast<KaxChapterTranslate
*>( l
);
4644 chapter_translation_c
*p_translate
= new chapter_translation_c();
4646 p_trans
->Read( es
, p_trans
->Generic().Context
, i_upper_level
, el
, true );
4647 for( j
= 0; j
< p_trans
->ListSize(); j
++ )
4649 EbmlElement
*l
= (*p_trans
)[j
];
4651 if( MKV_IS_ID( l
, KaxChapterTranslateEditionUID
) )
4653 p_translate
->editions
.push_back( uint64( *static_cast<KaxChapterTranslateEditionUID
*>( l
) ) );
4655 else if( MKV_IS_ID( l
, KaxChapterTranslateCodec
) )
4657 p_translate
->codec_id
= uint32( *static_cast<KaxChapterTranslateCodec
*>( l
) );
4659 else if( MKV_IS_ID( l
, KaxChapterTranslateID
) )
4661 p_translate
->p_translated
= new KaxChapterTranslateID( *static_cast<KaxChapterTranslateID
*>( l
) );
4665 translations
.push_back( p_translate
);
4670 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid(*l
).name() );
4674 double f_dur
= double(i_duration
) * double(i_timescale
) / 1000000.0;
4675 i_duration
= mtime_t(f_dur
);
4679 /*****************************************************************************
4681 *****************************************************************************/
4682 void matroska_segment_c::ParseChapterAtom( int i_level
, KaxChapterAtom
*ca
, chapter_item_c
& chapters
)
4686 msg_Dbg( &sys
.demuxer
, "| | | + ChapterAtom (level=%d)", i_level
);
4687 for( i
= 0; i
< ca
->ListSize(); i
++ )
4689 EbmlElement
*l
= (*ca
)[i
];
4691 if( MKV_IS_ID( l
, KaxChapterUID
) )
4693 chapters
.i_uid
= uint64_t(*(KaxChapterUID
*)l
);
4694 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterUID: %lld", chapters
.i_uid
);
4696 else if( MKV_IS_ID( l
, KaxChapterFlagHidden
) )
4698 KaxChapterFlagHidden
&flag
=*(KaxChapterFlagHidden
*)l
;
4699 chapters
.b_display_seekpoint
= uint8( flag
) == 0;
4701 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterFlagHidden: %s", chapters
.b_display_seekpoint
? "no":"yes" );
4703 else if( MKV_IS_ID( l
, KaxChapterTimeStart
) )
4705 KaxChapterTimeStart
&start
=*(KaxChapterTimeStart
*)l
;
4706 chapters
.i_start_time
= uint64( start
) / I64C(1000);
4708 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterTimeStart: %lld", chapters
.i_start_time
);
4710 else if( MKV_IS_ID( l
, KaxChapterTimeEnd
) )
4712 KaxChapterTimeEnd
&end
=*(KaxChapterTimeEnd
*)l
;
4713 chapters
.i_end_time
= uint64( end
) / I64C(1000);
4715 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterTimeEnd: %lld", chapters
.i_end_time
);
4717 else if( MKV_IS_ID( l
, KaxChapterDisplay
) )
4719 EbmlMaster
*cd
= static_cast<EbmlMaster
*>(l
);
4721 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterDisplay" );
4722 for( j
= 0; j
< cd
->ListSize(); j
++ )
4724 EbmlElement
*l
= (*cd
)[j
];
4726 if( MKV_IS_ID( l
, KaxChapterString
) )
4730 KaxChapterString
&name
=*(KaxChapterString
*)l
;
4731 for (k
= 0; k
< i_level
; k
++)
4732 chapters
.psz_name
+= '+';
4733 chapters
.psz_name
+= ' ';
4734 char *psz_tmp_utf8
= ToUTF8( UTFstring( name
) );
4735 chapters
.psz_name
+= psz_tmp_utf8
;
4736 chapters
.b_user_display
= true;
4738 msg_Dbg( &sys
.demuxer
, "| | | | | + ChapterString '%s'", psz_tmp_utf8
);
4739 free( psz_tmp_utf8
);
4741 else if( MKV_IS_ID( l
, KaxChapterLanguage
) )
4743 KaxChapterLanguage
&lang
=*(KaxChapterLanguage
*)l
;
4744 const char *psz
= string( lang
).c_str();
4746 msg_Dbg( &sys
.demuxer
, "| | | | | + ChapterLanguage '%s'", psz
);
4748 else if( MKV_IS_ID( l
, KaxChapterCountry
) )
4750 KaxChapterCountry
&ct
=*(KaxChapterCountry
*)l
;
4751 const char *psz
= string( ct
).c_str();
4753 msg_Dbg( &sys
.demuxer
, "| | | | | + ChapterCountry '%s'", psz
);
4757 else if( MKV_IS_ID( l
, KaxChapterProcess
) )
4759 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterProcess" );
4761 KaxChapterProcess
*cp
= static_cast<KaxChapterProcess
*>(l
);
4762 chapter_codec_cmds_c
*p_ccodec
= NULL
;
4764 for( j
= 0; j
< cp
->ListSize(); j
++ )
4766 EbmlElement
*k
= (*cp
)[j
];
4768 if( MKV_IS_ID( k
, KaxChapterProcessCodecID
) )
4770 KaxChapterProcessCodecID
*p_codec_id
= static_cast<KaxChapterProcessCodecID
*>( k
);
4771 if ( uint32(*p_codec_id
) == 0 )
4772 p_ccodec
= new matroska_script_codec_c( sys
);
4773 else if ( uint32(*p_codec_id
) == 1 )
4774 p_ccodec
= new dvd_chapter_codec_c( sys
);
4779 if ( p_ccodec
!= NULL
)
4781 for( j
= 0; j
< cp
->ListSize(); j
++ )
4783 EbmlElement
*k
= (*cp
)[j
];
4785 if( MKV_IS_ID( k
, KaxChapterProcessPrivate
) )
4787 KaxChapterProcessPrivate
* p_private
= static_cast<KaxChapterProcessPrivate
*>( k
);
4788 p_ccodec
->SetPrivate( *p_private
);
4790 else if( MKV_IS_ID( k
, KaxChapterProcessCommand
) )
4792 p_ccodec
->AddCommand( *static_cast<KaxChapterProcessCommand
*>( k
) );
4795 chapters
.codecs
.push_back( p_ccodec
);
4798 else if( MKV_IS_ID( l
, KaxChapterAtom
) )
4800 chapter_item_c
*new_sub_chapter
= new chapter_item_c();
4801 ParseChapterAtom( i_level
+1, static_cast<KaxChapterAtom
*>(l
), *new_sub_chapter
);
4802 new_sub_chapter
->psz_parent
= &chapters
;
4803 chapters
.sub_chapters
.push_back( new_sub_chapter
);
4808 /*****************************************************************************
4810 *****************************************************************************/
4811 void matroska_segment_c::ParseChapters( KaxChapters
*chapters
)
4815 int i_upper_level
= 0;
4818 /* Master elements */
4819 chapters
->Read( es
, chapters
->Generic().Context
, i_upper_level
, el
, true );
4821 for( i
= 0; i
< chapters
->ListSize(); i
++ )
4823 EbmlElement
*l
= (*chapters
)[i
];
4825 if( MKV_IS_ID( l
, KaxEditionEntry
) )
4827 chapter_edition_c
*p_edition
= new chapter_edition_c();
4829 EbmlMaster
*E
= static_cast<EbmlMaster
*>(l
);
4831 msg_Dbg( &sys
.demuxer
, "| | + EditionEntry" );
4832 for( j
= 0; j
< E
->ListSize(); j
++ )
4834 EbmlElement
*l
= (*E
)[j
];
4836 if( MKV_IS_ID( l
, KaxChapterAtom
) )
4838 chapter_item_c
*new_sub_chapter
= new chapter_item_c();
4839 ParseChapterAtom( 0, static_cast<KaxChapterAtom
*>(l
), *new_sub_chapter
);
4840 p_edition
->sub_chapters
.push_back( new_sub_chapter
);
4842 else if( MKV_IS_ID( l
, KaxEditionUID
) )
4844 p_edition
->i_uid
= uint64(*static_cast<KaxEditionUID
*>( l
));
4846 else if( MKV_IS_ID( l
, KaxEditionFlagOrdered
) )
4848 p_edition
->b_ordered
= config_GetInt( &sys
.demuxer
, "mkv-use-ordered-chapters" ) ? (uint8(*static_cast<KaxEditionFlagOrdered
*>( l
)) != 0) : 0;
4850 else if( MKV_IS_ID( l
, KaxEditionFlagDefault
) )
4852 if (uint8(*static_cast<KaxEditionFlagDefault
*>( l
)) != 0)
4853 i_default_edition
= stored_editions
.size();
4857 msg_Dbg( &sys
.demuxer
, "| | | + Unknown (%s)", typeid(*l
).name() );
4860 stored_editions
.push_back( p_edition
);
4864 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid(*l
).name() );
4868 for( i
= 0; i
< stored_editions
.size(); i
++ )
4870 stored_editions
[i
]->RefreshChapters( );
4873 if ( stored_editions
.size() != 0 && stored_editions
[i_default_edition
]->b_ordered
)
4875 /* update the duration of the segment according to the sum of all sub chapters */
4876 i_dur
= stored_editions
[i_default_edition
]->Duration() / I64C(1000);
4882 void matroska_segment_c::ParseCluster( )
4887 int i_upper_level
= 0;
4889 /* Master elements */
4890 m
= static_cast<EbmlMaster
*>( cluster
);
4891 m
->Read( es
, cluster
->Generic().Context
, i_upper_level
, el
, true );
4893 for( i
= 0; i
< m
->ListSize(); i
++ )
4895 EbmlElement
*l
= (*m
)[i
];
4897 if( MKV_IS_ID( l
, KaxClusterTimecode
) )
4899 KaxClusterTimecode
&ctc
= *(KaxClusterTimecode
*)l
;
4901 cluster
->InitTimecode( uint64( ctc
), i_timescale
);
4906 i_start_time
= cluster
->GlobalTimecode() / 1000;
4909 /*****************************************************************************
4910 * InformationCreate:
4911 *****************************************************************************/
4912 void matroska_segment_c::InformationCreate( )
4916 sys
.meta
= vlc_meta_New();
4920 vlc_meta_Add( sys
.meta
, VLC_META_TITLE
, psz_title
);
4924 vlc_meta_Add( sys
.meta
, VLC_META_DATE
, psz_date_utc
);
4926 if( psz_segment_filename
)
4928 vlc_meta_Add( sys
.meta
, _("Segment filename"), psz_segment_filename
);
4930 if( psz_muxing_application
)
4932 vlc_meta_Add( sys
.meta
, _("Muxing application"), psz_muxing_application
);
4934 if( psz_writing_application
)
4936 vlc_meta_Add( sys
.meta
, _("Writing application"), psz_writing_application
);
4939 for( i_track
= 0; i_track
< tracks
.size(); i_track
++ )
4941 mkv_track_t
*tk
= tracks
[i_track
];
4942 vlc_meta_t
*mtk
= vlc_meta_New();
4944 sys
.meta
->track
= (vlc_meta_t
**)realloc( sys
.meta
->track
,
4945 sizeof( vlc_meta_t
* ) * ( sys
.meta
->i_track
+ 1 ) );
4946 sys
.meta
->track
[sys
.meta
->i_track
++] = mtk
;
4948 if( tk
->fmt
.psz_description
)
4950 vlc_meta_Add( sys
.meta
, VLC_META_DESCRIPTION
, tk
->fmt
.psz_description
);
4952 if( tk
->psz_codec_name
)
4954 vlc_meta_Add( sys
.meta
, VLC_META_CODEC_NAME
, tk
->psz_codec_name
);
4956 if( tk
->psz_codec_settings
)
4958 vlc_meta_Add( sys
.meta
, VLC_META_SETTING
, tk
->psz_codec_settings
);
4960 if( tk
->psz_codec_info_url
)
4962 vlc_meta_Add( sys
.meta
, VLC_META_CODEC_DESCRIPTION
, tk
->psz_codec_info_url
);
4964 if( tk
->psz_codec_download_url
)
4966 vlc_meta_Add( sys
.meta
, VLC_META_URL
, tk
->psz_codec_download_url
);
4970 if( i_tags_position
>= 0 )
4972 vlc_bool_t b_seekable
;
4974 stream_Control( sys
.demuxer
.s
, STREAM_CAN_FASTSEEK
, &b_seekable
);
4983 /*****************************************************************************
4985 *****************************************************************************/
4987 void matroska_segment_c::IndexAppendCluster( KaxCluster
*cluster
)
4989 #define idx p_indexes[i_index]
4991 idx
.i_block_number
= -1;
4992 idx
.i_position
= cluster
->GetElementPosition();
4994 idx
.b_key
= VLC_TRUE
;
4997 if( i_index
>= i_index_max
)
4999 i_index_max
+= 1024;
5000 p_indexes
= (mkv_index_t
*)realloc( p_indexes
, sizeof( mkv_index_t
) * i_index_max
);
5005 void chapter_edition_c::RefreshChapters( )
5007 chapter_item_c::RefreshChapters( b_ordered
, -1 );
5008 b_display_seekpoint
= false;
5011 int64_t chapter_item_c::RefreshChapters( bool b_ordered
, int64_t i_prev_user_time
)
5013 int64_t i_user_time
= i_prev_user_time
;
5015 // first the sub-chapters, and then ourself
5016 std::vector
<chapter_item_c
*>::iterator index
= sub_chapters
.begin();
5017 while ( index
!= sub_chapters
.end() )
5019 i_user_time
= (*index
)->RefreshChapters( b_ordered
, i_user_time
);
5025 // the ordered chapters always start at zero
5026 if ( i_prev_user_time
== -1 )
5028 if ( i_user_time
== -1 )
5030 i_prev_user_time
= 0;
5033 i_user_start_time
= i_prev_user_time
;
5034 if ( i_end_time
!= -1 && i_user_time
== i_prev_user_time
)
5036 i_user_end_time
= i_user_start_time
- i_start_time
+ i_end_time
;
5040 i_user_end_time
= i_user_time
;
5045 if ( sub_chapters
.begin() != sub_chapters
.end() )
5046 std::sort( sub_chapters
.begin(), sub_chapters
.end(), chapter_item_c::CompareTimecode
);
5047 i_user_start_time
= i_start_time
;
5048 if ( i_end_time
!= -1 )
5049 i_user_end_time
= i_end_time
;
5050 else if ( i_user_time
!= -1 )
5051 i_user_end_time
= i_user_time
;
5053 i_user_end_time
= i_user_start_time
;
5056 return i_user_end_time
;
5059 mtime_t
chapter_edition_c::Duration() const
5061 mtime_t i_result
= 0;
5063 if ( sub_chapters
.size() )
5065 std::vector
<chapter_item_c
*>::const_iterator index
= sub_chapters
.end();
5067 i_result
= (*index
)->i_user_end_time
;
5073 chapter_item_c
* chapter_edition_c::FindTimecode( mtime_t i_timecode
, const chapter_item_c
* p_current
)
5077 bool b_found_current
= false;
5078 return chapter_item_c::FindTimecode( i_timecode
, p_current
, b_found_current
);
5081 chapter_item_c
*chapter_item_c::FindTimecode( mtime_t i_user_timecode
, const chapter_item_c
* p_current
, bool & b_found
)
5083 chapter_item_c
*psz_result
= NULL
;
5085 if ( p_current
== this )
5088 if ( i_user_timecode
>= i_user_start_time
&&
5089 ( i_user_timecode
< i_user_end_time
||
5090 ( i_user_start_time
== i_user_end_time
&& i_user_timecode
== i_user_end_time
)))
5092 std::vector
<chapter_item_c
*>::iterator index
= sub_chapters
.begin();
5093 while ( index
!= sub_chapters
.end() && ((p_current
== NULL
&& psz_result
== NULL
) || (p_current
!= NULL
&& (!b_found
|| psz_result
== NULL
))))
5095 psz_result
= (*index
)->FindTimecode( i_user_timecode
, p_current
, b_found
);
5099 if ( psz_result
== NULL
)
5106 bool chapter_item_c::ParentOf( const chapter_item_c
& item
) const
5108 if ( &item
== this )
5111 std::vector
<chapter_item_c
*>::const_iterator index
= sub_chapters
.begin();
5112 while ( index
!= sub_chapters
.end() )
5114 if ( (*index
)->ParentOf( item
) )
5122 void demux_sys_t::PreloadFamily( const matroska_segment_c
& of_segment
)
5124 for (size_t i
=0; i
<opened_segments
.size(); i
++)
5126 opened_segments
[i
]->PreloadFamily( of_segment
);
5129 bool matroska_segment_c::PreloadFamily( const matroska_segment_c
& of_segment
)
5134 for (size_t i
=0; i
<families
.size(); i
++)
5136 for (size_t j
=0; j
<of_segment
.families
.size(); j
++)
5138 if ( *(families
[i
]) == *(of_segment
.families
[j
]) )
5146 // preload all the linked segments for all preloaded segments
5147 void demux_sys_t::PreloadLinked( matroska_segment_c
*p_segment
)
5149 size_t i_preloaded
, i
, j
;
5150 virtual_segment_c
*p_seg
;
5152 p_current_segment
= VirtualFromSegments( p_segment
);
5154 used_segments
.push_back( p_current_segment
);
5156 // create all the other virtual segments of the family
5159 for ( i
=0; i
< opened_segments
.size(); i
++ )
5161 if ( opened_segments
[i
]->b_preloaded
&& !IsUsedSegment( *opened_segments
[i
] ) )
5163 p_seg
= VirtualFromSegments( opened_segments
[i
] );
5164 used_segments
.push_back( p_seg
);
5168 } while ( i_preloaded
); // worst case: will stop when all segments are found as family related
5170 // publish all editions of all usable segment
5171 for ( i
=0; i
< used_segments
.size(); i
++ )
5173 p_seg
= used_segments
[i
];
5174 if ( p_seg
->p_editions
!= NULL
)
5176 std::string sz_name
;
5177 input_title_t
*p_title
= vlc_input_title_New();
5178 p_seg
->i_sys_title
= i
;
5181 // TODO use a name for each edition, let the TITLE deal with a codec name
5182 for ( j
=0; j
<p_seg
->p_editions
->size(); j
++ )
5184 if ( p_title
->psz_name
== NULL
)
5186 sz_name
= (*p_seg
->p_editions
)[j
]->GetMainName();
5187 if ( sz_name
!= "" )
5188 p_title
->psz_name
= strdup( sz_name
.c_str() );
5191 chapter_edition_c
*p_edition
= (*p_seg
->p_editions
)[j
];
5194 p_edition
->PublishChapters( *p_title
, i_chapters
, 0 );
5197 // create a name if there is none
5198 if ( p_title
->psz_name
== NULL
)
5200 sz_name
= N_("Segment");
5202 sprintf( psz_str
, " %d", (int)i
);
5204 p_title
->psz_name
= strdup( sz_name
.c_str() );
5207 titles
.push_back( p_title
);
5211 // TODO decide which segment should be first used (VMG for DVD)
5214 bool demux_sys_t::IsUsedSegment( matroska_segment_c
&segment
) const
5216 for ( size_t i
=0; i
< used_segments
.size(); i
++ )
5218 if ( used_segments
[i
]->FindUID( *segment
.p_segment_uid
) )
5224 virtual_segment_c
*demux_sys_t::VirtualFromSegments( matroska_segment_c
*p_segment
) const
5226 size_t i_preloaded
, i
;
5228 virtual_segment_c
*p_result
= new virtual_segment_c( p_segment
);
5230 // fill our current virtual segment with all hard linked segments
5233 for ( i
=0; i
< opened_segments
.size(); i
++ )
5235 i_preloaded
+= p_result
->AddSegment( opened_segments
[i
] );
5237 } while ( i_preloaded
); // worst case: will stop when all segments are found as linked
5241 p_result
->PreloadLinked( );
5243 p_result
->PrepareChapters( );
5248 bool demux_sys_t::PreparePlayback( virtual_segment_c
*p_new_segment
)
5250 if ( p_new_segment
!= NULL
&& p_new_segment
!= p_current_segment
)
5252 if ( p_current_segment
!= NULL
&& p_current_segment
->Segment() != NULL
)
5253 p_current_segment
->Segment()->UnSelect();
5255 p_current_segment
= p_new_segment
;
5256 i_current_title
= p_new_segment
->i_sys_title
;
5259 p_current_segment
->LoadCues();
5260 f_duration
= p_current_segment
->Duration();
5262 /* add information */
5263 p_current_segment
->Segment()->InformationCreate( );
5265 p_current_segment
->Segment()->Select( 0 );
5270 void demux_sys_t::JumpTo( virtual_segment_c
& vsegment
, chapter_item_c
* p_chapter
)
5272 // if the segment is not part of the current segment, select the new one
5273 if ( &vsegment
!= p_current_segment
)
5275 PreparePlayback( &vsegment
);
5278 if ( p_chapter
!= NULL
)
5280 if ( !p_chapter
->Enter( true ) )
5282 // jump to the location in the found segment
5283 vsegment
.Seek( demuxer
, p_chapter
->i_user_start_time
, -1, p_chapter
);
5289 bool matroska_segment_c::CompareSegmentUIDs( const matroska_segment_c
* p_item_a
, const matroska_segment_c
* p_item_b
)
5291 if ( p_item_a
== NULL
|| p_item_b
== NULL
)
5294 EbmlBinary
* p_itema
= (EbmlBinary
*)(p_item_a
->p_segment_uid
);
5295 if ( p_item_b
->p_prev_segment_uid
!= NULL
&& *p_itema
== *p_item_b
->p_prev_segment_uid
)
5298 p_itema
= (EbmlBinary
*)(&p_item_a
->p_next_segment_uid
);
5299 if ( p_item_b
->p_segment_uid
!= NULL
&& *p_itema
== *p_item_b
->p_segment_uid
)
5302 if ( p_item_b
->p_prev_segment_uid
!= NULL
&& *p_itema
== *p_item_b
->p_prev_segment_uid
)
5308 bool matroska_segment_c::Preload( )
5313 EbmlElement
*el
= NULL
;
5315 ep
->Reset( &sys
.demuxer
);
5317 while( ( el
= ep
->Get() ) != NULL
)
5319 if( MKV_IS_ID( el
, KaxInfo
) )
5321 ParseInfo( static_cast<KaxInfo
*>( el
) );
5323 else if( MKV_IS_ID( el
, KaxTracks
) )
5325 ParseTracks( static_cast<KaxTracks
*>( el
) );
5326 if ( tracks
.size() == 0 )
5328 msg_Err( &sys
.demuxer
, "No tracks supported" );
5332 else if( MKV_IS_ID( el
, KaxSeekHead
) )
5334 ParseSeekHead( static_cast<KaxSeekHead
*>( el
) );
5336 else if( MKV_IS_ID( el
, KaxCues
) )
5338 msg_Dbg( &sys
.demuxer
, "| + Cues" );
5340 else if( MKV_IS_ID( el
, KaxCluster
) )
5342 msg_Dbg( &sys
.demuxer
, "| + Cluster" );
5344 cluster
= (KaxCluster
*)el
;
5346 i_cluster_pos
= i_start_pos
= cluster
->GetElementPosition();
5350 /* stop parsing the stream */
5353 else if( MKV_IS_ID( el
, KaxAttachments
) )
5355 msg_Dbg( &sys
.demuxer
, "| + Attachments FIXME (but probably never supported)" );
5357 else if( MKV_IS_ID( el
, KaxChapters
) )
5359 msg_Dbg( &sys
.demuxer
, "| + Chapters" );
5360 ParseChapters( static_cast<KaxChapters
*>( el
) );
5362 else if( MKV_IS_ID( el
, KaxTag
) )
5364 msg_Dbg( &sys
.demuxer
, "| + Tags FIXME TODO" );
5368 msg_Dbg( &sys
.demuxer
, "| + Unknown (%s)", typeid(*el
).name() );
5377 matroska_segment_c
*demux_sys_t::FindSegment( const EbmlBinary
& uid
) const
5379 for (size_t i
=0; i
<opened_segments
.size(); i
++)
5381 if ( *opened_segments
[i
]->p_segment_uid
== uid
)
5382 return opened_segments
[i
];
5387 chapter_item_c
*demux_sys_t::BrowseCodecPrivate( unsigned int codec_id
,
5388 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
5389 const void *p_cookie
,
5390 size_t i_cookie_size
,
5391 virtual_segment_c
* &p_segment_found
)
5393 chapter_item_c
*p_result
= NULL
;
5394 for (size_t i
=0; i
<used_segments
.size(); i
++)
5396 p_result
= used_segments
[i
]->BrowseCodecPrivate( codec_id
, match
, p_cookie
, i_cookie_size
);
5397 if ( p_result
!= NULL
)
5399 p_segment_found
= used_segments
[i
];
5406 chapter_item_c
*demux_sys_t::FindChapter( int64_t i_find_uid
, virtual_segment_c
* & p_segment_found
)
5408 chapter_item_c
*p_result
= NULL
;
5409 for (size_t i
=0; i
<used_segments
.size(); i
++)
5411 p_result
= used_segments
[i
]->FindChapter( i_find_uid
);
5412 if ( p_result
!= NULL
)
5414 p_segment_found
= used_segments
[i
];
5421 void virtual_segment_c::Sort()
5423 // keep the current segment index
5424 matroska_segment_c
*p_segment
= linked_segments
[i_current_segment
];
5426 std::sort( linked_segments
.begin(), linked_segments
.end(), matroska_segment_c::CompareSegmentUIDs
);
5428 for ( i_current_segment
=0; i_current_segment
<linked_segments
.size(); i_current_segment
++)
5429 if ( linked_segments
[i_current_segment
] == p_segment
)
5433 size_t virtual_segment_c::AddSegment( matroska_segment_c
*p_segment
)
5436 // check if it's not already in here
5437 for ( i
=0; i
<linked_segments
.size(); i
++ )
5439 if ( linked_segments
[i
]->p_segment_uid
!= NULL
5440 && p_segment
->p_segment_uid
!= NULL
5441 && *p_segment
->p_segment_uid
== *linked_segments
[i
]->p_segment_uid
)
5445 // find possible mates
5446 for ( i
=0; i
<linked_uids
.size(); i
++ )
5448 if ( (p_segment
->p_segment_uid
!= NULL
&& *p_segment
->p_segment_uid
== linked_uids
[i
])
5449 || (p_segment
->p_prev_segment_uid
!= NULL
&& *p_segment
->p_prev_segment_uid
== linked_uids
[i
])
5450 || (p_segment
->p_next_segment_uid
!=NULL
&& *p_segment
->p_next_segment_uid
== linked_uids
[i
]) )
5452 linked_segments
.push_back( p_segment
);
5454 AppendUID( p_segment
->p_prev_segment_uid
);
5455 AppendUID( p_segment
->p_next_segment_uid
);
5463 void virtual_segment_c::PreloadLinked( )
5465 for ( size_t i
=0; i
<linked_segments
.size(); i
++ )
5467 linked_segments
[i
]->Preload( );
5469 i_current_edition
= linked_segments
[0]->i_default_edition
;
5472 mtime_t
virtual_segment_c::Duration() const
5475 if ( linked_segments
.size() == 0 )
5478 matroska_segment_c
*p_last_segment
= linked_segments
[linked_segments
.size()-1];
5479 // p_last_segment->ParseCluster( );
5481 i_duration
= p_last_segment
->i_start_time
/ 1000 + p_last_segment
->i_duration
;
5486 void virtual_segment_c::LoadCues( )
5488 for ( size_t i
=0; i
<linked_segments
.size(); i
++ )
5490 linked_segments
[i
]->LoadCues();
5494 void virtual_segment_c::AppendUID( const EbmlBinary
* p_UID
)
5496 if ( p_UID
== NULL
)
5498 if ( p_UID
->GetBuffer() == NULL
)
5501 for (size_t i
=0; i
<linked_uids
.size(); i
++)
5503 if ( *p_UID
== linked_uids
[i
] )
5506 linked_uids
.push_back( *(KaxSegmentUID
*)(p_UID
) );
5509 void matroska_segment_c::Seek( mtime_t i_date
, mtime_t i_time_offset
)
5512 #if LIBMATROSKA_VERSION >= 0x000800
5513 KaxSimpleBlock
*simpleblock
;
5515 int i_track_skipping
;
5516 int64_t i_block_duration
;
5517 int64_t i_block_ref1
;
5518 int64_t i_block_ref2
;
5520 int64_t i_seek_position
= i_start_pos
;
5521 int64_t i_seek_time
= i_start_time
;
5527 for( ; i_idx
< i_index
; i_idx
++ )
5529 if( p_indexes
[i_idx
].i_time
+ i_time_offset
> i_date
)
5540 i_seek_position
= p_indexes
[i_idx
].i_position
;
5541 i_seek_time
= p_indexes
[i_idx
].i_time
;
5544 msg_Dbg( &sys
.demuxer
, "seek got "I64Fd
" (%d%%)",
5545 i_seek_time
, (int)( 100 * i_seek_position
/ stream_Size( sys
.demuxer
.s
) ) );
5547 es
.I_O().setFilePointer( i_seek_position
, seek_beginning
);
5550 ep
= new EbmlParser( &es
, segment
, &sys
.demuxer
);
5553 sys
.i_start_pts
= i_date
;
5555 es_out_Control( sys
.demuxer
.out
, ES_OUT_RESET_PCR
);
5557 /* now parse until key frame */
5558 i_track_skipping
= 0;
5559 for( i_track
= 0; i_track
< tracks
.size(); i_track
++ )
5561 if( tracks
[i_track
]->fmt
.i_cat
== VIDEO_ES
)
5563 tracks
[i_track
]->b_search_keyframe
= VLC_TRUE
;
5566 es_out_Control( sys
.demuxer
.out
, ES_OUT_SET_NEXT_DISPLAY_TIME
, tracks
[i_track
]->p_es
, i_date
);
5570 while( i_track_skipping
> 0 )
5572 #if LIBMATROSKA_VERSION >= 0x000800
5573 if( BlockGet( block
, simpleblock
, &i_block_ref1
, &i_block_ref2
, &i_block_duration
) )
5575 if( BlockGet( block
, &i_block_ref1
, &i_block_ref2
, &i_block_duration
) )
5578 msg_Warn( &sys
.demuxer
, "cannot get block EOF?" );
5584 for( i_track
= 0; i_track
< tracks
.size(); i_track
++ )
5586 if( tracks
[i_track
]->i_number
== block
->TrackNum() )
5592 sys
.i_pts
= (sys
.i_chapter_time
+ block
->GlobalTimecode()) / (mtime_t
) 1000;
5594 if( i_track
< tracks
.size() )
5596 if( sys
.i_pts
>= sys
.i_start_pts
)
5598 cluster
= static_cast<KaxCluster
*>(ep
->UnGet( i_block_pos
, i_cluster_pos
));
5599 i_track_skipping
= 0;
5601 else if( tracks
[i_track
]->fmt
.i_cat
== VIDEO_ES
)
5603 if( i_block_ref1
== 0 && tracks
[i_track
]->b_search_keyframe
)
5605 tracks
[i_track
]->b_search_keyframe
= VLC_FALSE
;
5608 if( !tracks
[i_track
]->b_search_keyframe
)
5610 #if LIBMATROSKA_VERSION >= 0x000800
5611 BlockDecode( &sys
.demuxer
, block
, simpleblock
, sys
.i_pts
, 0, i_block_ref1
>= 0 || i_block_ref2
> 0 );
5613 BlockDecode( &sys
.demuxer
, block
, sys
.i_pts
, 0, i_block_ref1
>= 0 || i_block_ref2
> 0 );
5623 void virtual_segment_c::Seek( demux_t
& demuxer
, mtime_t i_date
, mtime_t i_time_offset
, chapter_item_c
*psz_chapter
)
5625 demux_sys_t
*p_sys
= demuxer
.p_sys
;
5628 // find the actual time for an ordered edition
5629 if ( psz_chapter
== NULL
)
5631 if ( Edition() && Edition()->b_ordered
)
5633 /* 1st, we need to know in which chapter we are */
5634 psz_chapter
= (*p_editions
)[i_current_edition
]->FindTimecode( i_date
, psz_current_chapter
);
5638 if ( psz_chapter
!= NULL
)
5640 psz_current_chapter
= psz_chapter
;
5641 p_sys
->i_chapter_time
= i_time_offset
= psz_chapter
->i_user_start_time
- psz_chapter
->i_start_time
;
5642 if ( psz_chapter
->i_seekpoint_num
> 0 )
5644 demuxer
.info
.i_update
|= INPUT_UPDATE_TITLE
| INPUT_UPDATE_SEEKPOINT
;
5645 demuxer
.info
.i_title
= p_sys
->i_current_title
= i_sys_title
;
5646 demuxer
.info
.i_seekpoint
= psz_chapter
->i_seekpoint_num
- 1;
5650 // find the best matching segment
5651 for ( i
=0; i
<linked_segments
.size(); i
++ )
5653 if ( i_date
< linked_segments
[i
]->i_start_time
)
5660 if ( i_current_segment
!= i
)
5662 linked_segments
[i_current_segment
]->UnSelect();
5663 linked_segments
[i
]->Select( i_date
);
5664 i_current_segment
= i
;
5667 linked_segments
[i
]->Seek( i_date
, i_time_offset
);
5670 void chapter_codec_cmds_c::AddCommand( const KaxChapterProcessCommand
& command
)
5674 uint32 codec_time
= uint32(-1);
5675 for( i
= 0; i
< command
.ListSize(); i
++ )
5677 const EbmlElement
*k
= command
[i
];
5679 if( MKV_IS_ID( k
, KaxChapterProcessTime
) )
5681 codec_time
= uint32( *static_cast<const KaxChapterProcessTime
*>( k
) );
5686 for( i
= 0; i
< command
.ListSize(); i
++ )
5688 const EbmlElement
*k
= command
[i
];
5690 if( MKV_IS_ID( k
, KaxChapterProcessData
) )
5692 KaxChapterProcessData
*p_data
= new KaxChapterProcessData( *static_cast<const KaxChapterProcessData
*>( k
) );
5693 switch ( codec_time
)
5696 during_cmds
.push_back( p_data
);
5699 enter_cmds
.push_back( p_data
);
5702 leave_cmds
.push_back( p_data
);
5711 bool chapter_item_c::Enter( bool b_do_subs
)
5713 bool f_result
= false;
5714 std::vector
<chapter_codec_cmds_c
*>::iterator index
= codecs
.begin();
5715 while ( index
!= codecs
.end() )
5717 f_result
|= (*index
)->Enter();
5724 std::vector
<chapter_item_c
*>::iterator index_
= sub_chapters
.begin();
5725 while ( index_
!= sub_chapters
.end() )
5727 f_result
|= (*index_
)->Enter( true );
5734 bool chapter_item_c::Leave( bool b_do_subs
)
5736 bool f_result
= false;
5737 b_is_leaving
= true;
5738 std::vector
<chapter_codec_cmds_c
*>::iterator index
= codecs
.begin();
5739 while ( index
!= codecs
.end() )
5741 f_result
|= (*index
)->Leave();
5748 std::vector
<chapter_item_c
*>::iterator index_
= sub_chapters
.begin();
5749 while ( index_
!= sub_chapters
.end() )
5751 f_result
|= (*index_
)->Leave( true );
5755 b_is_leaving
= false;
5759 bool chapter_item_c::EnterAndLeave( chapter_item_c
*p_item
, bool b_final_enter
)
5761 chapter_item_c
*p_common_parent
= p_item
;
5763 // leave, up to a common parent
5764 while ( p_common_parent
!= NULL
&& !p_common_parent
->ParentOf( *this ) )
5766 if ( !p_common_parent
->b_is_leaving
&& p_common_parent
->Leave( false ) )
5768 p_common_parent
= p_common_parent
->psz_parent
;
5771 // enter from the parent to <this>
5772 if ( p_common_parent
!= NULL
)
5776 if ( p_common_parent
== this )
5777 return Enter( true );
5779 for ( size_t i
= 0; i
<p_common_parent
->sub_chapters
.size(); i
++ )
5781 if ( p_common_parent
->sub_chapters
[i
]->ParentOf( *this ) )
5783 p_common_parent
= p_common_parent
->sub_chapters
[i
];
5784 if ( p_common_parent
!= this )
5785 if ( p_common_parent
->Enter( false ) )
5794 if ( b_final_enter
)
5795 return Enter( true );
5800 bool dvd_chapter_codec_c::Enter()
5802 bool f_result
= false;
5803 std::vector
<KaxChapterProcessData
*>::iterator index
= enter_cmds
.begin();
5804 while ( index
!= enter_cmds
.end() )
5806 if ( (*index
)->GetSize() )
5808 binary
*p_data
= (*index
)->GetBuffer();
5809 size_t i_size
= *p_data
++;
5810 // avoid reading too much from the buffer
5811 i_size
= min( i_size
, ((*index
)->GetSize() - 1) >> 3 );
5812 for ( ; i_size
> 0; i_size
--, p_data
+= 8 )
5814 msg_Dbg( &sys
.demuxer
, "Matroska DVD enter command" );
5815 f_result
|= sys
.dvd_interpretor
.Interpret( p_data
);
5823 bool dvd_chapter_codec_c::Leave()
5825 bool f_result
= false;
5826 std::vector
<KaxChapterProcessData
*>::iterator index
= leave_cmds
.begin();
5827 while ( index
!= leave_cmds
.end() )
5829 if ( (*index
)->GetSize() )
5831 binary
*p_data
= (*index
)->GetBuffer();
5832 size_t i_size
= *p_data
++;
5833 // avoid reading too much from the buffer
5834 i_size
= min( i_size
, ((*index
)->GetSize() - 1) >> 3 );
5835 for ( ; i_size
> 0; i_size
--, p_data
+= 8 )
5837 msg_Dbg( &sys
.demuxer
, "Matroska DVD leave command" );
5838 f_result
|= sys
.dvd_interpretor
.Interpret( p_data
);
5846 // see http://www.dvd-replica.com/DVD/vmcmdset.php for a description of DVD commands
5847 bool dvd_command_interpretor_c::Interpret( const binary
* p_command
, size_t i_size
)
5852 virtual_segment_c
*p_segment
= NULL
;
5853 chapter_item_c
*p_chapter
= NULL
;
5854 bool f_result
= false;
5855 uint16 i_command
= ( p_command
[0] << 8 ) + p_command
[1];
5857 // handle register tests if there are some
5858 if ( (i_command
& 0xF0) != 0 )
5860 bool b_test_positive
= true;//(i_command & CMD_DVD_IF_NOT) == 0;
5861 bool b_test_value
= (i_command
& CMD_DVD_TEST_VALUE
) != 0;
5862 uint8 i_test
= i_command
& 0x70;
5865 // see http://dvd.sourceforge.net/dvdinfo/vmi.html
5868 switch ( i_command
>> 12 )
5871 i_cr1
= p_command
[3];
5872 i_cr2
= (p_command
[4] << 8) + p_command
[5];
5877 i_cr1
= p_command
[6];
5878 i_cr2
= p_command
[7];
5879 b_test_value
= false;
5883 if ( ((p_command
[1] >> 4) & 0x7) == 0)
5885 i_cr1
= p_command
[2];
5886 i_cr2
= (p_command
[6] << 8) + p_command
[7];
5890 i_cr1
= p_command
[2];
5891 i_cr2
= (p_command
[6] << 8) + p_command
[7];
5899 i_value
= GetPRM( i_cr2
);
5903 case CMD_DVD_IF_GPREG_EQUAL
:
5905 msg_Dbg( &sys
.demuxer
, "IF %s EQUALS %s", GetRegTypeName( false, i_cr1
).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
5906 if (!( GetPRM( i_cr1
) == i_value
))
5908 b_test_positive
= false;
5911 case CMD_DVD_IF_GPREG_NOT_EQUAL
:
5913 msg_Dbg( &sys
.demuxer
, "IF %s NOT EQUALS %s", GetRegTypeName( false, i_cr1
).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
5914 if (!( GetPRM( i_cr1
) != i_value
))
5916 b_test_positive
= false;
5919 case CMD_DVD_IF_GPREG_INF
:
5921 msg_Dbg( &sys
.demuxer
, "IF %s < %s", GetRegTypeName( false, p_command
[3] ).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
5922 if (!( GetPRM( i_cr1
) < i_value
))
5924 b_test_positive
= false;
5927 case CMD_DVD_IF_GPREG_INF_EQUAL
:
5928 // if inferior or equal
5929 msg_Dbg( &sys
.demuxer
, "IF %s < %s", GetRegTypeName( false, p_command
[3] ).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
5930 if (!( GetPRM( i_cr1
) <= i_value
))
5932 b_test_positive
= false;
5935 case CMD_DVD_IF_GPREG_AND
:
5937 msg_Dbg( &sys
.demuxer
, "IF %s & %s", GetRegTypeName( false, p_command
[3] ).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
5938 if (!( GetPRM( i_cr1
) & i_value
))
5940 b_test_positive
= false;
5943 case CMD_DVD_IF_GPREG_SUP
:
5945 msg_Dbg( &sys
.demuxer
, "IF %s >= %s", GetRegTypeName( false, p_command
[3] ).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
5946 if (!( GetPRM( i_cr1
) > i_value
))
5948 b_test_positive
= false;
5951 case CMD_DVD_IF_GPREG_SUP_EQUAL
:
5952 // if superior or equal
5953 msg_Dbg( &sys
.demuxer
, "IF %s >= %s", GetRegTypeName( false, p_command
[3] ).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
5954 if (!( GetPRM( i_cr1
) >= i_value
))
5956 b_test_positive
= false;
5961 if ( !b_test_positive
)
5965 // strip the test command
5966 i_command
&= 0xFF0F;
5968 switch ( i_command
)
5973 msg_Dbg( &sys
.demuxer
, "NOP" );
5978 msg_Dbg( &sys
.demuxer
, "Break" );
5982 case CMD_DVD_JUMP_TT
:
5984 uint8 i_title
= p_command
[5];
5985 msg_Dbg( &sys
.demuxer
, "JumpTT %d", i_title
);
5987 // find in the ChapProcessPrivate matching this Title level
5988 p_chapter
= sys
.BrowseCodecPrivate( 1, MatchTitleNumber
, &i_title
, sizeof(i_title
), p_segment
);
5989 if ( p_segment
!= NULL
)
5991 sys
.JumpTo( *p_segment
, p_chapter
);
5997 case CMD_DVD_CALLSS_VTSM1
:
5999 msg_Dbg( &sys
.demuxer
, "CallSS" );
6001 switch( (p_command
[6] & 0xC0) >> 6 ) {
6003 p_type
= p_command
[5] & 0x0F;
6007 msg_Dbg( &sys
.demuxer
, "CallSS PGC (rsm_cell %x)", p_command
[4]);
6010 msg_Dbg( &sys
.demuxer
, "CallSS Title Entry (rsm_cell %x)", p_command
[4]);
6013 msg_Dbg( &sys
.demuxer
, "CallSS Root Menu (rsm_cell %x)", p_command
[4]);
6016 msg_Dbg( &sys
.demuxer
, "CallSS Subpicture Menu (rsm_cell %x)", p_command
[4]);
6019 msg_Dbg( &sys
.demuxer
, "CallSS Audio Menu (rsm_cell %x)", p_command
[4]);
6022 msg_Dbg( &sys
.demuxer
, "CallSS Angle Menu (rsm_cell %x)", p_command
[4]);
6025 msg_Dbg( &sys
.demuxer
, "CallSS Chapter Menu (rsm_cell %x)", p_command
[4]);
6028 msg_Dbg( &sys
.demuxer
, "CallSS <unknown> (rsm_cell %x)", p_command
[4]);
6031 p_chapter
= sys
.BrowseCodecPrivate( 1, MatchPgcType
, &p_type
, 1, p_segment
);
6032 if ( p_segment
!= NULL
)
6034 sys
.JumpTo( *p_segment
, p_chapter
);
6039 msg_Dbg( &sys
.demuxer
, "CallSS VMGM (menu %d, rsm_cell %x)", p_command
[5] & 0x0F, p_command
[4]);
6042 msg_Dbg( &sys
.demuxer
, "CallSS VTSM (menu %d, rsm_cell %x)", p_command
[5] & 0x0F, p_command
[4]);
6045 msg_Dbg( &sys
.demuxer
, "CallSS VMGM (pgc %d, rsm_cell %x)", (p_command
[2] << 8) + p_command
[3], p_command
[4]);
6050 case CMD_DVD_JUMP_SS
:
6052 msg_Dbg( &sys
.demuxer
, "JumpSS");
6054 switch( (p_command
[5] & 0xC0) >> 6 ) {
6056 msg_Dbg( &sys
.demuxer
, "JumpSS FP");
6059 p_type
= p_command
[5] & 0x0F;
6063 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Title Entry");
6066 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Root Menu");
6069 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Subpicture Menu");
6072 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Audio Menu");
6075 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Angle Menu");
6078 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Chapter Menu");
6081 msg_Dbg( &sys
.demuxer
, "JumpSS <unknown>");
6085 p_chapter
= sys
.BrowseCodecPrivate( 1, MatchIsVMG
, NULL
, 0, p_segment
);
6086 if ( p_segment
!= NULL
)
6088 p_chapter
= p_segment
->BrowseCodecPrivate( 1, MatchPgcType
, &p_type
, 1 );
6089 if ( p_chapter
!= NULL
)
6091 sys
.JumpTo( *p_segment
, p_chapter
);
6097 p_type
= p_command
[5] & 0x0F;
6101 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Title Entry", p_command
[4], p_command
[3]);
6104 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Root Menu", p_command
[4], p_command
[3]);
6107 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Subpicture Menu", p_command
[4], p_command
[3]);
6110 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Audio Menu", p_command
[4], p_command
[3]);
6113 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Angle Menu", p_command
[4], p_command
[3]);
6116 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Chapter Menu", p_command
[4], p_command
[3]);
6119 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) <unknown>", p_command
[4], p_command
[3]);
6123 p_chapter
= sys
.BrowseCodecPrivate( 1, MatchVTSMNumber
, &p_command
[4], 1, p_segment
);
6125 if ( p_segment
!= NULL
&& p_chapter
!= NULL
)
6127 // find the title in the VTS
6128 p_chapter
= p_chapter
->BrowseCodecPrivate( 1, MatchTitleNumber
, &p_command
[3], 1 );
6129 if ( p_chapter
!= NULL
)
6131 // find the specified menu in the VTSM
6132 p_chapter
= p_segment
->BrowseCodecPrivate( 1, MatchPgcType
, &p_type
, 1 );
6133 if ( p_chapter
!= NULL
)
6135 sys
.JumpTo( *p_segment
, p_chapter
);
6140 msg_Dbg( &sys
.demuxer
, "Title (%d) does not exist in this VTS", p_command
[3] );
6143 msg_Dbg( &sys
.demuxer
, "DVD Domain VTS (%d) not found", p_command
[4] );
6146 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM (pgc %d)", (p_command
[2] << 8) + p_command
[3]);
6151 case CMD_DVD_JUMPVTS_PTT
:
6153 uint8 i_title
= p_command
[5];
6154 uint8 i_ptt
= p_command
[3];
6156 msg_Dbg( &sys
.demuxer
, "JumpVTS Title (%d) PTT (%d)", i_title
, i_ptt
);
6158 // find the current VTS content segment
6159 p_chapter
= sys
.p_current_segment
->BrowseCodecPrivate( 1, MatchIsDomain
, NULL
, 0 );
6160 if ( p_chapter
!= NULL
)
6162 int16 i_curr_title
= p_chapter
->GetTitleNumber( );
6163 if ( i_curr_title
> 0 )
6165 p_chapter
= sys
.BrowseCodecPrivate( 1, MatchVTSNumber
, &i_curr_title
, sizeof(i_curr_title
), p_segment
);
6167 if ( p_segment
!= NULL
&& p_chapter
!= NULL
)
6169 // find the title in the VTS
6170 p_chapter
= p_chapter
->BrowseCodecPrivate( 1, MatchTitleNumber
, &i_title
, sizeof(i_title
) );
6171 if ( p_chapter
!= NULL
)
6173 // find the chapter in the title
6174 p_chapter
= p_chapter
->BrowseCodecPrivate( 1, MatchChapterNumber
, &i_ptt
, sizeof(i_ptt
) );
6175 if ( p_chapter
!= NULL
)
6177 sys
.JumpTo( *p_segment
, p_chapter
);
6182 msg_Dbg( &sys
.demuxer
, "Title (%d) does not exist in this VTS", i_title
);
6185 msg_Dbg( &sys
.demuxer
, "DVD Domain VTS (%d) not found", i_curr_title
);
6188 msg_Dbg( &sys
.demuxer
, "JumpVTS_PTT command found but not in a VTS(M)");
6191 msg_Dbg( &sys
.demuxer
, "JumpVTS_PTT command but the DVD domain wasn't found");
6194 case CMD_DVD_SET_GPRMMD
:
6196 msg_Dbg( &sys
.demuxer
, "Set GPRMMD [%d]=%d", (p_command
[4] << 8) + p_command
[5], (p_command
[2] << 8) + p_command
[3]);
6198 if ( !SetGPRM( (p_command
[4] << 8) + p_command
[5], (p_command
[2] << 8) + p_command
[3] ) )
6199 msg_Dbg( &sys
.demuxer
, "Set GPRMMD failed" );
6202 case CMD_DVD_LINKPGCN
:
6204 uint16 i_pgcn
= (p_command
[6] << 8) + p_command
[7];
6206 msg_Dbg( &sys
.demuxer
, "Link PGCN(%d)", i_pgcn
);
6207 p_chapter
= sys
.p_current_segment
->BrowseCodecPrivate( 1, MatchPgcNumber
, &i_pgcn
, 2 );
6208 if ( p_chapter
!= NULL
)
6210 if ( !p_chapter
->Enter( true ) )
6211 // jump to the location in the found segment
6212 sys
.p_current_segment
->Seek( sys
.demuxer
, p_chapter
->i_user_start_time
, -1, p_chapter
);
6218 case CMD_DVD_LINKCN
:
6220 uint8 i_cn
= p_command
[7];
6222 p_chapter
= sys
.p_current_segment
->CurrentChapter();
6224 msg_Dbg( &sys
.demuxer
, "LinkCN (cell %d)", i_cn
);
6225 p_chapter
= p_chapter
->BrowseCodecPrivate( 1, MatchCellNumber
, &i_cn
, 1 );
6226 if ( p_chapter
!= NULL
)
6228 if ( !p_chapter
->Enter( true ) )
6229 // jump to the location in the found segment
6230 sys
.p_current_segment
->Seek( sys
.demuxer
, p_chapter
->i_user_start_time
, -1, p_chapter
);
6236 case CMD_DVD_GOTO_LINE
:
6238 msg_Dbg( &sys
.demuxer
, "GotoLine (%d)", (p_command
[6] << 8) + p_command
[7] );
6242 case CMD_DVD_SET_HL_BTNN1
:
6244 msg_Dbg( &sys
.demuxer
, "SetHL_BTN (%d)", p_command
[4] );
6245 SetSPRM( 0x88, p_command
[4] );
6250 msg_Dbg( &sys
.demuxer
, "unsupported command : %02X %02X %02X %02X %02X %02X %02X %02X"
6266 bool dvd_command_interpretor_c::MatchIsDomain( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6268 return ( data
.p_private_data
!= NULL
&& data
.p_private_data
->GetBuffer()[0] == MATROSKA_DVD_LEVEL_SS
);
6271 bool dvd_command_interpretor_c::MatchIsVMG( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6273 if ( data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 2 )
6276 return ( data
.p_private_data
->GetBuffer()[0] == MATROSKA_DVD_LEVEL_SS
&& data
.p_private_data
->GetBuffer()[1] == 0xC0);
6279 bool dvd_command_interpretor_c::MatchVTSNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6281 if ( i_cookie_size
!= 2 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 4 )
6284 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_SS
|| data
.p_private_data
->GetBuffer()[1] != 0x80 )
6287 uint16 i_gtitle
= (data
.p_private_data
->GetBuffer()[2] << 8 ) + data
.p_private_data
->GetBuffer()[3];
6288 uint16 i_title
= *(uint16
*)p_cookie
;
6290 return (i_gtitle
== i_title
);
6293 bool dvd_command_interpretor_c::MatchVTSMNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6295 if ( i_cookie_size
!= 1 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 4 )
6298 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_SS
|| data
.p_private_data
->GetBuffer()[1] != 0x40 )
6301 uint8 i_gtitle
= data
.p_private_data
->GetBuffer()[3];
6302 uint8 i_title
= *(uint8
*)p_cookie
;
6304 return (i_gtitle
== i_title
);
6307 bool dvd_command_interpretor_c::MatchTitleNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6309 if ( i_cookie_size
!= 1 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 4 )
6312 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_TT
)
6315 uint16 i_gtitle
= (data
.p_private_data
->GetBuffer()[1] << 8 ) + data
.p_private_data
->GetBuffer()[2];
6316 uint8 i_title
= *(uint8
*)p_cookie
;
6318 return (i_gtitle
== i_title
);
6321 bool dvd_command_interpretor_c::MatchPgcType( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6323 if ( i_cookie_size
!= 1 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 8 )
6326 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_PGC
)
6329 uint8 i_pgc_type
= data
.p_private_data
->GetBuffer()[3] & 0x0F;
6330 uint8 i_pgc
= *(uint8
*)p_cookie
;
6332 return (i_pgc_type
== i_pgc
);
6335 bool dvd_command_interpretor_c::MatchPgcNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6337 if ( i_cookie_size
!= 2 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 8 )
6340 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_PGC
)
6343 uint16
*i_pgc_n
= (uint16
*)p_cookie
;
6344 uint16 i_pgc_num
= (data
.p_private_data
->GetBuffer()[1] << 8) + data
.p_private_data
->GetBuffer()[2];
6346 return (i_pgc_num
== *i_pgc_n
);
6349 bool dvd_command_interpretor_c::MatchChapterNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6351 if ( i_cookie_size
!= 1 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 2 )
6354 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_PTT
)
6357 uint8 i_chapter
= data
.p_private_data
->GetBuffer()[1];
6358 uint8 i_ptt
= *(uint8
*)p_cookie
;
6360 return (i_chapter
== i_ptt
);
6363 bool dvd_command_interpretor_c::MatchCellNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6365 if ( i_cookie_size
!= 1 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 5 )
6368 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_CN
)
6371 uint8
*i_cell_n
= (uint8
*)p_cookie
;
6372 uint8 i_cell_num
= data
.p_private_data
->GetBuffer()[3];
6374 return (i_cell_num
== *i_cell_n
);
6377 bool matroska_script_codec_c::Enter()
6379 bool f_result
= false;
6380 std::vector
<KaxChapterProcessData
*>::iterator index
= enter_cmds
.begin();
6381 while ( index
!= enter_cmds
.end() )
6383 if ( (*index
)->GetSize() )
6385 msg_Dbg( &sys
.demuxer
, "Matroska Script enter command" );
6386 f_result
|= interpretor
.Interpret( (*index
)->GetBuffer(), (*index
)->GetSize() );
6393 bool matroska_script_codec_c::Leave()
6395 bool f_result
= false;
6396 std::vector
<KaxChapterProcessData
*>::iterator index
= leave_cmds
.begin();
6397 while ( index
!= leave_cmds
.end() )
6399 if ( (*index
)->GetSize() )
6401 msg_Dbg( &sys
.demuxer
, "Matroska Script leave command" );
6402 f_result
|= interpretor
.Interpret( (*index
)->GetBuffer(), (*index
)->GetSize() );
6409 // see http://www.matroska.org/technical/specs/chapters/index.html#mscript
6410 // for a description of existing commands
6411 bool matroska_script_interpretor_c::Interpret( const binary
* p_command
, size_t i_size
)
6413 bool b_result
= false;
6415 char *psz_str
= (char*) malloc( i_size
+ 1 );
6416 memcpy( psz_str
, p_command
, i_size
);
6417 psz_str
[ i_size
] = '\0';
6419 std::string sz_command
= psz_str
;
6422 msg_Dbg( &sys
.demuxer
, "command : %s", sz_command
.c_str() );
6424 #if defined(__GNUC__) && (__GNUC__ < 3)
6425 if ( sz_command
.compare( CMD_MS_GOTO_AND_PLAY
, 0, CMD_MS_GOTO_AND_PLAY
.size() ) == 0 )
6427 if ( sz_command
.compare( 0, CMD_MS_GOTO_AND_PLAY
.size(), CMD_MS_GOTO_AND_PLAY
) == 0 )
6433 for ( i
=CMD_MS_GOTO_AND_PLAY
.size(); i
<sz_command
.size(); i
++)
6435 if ( sz_command
[i
] == '(' )
6442 for ( j
=i
; j
<sz_command
.size(); j
++)
6444 if ( sz_command
[j
] == ')' )
6451 std::string st
= sz_command
.substr( i
+1, j
-i
-1 );
6452 int64_t i_chapter_uid
= atoi( st
.c_str() );
6454 virtual_segment_c
*p_segment
;
6455 chapter_item_c
*p_chapter
= sys
.FindChapter( i_chapter_uid
, p_segment
);
6457 if ( p_chapter
== NULL
)
6458 msg_Dbg( &sys
.demuxer
, "Chapter "I64Fd
" not found", i_chapter_uid
);
6461 if ( !p_chapter
->EnterAndLeave( sys
.p_current_segment
->CurrentChapter() ) )
6462 p_segment
->Seek( sys
.demuxer
, p_chapter
->i_user_start_time
, -1, p_chapter
);
6470 void demux_sys_t::SwapButtons()
6472 #ifndef WORDS_BIGENDIAN
6473 uint8_t button
, i
, j
;
6475 for( button
= 1; button
<= pci_packet
.hli
.hl_gi
.btn_ns
; button
++) {
6476 btni_t
*button_ptr
= &(pci_packet
.hli
.btnit
[button
-1]);
6477 binary
*p_data
= (binary
*) button_ptr
;
6479 uint16 i_x_start
= ((p_data
[0] & 0x3F) << 4 ) + ( p_data
[1] >> 4 );
6480 uint16 i_x_end
= ((p_data
[1] & 0x03) << 8 ) + p_data
[2];
6481 uint16 i_y_start
= ((p_data
[3] & 0x3F) << 4 ) + ( p_data
[4] >> 4 );
6482 uint16 i_y_end
= ((p_data
[4] & 0x03) << 8 ) + p_data
[5];
6483 button_ptr
->x_start
= i_x_start
;
6484 button_ptr
->x_end
= i_x_end
;
6485 button_ptr
->y_start
= i_y_start
;
6486 button_ptr
->y_end
= i_y_end
;
6489 for ( i
= 0; i
<3; i
++ )
6491 for ( j
= 0; j
<2; j
++ )
6493 pci_packet
.hli
.btn_colit
.btn_coli
[i
][j
] = U32_AT( &pci_packet
.hli
.btn_colit
.btn_coli
[i
][j
] );