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() */
37 #include <vlc_codecs.h> /* BITMAPINFOHEADER, WAVEFORMATEX */
40 #include <vlc_charset.h>
41 #include <vlc_input.h>
42 #include <vlc_demux.h>
55 /* libebml and matroska */
56 #include "ebml/EbmlHead.h"
57 #include "ebml/EbmlSubHead.h"
58 #include "ebml/EbmlStream.h"
59 #include "ebml/EbmlContexts.h"
60 #include "ebml/EbmlVoid.h"
61 #include "ebml/EbmlVersion.h"
62 #include "ebml/StdIOCallback.h"
64 #include "matroska/KaxAttachments.h"
65 #include "matroska/KaxBlock.h"
66 #include "matroska/KaxBlockData.h"
67 #include "matroska/KaxChapters.h"
68 #include "matroska/KaxCluster.h"
69 #include "matroska/KaxClusterData.h"
70 #include "matroska/KaxContexts.h"
71 #include "matroska/KaxCues.h"
72 #include "matroska/KaxCuesData.h"
73 #include "matroska/KaxInfo.h"
74 #include "matroska/KaxInfoData.h"
75 #include "matroska/KaxSeekHead.h"
76 #include "matroska/KaxSegment.h"
77 #include "matroska/KaxTag.h"
78 #include "matroska/KaxTags.h"
79 #include "matroska/KaxTagMulti.h"
80 #include "matroska/KaxTracks.h"
81 #include "matroska/KaxTrackAudio.h"
82 #include "matroska/KaxTrackVideo.h"
83 #include "matroska/KaxTrackEntryData.h"
84 #include "matroska/KaxContentEncoding.h"
85 #include "matroska/KaxVersion.h"
87 #include "ebml/StdIOCallback.h"
89 #if LIBMATROSKA_VERSION < 0x000706
90 START_LIBMATROSKA_NAMESPACE
91 extern const EbmlSemanticContext MATROSKA_DLL_API KaxMatroska_Context
;
92 END_LIBMATROSKA_NAMESPACE
98 #include "mp4/libmp4.h"
104 #define MATROSKA_COMPRESSION_NONE -1
105 #define MATROSKA_COMPRESSION_ZLIB 0
106 #define MATROSKA_COMPRESSION_BLIB 1
107 #define MATROSKA_COMPRESSION_LZOX 2
108 #define MATROSKA_COMPRESSION_HEADER 3
110 #define MKVD_TIMECODESCALE 1000000
112 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
113 #undef ATTRIBUTE_PACKED
114 #undef PRAGMA_PACK_BEGIN
115 #undef PRAGMA_PACK_END
117 #if defined(__GNUC__)
118 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
119 #define ATTRIBUTE_PACKED __attribute__ ((packed))
120 #define PRAGMA_PACK 0
124 #if !defined(ATTRIBUTE_PACKED)
125 #define ATTRIBUTE_PACKED
126 #define PRAGMA_PACK 1
133 /*************************************
134 * taken from libdvdnav / libdvdread
135 **************************************/
138 * DVD Time Information.
144 uint8_t frame_u
; /* The two high bits are the frame rate. */
145 } ATTRIBUTE_PACKED dvd_time_t
;
151 #ifdef WORDS_BIGENDIAN
152 unsigned char zero
: 7; /* 25-31 */
153 unsigned char video_pres_mode_change
: 1; /* 24 */
155 unsigned char karaoke_audio_pres_mode_change
: 1; /* 23 */
156 unsigned char angle_change
: 1;
157 unsigned char subpic_stream_change
: 1;
158 unsigned char audio_stream_change
: 1;
159 unsigned char pause_on
: 1;
160 unsigned char still_off
: 1;
161 unsigned char button_select_or_activate
: 1;
162 unsigned char resume
: 1; /* 16 */
164 unsigned char chapter_menu_call
: 1; /* 15 */
165 unsigned char angle_menu_call
: 1;
166 unsigned char audio_menu_call
: 1;
167 unsigned char subpic_menu_call
: 1;
168 unsigned char root_menu_call
: 1;
169 unsigned char title_menu_call
: 1;
170 unsigned char backward_scan
: 1;
171 unsigned char forward_scan
: 1; /* 8 */
173 unsigned char next_pg_search
: 1; /* 7 */
174 unsigned char prev_or_top_pg_search
: 1;
175 unsigned char time_or_chapter_search
: 1;
176 unsigned char go_up
: 1;
177 unsigned char stop
: 1;
178 unsigned char title_play
: 1;
179 unsigned char chapter_search_or_play
: 1;
180 unsigned char title_or_time_play
: 1; /* 0 */
182 unsigned char video_pres_mode_change
: 1; /* 24 */
183 unsigned char zero
: 7; /* 25-31 */
185 unsigned char resume
: 1; /* 16 */
186 unsigned char button_select_or_activate
: 1;
187 unsigned char still_off
: 1;
188 unsigned char pause_on
: 1;
189 unsigned char audio_stream_change
: 1;
190 unsigned char subpic_stream_change
: 1;
191 unsigned char angle_change
: 1;
192 unsigned char karaoke_audio_pres_mode_change
: 1; /* 23 */
194 unsigned char forward_scan
: 1; /* 8 */
195 unsigned char backward_scan
: 1;
196 unsigned char title_menu_call
: 1;
197 unsigned char root_menu_call
: 1;
198 unsigned char subpic_menu_call
: 1;
199 unsigned char audio_menu_call
: 1;
200 unsigned char angle_menu_call
: 1;
201 unsigned char chapter_menu_call
: 1; /* 15 */
203 unsigned char title_or_time_play
: 1; /* 0 */
204 unsigned char chapter_search_or_play
: 1;
205 unsigned char title_play
: 1;
206 unsigned char stop
: 1;
207 unsigned char go_up
: 1;
208 unsigned char time_or_chapter_search
: 1;
209 unsigned char prev_or_top_pg_search
: 1;
210 unsigned char next_pg_search
: 1; /* 7 */
212 } ATTRIBUTE_PACKED user_ops_t
;
215 * Type to store per-command data.
219 } ATTRIBUTE_PACKED vm_cmd_t
;
220 #define COMMAND_DATA_SIZE 8
223 * PCI General Information
226 uint32_t nv_pck_lbn
; /**< sector address of this nav pack */
227 uint16_t vobu_cat
; /**< 'category' of vobu */
228 uint16_t zero1
; /**< reserved */
229 user_ops_t vobu_uop_ctl
; /**< UOP of vobu */
230 uint32_t vobu_s_ptm
; /**< start presentation time of vobu */
231 uint32_t vobu_e_ptm
; /**< end presentation time of vobu */
232 uint32_t vobu_se_e_ptm
; /**< end ptm of sequence end in vobu */
233 dvd_time_t e_eltm
; /**< Cell elapsed time */
235 } ATTRIBUTE_PACKED pci_gi_t
;
238 * Non Seamless Angle Information
241 uint32_t nsml_agl_dsta
[9]; /**< address of destination vobu in AGL_C#n */
242 } ATTRIBUTE_PACKED nsml_agli_t
;
245 * Highlight General Information
247 * For btngrX_dsp_ty the bits have the following meaning:
248 * 000b: normal 4/3 only buttons
249 * XX1b: wide (16/9) buttons
250 * X1Xb: letterbox buttons
251 * 1XXb: pan&scan buttons
254 uint16_t hli_ss
; /**< status, only low 2 bits 0: no buttons, 1: different 2: equal 3: eual except for button cmds */
255 uint32_t hli_s_ptm
; /**< start ptm of hli */
256 uint32_t hli_e_ptm
; /**< end ptm of hli */
257 uint32_t btn_se_e_ptm
; /**< end ptm of button select */
258 #ifdef WORDS_BIGENDIAN
259 unsigned char zero1
: 2; /**< reserved */
260 unsigned char btngr_ns
: 2; /**< number of button groups 1, 2 or 3 with 36/18/12 buttons */
261 unsigned char zero2
: 1; /**< reserved */
262 unsigned char btngr1_dsp_ty
: 3; /**< display type of subpic stream for button group 1 */
263 unsigned char zero3
: 1; /**< reserved */
264 unsigned char btngr2_dsp_ty
: 3; /**< display type of subpic stream for button group 2 */
265 unsigned char zero4
: 1; /**< reserved */
266 unsigned char btngr3_dsp_ty
: 3; /**< display type of subpic stream for button group 3 */
268 unsigned char btngr1_dsp_ty
: 3;
269 unsigned char zero2
: 1;
270 unsigned char btngr_ns
: 2;
271 unsigned char zero1
: 2;
272 unsigned char btngr3_dsp_ty
: 3;
273 unsigned char zero4
: 1;
274 unsigned char btngr2_dsp_ty
: 3;
275 unsigned char zero3
: 1;
277 uint8_t btn_ofn
; /**< button offset number range 0-255 */
278 uint8_t btn_ns
; /**< number of valid buttons <= 36/18/12 (low 6 bits) */
279 uint8_t nsl_btn_ns
; /**< number of buttons selectable by U_BTNNi (low 6 bits) nsl_btn_ns <= btn_ns */
280 uint8_t zero5
; /**< reserved */
281 uint8_t fosl_btnn
; /**< forcedly selected button (low 6 bits) */
282 uint8_t foac_btnn
; /**< forcedly activated button (low 6 bits) */
283 } ATTRIBUTE_PACKED hl_gi_t
;
287 * Button Color Information Table
288 * Each entry beeing a 32bit word that contains the color indexs and alpha
289 * values to use. They are all represented by 4 bit number and stored
290 * like this [Ci3, Ci2, Ci1, Ci0, A3, A2, A1, A0]. The actual palette
291 * that the indexes reference is in the PGC.
292 * \todo split the uint32_t into a struct
295 uint32_t btn_coli
[3][2]; /**< [button color number-1][select:0/action:1] */
296 } ATTRIBUTE_PACKED btn_colit_t
;
301 * NOTE: I've had to change the structure from the disk layout to get
302 * the packing to work with Sun's Forte C compiler.
303 * The 4 and 7 bytes are 'rotated' was: ABC DEF GHIJ is: ABCG DEFH IJ
306 #ifdef WORDS_BIGENDIAN
307 uint32 btn_coln
: 2; /**< button color number */
308 uint32 x_start
: 10; /**< x start offset within the overlay */
309 uint32 zero1
: 2; /**< reserved */
310 uint32 x_end
: 10; /**< x end offset within the overlay */
312 uint32 zero3
: 2; /**< reserved */
313 uint32 up
: 6; /**< button index when pressing up */
315 uint32 auto_action_mode
: 2; /**< 0: no, 1: activated if selected */
316 uint32 y_start
: 10; /**< y start offset within the overlay */
317 uint32 zero2
: 2; /**< reserved */
318 uint32 y_end
: 10; /**< y end offset within the overlay */
320 uint32 zero4
: 2; /**< reserved */
321 uint32 down
: 6; /**< button index when pressing down */
322 unsigned char zero5
: 2; /**< reserved */
323 unsigned char left
: 6; /**< button index when pressing left */
324 unsigned char zero6
: 2; /**< reserved */
325 unsigned char right
: 6; /**< button index when pressing right */
338 uint32 auto_action_mode
: 2;
342 unsigned char left
: 6;
343 unsigned char zero5
: 2;
344 unsigned char right
: 6;
345 unsigned char zero6
: 2;
348 } ATTRIBUTE_PACKED btni_t
;
351 * Highlight Information
355 btn_colit_t btn_colit
;
357 } ATTRIBUTE_PACKED hli_t
;
364 nsml_agli_t nsml_agli
;
367 } ATTRIBUTE_PACKED pci_t
;
373 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
377 * What's between a directory and a filename?
380 #define DIRECTORY_SEPARATOR '\\'
382 #define DIRECTORY_SEPARATOR '/'
385 using namespace LIBMATROSKA_NAMESPACE
;
388 /*****************************************************************************
390 *****************************************************************************/
391 static int Open ( vlc_object_t
* );
392 static void Close( vlc_object_t
* );
395 set_shortname( "Matroska" );
396 set_description( _("Matroska stream demuxer" ) );
397 set_capability( "demux2", 50 );
398 set_callbacks( Open
, Close
);
399 set_category( CAT_INPUT
);
400 set_subcategory( SUBCAT_INPUT_DEMUX
);
402 add_bool( "mkv-use-ordered-chapters", 1, NULL
,
403 N_("Ordered chapters"),
404 N_("Play ordered chapters as specified in the segment."), VLC_TRUE
);
406 add_bool( "mkv-use-chapter-codec", 1, NULL
,
407 N_("Chapter codecs"),
408 N_("Use chapter codecs found in the segment."), VLC_TRUE
);
410 add_bool( "mkv-preload-local-dir", 1, NULL
,
411 N_("Preload Directory"),
412 N_("Preload matroska files from the same family in the same directory (not good for broken files)."), VLC_TRUE
);
414 add_bool( "mkv-seek-percent", 0, NULL
,
415 N_("Seek based on percent not time"),
416 N_("Seek based on percent not time."), VLC_TRUE
);
418 add_bool( "mkv-use-dummy", 0, NULL
,
419 N_("Dummy Elements"),
420 N_("Read and discard unknown EBML elements (not good for broken files)."), VLC_TRUE
);
422 add_shortcut( "mka" );
423 add_shortcut( "mkv" );
426 /*****************************************************************************
428 *****************************************************************************/
430 block_t
*block_zlib_decompress( vlc_object_t
*p_this
, block_t
*p_in_block
) {
431 int result
, dstsize
, n
;
436 d_stream
.zalloc
= (alloc_func
)0;
437 d_stream
.zfree
= (free_func
)0;
438 d_stream
.opaque
= (voidpf
)0;
439 result
= inflateInit(&d_stream
);
442 msg_Dbg( p_this
, "inflateInit() failed. Result: %d", result
);
446 d_stream
.next_in
= (Bytef
*)p_in_block
->p_buffer
;
447 d_stream
.avail_in
= p_in_block
->i_buffer
;
449 p_block
= block_New( p_this
, 0 );
454 p_block
= block_Realloc( p_block
, 0, n
* 1000 );
455 dst
= (unsigned char *)p_block
->p_buffer
;
456 d_stream
.next_out
= (Bytef
*)&dst
[(n
- 1) * 1000];
457 d_stream
.avail_out
= 1000;
458 result
= inflate(&d_stream
, Z_NO_FLUSH
);
459 if( ( result
!= Z_OK
) && ( result
!= Z_STREAM_END
) )
461 msg_Dbg( p_this
, "Zlib decompression failed. Result: %d", result
);
465 while( ( d_stream
.avail_out
== 0 ) && ( d_stream
.avail_in
!= 0 ) &&
466 ( result
!= Z_STREAM_END
) );
468 dstsize
= d_stream
.total_out
;
469 inflateEnd( &d_stream
);
471 p_block
= block_Realloc( p_block
, 0, dstsize
);
472 p_block
->i_buffer
= dstsize
;
473 block_Release( p_in_block
);
480 * Helper function to print the mkv parse tree
482 static void MkvTree( demux_t
& demuxer
, int i_level
, const char *psz_format
, ... )
487 msg_Err( &demuxer
, "too deep tree" );
490 va_start( args
, psz_format
);
491 static const char psz_foo
[] = "| | | | | | | | | |";
492 char *psz_foo2
= (char*)malloc( ( i_level
* 4 + 3 + strlen( psz_format
) ) * sizeof(char) );
493 strncpy( psz_foo2
, psz_foo
, 4 * i_level
);
494 psz_foo2
[ 4 * i_level
] = '+';
495 psz_foo2
[ 4 * i_level
+ 1 ] = ' ';
496 strcpy( &psz_foo2
[ 4 * i_level
+ 2 ], psz_format
);
497 __msg_GenericVa( VLC_OBJECT(&demuxer
), MSG_QUEUE_NORMAL
, VLC_MSG_DBG
, "mkv", psz_foo2
, args
);
502 /*****************************************************************************
504 *****************************************************************************/
505 class vlc_stream_io_callback
: public IOCallback
513 vlc_stream_io_callback( stream_t
*, vlc_bool_t
);
515 virtual ~vlc_stream_io_callback()
521 virtual uint32
read ( void *p_buffer
, size_t i_size
);
522 virtual void setFilePointer ( int64_t i_offset
, seek_mode mode
= seek_beginning
);
523 virtual size_t write ( const void *p_buffer
, size_t i_size
);
524 virtual uint64
getFilePointer ( void );
525 virtual void close ( void );
528 /*****************************************************************************
530 *****************************************************************************/
534 EbmlParser( EbmlStream
*es
, EbmlElement
*el_start
, demux_t
*p_demux
);
535 virtual ~EbmlParser( void );
539 void Reset( demux_t
*p_demux
);
540 EbmlElement
*Get( void );
542 EbmlElement
*UnGet( uint64 i_block_pos
, uint64 i_cluster_pos
);
544 int GetLevel( void );
549 EbmlElement
*m_el
[10];
550 int64_t mi_remain_size
[10];
560 /*****************************************************************************
561 * Some functions to manipulate memory
562 *****************************************************************************/
563 #define GetFOURCC( p ) __GetFOURCC( (uint8_t*)p )
564 static vlc_fourcc_t
__GetFOURCC( uint8_t *p
)
566 return VLC_FOURCC( p
[0], p
[1], p
[2], p
[3] );
569 /*****************************************************************************
570 * definitions of structures and functions used by this plugins
571 *****************************************************************************/
576 vlc_bool_t b_default
;
577 vlc_bool_t b_enabled
;
578 unsigned int i_number
;
581 uint8_t *p_extra_data
;
585 uint64_t i_default_duration
;
586 float f_timecodescale
;
595 unsigned int i_original_rate
;
598 /* data to be send first */
600 uint8_t *p_data_init
;
602 /* hack : it's for seek */
603 vlc_bool_t b_search_keyframe
;
607 const char *psz_codec_name
;
608 const char *psz_codec_settings
;
609 const char *psz_codec_info_url
;
610 const char *psz_codec_download_url
;
612 /* encryption/compression */
613 int i_compression_type
;
614 KaxContentCompSettings
*p_compression_data
;
631 const binary MATROSKA_DVD_LEVEL_SS
= 0x30;
632 const binary MATROSKA_DVD_LEVEL_LU
= 0x2A;
633 const binary MATROSKA_DVD_LEVEL_TT
= 0x28;
634 const binary MATROSKA_DVD_LEVEL_PGC
= 0x20;
635 const binary MATROSKA_DVD_LEVEL_PG
= 0x18;
636 const binary MATROSKA_DVD_LEVEL_PTT
= 0x10;
637 const binary MATROSKA_DVD_LEVEL_CN
= 0x08;
639 class chapter_codec_cmds_c
642 chapter_codec_cmds_c( demux_sys_t
& demuxer
, int codec_id
= -1)
643 :p_private_data(NULL
)
644 ,i_codec_id( codec_id
)
648 virtual ~chapter_codec_cmds_c()
650 delete p_private_data
;
651 std::vector
<KaxChapterProcessData
*>::iterator indexe
= enter_cmds
.begin();
652 while ( indexe
!= enter_cmds
.end() )
657 std::vector
<KaxChapterProcessData
*>::iterator indexl
= leave_cmds
.begin();
658 while ( indexl
!= leave_cmds
.end() )
663 std::vector
<KaxChapterProcessData
*>::iterator indexd
= during_cmds
.begin();
664 while ( indexd
!= during_cmds
.end() )
671 void SetPrivate( const KaxChapterProcessPrivate
& private_data
)
673 p_private_data
= new KaxChapterProcessPrivate( private_data
);
676 void AddCommand( const KaxChapterProcessCommand
& command
);
678 /// \return wether the codec has seeked in the files or not
679 virtual bool Enter() { return false; }
680 virtual bool Leave() { return false; }
681 virtual std::string
GetCodecName( bool f_for_title
= false ) const { return ""; }
682 virtual int16
GetTitleNumber() { return -1; }
684 KaxChapterProcessPrivate
*p_private_data
;
687 std::vector
<KaxChapterProcessData
*> enter_cmds
;
688 std::vector
<KaxChapterProcessData
*> during_cmds
;
689 std::vector
<KaxChapterProcessData
*> leave_cmds
;
695 class dvd_command_interpretor_c
698 dvd_command_interpretor_c( demux_sys_t
& demuxer
)
701 memset( p_PRMs
, 0, sizeof(p_PRMs
) );
702 p_PRMs
[ 0x80 + 1 ] = 15;
703 p_PRMs
[ 0x80 + 2 ] = 62;
704 p_PRMs
[ 0x80 + 3 ] = 1;
705 p_PRMs
[ 0x80 + 4 ] = 1;
706 p_PRMs
[ 0x80 + 7 ] = 1;
707 p_PRMs
[ 0x80 + 8 ] = 1;
708 p_PRMs
[ 0x80 + 16 ] = 0xFFFFu
;
709 p_PRMs
[ 0x80 + 18 ] = 0xFFFFu
;
712 bool Interpret( const binary
* p_command
, size_t i_size
= 8 );
714 uint16
GetPRM( size_t index
) const
717 return p_PRMs
[ index
];
721 uint16
GetGPRM( size_t index
) const
723 if ( index
>= 0 && index
< 16 )
724 return p_PRMs
[ index
];
728 uint16
GetSPRM( size_t index
) const
730 // 21,22,23 reserved for future use
731 if ( index
>= 0x80 && index
< 0x95 )
732 return p_PRMs
[ index
];
736 bool SetPRM( size_t index
, uint16 value
)
738 if ( index
>= 0 && index
< 16 )
740 p_PRMs
[ index
] = value
;
746 bool SetGPRM( size_t index
, uint16 value
)
748 if ( index
>= 0 && index
< 16 )
750 p_PRMs
[ index
] = value
;
756 bool SetSPRM( size_t index
, uint16 value
)
758 if ( index
> 0x80 && index
<= 0x8D && index
!= 0x8C )
760 p_PRMs
[ index
] = value
;
767 std::string
GetRegTypeName( bool b_value
, uint16 value
) const
770 char s_value
[6], s_reg_value
[6];
771 sprintf( s_value
, "%.5d", value
);
779 else if ( value
< 0x80 )
781 sprintf( s_reg_value
, "%.5d", GetPRM( value
) );
785 result
+= s_reg_value
;
790 sprintf( s_reg_value
, "%.5d", GetPRM( value
) );
794 result
+= s_reg_value
;
806 // wether it's a comparison on the value or register
807 static const uint16 CMD_DVD_TEST_VALUE
= 0x80;
808 static const uint16 CMD_DVD_IF_GPREG_AND
= (1 << 4);
809 static const uint16 CMD_DVD_IF_GPREG_EQUAL
= (2 << 4);
810 static const uint16 CMD_DVD_IF_GPREG_NOT_EQUAL
= (3 << 4);
811 static const uint16 CMD_DVD_IF_GPREG_SUP_EQUAL
= (4 << 4);
812 static const uint16 CMD_DVD_IF_GPREG_SUP
= (5 << 4);
813 static const uint16 CMD_DVD_IF_GPREG_INF_EQUAL
= (6 << 4);
814 static const uint16 CMD_DVD_IF_GPREG_INF
= (7 << 4);
816 static const uint16 CMD_DVD_NOP
= 0x0000;
817 static const uint16 CMD_DVD_GOTO_LINE
= 0x0001;
818 static const uint16 CMD_DVD_BREAK
= 0x0002;
820 static const uint16 CMD_DVD_NOP2
= 0x2001;
821 static const uint16 CMD_DVD_LINKPGCN
= 0x2004;
822 static const uint16 CMD_DVD_LINKPGN
= 0x2006;
823 static const uint16 CMD_DVD_LINKCN
= 0x2007;
824 static const uint16 CMD_DVD_JUMP_TT
= 0x3002;
825 static const uint16 CMD_DVD_JUMPVTS_TT
= 0x3003;
826 static const uint16 CMD_DVD_JUMPVTS_PTT
= 0x3005;
827 static const uint16 CMD_DVD_JUMP_SS
= 0x3006;
828 static const uint16 CMD_DVD_CALLSS_VTSM1
= 0x3008;
830 static const uint16 CMD_DVD_SET_HL_BTNN2
= 0x4600;
831 static const uint16 CMD_DVD_SET_HL_BTNN_LINKPGCN1
= 0x4604;
832 static const uint16 CMD_DVD_SET_STREAM
= 0x5100;
833 static const uint16 CMD_DVD_SET_GPRMMD
= 0x5300;
834 static const uint16 CMD_DVD_SET_HL_BTNN1
= 0x5600;
835 static const uint16 CMD_DVD_SET_HL_BTNN_LINKPGCN2
= 0x5604;
836 static const uint16 CMD_DVD_SET_HL_BTNN_LINKCN
= 0x5607;
838 static const uint16 CMD_DVD_MOV_SPREG_PREG
= 0x6100;
839 static const uint16 CMD_DVD_GPREG_MOV_VALUE
= 0x7100;
840 static const uint16 CMD_DVD_SUB_GPREG
= 0x7400;
841 static const uint16 CMD_DVD_MULT_GPREG
= 0x7500;
842 static const uint16 CMD_DVD_GPREG_DIV_VALUE
= 0x7600;
843 static const uint16 CMD_DVD_GPREG_AND_VALUE
= 0x7900;
845 // callbacks when browsing inside CodecPrivate
846 static bool MatchIsDomain ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
847 static bool MatchIsVMG ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
848 static bool MatchVTSNumber ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
849 static bool MatchVTSMNumber ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
850 static bool MatchTitleNumber ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
851 static bool MatchPgcType ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
852 static bool MatchPgcNumber ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
853 static bool MatchChapterNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
854 static bool MatchCellNumber ( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
);
857 class dvd_chapter_codec_c
: public chapter_codec_cmds_c
860 dvd_chapter_codec_c( demux_sys_t
& sys
)
861 :chapter_codec_cmds_c( sys
, 1 )
866 std::string
GetCodecName( bool f_for_title
= false ) const;
867 int16
GetTitleNumber();
870 class matroska_script_interpretor_c
873 matroska_script_interpretor_c( demux_sys_t
& demuxer
)
877 bool Interpret( const binary
* p_command
, size_t i_size
);
880 static const std::string CMD_MS_GOTO_AND_PLAY
;
886 const std::string
matroska_script_interpretor_c::CMD_MS_GOTO_AND_PLAY
= "GotoAndPlay";
889 class matroska_script_codec_c
: public chapter_codec_cmds_c
892 matroska_script_codec_c( demux_sys_t
& sys
)
893 :chapter_codec_cmds_c( sys
, 0 )
901 matroska_script_interpretor_c interpretor
;
904 class chapter_translation_c
907 chapter_translation_c()
911 ~chapter_translation_c()
916 KaxChapterTranslateID
*p_translated
;
917 unsigned int codec_id
;
918 std::vector
<uint64_t> editions
;
927 ,i_user_start_time(-1)
930 ,b_display_seekpoint(true)
931 ,b_user_display(false)
936 virtual ~chapter_item_c()
938 std::vector
<chapter_codec_cmds_c
*>::iterator index
= codecs
.begin();
939 while ( index
!= codecs
.end() )
944 std::vector
<chapter_item_c
*>::iterator index_
= sub_chapters
.begin();
945 while ( index_
!= sub_chapters
.end() )
952 int64_t RefreshChapters( bool b_ordered
, int64_t i_prev_user_time
);
953 int PublishChapters( input_title_t
& title
, int & i_user_chapters
, int i_level
= 0 );
954 virtual chapter_item_c
* FindTimecode( mtime_t i_timecode
, const chapter_item_c
* p_current
, bool & b_found
);
955 void Append( const chapter_item_c
& edition
);
956 chapter_item_c
* FindChapter( int64_t i_find_uid
);
957 virtual chapter_item_c
*BrowseCodecPrivate( unsigned int codec_id
,
958 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
959 const void *p_cookie
,
960 size_t i_cookie_size
);
961 std::string
GetCodecName( bool f_for_title
= false ) const;
962 bool ParentOf( const chapter_item_c
& item
) const;
963 int16
GetTitleNumber( ) const;
965 int64_t i_start_time
, i_end_time
;
966 int64_t i_user_start_time
, i_user_end_time
; /* the time in the stream when an edition is ordered */
967 std::vector
<chapter_item_c
*> sub_chapters
;
970 bool b_display_seekpoint
;
972 std::string psz_name
;
973 chapter_item_c
*psz_parent
;
976 std::vector
<chapter_codec_cmds_c
*> codecs
;
978 static bool CompareTimecode( const chapter_item_c
* itemA
, const chapter_item_c
* itemB
)
980 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
) );
983 bool Enter( bool b_do_subchapters
);
984 bool Leave( bool b_do_subchapters
);
985 bool EnterAndLeave( chapter_item_c
*p_item
, bool b_enter
= true );
988 class chapter_edition_c
: public chapter_item_c
995 void RefreshChapters( );
996 mtime_t
Duration() const;
997 std::string
GetMainName() const;
998 chapter_item_c
* FindTimecode( mtime_t i_timecode
, const chapter_item_c
* p_current
);
1003 class matroska_segment_c
1006 matroska_segment_c( demux_sys_t
& demuxer
, EbmlStream
& estream
)
1009 ,i_timescale(MKVD_TIMECODESCALE
)
1012 ,i_cues_position(-1)
1013 ,i_chapters_position(-1)
1014 ,i_tags_position(-1)
1019 ,p_segment_uid(NULL
)
1020 ,p_prev_segment_uid(NULL
)
1021 ,p_next_segment_uid(NULL
)
1025 ,psz_muxing_application(NULL
)
1026 ,psz_writing_application(NULL
)
1027 ,psz_segment_filename(NULL
)
1030 ,i_default_edition(0)
1035 p_indexes
= (mkv_index_t
*)malloc( sizeof( mkv_index_t
) * i_index_max
);
1038 virtual ~matroska_segment_c()
1040 for( size_t i_track
= 0; i_track
< tracks
.size(); i_track
++ )
1042 if ( tracks
[i_track
]->p_compression_data
)
1044 delete tracks
[i_track
]->p_compression_data
;
1046 es_format_Clean( &tracks
[i_track
]->fmt
);
1047 if( tracks
[i_track
]->p_extra_data
)
1048 free( tracks
[i_track
]->p_extra_data
);
1049 if( tracks
[i_track
]->psz_codec
)
1050 free( tracks
[i_track
]->psz_codec
);
1051 delete tracks
[i_track
];
1054 if( psz_writing_application
)
1056 free( psz_writing_application
);
1058 if( psz_muxing_application
)
1060 free( psz_muxing_application
);
1062 if( psz_segment_filename
)
1064 free( psz_segment_filename
);
1072 free( psz_date_utc
);
1079 delete p_segment_uid
;
1080 delete p_prev_segment_uid
;
1081 delete p_next_segment_uid
;
1083 std::vector
<chapter_edition_c
*>::iterator index
= stored_editions
.begin();
1084 while ( index
!= stored_editions
.end() )
1089 std::vector
<chapter_translation_c
*>::iterator indext
= translations
.begin();
1090 while ( indext
!= translations
.end() )
1095 std::vector
<KaxSegmentFamily
*>::iterator indexf
= families
.begin();
1096 while ( indexf
!= families
.end() )
1103 KaxSegment
*segment
;
1107 uint64_t i_timescale
;
1109 /* duration of the segment */
1111 mtime_t i_start_time
;
1114 std::vector
<mkv_track_t
*> tracks
;
1117 int64_t i_cues_position
;
1118 int64_t i_chapters_position
;
1119 int64_t i_tags_position
;
1121 KaxCluster
*cluster
;
1123 uint64 i_cluster_pos
;
1124 int64_t i_start_pos
;
1125 KaxSegmentUID
*p_segment_uid
;
1126 KaxPrevUID
*p_prev_segment_uid
;
1127 KaxNextUID
*p_next_segment_uid
;
1132 mkv_index_t
*p_indexes
;
1135 char *psz_muxing_application
;
1136 char *psz_writing_application
;
1137 char *psz_segment_filename
;
1141 /* !!!!! GCC 3.3 bug on Darwin !!!!! */
1142 /* when you remove this variable the compiler issues an atomicity error */
1143 /* this variable only works when using std::vector<chapter_edition_c> */
1144 std::vector
<chapter_edition_c
*> stored_editions
;
1145 int i_default_edition
;
1147 std::vector
<chapter_translation_c
*> translations
;
1148 std::vector
<KaxSegmentFamily
*> families
;
1155 bool PreloadFamily( const matroska_segment_c
& segment
);
1156 void ParseInfo( KaxInfo
*info
);
1157 void ParseChapters( KaxChapters
*chapters
);
1158 void ParseSeekHead( KaxSeekHead
*seekhead
);
1159 void ParseTracks( KaxTracks
*tracks
);
1160 void ParseChapterAtom( int i_level
, KaxChapterAtom
*ca
, chapter_item_c
& chapters
);
1161 void ParseTrackEntry( KaxTrackEntry
*m
);
1162 void ParseCluster( );
1163 void IndexAppendCluster( KaxCluster
*cluster
);
1166 void InformationCreate( );
1167 void Seek( mtime_t i_date
, mtime_t i_time_offset
);
1168 #if LIBMATROSKA_VERSION >= 0x000800
1169 int BlockGet( KaxBlock
* &, KaxSimpleBlock
* &, int64_t *, int64_t *, int64_t *);
1171 int BlockGet( KaxBlock
* &, int64_t *, int64_t *, int64_t *);
1173 bool Select( mtime_t i_start_time
);
1176 static bool CompareSegmentUIDs( const matroska_segment_c
* item_a
, const matroska_segment_c
* item_b
);
1179 // class holding hard-linked segment together in the playback order
1180 class virtual_segment_c
1183 virtual_segment_c( matroska_segment_c
*p_segment
)
1186 ,i_current_segment(0)
1187 ,i_current_edition(-1)
1188 ,psz_current_chapter(NULL
)
1190 linked_segments
.push_back( p_segment
);
1192 AppendUID( p_segment
->p_segment_uid
);
1193 AppendUID( p_segment
->p_prev_segment_uid
);
1194 AppendUID( p_segment
->p_next_segment_uid
);
1198 size_t AddSegment( matroska_segment_c
*p_segment
);
1199 void PreloadLinked( );
1200 mtime_t
Duration( ) const;
1202 void Seek( demux_t
& demuxer
, mtime_t i_date
, mtime_t i_time_offset
, chapter_item_c
*psz_chapter
);
1204 inline chapter_edition_c
*Edition()
1206 if ( i_current_edition
>= 0 && size_t(i_current_edition
) < p_editions
->size() )
1207 return (*p_editions
)[i_current_edition
];
1211 matroska_segment_c
* Segment() const
1213 if ( linked_segments
.size() == 0 || i_current_segment
>= linked_segments
.size() )
1215 return linked_segments
[i_current_segment
];
1218 inline chapter_item_c
*CurrentChapter() {
1219 return psz_current_chapter
;
1224 if ( i_current_segment
< linked_segments
.size()-1 )
1226 i_current_segment
++;
1232 bool FindUID( KaxSegmentUID
& uid
) const
1234 for ( size_t i
=0; i
<linked_uids
.size(); i
++ )
1236 if ( linked_uids
[i
] == uid
)
1242 bool UpdateCurrentToChapter( demux_t
& demux
);
1243 void PrepareChapters( );
1245 chapter_item_c
*BrowseCodecPrivate( unsigned int codec_id
,
1246 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
1247 const void *p_cookie
,
1248 size_t i_cookie_size
);
1249 chapter_item_c
*FindChapter( int64_t i_find_uid
);
1251 std::vector
<chapter_edition_c
*> *p_editions
;
1255 std::vector
<matroska_segment_c
*> linked_segments
;
1256 std::vector
<KaxSegmentUID
> linked_uids
;
1257 size_t i_current_segment
;
1259 int i_current_edition
;
1260 chapter_item_c
*psz_current_chapter
;
1262 void AppendUID( const EbmlBinary
* UID
);
1265 class matroska_stream_c
1268 matroska_stream_c( demux_sys_t
& demuxer
)
1274 virtual ~matroska_stream_c()
1283 std::vector
<matroska_segment_c
*> segments
;
1296 vlc_bool_t b_clicked
;
1304 demux_sys_t( demux_t
& demux
)
1311 ,p_current_segment(NULL
)
1312 ,dvd_interpretor( *this )
1316 ,b_pci_packet_set(false)
1319 vlc_mutex_init( &demuxer
, &lock_demuxer
);
1322 virtual ~demux_sys_t()
1326 for ( i
=0; i
<streams
.size(); i
++ )
1328 for ( i
=0; i
<opened_segments
.size(); i
++ )
1329 delete opened_segments
[i
];
1330 for ( i
=0; i
<used_segments
.size(); i
++ )
1331 delete used_segments
[i
];
1332 if( meta
) vlc_meta_Delete( meta
);
1334 while( titles
.size() )
1335 { vlc_input_title_Delete( titles
.back() ); titles
.pop_back();}
1337 vlc_mutex_destroy( &lock_demuxer
);
1344 mtime_t i_start_pts
;
1345 mtime_t i_chapter_time
;
1349 std::vector
<input_title_t
*> titles
; // matroska editions
1350 size_t i_current_title
;
1352 std::vector
<matroska_stream_c
*> streams
;
1353 std::vector
<matroska_segment_c
*> opened_segments
;
1354 std::vector
<virtual_segment_c
*> used_segments
;
1355 virtual_segment_c
*p_current_segment
;
1357 dvd_command_interpretor_c dvd_interpretor
;
1359 /* duration of the stream */
1362 matroska_segment_c
*FindSegment( const EbmlBinary
& uid
) const;
1363 chapter_item_c
*BrowseCodecPrivate( unsigned int codec_id
,
1364 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
1365 const void *p_cookie
,
1366 size_t i_cookie_size
,
1367 virtual_segment_c
* & p_segment_found
);
1368 chapter_item_c
*FindChapter( int64_t i_find_uid
, virtual_segment_c
* & p_segment_found
);
1370 void PreloadFamily( const matroska_segment_c
& of_segment
);
1371 void PreloadLinked( matroska_segment_c
*p_segment
);
1372 bool PreparePlayback( virtual_segment_c
*p_new_segment
);
1373 matroska_stream_c
*AnalyseAllSegmentsFound( demux_t
*p_demux
, EbmlStream
*p_estream
, bool b_initial
= false );
1374 void JumpTo( virtual_segment_c
& p_segment
, chapter_item_c
* p_chapter
);
1376 void StartUiThread();
1377 void StopUiThread();
1379 inline void SwapButtons();
1381 /* for spu variables */
1382 input_thread_t
*p_input
;
1384 bool b_pci_packet_set
;
1385 uint8_t palette
[4][4];
1386 vlc_mutex_t lock_demuxer
;
1389 event_thread_t
*p_ev
;
1390 static int EventThread( vlc_object_t
*p_this
);
1391 static int EventMouse( vlc_object_t
*p_this
, char const *psz_var
,
1392 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
);
1393 static int EventKey( vlc_object_t
*p_this
, char const *psz_var
,
1394 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
);
1399 virtual_segment_c
*VirtualFromSegments( matroska_segment_c
*p_segment
) const;
1400 bool IsUsedSegment( matroska_segment_c
&p_segment
) const;
1403 static int Demux ( demux_t
* );
1404 static int Control( demux_t
*, int, va_list );
1405 static void Seek ( demux_t
*, mtime_t i_date
, double f_percent
, chapter_item_c
*psz_chapter
);
1407 #define MKV_IS_ID( el, C ) ( EbmlId( (*el) ) == C::ClassInfos.GlobalId )
1409 static inline char * ToUTF8( const UTFstring
&u
)
1411 return strdup( u
.GetUTF8().c_str() );
1414 /*****************************************************************************
1415 * Open: initializes matroska demux structures
1416 *****************************************************************************/
1417 static int Open( vlc_object_t
* p_this
)
1419 demux_t
*p_demux
= (demux_t
*)p_this
;
1421 matroska_stream_c
*p_stream
;
1422 matroska_segment_c
*p_segment
;
1424 std::string s_path
, s_filename
;
1425 vlc_stream_io_callback
*p_io_callback
;
1426 EbmlStream
*p_io_stream
;
1428 /* peek the begining */
1429 if( stream_Peek( p_demux
->s
, &p_peek
, 4 ) < 4 ) return VLC_EGENERIC
;
1431 /* is a valid file */
1432 if( p_peek
[0] != 0x1a || p_peek
[1] != 0x45 ||
1433 p_peek
[2] != 0xdf || p_peek
[3] != 0xa3 ) return VLC_EGENERIC
;
1435 /* Set the demux function */
1436 p_demux
->pf_demux
= Demux
;
1437 p_demux
->pf_control
= Control
;
1438 p_demux
->p_sys
= p_sys
= new demux_sys_t( *p_demux
);
1440 p_io_callback
= new vlc_stream_io_callback( p_demux
->s
, VLC_FALSE
);
1441 p_io_stream
= new EbmlStream( *p_io_callback
);
1443 if( p_io_stream
== NULL
)
1445 msg_Err( p_demux
, "failed to create EbmlStream" );
1446 delete p_io_callback
;
1448 return VLC_EGENERIC
;
1451 p_stream
= p_sys
->AnalyseAllSegmentsFound( p_demux
, p_io_stream
, true );
1452 if( p_stream
== NULL
)
1454 msg_Err( p_demux
, "cannot find KaxSegment" );
1457 p_sys
->streams
.push_back( p_stream
);
1459 p_stream
->p_in
= p_io_callback
;
1460 p_stream
->p_es
= p_io_stream
;
1462 for (size_t i
=0; i
<p_stream
->segments
.size(); i
++)
1464 p_stream
->segments
[i
]->Preload();
1467 p_segment
= p_stream
->segments
[0];
1468 if( p_segment
->cluster
!= NULL
)
1470 msg_Warn( p_demux
, "cannot find any cluster, damaged file ?" );
1472 // reset the stream reading to the first cluster of the segment used
1473 p_stream
->p_in
->setFilePointer( p_segment
->cluster
->GetElementPosition() );
1476 if (config_GetInt( p_demux
, "mkv-preload-local-dir" ))
1478 /* get the files from the same dir from the same family (based on p_demux->psz_path) */
1479 if (p_demux
->psz_path
[0] != '\0' && !strcmp(p_demux
->psz_access
, ""))
1481 // assume it's a regular file
1482 // get the directory path
1483 s_path
= p_demux
->psz_path
;
1484 if (s_path
.at(s_path
.length() - 1) == DIRECTORY_SEPARATOR
)
1486 s_path
= s_path
.substr(0,s_path
.length()-1);
1490 if (s_path
.find_last_of(DIRECTORY_SEPARATOR
) > 0)
1492 s_path
= s_path
.substr(0,s_path
.find_last_of(DIRECTORY_SEPARATOR
));
1496 DIR *p_src_dir
= utf8_opendir(s_path
.c_str());
1498 if (p_src_dir
!= NULL
)
1501 while ((psz_file
= utf8_readdir(p_src_dir
)) != NULL
)
1503 if (strlen(psz_file
) > 4)
1505 s_filename
= s_path
+ DIRECTORY_SEPARATOR
+ psz_file
;
1508 if (!strcasecmp(s_filename
.c_str(), p_demux
->psz_path
))
1510 if (!s_filename
.compare(p_demux
->psz_path
))
1512 continue; // don't reuse the original opened file
1514 #if defined(__GNUC__) && (__GNUC__ < 3)
1515 if (!s_filename
.compare("mkv", s_filename
.length() - 3, 3) ||
1516 !s_filename
.compare("mka", s_filename
.length() - 3, 3))
1518 if (!s_filename
.compare(s_filename
.length() - 3, 3, "mkv") ||
1519 !s_filename
.compare(s_filename
.length() - 3, 3, "mka"))
1522 // test wether this file belongs to our family
1523 stream_t
*p_file_stream
= stream_UrlNew( p_demux
, s_filename
.c_str());
1524 if ( p_file_stream
!= NULL
)
1526 vlc_stream_io_callback
*p_file_io
= new vlc_stream_io_callback( p_file_stream
, VLC_TRUE
);
1527 EbmlStream
*p_estream
= new EbmlStream(*p_file_io
);
1529 p_stream
= p_sys
->AnalyseAllSegmentsFound( p_demux
, p_estream
);
1531 if ( p_stream
== NULL
)
1533 msg_Dbg( p_demux
, "the file '%s' will not be used", s_filename
.c_str() );
1539 p_stream
->p_in
= p_file_io
;
1540 p_stream
->p_es
= p_estream
;
1541 p_sys
->streams
.push_back( p_stream
);
1546 msg_Dbg( p_demux
, "the file '%s' cannot be opened", s_filename
.c_str() );
1552 closedir( p_src_dir
);
1556 p_sys
->PreloadFamily( *p_segment
);
1559 p_sys
->PreloadLinked( p_segment
);
1561 if ( !p_sys
->PreparePlayback( NULL
) )
1563 msg_Err( p_demux
, "cannot use the segment" );
1567 p_sys
->StartUiThread();
1573 return VLC_EGENERIC
;
1576 /*****************************************************************************
1577 * Close: frees unused data
1578 *****************************************************************************/
1579 static void Close( vlc_object_t
*p_this
)
1581 demux_t
*p_demux
= (demux_t
*)p_this
;
1582 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1587 /*****************************************************************************
1589 *****************************************************************************/
1590 static int Control( demux_t
*p_demux
, int i_query
, va_list args
)
1592 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1602 case DEMUX_GET_META
:
1603 p_meta
= (vlc_meta_t
*)va_arg( args
, vlc_meta_t
* );
1604 vlc_meta_Merge( p_meta
, p_sys
->meta
);
1607 case DEMUX_GET_LENGTH
:
1608 pi64
= (int64_t*)va_arg( args
, int64_t * );
1609 if( p_sys
->f_duration
> 0.0 )
1611 *pi64
= (int64_t)(p_sys
->f_duration
* 1000);
1614 return VLC_EGENERIC
;
1616 case DEMUX_GET_POSITION
:
1617 pf
= (double*)va_arg( args
, double * );
1618 if ( p_sys
->f_duration
> 0.0 )
1619 *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
);
1622 case DEMUX_SET_POSITION
:
1623 f
= (double)va_arg( args
, double );
1624 Seek( p_demux
, -1, f
, NULL
);
1627 case DEMUX_GET_TIME
:
1628 pi64
= (int64_t*)va_arg( args
, int64_t * );
1629 *pi64
= p_sys
->i_pts
;
1632 case DEMUX_GET_TITLE_INFO
:
1633 if( p_sys
->titles
.size() )
1635 input_title_t
***ppp_title
= (input_title_t
***)va_arg( args
, input_title_t
*** );
1636 int *pi_int
= (int*)va_arg( args
, int* );
1638 *pi_int
= p_sys
->titles
.size();
1639 *ppp_title
= (input_title_t
**)malloc( sizeof( input_title_t
**) * p_sys
->titles
.size() );
1641 for( size_t i
= 0; i
< p_sys
->titles
.size(); i
++ )
1643 (*ppp_title
)[i
] = vlc_input_title_Duplicate( p_sys
->titles
[i
] );
1648 return VLC_EGENERIC
;
1650 case DEMUX_SET_TITLE
:
1651 /* TODO handle editions as titles */
1652 i_idx
= (int)va_arg( args
, int );
1653 if( i_idx
< p_sys
->used_segments
.size() )
1655 p_sys
->JumpTo( *p_sys
->used_segments
[i_idx
], NULL
);
1658 return VLC_EGENERIC
;
1660 case DEMUX_SET_SEEKPOINT
:
1661 i_skp
= (int)va_arg( args
, int );
1663 // TODO change the way it works with the << & >> buttons on the UI (+1/-1 instead of a number)
1664 if( p_sys
->titles
.size() && i_skp
< p_sys
->titles
[p_sys
->i_current_title
]->i_seekpoint
)
1666 Seek( p_demux
, (int64_t)p_sys
->titles
[p_sys
->i_current_title
]->seekpoint
[i_skp
]->i_time_offset
, -1, NULL
);
1667 p_demux
->info
.i_seekpoint
|= INPUT_UPDATE_SEEKPOINT
;
1668 p_demux
->info
.i_seekpoint
= i_skp
;
1671 return VLC_EGENERIC
;
1673 case DEMUX_SET_TIME
:
1676 return VLC_EGENERIC
;
1680 #if LIBMATROSKA_VERSION >= 0x000800
1681 int matroska_segment_c::BlockGet( KaxBlock
* & pp_block
, KaxSimpleBlock
* & pp_simpleblock
, int64_t *pi_ref1
, int64_t *pi_ref2
, int64_t *pi_duration
)
1683 int matroska_segment_c::BlockGet( KaxBlock
* & pp_block
, int64_t *pi_ref1
, int64_t *pi_ref2
, int64_t *pi_duration
)
1686 #if LIBMATROSKA_VERSION >= 0x000800
1687 pp_simpleblock
= NULL
;
1695 EbmlElement
*el
= NULL
;
1699 return VLC_EGENERIC
;
1701 #if LIBMATROSKA_VERSION >= 0x000800
1702 if( pp_simpleblock
!= NULL
|| ((el
= ep
->Get()) == NULL
&& pp_block
!= NULL
) )
1704 if( (el
= ep
->Get()) == NULL
&& pp_block
!= NULL
)
1707 /* update the index */
1708 #define idx p_indexes[i_index - 1]
1709 if( i_index
> 0 && idx
.i_time
== -1 )
1711 #if LIBMATROSKA_VERSION >= 0x000800
1712 if ( pp_simpleblock
!= NULL
)
1713 idx
.i_time
= pp_simpleblock
->GlobalTimecode() / (mtime_t
)1000;
1716 idx
.i_time
= (*pp_block
).GlobalTimecode() / (mtime_t
)1000;
1717 idx
.b_key
= *pi_ref1
== 0 ? VLC_TRUE
: VLC_FALSE
;
1723 i_level
= ep
->GetLevel();
1732 msg_Warn( &sys
.demuxer
, "EOF" );
1733 return VLC_EGENERIC
;
1740 if( MKV_IS_ID( el
, KaxCluster
) )
1742 cluster
= (KaxCluster
*)el
;
1743 i_cluster_pos
= cluster
->GetElementPosition();
1745 /* add it to the index */
1747 ( i_index
> 0 && p_indexes
[i_index
- 1].i_position
< (int64_t)cluster
->GetElementPosition() ) )
1749 IndexAppendCluster( cluster
);
1752 // reset silent tracks
1753 for (size_t i
=0; i
<tracks
.size(); i
++)
1755 tracks
[i
]->b_silent
= VLC_FALSE
;
1760 else if( MKV_IS_ID( el
, KaxCues
) )
1762 msg_Warn( &sys
.demuxer
, "find KaxCues FIXME" );
1763 return VLC_EGENERIC
;
1767 msg_Dbg( &sys
.demuxer
, "unknown (%s)", typeid( el
).name() );
1771 if( MKV_IS_ID( el
, KaxClusterTimecode
) )
1773 KaxClusterTimecode
&ctc
= *(KaxClusterTimecode
*)el
;
1775 ctc
.ReadData( es
.I_O(), SCOPE_ALL_DATA
);
1776 cluster
->InitTimecode( uint64( ctc
), i_timescale
);
1778 else if( MKV_IS_ID( el
, KaxClusterSilentTracks
) )
1782 else if( MKV_IS_ID( el
, KaxBlockGroup
) )
1784 i_block_pos
= el
->GetElementPosition();
1787 #if LIBMATROSKA_VERSION >= 0x000800
1788 else if( MKV_IS_ID( el
, KaxSimpleBlock
) )
1790 pp_simpleblock
= (KaxSimpleBlock
*)el
;
1792 pp_simpleblock
->ReadData( es
.I_O() );
1793 pp_simpleblock
->SetParent( *cluster
);
1798 if( MKV_IS_ID( el
, KaxBlock
) )
1800 pp_block
= (KaxBlock
*)el
;
1802 pp_block
->ReadData( es
.I_O() );
1803 pp_block
->SetParent( *cluster
);
1807 else if( MKV_IS_ID( el
, KaxBlockDuration
) )
1809 KaxBlockDuration
&dur
= *(KaxBlockDuration
*)el
;
1811 dur
.ReadData( es
.I_O() );
1812 *pi_duration
= uint64( dur
);
1814 else if( MKV_IS_ID( el
, KaxReferenceBlock
) )
1816 KaxReferenceBlock
&ref
= *(KaxReferenceBlock
*)el
;
1818 ref
.ReadData( es
.I_O() );
1821 *pi_ref1
= int64( ref
) * cluster
->GlobalTimecodeScale();
1823 else if( *pi_ref2
== 0 )
1825 *pi_ref2
= int64( ref
) * cluster
->GlobalTimecodeScale();
1828 else if( MKV_IS_ID( el
, KaxClusterSilentTrackNumber
) )
1830 KaxClusterSilentTrackNumber
&track_num
= *(KaxClusterSilentTrackNumber
*)el
;
1831 track_num
.ReadData( es
.I_O() );
1833 for (size_t i
=0; i
<tracks
.size(); i
++)
1835 if ( tracks
[i
]->i_number
== uint32(track_num
))
1837 tracks
[i
]->b_silent
= VLC_TRUE
;
1844 msg_Err( &sys
.demuxer
, "invalid level = %d", i_level
);
1845 return VLC_EGENERIC
;
1850 static block_t
*MemToBlock( demux_t
*p_demux
, uint8_t *p_mem
, int i_mem
, size_t offset
)
1853 if( !(p_block
= block_New( p_demux
, i_mem
+ offset
) ) ) return NULL
;
1854 memcpy( p_block
->p_buffer
+ offset
, p_mem
, i_mem
);
1855 //p_block->i_rate = p_input->stream.control.i_rate;
1859 #if LIBMATROSKA_VERSION >= 0x000800
1860 static void BlockDecode( demux_t
*p_demux
, KaxBlock
*block
, KaxSimpleBlock
*simpleblock
,
1861 mtime_t i_pts
, mtime_t i_duration
, bool f_mandatory
)
1863 static void BlockDecode( demux_t
*p_demux
, KaxBlock
*block
, mtime_t i_pts
,
1864 mtime_t i_duration
, bool f_mandatory
)
1867 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1868 matroska_segment_c
*p_segment
= p_sys
->p_current_segment
->Segment();
1874 #define tk p_segment->tracks[i_track]
1875 for( i_track
= 0; i_track
< p_segment
->tracks
.size(); i_track
++ )
1877 #if LIBMATROSKA_VERSION >= 0x000800
1878 if( (block
!= NULL
&& tk
->i_number
== block
->TrackNum()) ||
1879 (simpleblock
!= NULL
&& tk
->i_number
== simpleblock
->TrackNum()))
1881 if( tk
->i_number
== block
->TrackNum() )
1888 if( i_track
>= p_segment
->tracks
.size() )
1890 msg_Err( p_demux
, "invalid track number" );
1893 if( tk
->fmt
.i_cat
!= NAV_ES
&& tk
->p_es
== NULL
)
1895 msg_Err( p_demux
, "unknown track number" );
1898 if( i_pts
+ i_duration
< p_sys
->i_start_pts
&& tk
->fmt
.i_cat
== AUDIO_ES
)
1900 return; /* discard audio packets that shouldn't be rendered */
1903 if ( tk
->fmt
.i_cat
!= NAV_ES
)
1905 es_out_Control( p_demux
->out
, ES_OUT_GET_ES_STATE
, tk
->p_es
, &b
);
1909 tk
->b_inited
= VLC_FALSE
;
1915 /* First send init data */
1916 if( !tk
->b_inited
&& tk
->i_data_init
> 0 )
1920 msg_Dbg( p_demux
, "sending header (%d bytes)", tk
->i_data_init
);
1921 p_init
= MemToBlock( p_demux
, tk
->p_data_init
, tk
->i_data_init
, 0 );
1922 if( p_init
) es_out_Send( p_demux
->out
, tk
->p_es
, p_init
);
1924 tk
->b_inited
= VLC_TRUE
;
1927 #if LIBMATROSKA_VERSION >= 0x000800
1929 (block
!= NULL
&& i
< block
->NumberFrames()) || (simpleblock
!= NULL
&& i
< simpleblock
->NumberFrames());
1932 for( i
= 0; i
< block
->NumberFrames(); i
++ )
1937 #if LIBMATROSKA_VERSION >= 0x000800
1938 if ( simpleblock
!= NULL
)
1940 data
= &simpleblock
->GetBuffer(i
);
1941 // condition when the DTS is correct (keyframe or B frame == NOT P frame)
1942 f_mandatory
= simpleblock
->IsDiscardable() || simpleblock
->IsKeyframe();
1946 data
= &block
->GetBuffer(i
);
1948 if( tk
->i_compression_type
== MATROSKA_COMPRESSION_HEADER
&& tk
->p_compression_data
!= NULL
)
1949 p_block
= MemToBlock( p_demux
, data
->Buffer(), data
->Size(), tk
->p_compression_data
->GetSize() );
1951 p_block
= MemToBlock( p_demux
, data
->Buffer(), data
->Size(), 0 );
1953 if( p_block
== NULL
)
1958 #if defined(HAVE_ZLIB_H)
1959 if( tk
->i_compression_type
== MATROSKA_COMPRESSION_ZLIB
)
1961 p_block
= block_zlib_decompress( VLC_OBJECT(p_demux
), p_block
);
1965 if( tk
->i_compression_type
== MATROSKA_COMPRESSION_HEADER
)
1967 memcpy( p_block
->p_buffer
, tk
->p_compression_data
->GetBuffer(), tk
->p_compression_data
->GetSize() );
1970 if ( tk
->fmt
.i_cat
== NAV_ES
)
1972 // TODO handle the start/stop times of this packet
1973 if ( p_sys
->b_ui_hooked
)
1975 vlc_mutex_lock( &p_sys
->p_ev
->lock
);
1976 memcpy( &p_sys
->pci_packet
, &p_block
->p_buffer
[1], sizeof(pci_t
) );
1977 p_sys
->SwapButtons();
1978 p_sys
->b_pci_packet_set
= true;
1979 vlc_mutex_unlock( &p_sys
->p_ev
->lock
);
1980 block_Release( p_block
);
1984 // correct timestamping when B frames are used
1985 if( tk
->fmt
.i_cat
!= VIDEO_ES
)
1987 p_block
->i_dts
= p_block
->i_pts
= i_pts
;
1991 if( !strcmp( tk
->psz_codec
, "V_MS/VFW/FOURCC" ) )
1993 // in VFW we have no idea about B frames
1995 p_block
->i_dts
= i_pts
;
1999 p_block
->i_pts
= i_pts
;
2001 p_block
->i_dts
= p_block
->i_pts
;
2003 p_block
->i_dts
= min( i_pts
, tk
->i_last_dts
+ (mtime_t
)(tk
->i_default_duration
>> 10));
2004 p_sys
->i_pts
= p_block
->i_dts
;
2007 tk
->i_last_dts
= p_block
->i_dts
;
2010 msg_Dbg( p_demux
, "block i_dts: "I64Fd
" / i_pts: "I64Fd
, p_block
->i_dts
, p_block
->i_pts
);
2012 if( strcmp( tk
->psz_codec
, "S_VOBSUB" ) )
2014 p_block
->i_length
= i_duration
* 1000;
2017 es_out_Send( p_demux
->out
, tk
->p_es
, p_block
);
2019 /* use time stamp only for first block */
2026 matroska_stream_c
*demux_sys_t::AnalyseAllSegmentsFound( demux_t
*p_demux
, EbmlStream
*p_estream
, bool b_initial
)
2028 int i_upper_lvl
= 0;
2030 EbmlElement
*p_l0
, *p_l1
, *p_l2
;
2031 bool b_keep_stream
= false, b_keep_segment
;
2033 // verify the EBML Header
2034 p_l0
= p_estream
->FindNextID(EbmlHead::ClassInfos
, 0xFFFFFFFFL
);
2037 msg_Err( p_demux
, "No EBML header found" );
2041 // verify we can read this Segment, we only support Matroska version 1 for now
2042 p_l0
->Read(*p_estream
, EbmlHead::ClassInfos
.Context
, i_upper_lvl
, p_l0
, true);
2044 EDocType doc_type
= GetChild
<EDocType
>(*static_cast<EbmlHead
*>(p_l0
));
2045 if (std::string(doc_type
) != "matroska")
2047 msg_Err( p_demux
, "Not a Matroska file : DocType = %s ", std::string(doc_type
).c_str());
2051 EDocTypeReadVersion doc_read_version
= GetChild
<EDocTypeReadVersion
>(*static_cast<EbmlHead
*>(p_l0
));
2052 #if LIBMATROSKA_VERSION >= 0x000800
2053 if (uint64(doc_read_version
) > 2)
2055 msg_Err( p_demux
, "This matroska file is needs version "I64Fd
" and this VLC only supports version 1 & 2", uint64(doc_read_version
));
2059 if (uint64(doc_read_version
) != 1)
2061 msg_Err( p_demux
, "This matroska file is needs version "I64Fd
" and this VLC only supports version 1", uint64(doc_read_version
));
2069 // find all segments in this file
2070 p_l0
= p_estream
->FindNextID(KaxSegment::ClassInfos
, 0xFFFFFFFFFLL
);
2076 matroska_stream_c
*p_stream1
= new matroska_stream_c( *this );
2080 if (EbmlId(*p_l0
) == KaxSegment::ClassInfos
.GlobalId
)
2083 matroska_segment_c
*p_segment1
= new matroska_segment_c( *this, *p_estream
);
2084 b_keep_segment
= b_initial
;
2086 ep
= new EbmlParser(p_estream
, p_l0
, &demuxer
);
2087 p_segment1
->ep
= ep
;
2088 p_segment1
->segment
= (KaxSegment
*)p_l0
;
2090 while ((p_l1
= ep
->Get()))
2092 if (MKV_IS_ID(p_l1
, KaxInfo
))
2094 // find the families of this segment
2095 KaxInfo
*p_info
= static_cast<KaxInfo
*>(p_l1
);
2097 p_info
->Read(*p_estream
, KaxInfo::ClassInfos
.Context
, i_upper_lvl
, p_l2
, true);
2098 for( i
= 0; i
< p_info
->ListSize(); i
++ )
2100 EbmlElement
*l
= (*p_info
)[i
];
2102 if( MKV_IS_ID( l
, KaxSegmentUID
) )
2104 KaxSegmentUID
*p_uid
= static_cast<KaxSegmentUID
*>(l
);
2105 b_keep_segment
= (FindSegment( *p_uid
) == NULL
);
2106 if ( !b_keep_segment
)
2107 break; // this segment is already known
2108 opened_segments
.push_back( p_segment1
);
2109 delete p_segment1
->p_segment_uid
;
2110 p_segment1
->p_segment_uid
= new KaxSegmentUID(*p_uid
);
2112 else if( MKV_IS_ID( l
, KaxPrevUID
) )
2114 p_segment1
->p_prev_segment_uid
= new KaxPrevUID( *static_cast<KaxPrevUID
*>(l
) );
2116 else if( MKV_IS_ID( l
, KaxNextUID
) )
2118 p_segment1
->p_next_segment_uid
= new KaxNextUID( *static_cast<KaxNextUID
*>(l
) );
2120 else if( MKV_IS_ID( l
, KaxSegmentFamily
) )
2122 KaxSegmentFamily
*p_fam
= new KaxSegmentFamily( *static_cast<KaxSegmentFamily
*>(l
) );
2123 p_segment1
->families
.push_back( p_fam
);
2129 if ( b_keep_segment
)
2131 b_keep_stream
= true;
2132 p_stream1
->segments
.push_back( p_segment1
);
2137 if (p_l0
->IsFiniteSize() )
2139 p_l0
->SkipData(*p_estream
, KaxMatroska_Context
);
2140 p_l0
= p_estream
->FindNextID(KaxSegment::ClassInfos
, 0xFFFFFFFFL
);
2143 p_l0
= p_l0
->SkipData(*p_estream
, KaxSegment_Context
);
2146 if ( !b_keep_stream
)
2155 bool matroska_segment_c::Select( mtime_t i_start_time
)
2160 msg_Dbg( &sys
.demuxer
, "found %d es", (int)tracks
.size() );
2161 sys
.b_pci_packet_set
= false;
2163 for( i_track
= 0; i_track
< tracks
.size(); i_track
++ )
2165 if( tracks
[i_track
]->fmt
.i_cat
== UNKNOWN_ES
)
2167 msg_Warn( &sys
.demuxer
, "invalid track[%d, n=%d]", (int)i_track
, tracks
[i_track
]->i_number
);
2168 tracks
[i_track
]->p_es
= NULL
;
2172 if( !strcmp( tracks
[i_track
]->psz_codec
, "V_MS/VFW/FOURCC" ) )
2174 if( tracks
[i_track
]->i_extra_data
< (int)sizeof( BITMAPINFOHEADER
) )
2176 msg_Err( &sys
.demuxer
, "missing/invalid BITMAPINFOHEADER" );
2177 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'u', 'n', 'd', 'f' );
2181 BITMAPINFOHEADER
*p_bih
= (BITMAPINFOHEADER
*)tracks
[i_track
]->p_extra_data
;
2183 tracks
[i_track
]->fmt
.video
.i_width
= GetDWLE( &p_bih
->biWidth
);
2184 tracks
[i_track
]->fmt
.video
.i_height
= GetDWLE( &p_bih
->biHeight
);
2185 tracks
[i_track
]->fmt
.i_codec
= GetFOURCC( &p_bih
->biCompression
);
2187 tracks
[i_track
]->fmt
.i_extra
= GetDWLE( &p_bih
->biSize
) - sizeof( BITMAPINFOHEADER
);
2188 if( tracks
[i_track
]->fmt
.i_extra
> 0 )
2190 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->fmt
.i_extra
);
2191 memcpy( tracks
[i_track
]->fmt
.p_extra
, &p_bih
[1], tracks
[i_track
]->fmt
.i_extra
);
2195 else if( !strcmp( tracks
[i_track
]->psz_codec
, "V_MPEG1" ) ||
2196 !strcmp( tracks
[i_track
]->psz_codec
, "V_MPEG2" ) )
2198 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'm', 'p', 'g', 'v' );
2200 else if( !strncmp( tracks
[i_track
]->psz_codec
, "V_THEORA", 8 ) )
2202 uint8_t *p_data
= tracks
[i_track
]->p_extra_data
;
2203 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 't', 'h', 'e', 'o' );
2204 if( tracks
[i_track
]->i_extra_data
>= 4 ) {
2205 if( p_data
[0] == 2 ) {
2207 int i_size1
= 0, i_size2
= 0;
2209 /* read size of first header packet */
2210 while( *p_data
== 0xFF &&
2211 i
< tracks
[i_track
]->i_extra_data
)
2220 msg_Dbg( &sys
.demuxer
, "first theora header size %d", i_size1
);
2221 /* read size of second header packet */
2222 while( *p_data
== 0xFF &&
2223 i
< tracks
[i_track
]->i_extra_data
)
2232 int i_size3
= tracks
[i_track
]->i_extra_data
- i
- i_size1
2234 msg_Dbg( &sys
.demuxer
, "second theora header size %d", i_size2
);
2235 msg_Dbg( &sys
.demuxer
, "third theora header size %d", i_size3
);
2236 tracks
[i_track
]->fmt
.i_extra
= i_size1
+ i_size2
+ i_size3
2238 if( i_size1
> 0 && i_size2
> 0 && i_size3
> 0 ) {
2239 tracks
[i_track
]->fmt
.p_extra
=
2240 malloc( tracks
[i_track
]->fmt
.i_extra
);
2241 uint8_t *p_out
= (uint8_t*)tracks
[i_track
]->fmt
.p_extra
;
2242 *p_out
++ = (i_size1
>>8) & 0xFF;
2243 *p_out
++ = i_size1
& 0xFF;
2244 memcpy( p_out
, p_data
, i_size1
);
2248 *p_out
++ = (i_size2
>>8) & 0xFF;
2249 *p_out
++ = i_size2
& 0xFF;
2250 memcpy( p_out
, p_data
, i_size2
);
2254 *p_out
++ = (i_size3
>>8) & 0xFF;
2255 *p_out
++ = i_size3
& 0xFF;
2256 memcpy( p_out
, p_data
, i_size3
);
2262 msg_Err( &sys
.demuxer
, "inconsistant theora extradata" );
2266 msg_Err( &sys
.demuxer
, "Wrong number of ogg packets with theora headers (%d)", p_data
[0] + 1 );
2270 else if( !strncmp( tracks
[i_track
]->psz_codec
, "V_MPEG4", 7 ) )
2272 if( !strcmp( tracks
[i_track
]->psz_codec
, "V_MPEG4/MS/V3" ) )
2274 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'D', 'I', 'V', '3' );
2276 else if( !strncmp( tracks
[i_track
]->psz_codec
, "V_MPEG4/ISO", 11 ) )
2278 /* A MPEG 4 codec, SP, ASP, AP or AVC */
2279 if( !strcmp( tracks
[i_track
]->psz_codec
, "V_MPEG4/ISO/AVC" ) )
2280 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'a', 'v', 'c', '1' );
2282 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'm', 'p', '4', 'v' );
2283 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2284 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2285 memcpy( tracks
[i_track
]->fmt
.p_extra
,tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2288 else if( !strcmp( tracks
[i_track
]->psz_codec
, "V_QUICKTIME" ) )
2290 MP4_Box_t
*p_box
= (MP4_Box_t
*)malloc( sizeof( MP4_Box_t
) );
2291 stream_t
*p_mp4_stream
= stream_MemoryNew( VLC_OBJECT(&sys
.demuxer
),
2292 tracks
[i_track
]->p_extra_data
,
2293 tracks
[i_track
]->i_extra_data
,
2295 MP4_ReadBoxCommon( p_mp4_stream
, p_box
);
2296 MP4_ReadBox_sample_vide( p_mp4_stream
, p_box
);
2297 tracks
[i_track
]->fmt
.i_codec
= p_box
->i_type
;
2298 tracks
[i_track
]->fmt
.video
.i_width
= p_box
->data
.p_sample_vide
->i_width
;
2299 tracks
[i_track
]->fmt
.video
.i_height
= p_box
->data
.p_sample_vide
->i_height
;
2300 tracks
[i_track
]->fmt
.i_extra
= p_box
->data
.p_sample_vide
->i_qt_image_description
;
2301 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->fmt
.i_extra
);
2302 memcpy( tracks
[i_track
]->fmt
.p_extra
, p_box
->data
.p_sample_vide
->p_qt_image_description
, tracks
[i_track
]->fmt
.i_extra
);
2303 MP4_FreeBox_sample_vide( p_box
);
2304 stream_Delete( p_mp4_stream
);
2306 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_MS/ACM" ) )
2308 if( tracks
[i_track
]->i_extra_data
< (int)sizeof( WAVEFORMATEX
) )
2310 msg_Err( &sys
.demuxer
, "missing/invalid WAVEFORMATEX" );
2311 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'u', 'n', 'd', 'f' );
2315 WAVEFORMATEX
*p_wf
= (WAVEFORMATEX
*)tracks
[i_track
]->p_extra_data
;
2317 wf_tag_to_fourcc( GetWLE( &p_wf
->wFormatTag
), &tracks
[i_track
]->fmt
.i_codec
, NULL
);
2319 tracks
[i_track
]->fmt
.audio
.i_channels
= GetWLE( &p_wf
->nChannels
);
2320 tracks
[i_track
]->fmt
.audio
.i_rate
= GetDWLE( &p_wf
->nSamplesPerSec
);
2321 tracks
[i_track
]->fmt
.i_bitrate
= GetDWLE( &p_wf
->nAvgBytesPerSec
) * 8;
2322 tracks
[i_track
]->fmt
.audio
.i_blockalign
= GetWLE( &p_wf
->nBlockAlign
);;
2323 tracks
[i_track
]->fmt
.audio
.i_bitspersample
= GetWLE( &p_wf
->wBitsPerSample
);
2325 tracks
[i_track
]->fmt
.i_extra
= GetWLE( &p_wf
->cbSize
);
2326 if( tracks
[i_track
]->fmt
.i_extra
> 0 )
2328 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->fmt
.i_extra
);
2329 memcpy( tracks
[i_track
]->fmt
.p_extra
, &p_wf
[1], tracks
[i_track
]->fmt
.i_extra
);
2333 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_MPEG/L3" ) ||
2334 !strcmp( tracks
[i_track
]->psz_codec
, "A_MPEG/L2" ) ||
2335 !strcmp( tracks
[i_track
]->psz_codec
, "A_MPEG/L1" ) )
2337 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'm', 'p', 'g', 'a' );
2339 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_AC3" ) )
2341 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'a', '5', '2', ' ' );
2343 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_DTS" ) )
2345 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'd', 't', 's', ' ' );
2347 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_FLAC" ) )
2349 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'f', 'l', 'a', 'c' );
2350 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2351 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2352 memcpy( tracks
[i_track
]->fmt
.p_extra
,tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2354 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_VORBIS" ) )
2356 int i
, i_offset
= 1, i_size
[3], i_extra
;
2359 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'v', 'o', 'r', 'b' );
2361 /* Split the 3 headers */
2362 if( tracks
[i_track
]->p_extra_data
[0] != 0x02 )
2363 msg_Err( &sys
.demuxer
, "invalid vorbis header" );
2365 for( i
= 0; i
< 2; i
++ )
2368 while( i_offset
< tracks
[i_track
]->i_extra_data
)
2370 i_size
[i
] += tracks
[i_track
]->p_extra_data
[i_offset
];
2371 if( tracks
[i_track
]->p_extra_data
[i_offset
++] != 0xff ) break;
2375 i_size
[0] = __MIN(i_size
[0], tracks
[i_track
]->i_extra_data
- i_offset
);
2376 i_size
[1] = __MIN(i_size
[1], tracks
[i_track
]->i_extra_data
-i_offset
-i_size
[0]);
2377 i_size
[2] = tracks
[i_track
]->i_extra_data
- i_offset
- i_size
[0] - i_size
[1];
2379 tracks
[i_track
]->fmt
.i_extra
= 3 * 2 + i_size
[0] + i_size
[1] + i_size
[2];
2380 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->fmt
.i_extra
);
2381 p_extra
= (uint8_t *)tracks
[i_track
]->fmt
.p_extra
; i_extra
= 0;
2382 for( i
= 0; i
< 3; i
++ )
2384 *(p_extra
++) = i_size
[i
] >> 8;
2385 *(p_extra
++) = i_size
[i
] & 0xFF;
2386 memcpy( p_extra
, tracks
[i_track
]->p_extra_data
+ i_offset
+ i_extra
,
2388 p_extra
+= i_size
[i
];
2389 i_extra
+= i_size
[i
];
2392 else if( !strncmp( tracks
[i_track
]->psz_codec
, "A_AAC/MPEG2/", strlen( "A_AAC/MPEG2/" ) ) ||
2393 !strncmp( tracks
[i_track
]->psz_codec
, "A_AAC/MPEG4/", strlen( "A_AAC/MPEG4/" ) ) )
2395 int i_profile
, i_srate
, sbr
= 0;
2396 static unsigned int i_sample_rates
[] =
2398 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
2399 16000, 12000, 11025, 8000, 7350, 0, 0, 0
2402 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'm', 'p', '4', 'a' );
2403 /* create data for faad (MP4DecSpecificDescrTag)*/
2405 if( !strcmp( &tracks
[i_track
]->psz_codec
[12], "MAIN" ) )
2409 else if( !strcmp( &tracks
[i_track
]->psz_codec
[12], "LC" ) )
2413 else if( !strcmp( &tracks
[i_track
]->psz_codec
[12], "SSR" ) )
2417 else if( !strcmp( &tracks
[i_track
]->psz_codec
[12], "LC/SBR" ) )
2427 for( i_srate
= 0; i_srate
< 13; i_srate
++ )
2429 if( i_sample_rates
[i_srate
] == tracks
[i_track
]->i_original_rate
)
2434 msg_Dbg( &sys
.demuxer
, "profile=%d srate=%d", i_profile
, i_srate
);
2436 tracks
[i_track
]->fmt
.i_extra
= sbr
? 5 : 2;
2437 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->fmt
.i_extra
);
2438 ((uint8_t*)tracks
[i_track
]->fmt
.p_extra
)[0] = ((i_profile
+ 1) << 3) | ((i_srate
&0xe) >> 1);
2439 ((uint8_t*)tracks
[i_track
]->fmt
.p_extra
)[1] = ((i_srate
& 0x1) << 7) | (tracks
[i_track
]->fmt
.audio
.i_channels
<< 3);
2442 int syncExtensionType
= 0x2B7;
2444 for (iDSRI
=0; iDSRI
<13; iDSRI
++)
2445 if( i_sample_rates
[iDSRI
] == tracks
[i_track
]->fmt
.audio
.i_rate
)
2447 ((uint8_t*)tracks
[i_track
]->fmt
.p_extra
)[2] = (syncExtensionType
>> 3) & 0xFF;
2448 ((uint8_t*)tracks
[i_track
]->fmt
.p_extra
)[3] = ((syncExtensionType
& 0x7) << 5) | 5;
2449 ((uint8_t*)tracks
[i_track
]->fmt
.p_extra
)[4] = ((1 & 0x1) << 7) | (iDSRI
<< 3);
2452 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_AAC" ) )
2454 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'm', 'p', '4', 'a' );
2455 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2456 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2457 memcpy( tracks
[i_track
]->fmt
.p_extra
, tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2459 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_WAVPACK4" ) )
2461 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'W', 'V', 'P', 'K' );
2462 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2463 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2464 memcpy( tracks
[i_track
]->fmt
.p_extra
, tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2466 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_TTA1" ) )
2468 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'T', 'T', 'A', '1' );
2469 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2470 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2471 memcpy( tracks
[i_track
]->fmt
.p_extra
, tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2473 else if( !strcmp( tracks
[i_track
]->psz_codec
, "A_PCM/INT/BIG" ) ||
2474 !strcmp( tracks
[i_track
]->psz_codec
, "A_PCM/INT/LIT" ) ||
2475 !strcmp( tracks
[i_track
]->psz_codec
, "A_PCM/FLOAT/IEEE" ) )
2477 if( !strcmp( tracks
[i_track
]->psz_codec
, "A_PCM/INT/BIG" ) )
2479 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 't', 'w', 'o', 's' );
2483 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'a', 'r', 'a', 'w' );
2485 tracks
[i_track
]->fmt
.audio
.i_blockalign
= ( tracks
[i_track
]->fmt
.audio
.i_bitspersample
+ 7 ) / 8 * tracks
[i_track
]->fmt
.audio
.i_channels
;
2487 else if( !strcmp( tracks
[i_track
]->psz_codec
, "S_TEXT/UTF8" ) )
2489 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 's', 'u', 'b', 't' );
2490 tracks
[i_track
]->fmt
.subs
.psz_encoding
= strdup( "UTF-8" );
2492 else if( !strcmp( tracks
[i_track
]->psz_codec
, "S_TEXT/USF" ) )
2494 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'u', 's', 'f', ' ' );
2495 tracks
[i_track
]->fmt
.subs
.psz_encoding
= strdup( "UTF-8" );
2496 if( tracks
[i_track
]->i_extra_data
)
2498 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2499 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2500 memcpy( tracks
[i_track
]->fmt
.p_extra
, tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2503 else if( !strcmp( tracks
[i_track
]->psz_codec
, "S_TEXT/SSA" ) ||
2504 !strcmp( tracks
[i_track
]->psz_codec
, "S_TEXT/ASS" ) ||
2505 !strcmp( tracks
[i_track
]->psz_codec
, "S_SSA" ) ||
2506 !strcmp( tracks
[i_track
]->psz_codec
, "S_ASS" ))
2508 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 's', 's', 'a', ' ' );
2509 tracks
[i_track
]->fmt
.subs
.psz_encoding
= strdup( "UTF-8" );
2510 if( tracks
[i_track
]->i_extra_data
)
2512 tracks
[i_track
]->fmt
.i_extra
= tracks
[i_track
]->i_extra_data
;
2513 tracks
[i_track
]->fmt
.p_extra
= malloc( tracks
[i_track
]->i_extra_data
);
2514 memcpy( tracks
[i_track
]->fmt
.p_extra
, tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2517 else if( !strcmp( tracks
[i_track
]->psz_codec
, "S_VOBSUB" ) )
2519 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 's','p','u',' ' );
2520 if( tracks
[i_track
]->i_extra_data
)
2523 char *p_buf
= (char *)malloc( tracks
[i_track
]->i_extra_data
+ 1);
2524 memcpy( p_buf
, tracks
[i_track
]->p_extra_data
, tracks
[i_track
]->i_extra_data
);
2525 p_buf
[tracks
[i_track
]->i_extra_data
] = '\0';
2527 p_start
= strstr( p_buf
, "size:" );
2528 if( sscanf( p_start
, "size: %dx%d",
2529 &tracks
[i_track
]->fmt
.subs
.spu
.i_original_frame_width
, &tracks
[i_track
]->fmt
.subs
.spu
.i_original_frame_height
) == 2 )
2531 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
);
2535 msg_Warn( &sys
.demuxer
, "reading original frame size for vobsub failed" );
2540 else if( !strcmp( tracks
[i_track
]->psz_codec
, "B_VOBBTN" ) )
2542 tracks
[i_track
]->fmt
.i_cat
= NAV_ES
;
2547 msg_Err( &sys
.demuxer
, "unknow codec id=`%s'", tracks
[i_track
]->psz_codec
);
2548 tracks
[i_track
]->fmt
.i_codec
= VLC_FOURCC( 'u', 'n', 'd', 'f' );
2550 if( tracks
[i_track
]->b_default
)
2552 tracks
[i_track
]->fmt
.i_priority
= 1000;
2555 tracks
[i_track
]->p_es
= es_out_Add( sys
.demuxer
.out
, &tracks
[i_track
]->fmt
);
2557 es_out_Control( sys
.demuxer
.out
, ES_OUT_SET_NEXT_DISPLAY_TIME
, tracks
[i_track
]->p_es
, i_start_time
);
2560 sys
.i_start_pts
= i_start_time
;
2561 // reset the stream reading to the first cluster of the segment used
2562 es
.I_O().setFilePointer( i_start_pos
);
2565 ep
= new EbmlParser( &es
, segment
, &sys
.demuxer
);
2570 void demux_sys_t::StartUiThread()
2574 msg_Dbg( &demuxer
, "Starting the UI Hook" );
2576 /* FIXME hack hack hack hack FIXME */
2577 /* Get p_input and create variable */
2578 p_input
= (input_thread_t
*) vlc_object_find( &demuxer
, VLC_OBJECT_INPUT
, FIND_PARENT
);
2579 var_Create( p_input
, "x-start", VLC_VAR_INTEGER
);
2580 var_Create( p_input
, "y-start", VLC_VAR_INTEGER
);
2581 var_Create( p_input
, "x-end", VLC_VAR_INTEGER
);
2582 var_Create( p_input
, "y-end", VLC_VAR_INTEGER
);
2583 var_Create( p_input
, "color", VLC_VAR_ADDRESS
);
2584 var_Create( p_input
, "menu-palette", VLC_VAR_ADDRESS
);
2585 var_Create( p_input
, "highlight", VLC_VAR_BOOL
);
2586 var_Create( p_input
, "highlight-mutex", VLC_VAR_MUTEX
);
2588 /* Now create our event thread catcher */
2589 p_ev
= (event_thread_t
*) vlc_object_create( &demuxer
, sizeof( event_thread_t
) );
2590 p_ev
->p_demux
= &demuxer
;
2591 p_ev
->b_die
= VLC_FALSE
;
2592 vlc_mutex_init( p_ev
, &p_ev
->lock
);
2593 vlc_thread_create( p_ev
, "mkv event thread handler", EventThread
,
2594 VLC_THREAD_PRIORITY_LOW
, VLC_FALSE
);
2598 void demux_sys_t::StopUiThread()
2602 p_ev
->b_die
= VLC_TRUE
;
2604 vlc_thread_join( p_ev
);
2605 vlc_object_destroy( p_ev
);
2609 var_Destroy( p_input
, "highlight-mutex" );
2610 var_Destroy( p_input
, "highlight" );
2611 var_Destroy( p_input
, "x-start" );
2612 var_Destroy( p_input
, "x-end" );
2613 var_Destroy( p_input
, "y-start" );
2614 var_Destroy( p_input
, "y-end" );
2615 var_Destroy( p_input
, "color" );
2616 var_Destroy( p_input
, "menu-palette" );
2618 vlc_object_release( p_input
);
2620 msg_Dbg( &demuxer
, "Stopping the UI Hook" );
2622 b_ui_hooked
= false;
2625 int demux_sys_t::EventMouse( vlc_object_t
*p_this
, char const *psz_var
,
2626 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
)
2628 event_thread_t
*p_ev
= (event_thread_t
*) p_data
;
2629 vlc_mutex_lock( &p_ev
->lock
);
2630 if( psz_var
[6] == 'c' )
2632 p_ev
->b_clicked
= VLC_TRUE
;
2633 msg_Dbg( p_this
, "Event Mouse: clicked");
2635 else if( psz_var
[6] == 'm' )
2636 p_ev
->b_moved
= VLC_TRUE
;
2637 vlc_mutex_unlock( &p_ev
->lock
);
2642 int demux_sys_t::EventKey( vlc_object_t
*p_this
, char const *psz_var
,
2643 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
)
2645 event_thread_t
*p_ev
= (event_thread_t
*) p_data
;
2646 vlc_mutex_lock( &p_ev
->lock
);
2647 p_ev
->b_key
= VLC_TRUE
;
2648 vlc_mutex_unlock( &p_ev
->lock
);
2649 msg_Dbg( p_this
, "Event Key");
2654 int demux_sys_t::EventThread( vlc_object_t
*p_this
)
2656 event_thread_t
*p_ev
= (event_thread_t
*)p_this
;
2657 demux_sys_t
*p_sys
= p_ev
->p_demux
->p_sys
;
2658 vlc_object_t
*p_vout
= NULL
;
2660 p_ev
->b_moved
= VLC_FALSE
;
2661 p_ev
->b_clicked
= VLC_FALSE
;
2662 p_ev
->b_key
= VLC_FALSE
;
2664 /* catch all key event */
2665 var_AddCallback( p_ev
->p_libvlc
, "key-pressed", EventKey
, p_ev
);
2668 while( !p_ev
->b_die
)
2670 if ( !p_sys
->b_pci_packet_set
)
2677 vlc_bool_t b_activated
= VLC_FALSE
;
2683 struct libvlc_int_t::hotkey
*p_hotkeys
= p_ev
->p_libvlc
->p_hotkeys
;
2684 int i
, i_action
= -1;
2686 msg_Dbg( p_ev
->p_demux
, "Handle Key Event");
2688 vlc_mutex_lock( &p_ev
->lock
);
2690 pci_t
*pci
= (pci_t
*) &p_sys
->pci_packet
;
2692 var_Get( p_ev
->p_libvlc
, "key-pressed", &valk
);
2693 for( i
= 0; p_hotkeys
[i
].psz_action
!= NULL
; i
++ )
2695 if( p_hotkeys
[i
].i_key
== valk
.i_int
)
2697 i_action
= p_hotkeys
[i
].i_action
;
2701 uint16 i_curr_button
= p_sys
->dvd_interpretor
.GetSPRM( 0x88 );
2705 case ACTIONID_NAV_LEFT
:
2706 if ( i_curr_button
> 0 && i_curr_button
<= pci
->hli
.hl_gi
.btn_ns
)
2708 btni_t
*p_button_ptr
= &(pci
->hli
.btnit
[i_curr_button
-1]);
2709 if ( p_button_ptr
->left
> 0 && p_button_ptr
->left
<= pci
->hli
.hl_gi
.btn_ns
)
2711 i_curr_button
= p_button_ptr
->left
;
2712 p_sys
->dvd_interpretor
.SetSPRM( 0x88, i_curr_button
);
2713 btni_t button_ptr
= pci
->hli
.btnit
[i_curr_button
-1];
2714 if ( button_ptr
.auto_action_mode
)
2716 vlc_mutex_unlock( &p_ev
->lock
);
2717 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2719 // process the button action
2720 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2722 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2723 vlc_mutex_lock( &p_ev
->lock
);
2728 case ACTIONID_NAV_RIGHT
:
2729 if ( i_curr_button
> 0 && i_curr_button
<= pci
->hli
.hl_gi
.btn_ns
)
2731 btni_t
*p_button_ptr
= &(pci
->hli
.btnit
[i_curr_button
-1]);
2732 if ( p_button_ptr
->right
> 0 && p_button_ptr
->right
<= pci
->hli
.hl_gi
.btn_ns
)
2734 i_curr_button
= p_button_ptr
->right
;
2735 p_sys
->dvd_interpretor
.SetSPRM( 0x88, i_curr_button
);
2736 btni_t button_ptr
= pci
->hli
.btnit
[i_curr_button
-1];
2737 if ( button_ptr
.auto_action_mode
)
2739 vlc_mutex_unlock( &p_ev
->lock
);
2740 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2742 // process the button action
2743 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2745 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2746 vlc_mutex_lock( &p_ev
->lock
);
2751 case ACTIONID_NAV_UP
:
2752 if ( i_curr_button
> 0 && i_curr_button
<= pci
->hli
.hl_gi
.btn_ns
)
2754 btni_t
*p_button_ptr
= &(pci
->hli
.btnit
[i_curr_button
-1]);
2755 if ( p_button_ptr
->up
> 0 && p_button_ptr
->up
<= pci
->hli
.hl_gi
.btn_ns
)
2757 i_curr_button
= p_button_ptr
->up
;
2758 p_sys
->dvd_interpretor
.SetSPRM( 0x88, i_curr_button
);
2759 btni_t button_ptr
= pci
->hli
.btnit
[i_curr_button
-1];
2760 if ( button_ptr
.auto_action_mode
)
2762 vlc_mutex_unlock( &p_ev
->lock
);
2763 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2765 // process the button action
2766 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2768 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2769 vlc_mutex_lock( &p_ev
->lock
);
2774 case ACTIONID_NAV_DOWN
:
2775 if ( i_curr_button
> 0 && i_curr_button
<= pci
->hli
.hl_gi
.btn_ns
)
2777 btni_t
*p_button_ptr
= &(pci
->hli
.btnit
[i_curr_button
-1]);
2778 if ( p_button_ptr
->down
> 0 && p_button_ptr
->down
<= pci
->hli
.hl_gi
.btn_ns
)
2780 i_curr_button
= p_button_ptr
->down
;
2781 p_sys
->dvd_interpretor
.SetSPRM( 0x88, i_curr_button
);
2782 btni_t button_ptr
= pci
->hli
.btnit
[i_curr_button
-1];
2783 if ( button_ptr
.auto_action_mode
)
2785 vlc_mutex_unlock( &p_ev
->lock
);
2786 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2788 // process the button action
2789 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2791 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2792 vlc_mutex_lock( &p_ev
->lock
);
2797 case ACTIONID_NAV_ACTIVATE
:
2798 b_activated
= VLC_TRUE
;
2800 if ( i_curr_button
> 0 && i_curr_button
<= pci
->hli
.hl_gi
.btn_ns
)
2802 btni_t button_ptr
= pci
->hli
.btnit
[i_curr_button
-1];
2804 vlc_mutex_unlock( &p_ev
->lock
);
2805 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2807 // process the button action
2808 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2810 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2811 vlc_mutex_lock( &p_ev
->lock
);
2817 p_ev
->b_key
= VLC_FALSE
;
2818 vlc_mutex_unlock( &p_ev
->lock
);
2822 if( p_vout
&& ( p_ev
->b_moved
|| p_ev
->b_clicked
) )
2824 vlc_value_t valx
, valy
;
2826 vlc_mutex_lock( &p_ev
->lock
);
2827 pci_t
*pci
= (pci_t
*) &p_sys
->pci_packet
;
2828 var_Get( p_vout
, "mouse-x", &valx
);
2829 var_Get( p_vout
, "mouse-y", &valy
);
2831 if( p_ev
->b_clicked
)
2834 int32_t best
,dist
,d
;
2835 int32_t mx
,my
,dx
,dy
;
2837 msg_Dbg( p_ev
->p_demux
, "Handle Mouse Event: Mouse clicked x(%d)*y(%d)", (unsigned)valx
.i_int
, (unsigned)valy
.i_int
);
2839 b_activated
= VLC_TRUE
;
2840 // get current button
2842 dist
= 0x08000000; /* >> than (720*720)+(567*567); */
2843 for(button
= 1; button
<= pci
->hli
.hl_gi
.btn_ns
; button
++)
2845 btni_t
*button_ptr
= &(pci
->hli
.btnit
[button
-1]);
2847 if(((unsigned)valx
.i_int
>= button_ptr
->x_start
)
2848 && ((unsigned)valx
.i_int
<= button_ptr
->x_end
)
2849 && ((unsigned)valy
.i_int
>= button_ptr
->y_start
)
2850 && ((unsigned)valy
.i_int
<= button_ptr
->y_end
))
2852 mx
= (button_ptr
->x_start
+ button_ptr
->x_end
)/2;
2853 my
= (button_ptr
->y_start
+ button_ptr
->y_end
)/2;
2854 dx
= mx
- valx
.i_int
;
2855 dy
= my
- valy
.i_int
;
2856 d
= (dx
*dx
) + (dy
*dy
);
2857 /* If the mouse is within the button and the mouse is closer
2858 * to the center of this button then it is the best choice. */
2868 btni_t button_ptr
= pci
->hli
.btnit
[best
-1];
2869 uint16 i_curr_button
= p_sys
->dvd_interpretor
.GetSPRM( 0x88 );
2871 msg_Dbg( &p_sys
->demuxer
, "Clicked button %d", best
);
2872 vlc_mutex_unlock( &p_ev
->lock
);
2873 vlc_mutex_lock( &p_sys
->lock_demuxer
);
2875 // process the button action
2876 p_sys
->dvd_interpretor
.SetSPRM( 0x88, best
);
2877 p_sys
->dvd_interpretor
.Interpret( button_ptr
.cmd
.bytes
, 8 );
2879 msg_Dbg( &p_sys
->demuxer
, "Processed button %d", best
);
2881 // select new button
2882 if ( best
!= i_curr_button
)
2886 if( var_Get( p_sys
->p_input
, "highlight-mutex", &val
) == VLC_SUCCESS
)
2888 vlc_mutex_t
*p_mutex
= (vlc_mutex_t
*) val
.p_address
;
2891 if(button_ptr
.btn_coln
!= 0) {
2892 i_palette
= pci
->hli
.btn_colit
.btn_coli
[button_ptr
.btn_coln
-1][1];
2897 for( int i
= 0; i
< 4; i
++ )
2899 uint32_t i_yuv
= 0xFF;//p_sys->clut[(hl.palette>>(16+i*4))&0x0f];
2900 uint8_t i_alpha
= (i_palette
>>(i
*4))&0x0f;
2901 i_alpha
= i_alpha
== 0xf ? 0xff : i_alpha
<< 4;
2903 p_sys
->palette
[i
][0] = (i_yuv
>> 16) & 0xff;
2904 p_sys
->palette
[i
][1] = (i_yuv
>> 0) & 0xff;
2905 p_sys
->palette
[i
][2] = (i_yuv
>> 8) & 0xff;
2906 p_sys
->palette
[i
][3] = i_alpha
;
2909 vlc_mutex_lock( p_mutex
);
2910 val
.i_int
= button_ptr
.x_start
; var_Set( p_sys
->p_input
, "x-start", val
);
2911 val
.i_int
= button_ptr
.x_end
; var_Set( p_sys
->p_input
, "x-end", val
);
2912 val
.i_int
= button_ptr
.y_start
; var_Set( p_sys
->p_input
, "y-start", val
);
2913 val
.i_int
= button_ptr
.y_end
; var_Set( p_sys
->p_input
, "y-end", val
);
2915 val
.p_address
= (void *)p_sys
->palette
;
2916 var_Set( p_sys
->p_input
, "menu-palette", val
);
2918 val
.b_bool
= VLC_TRUE
; var_Set( p_sys
->p_input
, "highlight", val
);
2919 vlc_mutex_unlock( p_mutex
);
2922 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
2923 vlc_mutex_lock( &p_ev
->lock
);
2926 else if( p_ev
->b_moved
)
2928 // dvdnav_mouse_select( NULL, pci, valx.i_int, valy.i_int );
2931 p_ev
->b_moved
= VLC_FALSE
;
2932 p_ev
->b_clicked
= VLC_FALSE
;
2933 vlc_mutex_unlock( &p_ev
->lock
);
2937 if( p_vout
&& p_vout
->b_die
)
2939 var_DelCallback( p_vout
, "mouse-moved", EventMouse
, p_ev
);
2940 var_DelCallback( p_vout
, "mouse-clicked", EventMouse
, p_ev
);
2941 vlc_object_release( p_vout
);
2945 else if( p_vout
== NULL
)
2947 p_vout
= (vlc_object_t
*) vlc_object_find( p_sys
->p_input
, VLC_OBJECT_VOUT
,
2951 var_AddCallback( p_vout
, "mouse-moved", EventMouse
, p_ev
);
2952 var_AddCallback( p_vout
, "mouse-clicked", EventMouse
, p_ev
);
2956 /* Wait a bit, 10ms */
2960 /* Release callback */
2963 var_DelCallback( p_vout
, "mouse-moved", EventMouse
, p_ev
);
2964 var_DelCallback( p_vout
, "mouse-clicked", EventMouse
, p_ev
);
2965 vlc_object_release( p_vout
);
2967 var_DelCallback( p_ev
->p_libvlc
, "key-pressed", EventKey
, p_ev
);
2969 vlc_mutex_destroy( &p_ev
->lock
);
2974 void matroska_segment_c::UnSelect( )
2978 for( i_track
= 0; i_track
< tracks
.size(); i_track
++ )
2980 if ( tracks
[i_track
]->p_es
!= NULL
)
2982 // es_format_Clean( &tracks[i_track]->fmt );
2983 es_out_Del( sys
.demuxer
.out
, tracks
[i_track
]->p_es
);
2984 tracks
[i_track
]->p_es
= NULL
;
2991 void virtual_segment_c::PrepareChapters( )
2993 if ( linked_segments
.size() == 0 )
2996 // !!! should be called only once !!!
2997 matroska_segment_c
*p_segment
;
3000 // copy editions from the first segment
3001 p_segment
= linked_segments
[0];
3002 p_editions
= &p_segment
->stored_editions
;
3004 for ( i
=1 ; i
<linked_segments
.size(); i
++ )
3006 p_segment
= linked_segments
[i
];
3007 // FIXME assume we have the same editions in all segments
3008 for (j
=0; j
<p_segment
->stored_editions
.size(); j
++)
3009 (*p_editions
)[j
]->Append( *p_segment
->stored_editions
[j
] );
3013 std::string
chapter_edition_c::GetMainName() const
3015 if ( sub_chapters
.size() )
3017 return sub_chapters
[0]->GetCodecName( true );
3022 int chapter_item_c::PublishChapters( input_title_t
& title
, int & i_user_chapters
, int i_level
)
3024 // add support for meta-elements from codec like DVD Titles
3025 if ( !b_display_seekpoint
|| psz_name
== "" )
3027 psz_name
= GetCodecName();
3028 if ( psz_name
!= "" )
3029 b_display_seekpoint
= true;
3032 if (b_display_seekpoint
)
3034 seekpoint_t
*sk
= vlc_seekpoint_New();
3036 sk
->i_level
= i_level
;
3037 sk
->i_time_offset
= i_start_time
;
3038 sk
->psz_name
= strdup( psz_name
.c_str() );
3040 // A start time of '0' is ok. A missing ChapterTime element is ok, too, because '0' is its default value.
3041 title
.i_seekpoint
++;
3042 title
.seekpoint
= (seekpoint_t
**)realloc( title
.seekpoint
, title
.i_seekpoint
* sizeof( seekpoint_t
* ) );
3043 title
.seekpoint
[title
.i_seekpoint
-1] = sk
;
3045 if ( b_user_display
)
3049 for ( size_t i
=0; i
<sub_chapters
.size() ; i
++)
3051 sub_chapters
[i
]->PublishChapters( title
, i_user_chapters
, i_level
+1 );
3054 i_seekpoint_num
= i_user_chapters
;
3056 return i_user_chapters
;
3059 bool virtual_segment_c::UpdateCurrentToChapter( demux_t
& demux
)
3061 demux_sys_t
& sys
= *demux
.p_sys
;
3062 chapter_item_c
*psz_curr_chapter
;
3063 bool b_has_seeked
= false;
3065 /* update current chapter/seekpoint */
3066 if ( p_editions
->size() )
3068 /* 1st, we need to know in which chapter we are */
3069 psz_curr_chapter
= (*p_editions
)[i_current_edition
]->FindTimecode( sys
.i_pts
, psz_current_chapter
);
3071 /* we have moved to a new chapter */
3072 if (psz_curr_chapter
!= NULL
&& psz_current_chapter
!= psz_curr_chapter
)
3074 if ( (*p_editions
)[i_current_edition
]->b_ordered
)
3076 // Leave/Enter up to the link point
3077 b_has_seeked
= psz_curr_chapter
->EnterAndLeave( psz_current_chapter
);
3078 if ( !b_has_seeked
)
3080 // only physically seek if necessary
3081 if ( psz_current_chapter
== NULL
|| (psz_current_chapter
->i_end_time
!= psz_curr_chapter
->i_start_time
) )
3082 Seek( demux
, sys
.i_pts
, 0, psz_curr_chapter
);
3086 if ( !b_has_seeked
)
3088 psz_current_chapter
= psz_curr_chapter
;
3089 if ( psz_curr_chapter
->i_seekpoint_num
> 0 )
3091 demux
.info
.i_update
|= INPUT_UPDATE_TITLE
| INPUT_UPDATE_SEEKPOINT
;
3092 demux
.info
.i_title
= sys
.i_current_title
= i_sys_title
;
3093 demux
.info
.i_seekpoint
= psz_curr_chapter
->i_seekpoint_num
- 1;
3099 else if (psz_curr_chapter
== NULL
)
3101 // out of the scope of the data described by chapters, leave the edition
3102 if ( (*p_editions
)[i_current_edition
]->b_ordered
&& psz_current_chapter
!= NULL
)
3104 if ( !(*p_editions
)[i_current_edition
]->EnterAndLeave( psz_current_chapter
, false ) )
3105 psz_current_chapter
= NULL
;
3114 chapter_item_c
*virtual_segment_c::BrowseCodecPrivate( unsigned int codec_id
,
3115 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
3116 const void *p_cookie
,
3117 size_t i_cookie_size
)
3119 // FIXME don't assume it is the first edition
3120 std::vector
<chapter_edition_c
*>::iterator index
= p_editions
->begin();
3121 if ( index
!= p_editions
->end() )
3123 chapter_item_c
*p_result
= (*index
)->BrowseCodecPrivate( codec_id
, match
, p_cookie
, i_cookie_size
);
3124 if ( p_result
!= NULL
)
3130 chapter_item_c
*virtual_segment_c::FindChapter( int64_t i_find_uid
)
3132 // FIXME don't assume it is the first edition
3133 std::vector
<chapter_edition_c
*>::iterator index
= p_editions
->begin();
3134 if ( index
!= p_editions
->end() )
3136 chapter_item_c
*p_result
= (*index
)->FindChapter( i_find_uid
);
3137 if ( p_result
!= NULL
)
3143 chapter_item_c
*chapter_item_c::BrowseCodecPrivate( unsigned int codec_id
,
3144 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
3145 const void *p_cookie
,
3146 size_t i_cookie_size
)
3149 std::vector
<chapter_codec_cmds_c
*>::const_iterator index
= codecs
.begin();
3150 while ( index
!= codecs
.end() )
3152 if ( match( **index
,p_cookie
, i_cookie_size
) )
3158 chapter_item_c
*p_result
= NULL
;
3159 std::vector
<chapter_item_c
*>::const_iterator index2
= sub_chapters
.begin();
3160 while ( index2
!= sub_chapters
.end() )
3162 p_result
= (*index2
)->BrowseCodecPrivate( codec_id
, match
, p_cookie
, i_cookie_size
);
3163 if ( p_result
!= NULL
)
3171 void chapter_item_c::Append( const chapter_item_c
& chapter
)
3173 // we are appending content for the same chapter UID
3175 chapter_item_c
*p_chapter
;
3177 for ( i
=0; i
<chapter
.sub_chapters
.size(); i
++ )
3179 p_chapter
= FindChapter( chapter
.sub_chapters
[i
]->i_uid
);
3180 if ( p_chapter
!= NULL
)
3182 p_chapter
->Append( *chapter
.sub_chapters
[i
] );
3186 sub_chapters
.push_back( chapter
.sub_chapters
[i
] );
3190 i_user_start_time
= min( i_user_start_time
, chapter
.i_user_start_time
);
3191 i_user_end_time
= max( i_user_end_time
, chapter
.i_user_end_time
);
3194 chapter_item_c
* chapter_item_c::FindChapter( int64_t i_find_uid
)
3197 chapter_item_c
*p_result
= NULL
;
3199 if ( i_uid
== i_find_uid
)
3202 for ( i
=0; i
<sub_chapters
.size(); i
++)
3204 p_result
= sub_chapters
[i
]->FindChapter( i_find_uid
);
3205 if ( p_result
!= NULL
)
3211 std::string
chapter_item_c::GetCodecName( bool f_for_title
) const
3215 std::vector
<chapter_codec_cmds_c
*>::const_iterator index
= codecs
.begin();
3216 while ( index
!= codecs
.end() )
3218 result
= (*index
)->GetCodecName( f_for_title
);
3227 std::string
dvd_chapter_codec_c::GetCodecName( bool f_for_title
) const
3230 if ( p_private_data
->GetSize() >= 3)
3232 const binary
* p_data
= p_private_data
->GetBuffer();
3233 /* if ( p_data[0] == MATROSKA_DVD_LEVEL_TT )
3235 uint16_t i_title = (p_data[1] << 8) + p_data[2];
3237 sprintf( psz_str, " %d ---", i_title );
3238 result = N_("--- DVD Title");
3241 else */ if ( p_data
[0] == MATROSKA_DVD_LEVEL_LU
)
3244 sprintf( psz_str
, " (%c%c) ---", p_data
[1], p_data
[2] );
3245 result
= N_("--- DVD Menu");
3248 else if ( p_data
[0] == MATROSKA_DVD_LEVEL_SS
&& f_for_title
)
3250 if ( p_data
[1] == 0x00 )
3251 result
= N_("First Played");
3252 else if ( p_data
[1] == 0xC0 )
3253 result
= N_("Video Manager");
3254 else if ( p_data
[1] == 0x80 )
3256 uint16_t i_title
= (p_data
[2] << 8) + p_data
[3];
3258 sprintf( psz_str
, " %d -----", i_title
);
3259 result
= N_("----- Title");
3268 int16
chapter_item_c::GetTitleNumber( ) const
3272 std::vector
<chapter_codec_cmds_c
*>::const_iterator index
= codecs
.begin();
3273 while ( index
!= codecs
.end() )
3275 result
= (*index
)->GetTitleNumber( );
3284 int16
dvd_chapter_codec_c::GetTitleNumber()
3286 if ( p_private_data
->GetSize() >= 3)
3288 const binary
* p_data
= p_private_data
->GetBuffer();
3289 if ( p_data
[0] == MATROSKA_DVD_LEVEL_SS
)
3291 return int16( (p_data
[2] << 8) + p_data
[3] );
3297 static void Seek( demux_t
*p_demux
, mtime_t i_date
, double f_percent
, chapter_item_c
*psz_chapter
)
3299 demux_sys_t
*p_sys
= p_demux
->p_sys
;
3300 virtual_segment_c
*p_vsegment
= p_sys
->p_current_segment
;
3301 matroska_segment_c
*p_segment
= p_vsegment
->Segment();
3302 mtime_t i_time_offset
= 0;
3306 msg_Dbg( p_demux
, "seek request to "I64Fd
" (%f%%)", i_date
, f_percent
);
3307 if( i_date
< 0 && f_percent
< 0 )
3309 msg_Warn( p_demux
, "cannot seek nowhere !" );
3312 if( f_percent
> 1.0 )
3314 msg_Warn( p_demux
, "cannot seek so far !" );
3318 /* seek without index or without date */
3319 if( f_percent
>= 0 && (config_GetInt( p_demux
, "mkv-seek-percent" ) || !p_segment
->b_cues
|| i_date
< 0 ))
3321 if (p_sys
->f_duration
>= 0)
3323 i_date
= int64_t( f_percent
* p_sys
->f_duration
* 1000.0 );
3327 int64_t i_pos
= int64_t( f_percent
* stream_Size( p_demux
->s
) );
3329 msg_Dbg( p_demux
, "inacurate way of seeking" );
3330 for( i_index
= 0; i_index
< p_segment
->i_index
; i_index
++ )
3332 if( p_segment
->p_indexes
[i_index
].i_position
>= i_pos
)
3337 if( i_index
== p_segment
->i_index
)
3342 i_date
= p_segment
->p_indexes
[i_index
].i_time
;
3345 if( p_segment
->p_indexes
[i_index
].i_position
< i_pos
)
3349 msg_Warn( p_demux
, "searching for cluster, could take some time" );
3351 /* search a cluster */
3352 while( ( el
= p_sys
->ep
->Get() ) != NULL
)
3354 if( MKV_IS_ID( el
, KaxCluster
) )
3356 KaxCluster
*cluster
= (KaxCluster
*)el
;
3358 /* add it to the index */
3359 p_segment
->IndexAppendCluster( cluster
);
3361 if( (int64_t)cluster
->GetElementPosition() >= i_pos
)
3363 p_sys
->cluster
= cluster
;
3374 p_vsegment
->Seek( *p_demux
, i_date
, i_time_offset
, psz_chapter
);
3377 /*****************************************************************************
3378 * Demux: reads and demuxes data packets
3379 *****************************************************************************
3380 * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
3381 *****************************************************************************/
3382 static int Demux( demux_t
*p_demux
)
3384 demux_sys_t
*p_sys
= p_demux
->p_sys
;
3386 vlc_mutex_lock( &p_sys
->lock_demuxer
);
3388 virtual_segment_c
*p_vsegment
= p_sys
->p_current_segment
;
3389 matroska_segment_c
*p_segment
= p_vsegment
->Segment();
3390 if ( p_segment
== NULL
) return 0;
3391 int i_block_count
= 0;
3396 if ( p_sys
->demuxer
.b_die
)
3399 if( p_sys
->i_pts
>= p_sys
->i_start_pts
)
3400 if ( p_vsegment
->UpdateCurrentToChapter( *p_demux
) )
3406 if ( p_vsegment
->Edition() && p_vsegment
->Edition()->b_ordered
&& p_vsegment
->CurrentChapter() == NULL
)
3408 /* nothing left to read in this ordered edition */
3409 if ( !p_vsegment
->SelectNext() )
3411 p_segment
->UnSelect( );
3413 es_out_Control( p_demux
->out
, ES_OUT_RESET_PCR
);
3415 /* switch to the next segment */
3416 p_segment
= p_vsegment
->Segment();
3417 if ( !p_segment
->Select( 0 ) )
3419 msg_Err( p_demux
, "Failed to select new segment" );
3426 int64_t i_block_duration
= 0;
3427 int64_t i_block_ref1
;
3428 int64_t i_block_ref2
;
3430 #if LIBMATROSKA_VERSION >= 0x000800
3431 KaxSimpleBlock
*simpleblock
;
3433 if( p_segment
->BlockGet( block
, simpleblock
, &i_block_ref1
, &i_block_ref2
, &i_block_duration
) )
3435 if( p_segment
->BlockGet( block
, &i_block_ref1
, &i_block_ref2
, &i_block_duration
) )
3438 if ( p_vsegment
->Edition() && p_vsegment
->Edition()->b_ordered
)
3440 const chapter_item_c
*p_chap
= p_vsegment
->CurrentChapter();
3441 // check if there are more chapters to read
3442 if ( p_chap
!= NULL
)
3444 /* TODO handle successive chapters with the same user_start_time/user_end_time
3445 if ( p_chap->i_user_start_time == p_chap->i_user_start_time )
3446 p_vsegment->SelectNext();
3448 p_sys
->i_pts
= p_chap
->i_user_end_time
;
3449 p_sys
->i_pts
++; // trick to avoid staying on segments with no duration and no content
3458 msg_Warn( p_demux
, "cannot get block EOF?" );
3459 p_segment
->UnSelect( );
3461 es_out_Control( p_demux
->out
, ES_OUT_RESET_PCR
);
3463 /* switch to the next segment */
3464 if ( !p_vsegment
->SelectNext() )
3465 // no more segments in this stream
3467 p_segment
= p_vsegment
->Segment();
3468 if ( !p_segment
->Select( 0 ) )
3470 msg_Err( p_demux
, "Failed to select new segment" );
3478 #if LIBMATROSKA_VERSION >= 0x000800
3479 if ( simpleblock
!= NULL
)
3480 p_sys
->i_pts
= (p_sys
->i_chapter_time
+ simpleblock
->GlobalTimecode()) / (mtime_t
) 1000;
3483 p_sys
->i_pts
= (p_sys
->i_chapter_time
+ block
->GlobalTimecode()) / (mtime_t
) 1000;
3485 if( p_sys
->i_pts
>= p_sys
->i_start_pts
)
3487 es_out_Control( p_demux
->out
, ES_OUT_SET_PCR
, p_sys
->i_pts
);
3489 if ( p_vsegment
->UpdateCurrentToChapter( *p_demux
) )
3497 if ( p_vsegment
->Edition() && p_vsegment
->Edition()->b_ordered
&& p_vsegment
->CurrentChapter() == NULL
)
3499 /* nothing left to read in this ordered edition */
3500 if ( !p_vsegment
->SelectNext() )
3505 p_segment
->UnSelect( );
3507 es_out_Control( p_demux
->out
, ES_OUT_RESET_PCR
);
3509 /* switch to the next segment */
3510 p_segment
= p_vsegment
->Segment();
3511 if ( !p_segment
->Select( 0 ) )
3513 msg_Err( p_demux
, "Failed to select new segment" );
3521 #if LIBMATROSKA_VERSION >= 0x000800
3522 BlockDecode( p_demux
, block
, simpleblock
, p_sys
->i_pts
, i_block_duration
, i_block_ref1
>= 0 || i_block_ref2
> 0 );
3524 BlockDecode( p_demux
, block
, p_sys
->i_pts
, i_block_duration
, i_block_ref1
>= 0 || i_block_ref2
> 0 );
3530 // TODO optimize when there is need to leave or when seeking has been called
3531 if( i_block_count
> 5 )
3538 vlc_mutex_unlock( &p_sys
->lock_demuxer
);
3545 /*****************************************************************************
3547 *****************************************************************************/
3548 vlc_stream_io_callback::vlc_stream_io_callback( stream_t
*s_
, vlc_bool_t b_owner_
)
3555 uint32
vlc_stream_io_callback::read( void *p_buffer
, size_t i_size
)
3557 if( i_size
<= 0 || mb_eof
)
3562 return stream_Read( s
, p_buffer
, i_size
);
3564 void vlc_stream_io_callback::setFilePointer(int64_t i_offset
, seek_mode mode
)
3570 case seek_beginning
:
3574 i_pos
= stream_Size( s
) - i_offset
;
3577 i_pos
= stream_Tell( s
) + i_offset
;
3581 if( i_pos
< 0 || i_pos
>= stream_Size( s
) )
3588 if( stream_Seek( s
, i_pos
) )
3594 size_t vlc_stream_io_callback::write( const void *p_buffer
, size_t i_size
)
3598 uint64
vlc_stream_io_callback::getFilePointer( void )
3602 return stream_Tell( s
);
3604 void vlc_stream_io_callback::close( void )
3610 /*****************************************************************************
3611 * Ebml Stream parser
3612 *****************************************************************************/
3613 EbmlParser::EbmlParser( EbmlStream
*es
, EbmlElement
*el_start
, demux_t
*p_demux
)
3620 mi_remain_size
[0] = el_start
->GetSize();
3622 for( i
= 1; i
< 6; i
++ )
3628 mb_keep
= VLC_FALSE
;
3629 mb_dummy
= config_GetInt( p_demux
, "mkv-use-dummy" );
3632 EbmlParser::~EbmlParser( void )
3636 for( i
= 1; i
< mi_level
; i
++ )
3642 mb_keep
= VLC_FALSE
;
3646 EbmlElement
* EbmlParser::UnGet( uint64 i_block_pos
, uint64 i_cluster_pos
)
3648 if ( mi_user_level
> mi_level
)
3650 while ( mi_user_level
!= mi_level
)
3652 delete m_el
[mi_user_level
];
3653 m_el
[mi_user_level
] = NULL
;
3658 mb_keep
= VLC_FALSE
;
3659 if ( m_el
[1]->GetElementPosition() == i_cluster_pos
)
3661 m_es
->I_O().setFilePointer( i_block_pos
, seek_beginning
);
3662 return (EbmlMaster
*) m_el
[1];
3666 // seek to the previous Cluster
3667 m_es
->I_O().setFilePointer( i_cluster_pos
, seek_beginning
);
3670 delete m_el
[mi_level
];
3671 m_el
[mi_level
] = NULL
;
3676 void EbmlParser::Up( void )
3678 if( mi_user_level
== mi_level
)
3680 fprintf( stderr
," arrrrrrrrrrrrrg Up cannot escape itself\n" );
3686 void EbmlParser::Down( void )
3692 void EbmlParser::Keep( void )
3697 int EbmlParser::GetLevel( void )
3699 return mi_user_level
;
3702 void EbmlParser::Reset( demux_t
*p_demux
)
3704 while ( mi_level
> 0)
3706 delete m_el
[mi_level
];
3707 m_el
[mi_level
] = NULL
;
3710 mi_user_level
= mi_level
= 1;
3711 #if LIBEBML_VERSION >= 0x000704
3712 // a little faster and cleaner
3713 m_es
->I_O().setFilePointer( static_cast<KaxSegment
*>(m_el
[0])->GetGlobalPosition(0) );
3715 m_es
->I_O().setFilePointer( m_el
[0]->GetElementPosition() + m_el
[0]->ElementSize(true) - m_el
[0]->GetSize() );
3717 mb_dummy
= config_GetInt( p_demux
, "mkv-use-dummy" );
3720 EbmlElement
*EbmlParser::Get( void )
3724 if( mi_user_level
!= mi_level
)
3730 EbmlElement
*ret
= m_got
;
3736 if( m_el
[mi_level
] )
3738 m_el
[mi_level
]->SkipData( *m_es
, m_el
[mi_level
]->Generic().Context
);
3741 delete m_el
[mi_level
];
3743 mb_keep
= VLC_FALSE
;
3746 m_el
[mi_level
] = m_es
->FindNextElement( m_el
[mi_level
- 1]->Generic().Context
, i_ulev
, 0xFFFFFFFFL
, mb_dummy
!= 0, 1 );
3747 // mi_remain_size[mi_level] = m_el[mi_level]->GetSize();
3758 delete m_el
[mi_level
- 1];
3759 m_got
= m_el
[mi_level
-1] = m_el
[mi_level
];
3760 m_el
[mi_level
] = NULL
;
3767 else if( m_el
[mi_level
] == NULL
)
3769 fprintf( stderr
," m_el[mi_level] == NULL\n" );
3772 return m_el
[mi_level
];
3776 /*****************************************************************************
3778 * * LoadCues : load the cues element and update index
3780 * * LoadTags : load ... the tags element
3782 * * InformationCreate : create all information, load tags if present
3784 *****************************************************************************/
3785 void matroska_segment_c::LoadCues( )
3787 int64_t i_sav_position
= es
.I_O().getFilePointer();
3789 EbmlElement
*el
, *cues
;
3791 /* *** Load the cue if found *** */
3792 if( i_cues_position
< 0 )
3794 msg_Warn( &sys
.demuxer
, "no cues/empty cues found->seek won't be precise" );
3796 // IndexAppendCluster( cluster );
3799 vlc_bool_t b_seekable
;
3801 stream_Control( sys
.demuxer
.s
, STREAM_CAN_FASTSEEK
, &b_seekable
);
3805 msg_Dbg( &sys
.demuxer
, "loading cues" );
3806 es
.I_O().setFilePointer( i_cues_position
, seek_beginning
);
3807 cues
= es
.FindNextID( KaxCues::ClassInfos
, 0xFFFFFFFFL
);
3811 msg_Err( &sys
.demuxer
, "cannot load cues (broken seekhead or file)" );
3812 es
.I_O().setFilePointer( i_sav_position
, seek_beginning
);
3816 ep
= new EbmlParser( &es
, cues
, &sys
.demuxer
);
3817 while( ( el
= ep
->Get() ) != NULL
)
3819 if( MKV_IS_ID( el
, KaxCuePoint
) )
3821 #define idx p_indexes[i_index]
3824 idx
.i_block_number
= -1;
3825 idx
.i_position
= -1;
3827 idx
.b_key
= VLC_TRUE
;
3830 while( ( el
= ep
->Get() ) != NULL
)
3832 if( MKV_IS_ID( el
, KaxCueTime
) )
3834 KaxCueTime
&ctime
= *(KaxCueTime
*)el
;
3836 ctime
.ReadData( es
.I_O() );
3838 idx
.i_time
= uint64( ctime
) * i_timescale
/ (mtime_t
)1000;
3840 else if( MKV_IS_ID( el
, KaxCueTrackPositions
) )
3843 while( ( el
= ep
->Get() ) != NULL
)
3845 if( MKV_IS_ID( el
, KaxCueTrack
) )
3847 KaxCueTrack
&ctrack
= *(KaxCueTrack
*)el
;
3849 ctrack
.ReadData( es
.I_O() );
3850 idx
.i_track
= uint16( ctrack
);
3852 else if( MKV_IS_ID( el
, KaxCueClusterPosition
) )
3854 KaxCueClusterPosition
&ccpos
= *(KaxCueClusterPosition
*)el
;
3856 ccpos
.ReadData( es
.I_O() );
3857 idx
.i_position
= segment
->GetGlobalPosition( uint64( ccpos
) );
3859 else if( MKV_IS_ID( el
, KaxCueBlockNumber
) )
3861 KaxCueBlockNumber
&cbnum
= *(KaxCueBlockNumber
*)el
;
3863 cbnum
.ReadData( es
.I_O() );
3864 idx
.i_block_number
= uint32( cbnum
);
3868 msg_Dbg( &sys
.demuxer
, " * Unknown (%s)", typeid(*el
).name() );
3875 msg_Dbg( &sys
.demuxer
, " * Unknown (%s)", typeid(*el
).name() );
3881 msg_Dbg( &sys
.demuxer
, " * added time="I64Fd
" pos="I64Fd
3882 " track=%d bnum=%d", idx
.i_time
, idx
.i_position
,
3883 idx
.i_track
, idx
.i_block_number
);
3887 if( i_index
>= i_index_max
)
3889 i_index_max
+= 1024;
3890 p_indexes
= (mkv_index_t
*)realloc( p_indexes
, sizeof( mkv_index_t
) * i_index_max
);
3896 msg_Dbg( &sys
.demuxer
, " * Unknown (%s)", typeid(*el
).name() );
3904 msg_Dbg( &sys
.demuxer
, "loading cues done." );
3905 es
.I_O().setFilePointer( i_sav_position
, seek_beginning
);
3908 void matroska_segment_c::LoadTags( )
3910 int64_t i_sav_position
= es
.I_O().getFilePointer();
3912 EbmlElement
*el
, *tags
;
3914 msg_Dbg( &sys
.demuxer
, "loading tags" );
3915 es
.I_O().setFilePointer( i_tags_position
, seek_beginning
);
3916 tags
= es
.FindNextID( KaxTags::ClassInfos
, 0xFFFFFFFFL
);
3920 msg_Err( &sys
.demuxer
, "cannot load tags (broken seekhead or file)" );
3921 es
.I_O().setFilePointer( i_sav_position
, seek_beginning
);
3925 msg_Dbg( &sys
.demuxer
, "Tags" );
3926 ep
= new EbmlParser( &es
, tags
, &sys
.demuxer
);
3927 while( ( el
= ep
->Get() ) != NULL
)
3929 if( MKV_IS_ID( el
, KaxTag
) )
3931 msg_Dbg( &sys
.demuxer
, "+ Tag" );
3933 while( ( el
= ep
->Get() ) != NULL
)
3935 if( MKV_IS_ID( el
, KaxTagTargets
) )
3937 msg_Dbg( &sys
.demuxer
, "| + Targets" );
3939 while( ( el
= ep
->Get() ) != NULL
)
3941 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid( *el
).name() );
3945 else if( MKV_IS_ID( el
, KaxTagGeneral
) )
3947 msg_Dbg( &sys
.demuxer
, "| + General" );
3949 while( ( el
= ep
->Get() ) != NULL
)
3951 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid( *el
).name() );
3955 else if( MKV_IS_ID( el
, KaxTagGenres
) )
3957 msg_Dbg( &sys
.demuxer
, "| + Genres" );
3959 while( ( el
= ep
->Get() ) != NULL
)
3961 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid( *el
).name() );
3965 else if( MKV_IS_ID( el
, KaxTagAudioSpecific
) )
3967 msg_Dbg( &sys
.demuxer
, "| + Audio Specific" );
3969 while( ( el
= ep
->Get() ) != NULL
)
3971 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid( *el
).name() );
3975 else if( MKV_IS_ID( el
, KaxTagImageSpecific
) )
3977 msg_Dbg( &sys
.demuxer
, "| + Images Specific" );
3979 while( ( el
= ep
->Get() ) != NULL
)
3981 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid( *el
).name() );
3985 else if( MKV_IS_ID( el
, KaxTagMultiComment
) )
3987 msg_Dbg( &sys
.demuxer
, "| + Multi Comment" );
3989 else if( MKV_IS_ID( el
, KaxTagMultiCommercial
) )
3991 msg_Dbg( &sys
.demuxer
, "| + Multi Commercial" );
3993 else if( MKV_IS_ID( el
, KaxTagMultiDate
) )
3995 msg_Dbg( &sys
.demuxer
, "| + Multi Date" );
3997 else if( MKV_IS_ID( el
, KaxTagMultiEntity
) )
3999 msg_Dbg( &sys
.demuxer
, "| + Multi Entity" );
4001 else if( MKV_IS_ID( el
, KaxTagMultiIdentifier
) )
4003 msg_Dbg( &sys
.demuxer
, "| + Multi Identifier" );
4005 else if( MKV_IS_ID( el
, KaxTagMultiLegal
) )
4007 msg_Dbg( &sys
.demuxer
, "| + Multi Legal" );
4009 else if( MKV_IS_ID( el
, KaxTagMultiTitle
) )
4011 msg_Dbg( &sys
.demuxer
, "| + Multi Title" );
4015 msg_Dbg( &sys
.demuxer
, "| + Unknown (%s)", typeid( *el
).name() );
4022 msg_Dbg( &sys
.demuxer
, "+ Unknown (%s)", typeid( *el
).name() );
4028 msg_Dbg( &sys
.demuxer
, "loading tags done." );
4029 es
.I_O().setFilePointer( i_sav_position
, seek_beginning
);
4032 /*****************************************************************************
4034 *****************************************************************************/
4035 void matroska_segment_c::ParseSeekHead( KaxSeekHead
*seekhead
)
4039 int i_upper_level
= 0;
4041 msg_Dbg( &sys
.demuxer
, "| + Seek head" );
4043 /* Master elements */
4044 seekhead
->Read( es
, seekhead
->Generic().Context
, i_upper_level
, el
, true );
4046 for( i
= 0; i
< seekhead
->ListSize(); i
++ )
4048 EbmlElement
*l
= (*seekhead
)[i
];
4050 if( MKV_IS_ID( l
, KaxSeek
) )
4052 EbmlMaster
*sk
= static_cast<EbmlMaster
*>(l
);
4053 EbmlId id
= EbmlVoid::ClassInfos
.GlobalId
;
4056 for( j
= 0; j
< sk
->ListSize(); j
++ )
4058 EbmlElement
*l
= (*sk
)[j
];
4060 if( MKV_IS_ID( l
, KaxSeekID
) )
4062 KaxSeekID
&sid
= *(KaxSeekID
*)l
;
4063 id
= EbmlId( sid
.GetBuffer(), sid
.GetSize() );
4065 else if( MKV_IS_ID( l
, KaxSeekPosition
) )
4067 KaxSeekPosition
&spos
= *(KaxSeekPosition
*)l
;
4068 i_pos
= uint64( spos
);
4072 msg_Dbg( &sys
.demuxer
, "| | | + Unknown (%s)", typeid(*l
).name() );
4078 if( id
== KaxCues::ClassInfos
.GlobalId
)
4080 msg_Dbg( &sys
.demuxer
, "| | | = cues at "I64Fd
, i_pos
);
4081 i_cues_position
= segment
->GetGlobalPosition( i_pos
);
4083 else if( id
== KaxChapters::ClassInfos
.GlobalId
)
4085 msg_Dbg( &sys
.demuxer
, "| | | = chapters at "I64Fd
, i_pos
);
4086 i_chapters_position
= segment
->GetGlobalPosition( i_pos
);
4088 else if( id
== KaxTags::ClassInfos
.GlobalId
)
4090 msg_Dbg( &sys
.demuxer
, "| | | = tags at "I64Fd
, i_pos
);
4091 i_tags_position
= segment
->GetGlobalPosition( i_pos
);
4097 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid(*l
).name() );
4102 /*****************************************************************************
4104 *****************************************************************************/
4105 void matroska_segment_c::ParseTrackEntry( KaxTrackEntry
*m
)
4108 bool bSupported
= true;
4112 msg_Dbg( &sys
.demuxer
, "| | + Track Entry" );
4114 tk
= new mkv_track_t();
4116 /* Init the track */
4117 memset( tk
, 0, sizeof( mkv_track_t
) );
4119 es_format_Init( &tk
->fmt
, UNKNOWN_ES
, 0 );
4120 tk
->fmt
.psz_language
= strdup("English");
4121 tk
->fmt
.psz_description
= NULL
;
4123 tk
->b_default
= VLC_TRUE
;
4124 tk
->b_enabled
= VLC_TRUE
;
4125 tk
->b_silent
= VLC_FALSE
;
4126 tk
->i_number
= tracks
.size() - 1;
4127 tk
->i_extra_data
= 0;
4128 tk
->p_extra_data
= NULL
;
4129 tk
->psz_codec
= NULL
;
4130 tk
->i_default_duration
= 0;
4131 tk
->f_timecodescale
= 1.0;
4133 tk
->b_inited
= VLC_FALSE
;
4134 tk
->i_data_init
= 0;
4135 tk
->p_data_init
= NULL
;
4137 tk
->psz_codec_name
= NULL
;
4138 tk
->psz_codec_settings
= NULL
;
4139 tk
->psz_codec_info_url
= NULL
;
4140 tk
->psz_codec_download_url
= NULL
;
4142 tk
->i_compression_type
= MATROSKA_COMPRESSION_NONE
;
4143 tk
->p_compression_data
= NULL
;
4145 for( i
= 0; i
< m
->ListSize(); i
++ )
4147 EbmlElement
*l
= (*m
)[i
];
4149 if( MKV_IS_ID( l
, KaxTrackNumber
) )
4151 KaxTrackNumber
&tnum
= *(KaxTrackNumber
*)l
;
4153 tk
->i_number
= uint32( tnum
);
4154 msg_Dbg( &sys
.demuxer
, "| | | + Track Number=%u", uint32( tnum
) );
4156 else if( MKV_IS_ID( l
, KaxTrackUID
) )
4158 KaxTrackUID
&tuid
= *(KaxTrackUID
*)l
;
4160 msg_Dbg( &sys
.demuxer
, "| | | + Track UID=%u", uint32( tuid
) );
4162 else if( MKV_IS_ID( l
, KaxTrackType
) )
4164 const char *psz_type
;
4165 KaxTrackType
&ttype
= *(KaxTrackType
*)l
;
4167 switch( uint8(ttype
) )
4171 tk
->fmt
.i_cat
= AUDIO_ES
;
4175 tk
->fmt
.i_cat
= VIDEO_ES
;
4177 case track_subtitle
:
4178 psz_type
= "subtitle";
4179 tk
->fmt
.i_cat
= SPU_ES
;
4182 psz_type
= "buttons";
4183 tk
->fmt
.i_cat
= SPU_ES
;
4186 psz_type
= "unknown";
4187 tk
->fmt
.i_cat
= UNKNOWN_ES
;
4191 msg_Dbg( &sys
.demuxer
, "| | | + Track Type=%s", psz_type
);
4193 // else if( EbmlId( *l ) == KaxTrackFlagEnabled::ClassInfos.GlobalId )
4195 // KaxTrackFlagEnabled &fenb = *(KaxTrackFlagEnabled*)l;
4197 // tk->b_enabled = uint32( fenb );
4198 // msg_Dbg( &sys.demuxer, "| | | + Track Enabled=%u",
4199 // uint32( fenb ) );
4201 else if( MKV_IS_ID( l
, KaxTrackFlagDefault
) )
4203 KaxTrackFlagDefault
&fdef
= *(KaxTrackFlagDefault
*)l
;
4205 tk
->b_default
= uint32( fdef
);
4206 msg_Dbg( &sys
.demuxer
, "| | | + Track Default=%u", uint32( fdef
) );
4208 else if( MKV_IS_ID( l
, KaxTrackFlagLacing
) )
4210 KaxTrackFlagLacing
&lac
= *(KaxTrackFlagLacing
*)l
;
4212 msg_Dbg( &sys
.demuxer
, "| | | + Track Lacing=%d", uint32( lac
) );
4214 else if( MKV_IS_ID( l
, KaxTrackMinCache
) )
4216 KaxTrackMinCache
&cmin
= *(KaxTrackMinCache
*)l
;
4218 msg_Dbg( &sys
.demuxer
, "| | | + Track MinCache=%d", uint32( cmin
) );
4220 else if( MKV_IS_ID( l
, KaxTrackMaxCache
) )
4222 KaxTrackMaxCache
&cmax
= *(KaxTrackMaxCache
*)l
;
4224 msg_Dbg( &sys
.demuxer
, "| | | + Track MaxCache=%d", uint32( cmax
) );
4226 else if( MKV_IS_ID( l
, KaxTrackDefaultDuration
) )
4228 KaxTrackDefaultDuration
&defd
= *(KaxTrackDefaultDuration
*)l
;
4230 tk
->i_default_duration
= uint64(defd
);
4231 msg_Dbg( &sys
.demuxer
, "| | | + Track Default Duration="I64Fd
, uint64(defd
) );
4233 else if( MKV_IS_ID( l
, KaxTrackTimecodeScale
) )
4235 KaxTrackTimecodeScale
&ttcs
= *(KaxTrackTimecodeScale
*)l
;
4237 tk
->f_timecodescale
= float( ttcs
);
4238 msg_Dbg( &sys
.demuxer
, "| | | + Track TimeCodeScale=%f", tk
->f_timecodescale
);
4240 else if( MKV_IS_ID( l
, KaxTrackName
) )
4242 KaxTrackName
&tname
= *(KaxTrackName
*)l
;
4244 tk
->fmt
.psz_description
= ToUTF8( UTFstring( tname
) );
4245 msg_Dbg( &sys
.demuxer
, "| | | + Track Name=%s", tk
->fmt
.psz_description
);
4247 else if( MKV_IS_ID( l
, KaxTrackLanguage
) )
4249 KaxTrackLanguage
&lang
= *(KaxTrackLanguage
*)l
;
4251 if ( tk
->fmt
.psz_language
!= NULL
)
4252 free( tk
->fmt
.psz_language
);
4253 tk
->fmt
.psz_language
= strdup( string( lang
).c_str() );
4254 msg_Dbg( &sys
.demuxer
,
4255 "| | | + Track Language=`%s'", tk
->fmt
.psz_language
);
4257 else if( MKV_IS_ID( l
, KaxCodecID
) )
4259 KaxCodecID
&codecid
= *(KaxCodecID
*)l
;
4261 tk
->psz_codec
= strdup( string( codecid
).c_str() );
4262 msg_Dbg( &sys
.demuxer
, "| | | + Track CodecId=%s", string( codecid
).c_str() );
4264 else if( MKV_IS_ID( l
, KaxCodecPrivate
) )
4266 KaxCodecPrivate
&cpriv
= *(KaxCodecPrivate
*)l
;
4268 tk
->i_extra_data
= cpriv
.GetSize();
4269 if( tk
->i_extra_data
> 0 )
4271 tk
->p_extra_data
= (uint8_t*)malloc( tk
->i_extra_data
);
4272 memcpy( tk
->p_extra_data
, cpriv
.GetBuffer(), tk
->i_extra_data
);
4274 msg_Dbg( &sys
.demuxer
, "| | | + Track CodecPrivate size="I64Fd
, cpriv
.GetSize() );
4276 else if( MKV_IS_ID( l
, KaxCodecName
) )
4278 KaxCodecName
&cname
= *(KaxCodecName
*)l
;
4280 tk
->psz_codec_name
= ToUTF8( UTFstring( cname
) );
4281 msg_Dbg( &sys
.demuxer
, "| | | + Track Codec Name=%s", tk
->psz_codec_name
);
4283 else if( MKV_IS_ID( l
, KaxContentEncodings
) )
4285 EbmlMaster
*cencs
= static_cast<EbmlMaster
*>(l
);
4286 MkvTree( sys
.demuxer
, 3, "Content Encodings" );
4287 if ( cencs
->ListSize() > 1 )
4289 msg_Err( &sys
.demuxer
, "Multiple Compression method not supported" );
4292 for( j
= 0; j
< cencs
->ListSize(); j
++ )
4294 EbmlElement
*l2
= (*cencs
)[j
];
4295 if( MKV_IS_ID( l2
, KaxContentEncoding
) )
4297 MkvTree( sys
.demuxer
, 4, "Content Encoding" );
4298 EbmlMaster
*cenc
= static_cast<EbmlMaster
*>(l2
);
4299 for( k
= 0; k
< cenc
->ListSize(); k
++ )
4301 EbmlElement
*l3
= (*cenc
)[k
];
4302 if( MKV_IS_ID( l3
, KaxContentEncodingOrder
) )
4304 KaxContentEncodingOrder
&encord
= *(KaxContentEncodingOrder
*)l3
;
4305 MkvTree( sys
.demuxer
, 5, "Order: %i", uint32( encord
) );
4307 else if( MKV_IS_ID( l3
, KaxContentEncodingScope
) )
4309 KaxContentEncodingScope
&encscope
= *(KaxContentEncodingScope
*)l3
;
4310 MkvTree( sys
.demuxer
, 5, "Scope: %i", uint32( encscope
) );
4312 else if( MKV_IS_ID( l3
, KaxContentEncodingType
) )
4314 KaxContentEncodingType
&enctype
= *(KaxContentEncodingType
*)l3
;
4315 MkvTree( sys
.demuxer
, 5, "Type: %i", uint32( enctype
) );
4317 else if( MKV_IS_ID( l3
, KaxContentCompression
) )
4319 EbmlMaster
*compr
= static_cast<EbmlMaster
*>(l3
);
4320 MkvTree( sys
.demuxer
, 5, "Content Compression" );
4321 for( n
= 0; n
< compr
->ListSize(); n
++ )
4323 EbmlElement
*l4
= (*compr
)[n
];
4324 if( MKV_IS_ID( l4
, KaxContentCompAlgo
) )
4326 KaxContentCompAlgo
&compalg
= *(KaxContentCompAlgo
*)l4
;
4327 MkvTree( sys
.demuxer
, 6, "Compression Algorithm: %i", uint32(compalg
) );
4328 tk
->i_compression_type
= uint32( compalg
);
4329 if ( ( tk
->i_compression_type
!= MATROSKA_COMPRESSION_ZLIB
) &&
4330 ( tk
->i_compression_type
!= MATROSKA_COMPRESSION_HEADER
) )
4332 msg_Err( &sys
.demuxer
, "Track Compression method %d not supported", tk
->i_compression_type
);
4336 else if( MKV_IS_ID( l4
, KaxContentCompSettings
) )
4338 tk
->p_compression_data
= new KaxContentCompSettings( *(KaxContentCompSettings
*)l4
);
4342 MkvTree( sys
.demuxer
, 6, "Unknown (%s)", typeid(*l4
).name() );
4348 MkvTree( sys
.demuxer
, 5, "Unknown (%s)", typeid(*l3
).name() );
4354 MkvTree( sys
.demuxer
, 4, "Unknown (%s)", typeid(*l2
).name() );
4358 // else if( EbmlId( *l ) == KaxCodecSettings::ClassInfos.GlobalId )
4360 // KaxCodecSettings &cset = *(KaxCodecSettings*)l;
4362 // tk->psz_codec_settings = ToUTF8( UTFstring( cset ) );
4363 // msg_Dbg( &sys.demuxer, "| | | + Track Codec Settings=%s", tk->psz_codec_settings );
4365 // else if( EbmlId( *l ) == KaxCodecInfoURL::ClassInfos.GlobalId )
4367 // KaxCodecInfoURL &ciurl = *(KaxCodecInfoURL*)l;
4369 // tk->psz_codec_info_url = strdup( string( ciurl ).c_str() );
4370 // msg_Dbg( &sys.demuxer, "| | | + Track Codec Info URL=%s", tk->psz_codec_info_url );
4372 // else if( EbmlId( *l ) == KaxCodecDownloadURL::ClassInfos.GlobalId )
4374 // KaxCodecDownloadURL &cdurl = *(KaxCodecDownloadURL*)l;
4376 // tk->psz_codec_download_url = strdup( string( cdurl ).c_str() );
4377 // msg_Dbg( &sys.demuxer, "| | | + Track Codec Info URL=%s", tk->psz_codec_download_url );
4379 // else if( EbmlId( *l ) == KaxCodecDecodeAll::ClassInfos.GlobalId )
4381 // KaxCodecDecodeAll &cdall = *(KaxCodecDecodeAll*)l;
4383 // msg_Dbg( &sys.demuxer, "| | | + Track Codec Decode All=%u <== UNUSED", uint8( cdall ) );
4385 // else if( EbmlId( *l ) == KaxTrackOverlay::ClassInfos.GlobalId )
4387 // KaxTrackOverlay &tovr = *(KaxTrackOverlay*)l;
4389 // msg_Dbg( &sys.demuxer, "| | | + Track Overlay=%u <== UNUSED", uint32( tovr ) );
4391 else if( MKV_IS_ID( l
, KaxTrackVideo
) )
4393 EbmlMaster
*tkv
= static_cast<EbmlMaster
*>(l
);
4395 unsigned int i_crop_right
= 0, i_crop_left
= 0, i_crop_top
= 0, i_crop_bottom
= 0;
4396 unsigned int i_display_unit
= 0, i_display_width
= 0, i_display_height
= 0;
4398 msg_Dbg( &sys
.demuxer
, "| | | + Track Video" );
4401 tk
->fmt
.video
.i_frame_rate_base
= (unsigned int)(tk
->i_default_duration
/ 1000);
4402 tk
->fmt
.video
.i_frame_rate
= 1000000;
4404 for( j
= 0; j
< tkv
->ListSize(); j
++ )
4406 EbmlElement
*l
= (*tkv
)[j
];
4407 // if( EbmlId( *el4 ) == KaxVideoFlagInterlaced::ClassInfos.GlobalId )
4409 // KaxVideoFlagInterlaced &fint = *(KaxVideoFlagInterlaced*)el4;
4411 // msg_Dbg( &sys.demuxer, "| | | | + Track Video Interlaced=%u", uint8( fint ) );
4413 // else if( EbmlId( *el4 ) == KaxVideoStereoMode::ClassInfos.GlobalId )
4415 // KaxVideoStereoMode &stereo = *(KaxVideoStereoMode*)el4;
4417 // msg_Dbg( &sys.demuxer, "| | | | + Track Video Stereo Mode=%u", uint8( stereo ) );
4420 if( MKV_IS_ID( l
, KaxVideoPixelWidth
) )
4422 KaxVideoPixelWidth
&vwidth
= *(KaxVideoPixelWidth
*)l
;
4424 tk
->fmt
.video
.i_width
+= uint16( vwidth
);
4425 msg_Dbg( &sys
.demuxer
, "| | | | + width=%d", uint16( vwidth
) );
4427 else if( MKV_IS_ID( l
, KaxVideoPixelHeight
) )
4429 KaxVideoPixelWidth
&vheight
= *(KaxVideoPixelWidth
*)l
;
4431 tk
->fmt
.video
.i_height
+= uint16( vheight
);
4432 msg_Dbg( &sys
.demuxer
, "| | | | + height=%d", uint16( vheight
) );
4434 else if( MKV_IS_ID( l
, KaxVideoDisplayWidth
) )
4436 KaxVideoDisplayWidth
&vwidth
= *(KaxVideoDisplayWidth
*)l
;
4438 i_display_width
= uint16( vwidth
);
4439 msg_Dbg( &sys
.demuxer
, "| | | | + display width=%d", uint16( vwidth
) );
4441 else if( MKV_IS_ID( l
, KaxVideoDisplayHeight
) )
4443 KaxVideoDisplayWidth
&vheight
= *(KaxVideoDisplayWidth
*)l
;
4445 i_display_height
= uint16( vheight
);
4446 msg_Dbg( &sys
.demuxer
, "| | | | + display height=%d", uint16( vheight
) );
4448 else if( MKV_IS_ID( l
, KaxVideoPixelCropBottom
) )
4450 KaxVideoPixelCropBottom
&cropval
= *(KaxVideoPixelCropBottom
*)l
;
4452 i_crop_bottom
= uint16( cropval
);
4453 msg_Dbg( &sys
.demuxer
, "| | | | + crop pixel bottom=%d", uint16( cropval
) );
4455 else if( MKV_IS_ID( l
, KaxVideoPixelCropTop
) )
4457 KaxVideoPixelCropTop
&cropval
= *(KaxVideoPixelCropTop
*)l
;
4459 i_crop_top
= uint16( cropval
);
4460 msg_Dbg( &sys
.demuxer
, "| | | | + crop pixel top=%d", uint16( cropval
) );
4462 else if( MKV_IS_ID( l
, KaxVideoPixelCropRight
) )
4464 KaxVideoPixelCropRight
&cropval
= *(KaxVideoPixelCropRight
*)l
;
4466 i_crop_right
= uint16( cropval
);
4467 msg_Dbg( &sys
.demuxer
, "| | | | + crop pixel right=%d", uint16( cropval
) );
4469 else if( MKV_IS_ID( l
, KaxVideoPixelCropLeft
) )
4471 KaxVideoPixelCropLeft
&cropval
= *(KaxVideoPixelCropLeft
*)l
;
4473 i_crop_left
= uint16( cropval
);
4474 msg_Dbg( &sys
.demuxer
, "| | | | + crop pixel left=%d", uint16( cropval
) );
4476 else if( MKV_IS_ID( l
, KaxVideoFrameRate
) )
4478 KaxVideoFrameRate
&vfps
= *(KaxVideoFrameRate
*)l
;
4480 tk
->f_fps
= float( vfps
);
4481 msg_Dbg( &sys
.demuxer
, " | | | + fps=%f", float( vfps
) );
4483 else if( EbmlId( *l
) == KaxVideoDisplayUnit::ClassInfos
.GlobalId
)
4485 KaxVideoDisplayUnit
&vdmode
= *(KaxVideoDisplayUnit
*)l
;
4487 i_display_unit
= uint8( vdmode
);
4488 msg_Dbg( &sys
.demuxer
, "| | | | + Track Video Display Unit=%s",
4489 uint8( vdmode
) == 0 ? "pixels" : ( uint8( vdmode
) == 1 ? "centimeters": "inches" ) );
4491 // else if( EbmlId( *l ) == KaxVideoAspectRatio::ClassInfos.GlobalId )
4493 // KaxVideoAspectRatio &ratio = *(KaxVideoAspectRatio*)l;
4495 // msg_Dbg( &sys.demuxer, " | | | + Track Video Aspect Ratio Type=%u", uint8( ratio ) );
4497 // else if( EbmlId( *l ) == KaxVideoGamma::ClassInfos.GlobalId )
4499 // KaxVideoGamma &gamma = *(KaxVideoGamma*)l;
4501 // msg_Dbg( &sys.demuxer, " | | | + gamma=%f", float( gamma ) );
4505 msg_Dbg( &sys
.demuxer
, "| | | | + Unknown (%s)", typeid(*l
).name() );
4508 if( i_display_height
&& i_display_width
)
4509 tk
->fmt
.video
.i_aspect
= VOUT_ASPECT_FACTOR
* i_display_width
/ i_display_height
;
4510 if( i_crop_left
|| i_crop_right
|| i_crop_top
|| i_crop_bottom
)
4512 tk
->fmt
.video
.i_visible_width
= tk
->fmt
.video
.i_width
;
4513 tk
->fmt
.video
.i_visible_height
= tk
->fmt
.video
.i_height
;
4514 tk
->fmt
.video
.i_x_offset
= i_crop_left
;
4515 tk
->fmt
.video
.i_y_offset
= i_crop_top
;
4516 tk
->fmt
.video
.i_visible_width
-= i_crop_left
+ i_crop_right
;
4517 tk
->fmt
.video
.i_visible_height
-= i_crop_top
+ i_crop_bottom
;
4519 /* FIXME: i_display_* allows you to not only set DAR, but also a zoom factor.
4520 we do not support this atm */
4522 else if( MKV_IS_ID( l
, KaxTrackAudio
) )
4524 EbmlMaster
*tka
= static_cast<EbmlMaster
*>(l
);
4527 msg_Dbg( &sys
.demuxer
, "| | | + Track Audio" );
4529 for( j
= 0; j
< tka
->ListSize(); j
++ )
4531 EbmlElement
*l
= (*tka
)[j
];
4533 if( MKV_IS_ID( l
, KaxAudioSamplingFreq
) )
4535 KaxAudioSamplingFreq
&afreq
= *(KaxAudioSamplingFreq
*)l
;
4537 tk
->i_original_rate
= tk
->fmt
.audio
.i_rate
= (int)float( afreq
);
4538 msg_Dbg( &sys
.demuxer
, "| | | | + afreq=%d", tk
->fmt
.audio
.i_rate
);
4540 else if( MKV_IS_ID( l
, KaxAudioOutputSamplingFreq
) )
4542 KaxAudioOutputSamplingFreq
&afreq
= *(KaxAudioOutputSamplingFreq
*)l
;
4544 tk
->fmt
.audio
.i_rate
= (int)float( afreq
);
4545 msg_Dbg( &sys
.demuxer
, "| | | | + aoutfreq=%d", tk
->fmt
.audio
.i_rate
);
4547 else if( MKV_IS_ID( l
, KaxAudioChannels
) )
4549 KaxAudioChannels
&achan
= *(KaxAudioChannels
*)l
;
4551 tk
->fmt
.audio
.i_channels
= uint8( achan
);
4552 msg_Dbg( &sys
.demuxer
, "| | | | + achan=%u", uint8( achan
) );
4554 else if( MKV_IS_ID( l
, KaxAudioBitDepth
) )
4556 KaxAudioBitDepth
&abits
= *(KaxAudioBitDepth
*)l
;
4558 tk
->fmt
.audio
.i_bitspersample
= uint8( abits
);
4559 msg_Dbg( &sys
.demuxer
, "| | | | + abits=%u", uint8( abits
) );
4563 msg_Dbg( &sys
.demuxer
, "| | | | + Unknown (%s)", typeid(*l
).name() );
4569 msg_Dbg( &sys
.demuxer
, "| | | + Unknown (%s)",
4570 typeid(*l
).name() );
4576 tracks
.push_back( tk
);
4580 msg_Err( &sys
.demuxer
, "Track Entry %d not supported", tk
->i_number
);
4585 /*****************************************************************************
4587 *****************************************************************************/
4588 void matroska_segment_c::ParseTracks( KaxTracks
*tracks
)
4592 int i_upper_level
= 0;
4594 msg_Dbg( &sys
.demuxer
, "| + Tracks" );
4596 /* Master elements */
4597 tracks
->Read( es
, tracks
->Generic().Context
, i_upper_level
, el
, true );
4599 for( i
= 0; i
< tracks
->ListSize(); i
++ )
4601 EbmlElement
*l
= (*tracks
)[i
];
4603 if( MKV_IS_ID( l
, KaxTrackEntry
) )
4605 ParseTrackEntry( static_cast<KaxTrackEntry
*>(l
) );
4609 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid(*l
).name() );
4614 /*****************************************************************************
4616 *****************************************************************************/
4617 void matroska_segment_c::ParseInfo( KaxInfo
*info
)
4622 int i_upper_level
= 0;
4624 msg_Dbg( &sys
.demuxer
, "| + Information" );
4626 /* Master elements */
4627 m
= static_cast<EbmlMaster
*>(info
);
4628 m
->Read( es
, info
->Generic().Context
, i_upper_level
, el
, true );
4630 for( i
= 0; i
< m
->ListSize(); i
++ )
4632 EbmlElement
*l
= (*m
)[i
];
4634 if( MKV_IS_ID( l
, KaxSegmentUID
) )
4636 if ( p_segment_uid
== NULL
)
4637 p_segment_uid
= new KaxSegmentUID(*static_cast<KaxSegmentUID
*>(l
));
4639 msg_Dbg( &sys
.demuxer
, "| | + UID=%d", *(uint32
*)p_segment_uid
->GetBuffer() );
4641 else if( MKV_IS_ID( l
, KaxPrevUID
) )
4643 if ( p_prev_segment_uid
== NULL
)
4644 p_prev_segment_uid
= new KaxPrevUID(*static_cast<KaxPrevUID
*>(l
));
4646 msg_Dbg( &sys
.demuxer
, "| | + PrevUID=%d", *(uint32
*)p_prev_segment_uid
->GetBuffer() );
4648 else if( MKV_IS_ID( l
, KaxNextUID
) )
4650 if ( p_next_segment_uid
== NULL
)
4651 p_next_segment_uid
= new KaxNextUID(*static_cast<KaxNextUID
*>(l
));
4653 msg_Dbg( &sys
.demuxer
, "| | + NextUID=%d", *(uint32
*)p_next_segment_uid
->GetBuffer() );
4655 else if( MKV_IS_ID( l
, KaxTimecodeScale
) )
4657 KaxTimecodeScale
&tcs
= *(KaxTimecodeScale
*)l
;
4659 i_timescale
= uint64(tcs
);
4661 msg_Dbg( &sys
.demuxer
, "| | + TimecodeScale="I64Fd
,
4664 else if( MKV_IS_ID( l
, KaxDuration
) )
4666 KaxDuration
&dur
= *(KaxDuration
*)l
;
4668 i_duration
= mtime_t( double( dur
) );
4670 msg_Dbg( &sys
.demuxer
, "| | + Duration="I64Fd
,
4673 else if( MKV_IS_ID( l
, KaxMuxingApp
) )
4675 KaxMuxingApp
&mapp
= *(KaxMuxingApp
*)l
;
4677 psz_muxing_application
= ToUTF8( UTFstring( mapp
) );
4679 msg_Dbg( &sys
.demuxer
, "| | + Muxing Application=%s",
4680 psz_muxing_application
);
4682 else if( MKV_IS_ID( l
, KaxWritingApp
) )
4684 KaxWritingApp
&wapp
= *(KaxWritingApp
*)l
;
4686 psz_writing_application
= ToUTF8( UTFstring( wapp
) );
4688 msg_Dbg( &sys
.demuxer
, "| | + Writing Application=%s",
4689 psz_writing_application
);
4691 else if( MKV_IS_ID( l
, KaxSegmentFilename
) )
4693 KaxSegmentFilename
&sfn
= *(KaxSegmentFilename
*)l
;
4695 psz_segment_filename
= ToUTF8( UTFstring( sfn
) );
4697 msg_Dbg( &sys
.demuxer
, "| | + Segment Filename=%s",
4698 psz_segment_filename
);
4700 else if( MKV_IS_ID( l
, KaxTitle
) )
4702 KaxTitle
&title
= *(KaxTitle
*)l
;
4704 psz_title
= ToUTF8( UTFstring( title
) );
4706 msg_Dbg( &sys
.demuxer
, "| | + Title=%s", psz_title
);
4708 else if( MKV_IS_ID( l
, KaxSegmentFamily
) )
4710 KaxSegmentFamily
*uid
= static_cast<KaxSegmentFamily
*>(l
);
4712 families
.push_back( new KaxSegmentFamily(*uid
) );
4714 msg_Dbg( &sys
.demuxer
, "| | + family=%d", *(uint32
*)uid
->GetBuffer() );
4716 #if defined( HAVE_GMTIME_R ) && !defined( __APPLE__ )
4717 else if( MKV_IS_ID( l
, KaxDateUTC
) )
4719 KaxDateUTC
&date
= *(KaxDateUTC
*)l
;
4724 i_date
= date
.GetEpochDate();
4725 memset( buffer
, 0, 256 );
4726 if( gmtime_r( &i_date
, &tmres
) &&
4727 asctime_r( &tmres
, buffer
) )
4729 buffer
[strlen( buffer
)-1]= '\0';
4730 psz_date_utc
= strdup( buffer
);
4731 msg_Dbg( &sys
.demuxer
, "| | + Date=%s", psz_date_utc
);
4735 #if LIBMATROSKA_VERSION >= 0x000704
4736 else if( MKV_IS_ID( l
, KaxChapterTranslate
) )
4738 KaxChapterTranslate
*p_trans
= static_cast<KaxChapterTranslate
*>( l
);
4739 chapter_translation_c
*p_translate
= new chapter_translation_c();
4741 p_trans
->Read( es
, p_trans
->Generic().Context
, i_upper_level
, el
, true );
4742 for( j
= 0; j
< p_trans
->ListSize(); j
++ )
4744 EbmlElement
*l
= (*p_trans
)[j
];
4746 if( MKV_IS_ID( l
, KaxChapterTranslateEditionUID
) )
4748 p_translate
->editions
.push_back( uint64( *static_cast<KaxChapterTranslateEditionUID
*>( l
) ) );
4750 else if( MKV_IS_ID( l
, KaxChapterTranslateCodec
) )
4752 p_translate
->codec_id
= uint32( *static_cast<KaxChapterTranslateCodec
*>( l
) );
4754 else if( MKV_IS_ID( l
, KaxChapterTranslateID
) )
4756 p_translate
->p_translated
= new KaxChapterTranslateID( *static_cast<KaxChapterTranslateID
*>( l
) );
4760 translations
.push_back( p_translate
);
4765 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid(*l
).name() );
4769 double f_dur
= double(i_duration
) * double(i_timescale
) / 1000000.0;
4770 i_duration
= mtime_t(f_dur
);
4774 /*****************************************************************************
4776 *****************************************************************************/
4777 void matroska_segment_c::ParseChapterAtom( int i_level
, KaxChapterAtom
*ca
, chapter_item_c
& chapters
)
4781 msg_Dbg( &sys
.demuxer
, "| | | + ChapterAtom (level=%d)", i_level
);
4782 for( i
= 0; i
< ca
->ListSize(); i
++ )
4784 EbmlElement
*l
= (*ca
)[i
];
4786 if( MKV_IS_ID( l
, KaxChapterUID
) )
4788 chapters
.i_uid
= uint64_t(*(KaxChapterUID
*)l
);
4789 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterUID: %lld", chapters
.i_uid
);
4791 else if( MKV_IS_ID( l
, KaxChapterFlagHidden
) )
4793 KaxChapterFlagHidden
&flag
=*(KaxChapterFlagHidden
*)l
;
4794 chapters
.b_display_seekpoint
= uint8( flag
) == 0;
4796 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterFlagHidden: %s", chapters
.b_display_seekpoint
? "no":"yes" );
4798 else if( MKV_IS_ID( l
, KaxChapterTimeStart
) )
4800 KaxChapterTimeStart
&start
=*(KaxChapterTimeStart
*)l
;
4801 chapters
.i_start_time
= uint64( start
) / I64C(1000);
4803 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterTimeStart: %lld", chapters
.i_start_time
);
4805 else if( MKV_IS_ID( l
, KaxChapterTimeEnd
) )
4807 KaxChapterTimeEnd
&end
=*(KaxChapterTimeEnd
*)l
;
4808 chapters
.i_end_time
= uint64( end
) / I64C(1000);
4810 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterTimeEnd: %lld", chapters
.i_end_time
);
4812 else if( MKV_IS_ID( l
, KaxChapterDisplay
) )
4814 EbmlMaster
*cd
= static_cast<EbmlMaster
*>(l
);
4816 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterDisplay" );
4817 for( j
= 0; j
< cd
->ListSize(); j
++ )
4819 EbmlElement
*l
= (*cd
)[j
];
4821 if( MKV_IS_ID( l
, KaxChapterString
) )
4825 KaxChapterString
&name
=*(KaxChapterString
*)l
;
4826 for (k
= 0; k
< i_level
; k
++)
4827 chapters
.psz_name
+= '+';
4828 chapters
.psz_name
+= ' ';
4829 char *psz_tmp_utf8
= ToUTF8( UTFstring( name
) );
4830 chapters
.psz_name
+= psz_tmp_utf8
;
4831 chapters
.b_user_display
= true;
4833 msg_Dbg( &sys
.demuxer
, "| | | | | + ChapterString '%s'", psz_tmp_utf8
);
4834 free( psz_tmp_utf8
);
4836 else if( MKV_IS_ID( l
, KaxChapterLanguage
) )
4838 KaxChapterLanguage
&lang
=*(KaxChapterLanguage
*)l
;
4839 const char *psz
= string( lang
).c_str();
4841 msg_Dbg( &sys
.demuxer
, "| | | | | + ChapterLanguage '%s'", psz
);
4843 else if( MKV_IS_ID( l
, KaxChapterCountry
) )
4845 KaxChapterCountry
&ct
=*(KaxChapterCountry
*)l
;
4846 const char *psz
= string( ct
).c_str();
4848 msg_Dbg( &sys
.demuxer
, "| | | | | + ChapterCountry '%s'", psz
);
4852 else if( MKV_IS_ID( l
, KaxChapterProcess
) )
4854 msg_Dbg( &sys
.demuxer
, "| | | | + ChapterProcess" );
4856 KaxChapterProcess
*cp
= static_cast<KaxChapterProcess
*>(l
);
4857 chapter_codec_cmds_c
*p_ccodec
= NULL
;
4859 for( j
= 0; j
< cp
->ListSize(); j
++ )
4861 EbmlElement
*k
= (*cp
)[j
];
4863 if( MKV_IS_ID( k
, KaxChapterProcessCodecID
) )
4865 KaxChapterProcessCodecID
*p_codec_id
= static_cast<KaxChapterProcessCodecID
*>( k
);
4866 if ( uint32(*p_codec_id
) == 0 )
4867 p_ccodec
= new matroska_script_codec_c( sys
);
4868 else if ( uint32(*p_codec_id
) == 1 )
4869 p_ccodec
= new dvd_chapter_codec_c( sys
);
4874 if ( p_ccodec
!= NULL
)
4876 for( j
= 0; j
< cp
->ListSize(); j
++ )
4878 EbmlElement
*k
= (*cp
)[j
];
4880 if( MKV_IS_ID( k
, KaxChapterProcessPrivate
) )
4882 KaxChapterProcessPrivate
* p_private
= static_cast<KaxChapterProcessPrivate
*>( k
);
4883 p_ccodec
->SetPrivate( *p_private
);
4885 else if( MKV_IS_ID( k
, KaxChapterProcessCommand
) )
4887 p_ccodec
->AddCommand( *static_cast<KaxChapterProcessCommand
*>( k
) );
4890 chapters
.codecs
.push_back( p_ccodec
);
4893 else if( MKV_IS_ID( l
, KaxChapterAtom
) )
4895 chapter_item_c
*new_sub_chapter
= new chapter_item_c();
4896 ParseChapterAtom( i_level
+1, static_cast<KaxChapterAtom
*>(l
), *new_sub_chapter
);
4897 new_sub_chapter
->psz_parent
= &chapters
;
4898 chapters
.sub_chapters
.push_back( new_sub_chapter
);
4903 /*****************************************************************************
4905 *****************************************************************************/
4906 void matroska_segment_c::ParseChapters( KaxChapters
*chapters
)
4910 int i_upper_level
= 0;
4913 /* Master elements */
4914 chapters
->Read( es
, chapters
->Generic().Context
, i_upper_level
, el
, true );
4916 for( i
= 0; i
< chapters
->ListSize(); i
++ )
4918 EbmlElement
*l
= (*chapters
)[i
];
4920 if( MKV_IS_ID( l
, KaxEditionEntry
) )
4922 chapter_edition_c
*p_edition
= new chapter_edition_c();
4924 EbmlMaster
*E
= static_cast<EbmlMaster
*>(l
);
4926 msg_Dbg( &sys
.demuxer
, "| | + EditionEntry" );
4927 for( j
= 0; j
< E
->ListSize(); j
++ )
4929 EbmlElement
*l
= (*E
)[j
];
4931 if( MKV_IS_ID( l
, KaxChapterAtom
) )
4933 chapter_item_c
*new_sub_chapter
= new chapter_item_c();
4934 ParseChapterAtom( 0, static_cast<KaxChapterAtom
*>(l
), *new_sub_chapter
);
4935 p_edition
->sub_chapters
.push_back( new_sub_chapter
);
4937 else if( MKV_IS_ID( l
, KaxEditionUID
) )
4939 p_edition
->i_uid
= uint64(*static_cast<KaxEditionUID
*>( l
));
4941 else if( MKV_IS_ID( l
, KaxEditionFlagOrdered
) )
4943 p_edition
->b_ordered
= config_GetInt( &sys
.demuxer
, "mkv-use-ordered-chapters" ) ? (uint8(*static_cast<KaxEditionFlagOrdered
*>( l
)) != 0) : 0;
4945 else if( MKV_IS_ID( l
, KaxEditionFlagDefault
) )
4947 if (uint8(*static_cast<KaxEditionFlagDefault
*>( l
)) != 0)
4948 i_default_edition
= stored_editions
.size();
4952 msg_Dbg( &sys
.demuxer
, "| | | + Unknown (%s)", typeid(*l
).name() );
4955 stored_editions
.push_back( p_edition
);
4959 msg_Dbg( &sys
.demuxer
, "| | + Unknown (%s)", typeid(*l
).name() );
4963 for( i
= 0; i
< stored_editions
.size(); i
++ )
4965 stored_editions
[i
]->RefreshChapters( );
4968 if ( stored_editions
.size() != 0 && stored_editions
[i_default_edition
]->b_ordered
)
4970 /* update the duration of the segment according to the sum of all sub chapters */
4971 i_dur
= stored_editions
[i_default_edition
]->Duration() / I64C(1000);
4977 void matroska_segment_c::ParseCluster( )
4982 int i_upper_level
= 0;
4984 /* Master elements */
4985 m
= static_cast<EbmlMaster
*>( cluster
);
4986 m
->Read( es
, cluster
->Generic().Context
, i_upper_level
, el
, true );
4988 for( i
= 0; i
< m
->ListSize(); i
++ )
4990 EbmlElement
*l
= (*m
)[i
];
4992 if( MKV_IS_ID( l
, KaxClusterTimecode
) )
4994 KaxClusterTimecode
&ctc
= *(KaxClusterTimecode
*)l
;
4996 cluster
->InitTimecode( uint64( ctc
), i_timescale
);
5001 i_start_time
= cluster
->GlobalTimecode() / 1000;
5004 /*****************************************************************************
5005 * InformationCreate:
5006 *****************************************************************************/
5007 void matroska_segment_c::InformationCreate( )
5009 sys
.meta
= vlc_meta_New();
5013 vlc_meta_SetTitle( sys
.meta
, psz_title
);
5017 vlc_meta_SetDate( sys
.meta
, psz_date_utc
);
5020 if( psz_segment_filename
)
5022 fprintf( stderr
, "***** WARNING: Unhandled meta - Use custom\n" );
5024 if( psz_muxing_application
)
5026 fprintf( stderr
, "***** WARNING: Unhandled meta - Use custom\n" );
5028 if( psz_writing_application
)
5030 fprintf( stderr
, "***** WARNING: Unhandled meta - Use custom\n" );
5033 for( size_t i_track
= 0; i_track
< tracks
.size(); i_track
++ )
5035 // mkv_track_t *tk = tracks[i_track];
5036 // vlc_meta_t *mtk = vlc_meta_New();
5037 fprintf( stderr
, "***** WARNING: Unhandled child meta\n");
5041 if( i_tags_position
>= 0 )
5043 vlc_bool_t b_seekable
;
5045 stream_Control( sys
.demuxer
.s
, STREAM_CAN_FASTSEEK
, &b_seekable
);
5054 /*****************************************************************************
5056 *****************************************************************************/
5058 void matroska_segment_c::IndexAppendCluster( KaxCluster
*cluster
)
5060 #define idx p_indexes[i_index]
5062 idx
.i_block_number
= -1;
5063 idx
.i_position
= cluster
->GetElementPosition();
5065 idx
.b_key
= VLC_TRUE
;
5068 if( i_index
>= i_index_max
)
5070 i_index_max
+= 1024;
5071 p_indexes
= (mkv_index_t
*)realloc( p_indexes
, sizeof( mkv_index_t
) * i_index_max
);
5076 void chapter_edition_c::RefreshChapters( )
5078 chapter_item_c::RefreshChapters( b_ordered
, -1 );
5079 b_display_seekpoint
= false;
5082 int64_t chapter_item_c::RefreshChapters( bool b_ordered
, int64_t i_prev_user_time
)
5084 int64_t i_user_time
= i_prev_user_time
;
5086 // first the sub-chapters, and then ourself
5087 std::vector
<chapter_item_c
*>::iterator index
= sub_chapters
.begin();
5088 while ( index
!= sub_chapters
.end() )
5090 i_user_time
= (*index
)->RefreshChapters( b_ordered
, i_user_time
);
5096 // the ordered chapters always start at zero
5097 if ( i_prev_user_time
== -1 )
5099 if ( i_user_time
== -1 )
5101 i_prev_user_time
= 0;
5104 i_user_start_time
= i_prev_user_time
;
5105 if ( i_end_time
!= -1 && i_user_time
== i_prev_user_time
)
5107 i_user_end_time
= i_user_start_time
- i_start_time
+ i_end_time
;
5111 i_user_end_time
= i_user_time
;
5116 if ( sub_chapters
.begin() != sub_chapters
.end() )
5117 std::sort( sub_chapters
.begin(), sub_chapters
.end(), chapter_item_c::CompareTimecode
);
5118 i_user_start_time
= i_start_time
;
5119 if ( i_end_time
!= -1 )
5120 i_user_end_time
= i_end_time
;
5121 else if ( i_user_time
!= -1 )
5122 i_user_end_time
= i_user_time
;
5124 i_user_end_time
= i_user_start_time
;
5127 return i_user_end_time
;
5130 mtime_t
chapter_edition_c::Duration() const
5132 mtime_t i_result
= 0;
5134 if ( sub_chapters
.size() )
5136 std::vector
<chapter_item_c
*>::const_iterator index
= sub_chapters
.end();
5138 i_result
= (*index
)->i_user_end_time
;
5144 chapter_item_c
* chapter_edition_c::FindTimecode( mtime_t i_timecode
, const chapter_item_c
* p_current
)
5148 bool b_found_current
= false;
5149 return chapter_item_c::FindTimecode( i_timecode
, p_current
, b_found_current
);
5152 chapter_item_c
*chapter_item_c::FindTimecode( mtime_t i_user_timecode
, const chapter_item_c
* p_current
, bool & b_found
)
5154 chapter_item_c
*psz_result
= NULL
;
5156 if ( p_current
== this )
5159 if ( i_user_timecode
>= i_user_start_time
&&
5160 ( i_user_timecode
< i_user_end_time
||
5161 ( i_user_start_time
== i_user_end_time
&& i_user_timecode
== i_user_end_time
)))
5163 std::vector
<chapter_item_c
*>::iterator index
= sub_chapters
.begin();
5164 while ( index
!= sub_chapters
.end() && ((p_current
== NULL
&& psz_result
== NULL
) || (p_current
!= NULL
&& (!b_found
|| psz_result
== NULL
))))
5166 psz_result
= (*index
)->FindTimecode( i_user_timecode
, p_current
, b_found
);
5170 if ( psz_result
== NULL
)
5177 bool chapter_item_c::ParentOf( const chapter_item_c
& item
) const
5179 if ( &item
== this )
5182 std::vector
<chapter_item_c
*>::const_iterator index
= sub_chapters
.begin();
5183 while ( index
!= sub_chapters
.end() )
5185 if ( (*index
)->ParentOf( item
) )
5193 void demux_sys_t::PreloadFamily( const matroska_segment_c
& of_segment
)
5195 for (size_t i
=0; i
<opened_segments
.size(); i
++)
5197 opened_segments
[i
]->PreloadFamily( of_segment
);
5200 bool matroska_segment_c::PreloadFamily( const matroska_segment_c
& of_segment
)
5205 for (size_t i
=0; i
<families
.size(); i
++)
5207 for (size_t j
=0; j
<of_segment
.families
.size(); j
++)
5209 if ( *(families
[i
]) == *(of_segment
.families
[j
]) )
5217 // preload all the linked segments for all preloaded segments
5218 void demux_sys_t::PreloadLinked( matroska_segment_c
*p_segment
)
5220 size_t i_preloaded
, i
, j
;
5221 virtual_segment_c
*p_seg
;
5223 p_current_segment
= VirtualFromSegments( p_segment
);
5225 used_segments
.push_back( p_current_segment
);
5227 // create all the other virtual segments of the family
5230 for ( i
=0; i
< opened_segments
.size(); i
++ )
5232 if ( opened_segments
[i
]->b_preloaded
&& !IsUsedSegment( *opened_segments
[i
] ) )
5234 p_seg
= VirtualFromSegments( opened_segments
[i
] );
5235 used_segments
.push_back( p_seg
);
5239 } while ( i_preloaded
); // worst case: will stop when all segments are found as family related
5241 // publish all editions of all usable segment
5242 for ( i
=0; i
< used_segments
.size(); i
++ )
5244 p_seg
= used_segments
[i
];
5245 if ( p_seg
->p_editions
!= NULL
)
5247 std::string sz_name
;
5248 input_title_t
*p_title
= vlc_input_title_New();
5249 p_seg
->i_sys_title
= i
;
5252 // TODO use a name for each edition, let the TITLE deal with a codec name
5253 for ( j
=0; j
<p_seg
->p_editions
->size(); j
++ )
5255 if ( p_title
->psz_name
== NULL
)
5257 sz_name
= (*p_seg
->p_editions
)[j
]->GetMainName();
5258 if ( sz_name
!= "" )
5259 p_title
->psz_name
= strdup( sz_name
.c_str() );
5262 chapter_edition_c
*p_edition
= (*p_seg
->p_editions
)[j
];
5265 p_edition
->PublishChapters( *p_title
, i_chapters
, 0 );
5268 // create a name if there is none
5269 if ( p_title
->psz_name
== NULL
)
5271 sz_name
= N_("Segment");
5273 sprintf( psz_str
, " %d", (int)i
);
5275 p_title
->psz_name
= strdup( sz_name
.c_str() );
5278 titles
.push_back( p_title
);
5282 // TODO decide which segment should be first used (VMG for DVD)
5285 bool demux_sys_t::IsUsedSegment( matroska_segment_c
&segment
) const
5287 for ( size_t i
=0; i
< used_segments
.size(); i
++ )
5289 if ( used_segments
[i
]->FindUID( *segment
.p_segment_uid
) )
5295 virtual_segment_c
*demux_sys_t::VirtualFromSegments( matroska_segment_c
*p_segment
) const
5297 size_t i_preloaded
, i
;
5299 virtual_segment_c
*p_result
= new virtual_segment_c( p_segment
);
5301 // fill our current virtual segment with all hard linked segments
5304 for ( i
=0; i
< opened_segments
.size(); i
++ )
5306 i_preloaded
+= p_result
->AddSegment( opened_segments
[i
] );
5308 } while ( i_preloaded
); // worst case: will stop when all segments are found as linked
5312 p_result
->PreloadLinked( );
5314 p_result
->PrepareChapters( );
5319 bool demux_sys_t::PreparePlayback( virtual_segment_c
*p_new_segment
)
5321 if ( p_new_segment
!= NULL
&& p_new_segment
!= p_current_segment
)
5323 if ( p_current_segment
!= NULL
&& p_current_segment
->Segment() != NULL
)
5324 p_current_segment
->Segment()->UnSelect();
5326 p_current_segment
= p_new_segment
;
5327 i_current_title
= p_new_segment
->i_sys_title
;
5330 p_current_segment
->LoadCues();
5331 f_duration
= p_current_segment
->Duration();
5333 /* add information */
5334 p_current_segment
->Segment()->InformationCreate( );
5336 p_current_segment
->Segment()->Select( 0 );
5341 void demux_sys_t::JumpTo( virtual_segment_c
& vsegment
, chapter_item_c
* p_chapter
)
5343 // if the segment is not part of the current segment, select the new one
5344 if ( &vsegment
!= p_current_segment
)
5346 PreparePlayback( &vsegment
);
5349 if ( p_chapter
!= NULL
)
5351 if ( !p_chapter
->Enter( true ) )
5353 // jump to the location in the found segment
5354 vsegment
.Seek( demuxer
, p_chapter
->i_user_start_time
, -1, p_chapter
);
5360 bool matroska_segment_c::CompareSegmentUIDs( const matroska_segment_c
* p_item_a
, const matroska_segment_c
* p_item_b
)
5364 if ( p_item_a
== NULL
|| p_item_b
== NULL
)
5367 p_tmp
= (EbmlBinary
*)p_item_a
->p_segment_uid
;
5368 if ( p_item_b
->p_prev_segment_uid
!= NULL
5369 && *p_tmp
== *p_item_b
->p_prev_segment_uid
)
5372 p_tmp
= (EbmlBinary
*)p_item_a
->p_next_segment_uid
;
5376 if ( p_item_b
->p_segment_uid
!= NULL
5377 && *p_tmp
== *p_item_b
->p_segment_uid
)
5380 if ( p_item_b
->p_prev_segment_uid
!= NULL
5381 && *p_tmp
== *p_item_b
->p_prev_segment_uid
)
5387 bool matroska_segment_c::Preload( )
5392 EbmlElement
*el
= NULL
;
5394 ep
->Reset( &sys
.demuxer
);
5396 while( ( el
= ep
->Get() ) != NULL
)
5398 if( MKV_IS_ID( el
, KaxInfo
) )
5400 ParseInfo( static_cast<KaxInfo
*>( el
) );
5402 else if( MKV_IS_ID( el
, KaxTracks
) )
5404 ParseTracks( static_cast<KaxTracks
*>( el
) );
5405 if ( tracks
.size() == 0 )
5407 msg_Err( &sys
.demuxer
, "No tracks supported" );
5411 else if( MKV_IS_ID( el
, KaxSeekHead
) )
5413 ParseSeekHead( static_cast<KaxSeekHead
*>( el
) );
5415 else if( MKV_IS_ID( el
, KaxCues
) )
5417 msg_Dbg( &sys
.demuxer
, "| + Cues" );
5419 else if( MKV_IS_ID( el
, KaxCluster
) )
5421 msg_Dbg( &sys
.demuxer
, "| + Cluster" );
5423 cluster
= (KaxCluster
*)el
;
5425 i_cluster_pos
= i_start_pos
= cluster
->GetElementPosition();
5429 /* stop parsing the stream */
5432 else if( MKV_IS_ID( el
, KaxAttachments
) )
5434 msg_Dbg( &sys
.demuxer
, "| + Attachments FIXME (but probably never supported)" );
5436 else if( MKV_IS_ID( el
, KaxChapters
) )
5438 msg_Dbg( &sys
.demuxer
, "| + Chapters" );
5439 ParseChapters( static_cast<KaxChapters
*>( el
) );
5441 else if( MKV_IS_ID( el
, KaxTag
) )
5443 msg_Dbg( &sys
.demuxer
, "| + Tags FIXME TODO" );
5447 msg_Dbg( &sys
.demuxer
, "| + Unknown (%s)", typeid(*el
).name() );
5456 matroska_segment_c
*demux_sys_t::FindSegment( const EbmlBinary
& uid
) const
5458 for (size_t i
=0; i
<opened_segments
.size(); i
++)
5460 if ( *opened_segments
[i
]->p_segment_uid
== uid
)
5461 return opened_segments
[i
];
5466 chapter_item_c
*demux_sys_t::BrowseCodecPrivate( unsigned int codec_id
,
5467 bool (*match
)(const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
),
5468 const void *p_cookie
,
5469 size_t i_cookie_size
,
5470 virtual_segment_c
* &p_segment_found
)
5472 chapter_item_c
*p_result
= NULL
;
5473 for (size_t i
=0; i
<used_segments
.size(); i
++)
5475 p_result
= used_segments
[i
]->BrowseCodecPrivate( codec_id
, match
, p_cookie
, i_cookie_size
);
5476 if ( p_result
!= NULL
)
5478 p_segment_found
= used_segments
[i
];
5485 chapter_item_c
*demux_sys_t::FindChapter( int64_t i_find_uid
, virtual_segment_c
* & p_segment_found
)
5487 chapter_item_c
*p_result
= NULL
;
5488 for (size_t i
=0; i
<used_segments
.size(); i
++)
5490 p_result
= used_segments
[i
]->FindChapter( i_find_uid
);
5491 if ( p_result
!= NULL
)
5493 p_segment_found
= used_segments
[i
];
5500 void virtual_segment_c::Sort()
5502 // keep the current segment index
5503 matroska_segment_c
*p_segment
= linked_segments
[i_current_segment
];
5505 std::sort( linked_segments
.begin(), linked_segments
.end(), matroska_segment_c::CompareSegmentUIDs
);
5507 for ( i_current_segment
=0; i_current_segment
<linked_segments
.size(); i_current_segment
++)
5508 if ( linked_segments
[i_current_segment
] == p_segment
)
5512 size_t virtual_segment_c::AddSegment( matroska_segment_c
*p_segment
)
5515 // check if it's not already in here
5516 for ( i
=0; i
<linked_segments
.size(); i
++ )
5518 if ( linked_segments
[i
]->p_segment_uid
!= NULL
5519 && p_segment
->p_segment_uid
!= NULL
5520 && *p_segment
->p_segment_uid
== *linked_segments
[i
]->p_segment_uid
)
5524 // find possible mates
5525 for ( i
=0; i
<linked_uids
.size(); i
++ )
5527 if ( (p_segment
->p_segment_uid
!= NULL
&& *p_segment
->p_segment_uid
== linked_uids
[i
])
5528 || (p_segment
->p_prev_segment_uid
!= NULL
&& *p_segment
->p_prev_segment_uid
== linked_uids
[i
])
5529 || (p_segment
->p_next_segment_uid
!=NULL
&& *p_segment
->p_next_segment_uid
== linked_uids
[i
]) )
5531 linked_segments
.push_back( p_segment
);
5533 AppendUID( p_segment
->p_prev_segment_uid
);
5534 AppendUID( p_segment
->p_next_segment_uid
);
5542 void virtual_segment_c::PreloadLinked( )
5544 for ( size_t i
=0; i
<linked_segments
.size(); i
++ )
5546 linked_segments
[i
]->Preload( );
5548 i_current_edition
= linked_segments
[0]->i_default_edition
;
5551 mtime_t
virtual_segment_c::Duration() const
5554 if ( linked_segments
.size() == 0 )
5557 matroska_segment_c
*p_last_segment
= linked_segments
[linked_segments
.size()-1];
5558 // p_last_segment->ParseCluster( );
5560 i_duration
= p_last_segment
->i_start_time
/ 1000 + p_last_segment
->i_duration
;
5565 void virtual_segment_c::LoadCues( )
5567 for ( size_t i
=0; i
<linked_segments
.size(); i
++ )
5569 linked_segments
[i
]->LoadCues();
5573 void virtual_segment_c::AppendUID( const EbmlBinary
* p_UID
)
5575 if ( p_UID
== NULL
)
5577 if ( p_UID
->GetBuffer() == NULL
)
5580 for (size_t i
=0; i
<linked_uids
.size(); i
++)
5582 if ( *p_UID
== linked_uids
[i
] )
5585 linked_uids
.push_back( *(KaxSegmentUID
*)(p_UID
) );
5588 void matroska_segment_c::Seek( mtime_t i_date
, mtime_t i_time_offset
)
5591 #if LIBMATROSKA_VERSION >= 0x000800
5592 KaxSimpleBlock
*simpleblock
;
5594 int i_track_skipping
;
5595 int64_t i_block_duration
;
5596 int64_t i_block_ref1
;
5597 int64_t i_block_ref2
;
5599 int64_t i_seek_position
= i_start_pos
;
5600 int64_t i_seek_time
= i_start_time
;
5606 for( ; i_idx
< i_index
; i_idx
++ )
5608 if( p_indexes
[i_idx
].i_time
+ i_time_offset
> i_date
)
5619 i_seek_position
= p_indexes
[i_idx
].i_position
;
5620 i_seek_time
= p_indexes
[i_idx
].i_time
;
5623 msg_Dbg( &sys
.demuxer
, "seek got "I64Fd
" (%d%%)",
5624 i_seek_time
, (int)( 100 * i_seek_position
/ stream_Size( sys
.demuxer
.s
) ) );
5626 es
.I_O().setFilePointer( i_seek_position
, seek_beginning
);
5629 ep
= new EbmlParser( &es
, segment
, &sys
.demuxer
);
5632 sys
.i_start_pts
= i_date
;
5634 es_out_Control( sys
.demuxer
.out
, ES_OUT_RESET_PCR
);
5636 /* now parse until key frame */
5637 i_track_skipping
= 0;
5638 for( i_track
= 0; i_track
< tracks
.size(); i_track
++ )
5640 if( tracks
[i_track
]->fmt
.i_cat
== VIDEO_ES
)
5642 tracks
[i_track
]->b_search_keyframe
= VLC_TRUE
;
5645 es_out_Control( sys
.demuxer
.out
, ES_OUT_SET_NEXT_DISPLAY_TIME
, tracks
[i_track
]->p_es
, i_date
);
5649 while( i_track_skipping
> 0 )
5651 #if LIBMATROSKA_VERSION >= 0x000800
5652 if( BlockGet( block
, simpleblock
, &i_block_ref1
, &i_block_ref2
, &i_block_duration
) )
5654 if( BlockGet( block
, &i_block_ref1
, &i_block_ref2
, &i_block_duration
) )
5657 msg_Warn( &sys
.demuxer
, "cannot get block EOF?" );
5663 for( i_track
= 0; i_track
< tracks
.size(); i_track
++ )
5665 if( tracks
[i_track
]->i_number
== block
->TrackNum() )
5671 sys
.i_pts
= (sys
.i_chapter_time
+ block
->GlobalTimecode()) / (mtime_t
) 1000;
5673 if( i_track
< tracks
.size() )
5675 if( sys
.i_pts
>= sys
.i_start_pts
)
5677 cluster
= static_cast<KaxCluster
*>(ep
->UnGet( i_block_pos
, i_cluster_pos
));
5678 i_track_skipping
= 0;
5680 else if( tracks
[i_track
]->fmt
.i_cat
== VIDEO_ES
)
5682 if( i_block_ref1
== 0 && tracks
[i_track
]->b_search_keyframe
)
5684 tracks
[i_track
]->b_search_keyframe
= VLC_FALSE
;
5687 if( !tracks
[i_track
]->b_search_keyframe
)
5689 #if LIBMATROSKA_VERSION >= 0x000800
5690 BlockDecode( &sys
.demuxer
, block
, simpleblock
, sys
.i_pts
, 0, i_block_ref1
>= 0 || i_block_ref2
> 0 );
5692 BlockDecode( &sys
.demuxer
, block
, sys
.i_pts
, 0, i_block_ref1
>= 0 || i_block_ref2
> 0 );
5702 void virtual_segment_c::Seek( demux_t
& demuxer
, mtime_t i_date
, mtime_t i_time_offset
, chapter_item_c
*psz_chapter
)
5704 demux_sys_t
*p_sys
= demuxer
.p_sys
;
5707 // find the actual time for an ordered edition
5708 if ( psz_chapter
== NULL
)
5710 if ( Edition() && Edition()->b_ordered
)
5712 /* 1st, we need to know in which chapter we are */
5713 psz_chapter
= (*p_editions
)[i_current_edition
]->FindTimecode( i_date
, psz_current_chapter
);
5717 if ( psz_chapter
!= NULL
)
5719 psz_current_chapter
= psz_chapter
;
5720 p_sys
->i_chapter_time
= i_time_offset
= psz_chapter
->i_user_start_time
- psz_chapter
->i_start_time
;
5721 if ( psz_chapter
->i_seekpoint_num
> 0 )
5723 demuxer
.info
.i_update
|= INPUT_UPDATE_TITLE
| INPUT_UPDATE_SEEKPOINT
;
5724 demuxer
.info
.i_title
= p_sys
->i_current_title
= i_sys_title
;
5725 demuxer
.info
.i_seekpoint
= psz_chapter
->i_seekpoint_num
- 1;
5729 // find the best matching segment
5730 for ( i
=0; i
<linked_segments
.size(); i
++ )
5732 if ( i_date
< linked_segments
[i
]->i_start_time
)
5739 if ( i_current_segment
!= i
)
5741 linked_segments
[i_current_segment
]->UnSelect();
5742 linked_segments
[i
]->Select( i_date
);
5743 i_current_segment
= i
;
5746 linked_segments
[i
]->Seek( i_date
, i_time_offset
);
5749 void chapter_codec_cmds_c::AddCommand( const KaxChapterProcessCommand
& command
)
5753 uint32 codec_time
= uint32(-1);
5754 for( i
= 0; i
< command
.ListSize(); i
++ )
5756 const EbmlElement
*k
= command
[i
];
5758 if( MKV_IS_ID( k
, KaxChapterProcessTime
) )
5760 codec_time
= uint32( *static_cast<const KaxChapterProcessTime
*>( k
) );
5765 for( i
= 0; i
< command
.ListSize(); i
++ )
5767 const EbmlElement
*k
= command
[i
];
5769 if( MKV_IS_ID( k
, KaxChapterProcessData
) )
5771 KaxChapterProcessData
*p_data
= new KaxChapterProcessData( *static_cast<const KaxChapterProcessData
*>( k
) );
5772 switch ( codec_time
)
5775 during_cmds
.push_back( p_data
);
5778 enter_cmds
.push_back( p_data
);
5781 leave_cmds
.push_back( p_data
);
5790 bool chapter_item_c::Enter( bool b_do_subs
)
5792 bool f_result
= false;
5793 std::vector
<chapter_codec_cmds_c
*>::iterator index
= codecs
.begin();
5794 while ( index
!= codecs
.end() )
5796 f_result
|= (*index
)->Enter();
5803 std::vector
<chapter_item_c
*>::iterator index_
= sub_chapters
.begin();
5804 while ( index_
!= sub_chapters
.end() )
5806 f_result
|= (*index_
)->Enter( true );
5813 bool chapter_item_c::Leave( bool b_do_subs
)
5815 bool f_result
= false;
5816 b_is_leaving
= true;
5817 std::vector
<chapter_codec_cmds_c
*>::iterator index
= codecs
.begin();
5818 while ( index
!= codecs
.end() )
5820 f_result
|= (*index
)->Leave();
5827 std::vector
<chapter_item_c
*>::iterator index_
= sub_chapters
.begin();
5828 while ( index_
!= sub_chapters
.end() )
5830 f_result
|= (*index_
)->Leave( true );
5834 b_is_leaving
= false;
5838 bool chapter_item_c::EnterAndLeave( chapter_item_c
*p_item
, bool b_final_enter
)
5840 chapter_item_c
*p_common_parent
= p_item
;
5842 // leave, up to a common parent
5843 while ( p_common_parent
!= NULL
&& !p_common_parent
->ParentOf( *this ) )
5845 if ( !p_common_parent
->b_is_leaving
&& p_common_parent
->Leave( false ) )
5847 p_common_parent
= p_common_parent
->psz_parent
;
5850 // enter from the parent to <this>
5851 if ( p_common_parent
!= NULL
)
5855 if ( p_common_parent
== this )
5856 return Enter( true );
5858 for ( size_t i
= 0; i
<p_common_parent
->sub_chapters
.size(); i
++ )
5860 if ( p_common_parent
->sub_chapters
[i
]->ParentOf( *this ) )
5862 p_common_parent
= p_common_parent
->sub_chapters
[i
];
5863 if ( p_common_parent
!= this )
5864 if ( p_common_parent
->Enter( false ) )
5873 if ( b_final_enter
)
5874 return Enter( true );
5879 bool dvd_chapter_codec_c::Enter()
5881 bool f_result
= false;
5882 std::vector
<KaxChapterProcessData
*>::iterator index
= enter_cmds
.begin();
5883 while ( index
!= enter_cmds
.end() )
5885 if ( (*index
)->GetSize() )
5887 binary
*p_data
= (*index
)->GetBuffer();
5888 size_t i_size
= *p_data
++;
5889 // avoid reading too much from the buffer
5890 i_size
= min( i_size
, ((*index
)->GetSize() - 1) >> 3 );
5891 for ( ; i_size
> 0; i_size
--, p_data
+= 8 )
5893 msg_Dbg( &sys
.demuxer
, "Matroska DVD enter command" );
5894 f_result
|= sys
.dvd_interpretor
.Interpret( p_data
);
5902 bool dvd_chapter_codec_c::Leave()
5904 bool f_result
= false;
5905 std::vector
<KaxChapterProcessData
*>::iterator index
= leave_cmds
.begin();
5906 while ( index
!= leave_cmds
.end() )
5908 if ( (*index
)->GetSize() )
5910 binary
*p_data
= (*index
)->GetBuffer();
5911 size_t i_size
= *p_data
++;
5912 // avoid reading too much from the buffer
5913 i_size
= min( i_size
, ((*index
)->GetSize() - 1) >> 3 );
5914 for ( ; i_size
> 0; i_size
--, p_data
+= 8 )
5916 msg_Dbg( &sys
.demuxer
, "Matroska DVD leave command" );
5917 f_result
|= sys
.dvd_interpretor
.Interpret( p_data
);
5925 // see http://www.dvd-replica.com/DVD/vmcmdset.php for a description of DVD commands
5926 bool dvd_command_interpretor_c::Interpret( const binary
* p_command
, size_t i_size
)
5931 virtual_segment_c
*p_segment
= NULL
;
5932 chapter_item_c
*p_chapter
= NULL
;
5933 bool f_result
= false;
5934 uint16 i_command
= ( p_command
[0] << 8 ) + p_command
[1];
5936 // handle register tests if there are some
5937 if ( (i_command
& 0xF0) != 0 )
5939 bool b_test_positive
= true;//(i_command & CMD_DVD_IF_NOT) == 0;
5940 bool b_test_value
= (i_command
& CMD_DVD_TEST_VALUE
) != 0;
5941 uint8 i_test
= i_command
& 0x70;
5944 // see http://dvd.sourceforge.net/dvdinfo/vmi.html
5947 switch ( i_command
>> 12 )
5950 i_cr1
= p_command
[3];
5951 i_cr2
= (p_command
[4] << 8) + p_command
[5];
5956 i_cr1
= p_command
[6];
5957 i_cr2
= p_command
[7];
5958 b_test_value
= false;
5962 if ( ((p_command
[1] >> 4) & 0x7) == 0)
5964 i_cr1
= p_command
[2];
5965 i_cr2
= (p_command
[6] << 8) + p_command
[7];
5969 i_cr1
= p_command
[2];
5970 i_cr2
= (p_command
[6] << 8) + p_command
[7];
5978 i_value
= GetPRM( i_cr2
);
5982 case CMD_DVD_IF_GPREG_EQUAL
:
5984 msg_Dbg( &sys
.demuxer
, "IF %s EQUALS %s", GetRegTypeName( false, i_cr1
).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
5985 if (!( GetPRM( i_cr1
) == i_value
))
5987 b_test_positive
= false;
5990 case CMD_DVD_IF_GPREG_NOT_EQUAL
:
5992 msg_Dbg( &sys
.demuxer
, "IF %s NOT EQUALS %s", GetRegTypeName( false, i_cr1
).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
5993 if (!( GetPRM( i_cr1
) != i_value
))
5995 b_test_positive
= false;
5998 case CMD_DVD_IF_GPREG_INF
:
6000 msg_Dbg( &sys
.demuxer
, "IF %s < %s", GetRegTypeName( false, p_command
[3] ).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
6001 if (!( GetPRM( i_cr1
) < i_value
))
6003 b_test_positive
= false;
6006 case CMD_DVD_IF_GPREG_INF_EQUAL
:
6007 // if inferior or equal
6008 msg_Dbg( &sys
.demuxer
, "IF %s < %s", GetRegTypeName( false, p_command
[3] ).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
6009 if (!( GetPRM( i_cr1
) <= i_value
))
6011 b_test_positive
= false;
6014 case CMD_DVD_IF_GPREG_AND
:
6016 msg_Dbg( &sys
.demuxer
, "IF %s & %s", GetRegTypeName( false, p_command
[3] ).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
6017 if (!( GetPRM( i_cr1
) & i_value
))
6019 b_test_positive
= false;
6022 case CMD_DVD_IF_GPREG_SUP
:
6024 msg_Dbg( &sys
.demuxer
, "IF %s >= %s", GetRegTypeName( false, p_command
[3] ).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
6025 if (!( GetPRM( i_cr1
) > i_value
))
6027 b_test_positive
= false;
6030 case CMD_DVD_IF_GPREG_SUP_EQUAL
:
6031 // if superior or equal
6032 msg_Dbg( &sys
.demuxer
, "IF %s >= %s", GetRegTypeName( false, p_command
[3] ).c_str(), GetRegTypeName( b_test_value
, i_value
).c_str() );
6033 if (!( GetPRM( i_cr1
) >= i_value
))
6035 b_test_positive
= false;
6040 if ( !b_test_positive
)
6044 // strip the test command
6045 i_command
&= 0xFF0F;
6047 switch ( i_command
)
6052 msg_Dbg( &sys
.demuxer
, "NOP" );
6057 msg_Dbg( &sys
.demuxer
, "Break" );
6061 case CMD_DVD_JUMP_TT
:
6063 uint8 i_title
= p_command
[5];
6064 msg_Dbg( &sys
.demuxer
, "JumpTT %d", i_title
);
6066 // find in the ChapProcessPrivate matching this Title level
6067 p_chapter
= sys
.BrowseCodecPrivate( 1, MatchTitleNumber
, &i_title
, sizeof(i_title
), p_segment
);
6068 if ( p_segment
!= NULL
)
6070 sys
.JumpTo( *p_segment
, p_chapter
);
6076 case CMD_DVD_CALLSS_VTSM1
:
6078 msg_Dbg( &sys
.demuxer
, "CallSS" );
6080 switch( (p_command
[6] & 0xC0) >> 6 ) {
6082 p_type
= p_command
[5] & 0x0F;
6086 msg_Dbg( &sys
.demuxer
, "CallSS PGC (rsm_cell %x)", p_command
[4]);
6089 msg_Dbg( &sys
.demuxer
, "CallSS Title Entry (rsm_cell %x)", p_command
[4]);
6092 msg_Dbg( &sys
.demuxer
, "CallSS Root Menu (rsm_cell %x)", p_command
[4]);
6095 msg_Dbg( &sys
.demuxer
, "CallSS Subpicture Menu (rsm_cell %x)", p_command
[4]);
6098 msg_Dbg( &sys
.demuxer
, "CallSS Audio Menu (rsm_cell %x)", p_command
[4]);
6101 msg_Dbg( &sys
.demuxer
, "CallSS Angle Menu (rsm_cell %x)", p_command
[4]);
6104 msg_Dbg( &sys
.demuxer
, "CallSS Chapter Menu (rsm_cell %x)", p_command
[4]);
6107 msg_Dbg( &sys
.demuxer
, "CallSS <unknown> (rsm_cell %x)", p_command
[4]);
6110 p_chapter
= sys
.BrowseCodecPrivate( 1, MatchPgcType
, &p_type
, 1, p_segment
);
6111 if ( p_segment
!= NULL
)
6113 sys
.JumpTo( *p_segment
, p_chapter
);
6118 msg_Dbg( &sys
.demuxer
, "CallSS VMGM (menu %d, rsm_cell %x)", p_command
[5] & 0x0F, p_command
[4]);
6121 msg_Dbg( &sys
.demuxer
, "CallSS VTSM (menu %d, rsm_cell %x)", p_command
[5] & 0x0F, p_command
[4]);
6124 msg_Dbg( &sys
.demuxer
, "CallSS VMGM (pgc %d, rsm_cell %x)", (p_command
[2] << 8) + p_command
[3], p_command
[4]);
6129 case CMD_DVD_JUMP_SS
:
6131 msg_Dbg( &sys
.demuxer
, "JumpSS");
6133 switch( (p_command
[5] & 0xC0) >> 6 ) {
6135 msg_Dbg( &sys
.demuxer
, "JumpSS FP");
6138 p_type
= p_command
[5] & 0x0F;
6142 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Title Entry");
6145 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Root Menu");
6148 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Subpicture Menu");
6151 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Audio Menu");
6154 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Angle Menu");
6157 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM Chapter Menu");
6160 msg_Dbg( &sys
.demuxer
, "JumpSS <unknown>");
6164 p_chapter
= sys
.BrowseCodecPrivate( 1, MatchIsVMG
, NULL
, 0, p_segment
);
6165 if ( p_segment
!= NULL
)
6167 p_chapter
= p_segment
->BrowseCodecPrivate( 1, MatchPgcType
, &p_type
, 1 );
6168 if ( p_chapter
!= NULL
)
6170 sys
.JumpTo( *p_segment
, p_chapter
);
6176 p_type
= p_command
[5] & 0x0F;
6180 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Title Entry", p_command
[4], p_command
[3]);
6183 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Root Menu", p_command
[4], p_command
[3]);
6186 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Subpicture Menu", p_command
[4], p_command
[3]);
6189 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Audio Menu", p_command
[4], p_command
[3]);
6192 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Angle Menu", p_command
[4], p_command
[3]);
6195 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) Chapter Menu", p_command
[4], p_command
[3]);
6198 msg_Dbg( &sys
.demuxer
, "JumpSS VTSM (vts %d, ttn %d) <unknown>", p_command
[4], p_command
[3]);
6202 p_chapter
= sys
.BrowseCodecPrivate( 1, MatchVTSMNumber
, &p_command
[4], 1, p_segment
);
6204 if ( p_segment
!= NULL
&& p_chapter
!= NULL
)
6206 // find the title in the VTS
6207 p_chapter
= p_chapter
->BrowseCodecPrivate( 1, MatchTitleNumber
, &p_command
[3], 1 );
6208 if ( p_chapter
!= NULL
)
6210 // find the specified menu in the VTSM
6211 p_chapter
= p_segment
->BrowseCodecPrivate( 1, MatchPgcType
, &p_type
, 1 );
6212 if ( p_chapter
!= NULL
)
6214 sys
.JumpTo( *p_segment
, p_chapter
);
6219 msg_Dbg( &sys
.demuxer
, "Title (%d) does not exist in this VTS", p_command
[3] );
6222 msg_Dbg( &sys
.demuxer
, "DVD Domain VTS (%d) not found", p_command
[4] );
6225 msg_Dbg( &sys
.demuxer
, "JumpSS VMGM (pgc %d)", (p_command
[2] << 8) + p_command
[3]);
6230 case CMD_DVD_JUMPVTS_PTT
:
6232 uint8 i_title
= p_command
[5];
6233 uint8 i_ptt
= p_command
[3];
6235 msg_Dbg( &sys
.demuxer
, "JumpVTS Title (%d) PTT (%d)", i_title
, i_ptt
);
6237 // find the current VTS content segment
6238 p_chapter
= sys
.p_current_segment
->BrowseCodecPrivate( 1, MatchIsDomain
, NULL
, 0 );
6239 if ( p_chapter
!= NULL
)
6241 int16 i_curr_title
= p_chapter
->GetTitleNumber( );
6242 if ( i_curr_title
> 0 )
6244 p_chapter
= sys
.BrowseCodecPrivate( 1, MatchVTSNumber
, &i_curr_title
, sizeof(i_curr_title
), p_segment
);
6246 if ( p_segment
!= NULL
&& p_chapter
!= NULL
)
6248 // find the title in the VTS
6249 p_chapter
= p_chapter
->BrowseCodecPrivate( 1, MatchTitleNumber
, &i_title
, sizeof(i_title
) );
6250 if ( p_chapter
!= NULL
)
6252 // find the chapter in the title
6253 p_chapter
= p_chapter
->BrowseCodecPrivate( 1, MatchChapterNumber
, &i_ptt
, sizeof(i_ptt
) );
6254 if ( p_chapter
!= NULL
)
6256 sys
.JumpTo( *p_segment
, p_chapter
);
6261 msg_Dbg( &sys
.demuxer
, "Title (%d) does not exist in this VTS", i_title
);
6264 msg_Dbg( &sys
.demuxer
, "DVD Domain VTS (%d) not found", i_curr_title
);
6267 msg_Dbg( &sys
.demuxer
, "JumpVTS_PTT command found but not in a VTS(M)");
6270 msg_Dbg( &sys
.demuxer
, "JumpVTS_PTT command but the DVD domain wasn't found");
6273 case CMD_DVD_SET_GPRMMD
:
6275 msg_Dbg( &sys
.demuxer
, "Set GPRMMD [%d]=%d", (p_command
[4] << 8) + p_command
[5], (p_command
[2] << 8) + p_command
[3]);
6277 if ( !SetGPRM( (p_command
[4] << 8) + p_command
[5], (p_command
[2] << 8) + p_command
[3] ) )
6278 msg_Dbg( &sys
.demuxer
, "Set GPRMMD failed" );
6281 case CMD_DVD_LINKPGCN
:
6283 uint16 i_pgcn
= (p_command
[6] << 8) + p_command
[7];
6285 msg_Dbg( &sys
.demuxer
, "Link PGCN(%d)", i_pgcn
);
6286 p_chapter
= sys
.p_current_segment
->BrowseCodecPrivate( 1, MatchPgcNumber
, &i_pgcn
, 2 );
6287 if ( p_chapter
!= NULL
)
6289 if ( !p_chapter
->Enter( true ) )
6290 // jump to the location in the found segment
6291 sys
.p_current_segment
->Seek( sys
.demuxer
, p_chapter
->i_user_start_time
, -1, p_chapter
);
6297 case CMD_DVD_LINKCN
:
6299 uint8 i_cn
= p_command
[7];
6301 p_chapter
= sys
.p_current_segment
->CurrentChapter();
6303 msg_Dbg( &sys
.demuxer
, "LinkCN (cell %d)", i_cn
);
6304 p_chapter
= p_chapter
->BrowseCodecPrivate( 1, MatchCellNumber
, &i_cn
, 1 );
6305 if ( p_chapter
!= NULL
)
6307 if ( !p_chapter
->Enter( true ) )
6308 // jump to the location in the found segment
6309 sys
.p_current_segment
->Seek( sys
.demuxer
, p_chapter
->i_user_start_time
, -1, p_chapter
);
6315 case CMD_DVD_GOTO_LINE
:
6317 msg_Dbg( &sys
.demuxer
, "GotoLine (%d)", (p_command
[6] << 8) + p_command
[7] );
6321 case CMD_DVD_SET_HL_BTNN1
:
6323 msg_Dbg( &sys
.demuxer
, "SetHL_BTN (%d)", p_command
[4] );
6324 SetSPRM( 0x88, p_command
[4] );
6329 msg_Dbg( &sys
.demuxer
, "unsupported command : %02X %02X %02X %02X %02X %02X %02X %02X"
6345 bool dvd_command_interpretor_c::MatchIsDomain( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6347 return ( data
.p_private_data
!= NULL
&& data
.p_private_data
->GetBuffer()[0] == MATROSKA_DVD_LEVEL_SS
);
6350 bool dvd_command_interpretor_c::MatchIsVMG( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6352 if ( data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 2 )
6355 return ( data
.p_private_data
->GetBuffer()[0] == MATROSKA_DVD_LEVEL_SS
&& data
.p_private_data
->GetBuffer()[1] == 0xC0);
6358 bool dvd_command_interpretor_c::MatchVTSNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6360 if ( i_cookie_size
!= 2 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 4 )
6363 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_SS
|| data
.p_private_data
->GetBuffer()[1] != 0x80 )
6366 uint16 i_gtitle
= (data
.p_private_data
->GetBuffer()[2] << 8 ) + data
.p_private_data
->GetBuffer()[3];
6367 uint16 i_title
= *(uint16
*)p_cookie
;
6369 return (i_gtitle
== i_title
);
6372 bool dvd_command_interpretor_c::MatchVTSMNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6374 if ( i_cookie_size
!= 1 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 4 )
6377 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_SS
|| data
.p_private_data
->GetBuffer()[1] != 0x40 )
6380 uint8 i_gtitle
= data
.p_private_data
->GetBuffer()[3];
6381 uint8 i_title
= *(uint8
*)p_cookie
;
6383 return (i_gtitle
== i_title
);
6386 bool dvd_command_interpretor_c::MatchTitleNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6388 if ( i_cookie_size
!= 1 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 4 )
6391 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_TT
)
6394 uint16 i_gtitle
= (data
.p_private_data
->GetBuffer()[1] << 8 ) + data
.p_private_data
->GetBuffer()[2];
6395 uint8 i_title
= *(uint8
*)p_cookie
;
6397 return (i_gtitle
== i_title
);
6400 bool dvd_command_interpretor_c::MatchPgcType( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6402 if ( i_cookie_size
!= 1 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 8 )
6405 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_PGC
)
6408 uint8 i_pgc_type
= data
.p_private_data
->GetBuffer()[3] & 0x0F;
6409 uint8 i_pgc
= *(uint8
*)p_cookie
;
6411 return (i_pgc_type
== i_pgc
);
6414 bool dvd_command_interpretor_c::MatchPgcNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6416 if ( i_cookie_size
!= 2 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 8 )
6419 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_PGC
)
6422 uint16
*i_pgc_n
= (uint16
*)p_cookie
;
6423 uint16 i_pgc_num
= (data
.p_private_data
->GetBuffer()[1] << 8) + data
.p_private_data
->GetBuffer()[2];
6425 return (i_pgc_num
== *i_pgc_n
);
6428 bool dvd_command_interpretor_c::MatchChapterNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6430 if ( i_cookie_size
!= 1 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 2 )
6433 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_PTT
)
6436 uint8 i_chapter
= data
.p_private_data
->GetBuffer()[1];
6437 uint8 i_ptt
= *(uint8
*)p_cookie
;
6439 return (i_chapter
== i_ptt
);
6442 bool dvd_command_interpretor_c::MatchCellNumber( const chapter_codec_cmds_c
&data
, const void *p_cookie
, size_t i_cookie_size
)
6444 if ( i_cookie_size
!= 1 || data
.p_private_data
== NULL
|| data
.p_private_data
->GetSize() < 5 )
6447 if ( data
.p_private_data
->GetBuffer()[0] != MATROSKA_DVD_LEVEL_CN
)
6450 uint8
*i_cell_n
= (uint8
*)p_cookie
;
6451 uint8 i_cell_num
= data
.p_private_data
->GetBuffer()[3];
6453 return (i_cell_num
== *i_cell_n
);
6456 bool matroska_script_codec_c::Enter()
6458 bool f_result
= false;
6459 std::vector
<KaxChapterProcessData
*>::iterator index
= enter_cmds
.begin();
6460 while ( index
!= enter_cmds
.end() )
6462 if ( (*index
)->GetSize() )
6464 msg_Dbg( &sys
.demuxer
, "Matroska Script enter command" );
6465 f_result
|= interpretor
.Interpret( (*index
)->GetBuffer(), (*index
)->GetSize() );
6472 bool matroska_script_codec_c::Leave()
6474 bool f_result
= false;
6475 std::vector
<KaxChapterProcessData
*>::iterator index
= leave_cmds
.begin();
6476 while ( index
!= leave_cmds
.end() )
6478 if ( (*index
)->GetSize() )
6480 msg_Dbg( &sys
.demuxer
, "Matroska Script leave command" );
6481 f_result
|= interpretor
.Interpret( (*index
)->GetBuffer(), (*index
)->GetSize() );
6488 // see http://www.matroska.org/technical/specs/chapters/index.html#mscript
6489 // for a description of existing commands
6490 bool matroska_script_interpretor_c::Interpret( const binary
* p_command
, size_t i_size
)
6492 bool b_result
= false;
6494 char *psz_str
= (char*) malloc( i_size
+ 1 );
6495 memcpy( psz_str
, p_command
, i_size
);
6496 psz_str
[ i_size
] = '\0';
6498 std::string sz_command
= psz_str
;
6501 msg_Dbg( &sys
.demuxer
, "command : %s", sz_command
.c_str() );
6503 #if defined(__GNUC__) && (__GNUC__ < 3)
6504 if ( sz_command
.compare( CMD_MS_GOTO_AND_PLAY
, 0, CMD_MS_GOTO_AND_PLAY
.size() ) == 0 )
6506 if ( sz_command
.compare( 0, CMD_MS_GOTO_AND_PLAY
.size(), CMD_MS_GOTO_AND_PLAY
) == 0 )
6512 for ( i
=CMD_MS_GOTO_AND_PLAY
.size(); i
<sz_command
.size(); i
++)
6514 if ( sz_command
[i
] == '(' )
6521 for ( j
=i
; j
<sz_command
.size(); j
++)
6523 if ( sz_command
[j
] == ')' )
6530 std::string st
= sz_command
.substr( i
+1, j
-i
-1 );
6531 int64_t i_chapter_uid
= atoi( st
.c_str() );
6533 virtual_segment_c
*p_segment
;
6534 chapter_item_c
*p_chapter
= sys
.FindChapter( i_chapter_uid
, p_segment
);
6536 if ( p_chapter
== NULL
)
6537 msg_Dbg( &sys
.demuxer
, "Chapter "I64Fd
" not found", i_chapter_uid
);
6540 if ( !p_chapter
->EnterAndLeave( sys
.p_current_segment
->CurrentChapter() ) )
6541 p_segment
->Seek( sys
.demuxer
, p_chapter
->i_user_start_time
, -1, p_chapter
);
6549 void demux_sys_t::SwapButtons()
6551 #ifndef WORDS_BIGENDIAN
6552 uint8_t button
, i
, j
;
6554 for( button
= 1; button
<= pci_packet
.hli
.hl_gi
.btn_ns
; button
++) {
6555 btni_t
*button_ptr
= &(pci_packet
.hli
.btnit
[button
-1]);
6556 binary
*p_data
= (binary
*) button_ptr
;
6558 uint16 i_x_start
= ((p_data
[0] & 0x3F) << 4 ) + ( p_data
[1] >> 4 );
6559 uint16 i_x_end
= ((p_data
[1] & 0x03) << 8 ) + p_data
[2];
6560 uint16 i_y_start
= ((p_data
[3] & 0x3F) << 4 ) + ( p_data
[4] >> 4 );
6561 uint16 i_y_end
= ((p_data
[4] & 0x03) << 8 ) + p_data
[5];
6562 button_ptr
->x_start
= i_x_start
;
6563 button_ptr
->x_end
= i_x_end
;
6564 button_ptr
->y_start
= i_y_start
;
6565 button_ptr
->y_end
= i_y_end
;
6568 for ( i
= 0; i
<3; i
++ )
6570 for ( j
= 0; j
<2; j
++ )
6572 pci_packet
.hli
.btn_colit
.btn_coli
[i
][j
] = U32_AT( &pci_packet
.hli
.btn_colit
.btn_coli
[i
][j
] );