git.sesse.net Git - vlc/blob - modules/demux/mkv.cpp

   1 /*****************************************************************************
   2  * mkv.cpp : matroska demuxer
   3  *****************************************************************************
   4  * Copyright (C) 2003-2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Steve Lhomme <steve.lhomme@free.fr>
   9  *
  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.
  14  *
  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.
  19  *
  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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <stdlib.h>                                      /* malloc(), free() */
  29
  30 #include <vlc/vlc.h>
  31
  32 #ifdef HAVE_TIME_H
  33 #   include <time.h>                                               /* time() */
  34 #endif
  35
  36 #include <vlc/input.h>
  37
  38 #include <codecs.h>                        /* BITMAPINFOHEADER, WAVEFORMATEX */
  39 #include "iso_lang.h"
  40 #include "vlc_meta.h"
  41
  42 #include <iostream>
  43 #include <cassert>
  44 #include <typeinfo>
  45 #include <string>
  46 #include <vector>
  47 #include <algorithm>
  48
  49 #ifdef HAVE_DIRENT_H
  50 #   include <dirent.h>
  51 #endif
  52
  53 /* libebml and matroska */
  54 #include "ebml/EbmlHead.h"
  55 #include "ebml/EbmlSubHead.h"
  56 #include "ebml/EbmlStream.h"
  57 #include "ebml/EbmlContexts.h"
  58 #include "ebml/EbmlVoid.h"
  59 #include "ebml/EbmlVersion.h"
  60 #include "ebml/StdIOCallback.h"
  61
  62 #include "matroska/KaxAttachments.h"
  63 #include "matroska/KaxBlock.h"
  64 #include "matroska/KaxBlockData.h"
  65 #include "matroska/KaxChapters.h"
  66 #include "matroska/KaxCluster.h"
  67 #include "matroska/KaxClusterData.h"
  68 #include "matroska/KaxContexts.h"
  69 #include "matroska/KaxCues.h"
  70 #include "matroska/KaxCuesData.h"
  71 #include "matroska/KaxInfo.h"
  72 #include "matroska/KaxInfoData.h"
  73 #include "matroska/KaxSeekHead.h"
  74 #include "matroska/KaxSegment.h"
  75 #include "matroska/KaxTag.h"
  76 #include "matroska/KaxTags.h"
  77 #include "matroska/KaxTagMulti.h"
  78 #include "matroska/KaxTracks.h"
  79 #include "matroska/KaxTrackAudio.h"
  80 #include "matroska/KaxTrackVideo.h"
  81 #include "matroska/KaxTrackEntryData.h"
  82 #include "matroska/KaxContentEncoding.h"
  83 #include "matroska/KaxVersion.h"
  84
  85 #include "ebml/StdIOCallback.h"
  86
  87 #if LIBMATROSKA_VERSION < 0x000706
  88 START_LIBMATROSKA_NAMESPACE
  89 extern const EbmlSemanticContext MATROSKA_DLL_API KaxMatroska_Context;
  90 END_LIBMATROSKA_NAMESPACE
  91 #endif
  92
  93 #include "vlc_keys.h"
  94
  95 extern "C" {
  96    #include "mp4/libmp4.h"
  97 }
  98 #ifdef HAVE_ZLIB_H
  99 #   include <zlib.h>
 100 #endif
 101
 102 #define MATROSKA_COMPRESSION_NONE  -1
 103 #define MATROSKA_COMPRESSION_ZLIB   0
 104 #define MATROSKA_COMPRESSION_BLIB   1
 105 #define MATROSKA_COMPRESSION_LZOX   2
 106 #define MATROSKA_COMPRESSION_HEADER 3
 107
 108 #define MKVD_TIMECODESCALE 1000000
 109
 110 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 111 #undef ATTRIBUTE_PACKED
 112 #undef PRAGMA_PACK_BEGIN
 113 #undef PRAGMA_PACK_END
 114
 115 #if defined(__GNUC__)
 116 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
 117 #define ATTRIBUTE_PACKED __attribute__ ((packed))
 118 #define PRAGMA_PACK 0
 119 #endif
 120 #endif
 121
 122 #if !defined(ATTRIBUTE_PACKED)
 123 #define ATTRIBUTE_PACKED
 124 #define PRAGMA_PACK 1
 125 #endif
 126
 127 #if PRAGMA_PACK
 128 #pragma pack(1)
 129 #endif
 130
 131 /*************************************
 132 *  taken from libdvdnav / libdvdread
 133 **************************************/
 134
 135 /**
 136  * DVD Time Information.
 137  */
 138 typedef struct {
 139   uint8_t hour;
 140   uint8_t minute;
 141   uint8_t second;
 142   uint8_t frame_u; /* The two high bits are the frame rate. */
 143 } ATTRIBUTE_PACKED dvd_time_t;
 144
 145 /**
 146  * User Operations.
 147  */
 148 typedef struct {
 149 #ifdef WORDS_BIGENDIAN
 150   unsigned char zero                           : 7; /* 25-31 */
 151   unsigned char video_pres_mode_change         : 1; /* 24 */
 152
 153   unsigned char karaoke_audio_pres_mode_change : 1; /* 23 */
 154   unsigned char angle_change                   : 1;
 155   unsigned char subpic_stream_change           : 1;
 156   unsigned char audio_stream_change            : 1;
 157   unsigned char pause_on                       : 1;
 158   unsigned char still_off                      : 1;
 159   unsigned char button_select_or_activate      : 1;
 160   unsigned char resume                         : 1; /* 16 */
 161
 162   unsigned char chapter_menu_call              : 1; /* 15 */
 163   unsigned char angle_menu_call                : 1;
 164   unsigned char audio_menu_call                : 1;
 165   unsigned char subpic_menu_call               : 1;
 166   unsigned char root_menu_call                 : 1;
 167   unsigned char title_menu_call                : 1;
 168   unsigned char backward_scan                  : 1;
 169   unsigned char forward_scan                   : 1; /* 8 */
 170
 171   unsigned char next_pg_search                 : 1; /* 7 */
 172   unsigned char prev_or_top_pg_search          : 1;
 173   unsigned char time_or_chapter_search         : 1;
 174   unsigned char go_up                          : 1;
 175   unsigned char stop                           : 1;
 176   unsigned char title_play                     : 1;
 177   unsigned char chapter_search_or_play         : 1;
 178   unsigned char title_or_time_play             : 1; /* 0 */
 179 #else
 180   unsigned char video_pres_mode_change         : 1; /* 24 */
 181   unsigned char zero                           : 7; /* 25-31 */
 182
 183   unsigned char resume                         : 1; /* 16 */
 184   unsigned char button_select_or_activate      : 1;
 185   unsigned char still_off                      : 1;
 186   unsigned char pause_on                       : 1;
 187   unsigned char audio_stream_change            : 1;
 188   unsigned char subpic_stream_change           : 1;
 189   unsigned char angle_change                   : 1;
 190   unsigned char karaoke_audio_pres_mode_change : 1; /* 23 */
 191
 192   unsigned char forward_scan                   : 1; /* 8 */
 193   unsigned char backward_scan                  : 1;
 194   unsigned char title_menu_call                : 1;
 195   unsigned char root_menu_call                 : 1;
 196   unsigned char subpic_menu_call               : 1;
 197   unsigned char audio_menu_call                : 1;
 198   unsigned char angle_menu_call                : 1;
 199   unsigned char chapter_menu_call              : 1; /* 15 */
 200
 201   unsigned char title_or_time_play             : 1; /* 0 */
 202   unsigned char chapter_search_or_play         : 1;
 203   unsigned char title_play                     : 1;
 204   unsigned char stop                           : 1;
 205   unsigned char go_up                          : 1;
 206   unsigned char time_or_chapter_search         : 1;
 207   unsigned char prev_or_top_pg_search          : 1;
 208   unsigned char next_pg_search                 : 1; /* 7 */
 209 #endif
 210 } ATTRIBUTE_PACKED user_ops_t;
 211
 212 /**
 213  * Type to store per-command data.
 214  */
 215 typedef struct {
 216   uint8_t bytes[8];
 217 } ATTRIBUTE_PACKED vm_cmd_t;
 218 #define COMMAND_DATA_SIZE 8
 219
 220 /**
 221  * PCI General Information
 222  */
 223 typedef struct {
 224   uint32_t nv_pck_lbn;      /**< sector address of this nav pack */
 225   uint16_t vobu_cat;        /**< 'category' of vobu */
 226   uint16_t zero1;           /**< reserved */
 227   user_ops_t vobu_uop_ctl;  /**< UOP of vobu */
 228   uint32_t vobu_s_ptm;      /**< start presentation time of vobu */
 229   uint32_t vobu_e_ptm;      /**< end presentation time of vobu */
 230   uint32_t vobu_se_e_ptm;   /**< end ptm of sequence end in vobu */
 231   dvd_time_t e_eltm;        /**< Cell elapsed time */
 232   char vobu_isrc[32];
 233 } ATTRIBUTE_PACKED pci_gi_t;
 234
 235 /**
 236  * Non Seamless Angle Information
 237  */
 238 typedef struct {
 239   uint32_t nsml_agl_dsta[9];  /**< address of destination vobu in AGL_C#n */
 240 } ATTRIBUTE_PACKED nsml_agli_t;
 241
 242 /**
 243  * Highlight General Information
 244  *
 245  * For btngrX_dsp_ty the bits have the following meaning:
 246  * 000b: normal 4/3 only buttons
 247  * XX1b: wide (16/9) buttons
 248  * X1Xb: letterbox buttons
 249  * 1XXb: pan&scan buttons
 250  */
 251 typedef struct {
 252   uint16_t hli_ss; /**< status, only low 2 bits 0: no buttons, 1: different 2: equal 3: eual except for button cmds */
 253   uint32_t hli_s_ptm;              /**< start ptm of hli */
 254   uint32_t hli_e_ptm;              /**< end ptm of hli */
 255   uint32_t btn_se_e_ptm;           /**< end ptm of button select */
 256 #ifdef WORDS_BIGENDIAN
 257   unsigned char zero1 : 2;          /**< reserved */
 258   unsigned char btngr_ns : 2;       /**< number of button groups 1, 2 or 3 with 36/18/12 buttons */
 259   unsigned char zero2 : 1;          /**< reserved */
 260   unsigned char btngr1_dsp_ty : 3;  /**< display type of subpic stream for button group 1 */
 261   unsigned char zero3 : 1;          /**< reserved */
 262   unsigned char btngr2_dsp_ty : 3;  /**< display type of subpic stream for button group 2 */
 263   unsigned char zero4 : 1;          /**< reserved */
 264   unsigned char btngr3_dsp_ty : 3;  /**< display type of subpic stream for button group 3 */
 265 #else
 266   unsigned char btngr1_dsp_ty : 3;
 267   unsigned char zero2 : 1;
 268   unsigned char btngr_ns : 2;
 269   unsigned char zero1 : 2;
 270   unsigned char btngr3_dsp_ty : 3;
 271   unsigned char zero4 : 1;
 272   unsigned char btngr2_dsp_ty : 3;
 273   unsigned char zero3 : 1;
 274 #endif
 275   uint8_t btn_ofn;     /**< button offset number range 0-255 */
 276   uint8_t btn_ns;      /**< number of valid buttons  <= 36/18/12 (low 6 bits) */
 277   uint8_t nsl_btn_ns;  /**< number of buttons selectable by U_BTNNi (low 6 bits)   nsl_btn_ns <= btn_ns */
 278   uint8_t zero5;       /**< reserved */
 279   uint8_t fosl_btnn;   /**< forcedly selected button  (low 6 bits) */
 280   uint8_t foac_btnn;   /**< forcedly activated button (low 6 bits) */
 281 } ATTRIBUTE_PACKED hl_gi_t;
 282
 283
 284 /**
 285  * Button Color Information Table
 286  * Each entry beeing a 32bit word that contains the color indexs and alpha
 287  * values to use.  They are all represented by 4 bit number and stored
 288  * like this [Ci3, Ci2, Ci1, Ci0, A3, A2, A1, A0].   The actual palette
 289  * that the indexes reference is in the PGC.
 290  * @TODO split the uint32_t into a struct
 291  */
 292 typedef struct {
 293   uint32_t btn_coli[3][2];  /**< [button color number-1][select:0/action:1] */
 294 } ATTRIBUTE_PACKED btn_colit_t;
 295
 296 /**
 297  * Button Information
 298  *
 299  * NOTE: I've had to change the structure from the disk layout to get
 300  * the packing to work with Sun's Forte C compiler.
 301  * The 4 and 7 bytes are 'rotated' was: ABC DEF GHIJ  is: ABCG DEFH IJ
 302  */
 303 typedef struct {
 304 #ifdef WORDS_BIGENDIAN
 305   uint32        btn_coln         : 2;  /**< button color number */
 306   uint32        x_start          : 10; /**< x start offset within the overlay */
 307   uint32        zero1            : 2;  /**< reserved */
 308   uint32        x_end            : 10; /**< x end offset within the overlay */
 309
 310   uint32        zero3            : 2;  /**< reserved */
 311   uint32        up               : 6;  /**< button index when pressing up */
 312
 313   uint32        auto_action_mode : 2;  /**< 0: no, 1: activated if selected */
 314   uint32        y_start          : 10; /**< y start offset within the overlay */
 315   uint32        zero2            : 2;  /**< reserved */
 316   uint32        y_end            : 10; /**< y end offset within the overlay */
 317
 318   uint32        zero4            : 2;  /**< reserved */
 319   uint32        down             : 6;  /**< button index when pressing down */
 320   unsigned char zero5            : 2;  /**< reserved */
 321   unsigned char left             : 6;  /**< button index when pressing left */
 322   unsigned char zero6            : 2;  /**< reserved */
 323   unsigned char right            : 6;  /**< button index when pressing right */
 324 #else
 325   uint32        x_end            : 10;
 326   uint32        zero1            : 2;
 327   uint32        x_start          : 10;
 328   uint32        btn_coln         : 2;
 329
 330   uint32        up               : 6;
 331   uint32        zero3            : 2;
 332
 333   uint32        y_end            : 10;
 334   uint32        zero2            : 2;
 335   uint32        y_start          : 10;
 336   uint32        auto_action_mode : 2;
 337
 338   uint32        down             : 6;
 339   uint32        zero4            : 2;
 340   unsigned char left             : 6;
 341   unsigned char zero5            : 2;
 342   unsigned char right            : 6;
 343   unsigned char zero6            : 2;
 344 #endif
 345   vm_cmd_t cmd;
 346 } ATTRIBUTE_PACKED btni_t;
 347
 348 /**
 349  * Highlight Information
 350  */
 351 typedef struct {
 352   hl_gi_t     hl_gi;
 353   btn_colit_t btn_colit;
 354   btni_t      btnit[36];
 355 } ATTRIBUTE_PACKED hli_t;
 356
 357 /**
 358  * PCI packet
 359  */
 360 typedef struct {
 361   pci_gi_t    pci_gi;
 362   nsml_agli_t nsml_agli;
 363   hli_t       hli;
 364   uint8_t     zero1[189];
 365 } ATTRIBUTE_PACKED pci_t;
 366
 367
 368 #if PRAGMA_PACK
 369 #pragma pack()
 370 #endif
 371 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 372
 373
 374 /**
 375  * What's between a directory and a filename?
 376  */
 377 #if defined( WIN32 )
 378     #define DIRECTORY_SEPARATOR '\\'
 379 #else
 380     #define DIRECTORY_SEPARATOR '/'
 381 #endif
 382
 383 using namespace LIBMATROSKA_NAMESPACE;
 384 using namespace std;
 385
 386 /*****************************************************************************
 387  * Module descriptor
 388  *****************************************************************************/
 389 static int  Open ( vlc_object_t * );
 390 static void Close( vlc_object_t * );
 391
 392 vlc_module_begin();
 393     set_shortname( "Matroska" );
 394     set_description( _("Matroska stream demuxer" ) );
 395     set_capability( "demux2", 50 );
 396     set_callbacks( Open, Close );
 397     set_category( CAT_INPUT );
 398     set_subcategory( SUBCAT_INPUT_DEMUX );
 399
 400     add_bool( "mkv-use-ordered-chapters", 1, NULL,
 401             N_("Ordered chapters"),
 402             N_("Play ordered chapters as specified in the segment."), VLC_TRUE );
 403
 404     add_bool( "mkv-use-chapter-codec", 1, NULL,
 405             N_("Chapter codecs"),
 406             N_("Use chapter codecs found in the segment."), VLC_TRUE );
 407
 408     add_bool( "mkv-preload-local-dir", 1, NULL,
 409             N_("Preload Directory"),
 410             N_("Preload matroska files from the same family in the same directory (not good for broken files)."), VLC_TRUE );
 411
 412     add_bool( "mkv-seek-percent", 0, NULL,
 413             N_("Seek based on percent not time"),
 414             N_("Seek based on percent not time."), VLC_TRUE );
 415
 416     add_bool( "mkv-use-dummy", 0, NULL,
 417             N_("Dummy Elements"),
 418             N_("Read and discard unknown EBML elements (not good for broken files)."), VLC_TRUE );
 419
 420     add_shortcut( "mka" );
 421     add_shortcut( "mkv" );
 422 vlc_module_end();
 423
 424 /*****************************************************************************
 425  * Local prototypes
 426  *****************************************************************************/
 427 #ifdef HAVE_ZLIB_H
 428 block_t *block_zlib_decompress( vlc_object_t *p_this, block_t *p_in_block ) {
 429     int result, dstsize, n;
 430     unsigned char *dst;
 431     block_t *p_block;
 432     z_stream d_stream;
 433
 434     d_stream.zalloc = (alloc_func)0;
 435     d_stream.zfree = (free_func)0;
 436     d_stream.opaque = (voidpf)0;
 437     result = inflateInit(&d_stream);
 438     if( result != Z_OK )
 439     {
 440         msg_Dbg( p_this, "inflateInit() failed. Result: %d", result );
 441         return NULL;
 442     }
 443
 444     d_stream.next_in = (Bytef *)p_in_block->p_buffer;
 445     d_stream.avail_in = p_in_block->i_buffer;
 446     n = 0;
 447     p_block = block_New( p_this, 0 );
 448     dst = NULL;
 449     do
 450     {
 451         n++;
 452         p_block = block_Realloc( p_block, 0, n * 1000 );
 453         dst = (unsigned char *)p_block->p_buffer;
 454         d_stream.next_out = (Bytef *)&dst[(n - 1) * 1000];
 455         d_stream.avail_out = 1000;
 456         result = inflate(&d_stream, Z_NO_FLUSH);
 457         if( ( result != Z_OK ) && ( result != Z_STREAM_END ) )
 458         {
 459             msg_Dbg( p_this, "Zlib decompression failed. Result: %d", result );
 460             return NULL;
 461         }
 462     }
 463     while( ( d_stream.avail_out == 0 ) && ( d_stream.avail_in != 0 ) &&
 464            ( result != Z_STREAM_END ) );
 465
 466     dstsize = d_stream.total_out;
 467     inflateEnd( &d_stream );
 468
 469     p_block = block_Realloc( p_block, 0, dstsize );
 470     p_block->i_buffer = dstsize;
 471     block_Release( p_in_block );
 472
 473     return p_block;
 474 }
 475 #endif
 476
 477 /**
 478  * Helper function to print the mkv parse tree
 479  */
 480 static void MkvTree( demux_t & demuxer, int i_level, char *psz_format, ... )
 481 {
 482     va_list args;
 483     if( i_level > 9 )
 484     {
 485         msg_Err( &demuxer, "too deep tree" );
 486         return;
 487     }
 488     va_start( args, psz_format );
 489     static char *psz_foo = "|   |   |   |   |   |   |   |   |   |";
 490     char *psz_foo2 = (char*)malloc( ( i_level * 4 + 3 + strlen( psz_format ) ) * sizeof(char) );
 491     strncpy( psz_foo2, psz_foo, 4 * i_level );
 492     psz_foo2[ 4 * i_level ] = '+';
 493     psz_foo2[ 4 * i_level + 1 ] = ' ';
 494     strcpy( &psz_foo2[ 4 * i_level + 2 ], psz_format );
 495     __msg_GenericVa( VLC_OBJECT(&demuxer), VLC_MSG_DBG, "mkv", psz_foo2, args );
 496     free( psz_foo2 );
 497     va_end( args );
 498 }
 499
 500 /*****************************************************************************
 501  * Stream managment
 502  *****************************************************************************/
 503 class vlc_stream_io_callback: public IOCallback
 504 {
 505   private:
 506     stream_t       *s;
 507     vlc_bool_t     mb_eof;
 508     vlc_bool_t     b_owner;
 509
 510   public:
 511     vlc_stream_io_callback( stream_t *, vlc_bool_t );
 512
 513     virtual ~vlc_stream_io_callback()
 514     {
 515         if( b_owner )
 516             stream_Delete( s );
 517     }
 518
 519     virtual uint32   read            ( void *p_buffer, size_t i_size);
 520     virtual void     setFilePointer  ( int64_t i_offset, seek_mode mode = seek_beginning );
 521     virtual size_t   write           ( const void *p_buffer, size_t i_size);
 522     virtual uint64   getFilePointer  ( void );
 523     virtual void     close           ( void );
 524 };
 525
 526 /*****************************************************************************
 527  * Ebml Stream parser
 528  *****************************************************************************/
 529 class EbmlParser
 530 {
 531   public:
 532     EbmlParser( EbmlStream *es, EbmlElement *el_start, demux_t *p_demux );
 533     virtual ~EbmlParser( void );
 534
 535     void Up( void );
 536     void Down( void );
 537     void Reset( demux_t *p_demux );
 538     EbmlElement *Get( void );
 539     void        Keep( void );
 540     EbmlElement *UnGet( uint64 i_block_pos, uint64 i_cluster_pos );
 541
 542     int GetLevel( void );
 543
 544   private:
 545     EbmlStream  *m_es;
 546     int         mi_level;
 547     EbmlElement *m_el[10];
 548     int64_t      mi_remain_size[10];
 549
 550     EbmlElement *m_got;
 551
 552     int         mi_user_level;
 553     vlc_bool_t  mb_keep;
 554     vlc_bool_t  mb_dummy;
 555 };
 556
 557
 558 /*****************************************************************************
 559  * Some functions to manipulate memory
 560  *****************************************************************************/
 561 #define GetFOURCC( p )  __GetFOURCC( (uint8_t*)p )
 562 static vlc_fourcc_t __GetFOURCC( uint8_t *p )
 563 {
 564     return VLC_FOURCC( p[0], p[1], p[2], p[3] );
 565 }
 566
 567 /*****************************************************************************
 568  * definitions of structures and functions used by this plugins
 569  *****************************************************************************/
 570 typedef struct
 571 {
 572 //    ~mkv_track_t();
 573
 574     vlc_bool_t   b_default;
 575     vlc_bool_t   b_enabled;
 576     unsigned int i_number;
 577
 578     int          i_extra_data;
 579     uint8_t      *p_extra_data;
 580
 581     char         *psz_codec;
 582
 583     uint64_t     i_default_duration;
 584     float        f_timecodescale;
 585     mtime_t      i_last_dts;
 586
 587     /* video */
 588     es_format_t fmt;
 589     float       f_fps;
 590     es_out_id_t *p_es;
 591
 592     /* audio */
 593     unsigned int i_original_rate;
 594
 595     vlc_bool_t      b_inited;
 596     /* data to be send first */
 597     int             i_data_init;
 598     uint8_t         *p_data_init;
 599
 600     /* hack : it's for seek */
 601     vlc_bool_t      b_search_keyframe;
 602     vlc_bool_t      b_silent;
 603
 604     /* informative */
 605     char         *psz_codec_name;
 606     char         *psz_codec_settings;
 607     char         *psz_codec_info_url;
 608     char         *psz_codec_download_url;
 609
 610     /* encryption/compression */
 611     int                    i_compression_type;
 612     KaxContentCompSettings *p_compression_data;
 613
 614 } mkv_track_t;
 615
 616 typedef struct
 617 {
 618     int     i_track;
 619     int     i_block_number;
 620
 621     int64_t i_position;
 622     int64_t i_time;
 623
 624     vlc_bool_t b_key;
 625 } mkv_index_t;
 626
 627 class demux_sys_t;
 628
 629 const binary MATROSKA_DVD_LEVEL_SS   = 0x30;
 630 const binary MATROSKA_DVD_LEVEL_LU   = 0x2A;
 631 const binary MATROSKA_DVD_LEVEL_TT   = 0x28;
 632 const binary MATROSKA_DVD_LEVEL_PGC  = 0x20;
 633 const binary MATROSKA_DVD_LEVEL_PG   = 0x18;
 634 const binary MATROSKA_DVD_LEVEL_PTT  = 0x10;
 635 const binary MATROSKA_DVD_LEVEL_CN   = 0x08;
 636
 637 class chapter_codec_cmds_c
 638 {
 639 public:
 640     chapter_codec_cmds_c( demux_sys_t & demuxer, int codec_id = -1)
 641     :p_private_data(NULL)
 642     ,i_codec_id( codec_id )
 643     ,sys( demuxer )
 644     {}
 645
 646     virtual ~chapter_codec_cmds_c()
 647     {
 648         delete p_private_data;
 649         std::vector<KaxChapterProcessData*>::iterator indexe = enter_cmds.begin();
 650         while ( indexe != enter_cmds.end() )
 651         {
 652             delete (*indexe);
 653             indexe++;
 654         }
 655         std::vector<KaxChapterProcessData*>::iterator indexl = leave_cmds.begin();
 656         while ( indexl != leave_cmds.end() )
 657         {
 658             delete (*indexl);
 659             indexl++;
 660         }
 661         std::vector<KaxChapterProcessData*>::iterator indexd = during_cmds.begin();
 662         while ( indexd != during_cmds.end() )
 663         {
 664             delete (*indexd);
 665             indexd++;
 666         }
 667     }
 668
 669     void SetPrivate( const KaxChapterProcessPrivate & private_data )
 670     {
 671         p_private_data = new KaxChapterProcessPrivate( private_data );
 672     }
 673
 674     void AddCommand( const KaxChapterProcessCommand & command );
 675
 676     /// \return wether the codec has seeked in the files or not
 677     virtual bool Enter() { return false; }
 678     virtual bool Leave() { return false; }
 679     virtual std::string GetCodecName( bool f_for_title = false ) const { return ""; }
 680     virtual int16 GetTitleNumber() { return -1; }
 681
 682     KaxChapterProcessPrivate *p_private_data;
 683
 684 protected:
 685     std::vector<KaxChapterProcessData*> enter_cmds;
 686     std::vector<KaxChapterProcessData*> during_cmds;
 687     std::vector<KaxChapterProcessData*> leave_cmds;
 688
 689     int i_codec_id;
 690     demux_sys_t & sys;
 691 };
 692
 693 class dvd_command_interpretor_c
 694 {
 695 public:
 696     dvd_command_interpretor_c( demux_sys_t & demuxer )
 697     :sys( demuxer )
 698     {
 699         memset( p_PRMs, 0, sizeof(p_PRMs) );
 700         p_PRMs[ 0x80 + 1 ] = 15;
 701         p_PRMs[ 0x80 + 2 ] = 62;
 702         p_PRMs[ 0x80 + 3 ] = 1;
 703         p_PRMs[ 0x80 + 4 ] = 1;
 704         p_PRMs[ 0x80 + 7 ] = 1;
 705         p_PRMs[ 0x80 + 8 ] = 1;
 706         p_PRMs[ 0x80 + 16 ] = 0xFFFFu;
 707         p_PRMs[ 0x80 + 18 ] = 0xFFFFu;
 708     }
 709
 710     bool Interpret( const binary * p_command, size_t i_size = 8 );
 711
 712     uint16 GetPRM( size_t index ) const
 713     {
 714         if ( index < 256 )
 715             return p_PRMs[ index ];
 716         else return 0;
 717     }
 718
 719     uint16 GetGPRM( size_t index ) const
 720     {
 721         if ( index >= 0 && index < 16 )
 722             return p_PRMs[ index ];
 723         else return 0;
 724     }
 725
 726     uint16 GetSPRM( size_t index ) const
 727     {
 728         // 21,22,23 reserved for future use
 729         if ( index >= 0x80 && index < 0x95 )
 730             return p_PRMs[ index ];
 731         else return 0;
 732     }
 733
 734     bool SetPRM( size_t index, uint16 value )
 735     {
 736         if ( index >= 0 && index < 16 )
 737         {
 738             p_PRMs[ index ] = value;
 739             return true;
 740         }
 741         return false;
 742     }
 743
 744     bool SetGPRM( size_t index, uint16 value )
 745     {
 746         if ( index >= 0 && index < 16 )
 747         {
 748             p_PRMs[ index ] = value;
 749             return true;
 750         }
 751         return false;
 752     }
 753
 754     bool SetSPRM( size_t index, uint16 value )
 755     {
 756         if ( index > 0x80 && index <= 0x8D && index != 0x8C )
 757         {
 758             p_PRMs[ index ] = value;
 759             return true;
 760         }
 761         return false;
 762     }
 763
 764 protected:
 765     std::string GetRegTypeName( bool b_value, uint16 value ) const
 766     {
 767         std::string result;
 768         char s_value[6], s_reg_value[6];
 769         sprintf( s_value, "%.5d", value );
 770
 771         if ( b_value )
 772         {
 773             result = "value (";
 774             result += s_value;
 775             result += ")";
 776         }
 777         else if ( value < 0x80 )
 778         {
 779             sprintf( s_reg_value, "%.5d", GetPRM( value ) );
 780             result = "GPreg[";
 781             result += s_value;
 782             result += "] (";
 783             result += s_reg_value;
 784             result += ")";
 785         }
 786         else
 787         {
 788             sprintf( s_reg_value, "%.5d", GetPRM( value ) );
 789             result = "SPreg[";
 790             result += s_value;
 791             result += "] (";
 792             result += s_reg_value;
 793             result += ")";
 794         }
 795         return result;
 796     }
 797
 798     uint16       p_PRMs[256];
 799     demux_sys_t  & sys;
 800
 801     // DVD command IDs
 802
 803     // Tests
 804     // wether it's a comparison on the value or register
 805     static const uint16 CMD_DVD_TEST_VALUE          = 0x80;
 806     static const uint16 CMD_DVD_IF_GPREG_AND        = (1 << 4);
 807     static const uint16 CMD_DVD_IF_GPREG_EQUAL      = (2 << 4);
 808     static const uint16 CMD_DVD_IF_GPREG_NOT_EQUAL  = (3 << 4);
 809     static const uint16 CMD_DVD_IF_GPREG_SUP_EQUAL  = (4 << 4);
 810     static const uint16 CMD_DVD_IF_GPREG_SUP        = (5 << 4);
 811     static const uint16 CMD_DVD_IF_GPREG_INF_EQUAL  = (6 << 4);
 812     static const uint16 CMD_DVD_IF_GPREG_INF        = (7 << 4);
 813
 814     static const uint16 CMD_DVD_NOP                    = 0x0000;
 815     static const uint16 CMD_DVD_GOTO_LINE              = 0x0001;
 816     static const uint16 CMD_DVD_BREAK                  = 0x0002;
 817     // Links
 818     static const uint16 CMD_DVD_NOP2                   = 0x2001;
 819     static const uint16 CMD_DVD_LINKPGCN               = 0x2004;
 820     static const uint16 CMD_DVD_LINKPGN                = 0x2006;
 821     static const uint16 CMD_DVD_LINKCN                 = 0x2007;
 822     static const uint16 CMD_DVD_JUMP_TT                = 0x3002;
 823     static const uint16 CMD_DVD_JUMPVTS_TT             = 0x3003;
 824     static const uint16 CMD_DVD_JUMPVTS_PTT            = 0x3005;
 825     static const uint16 CMD_DVD_JUMP_SS                = 0x3006;
 826     static const uint16 CMD_DVD_CALLSS_VTSM1           = 0x3008;
 827     //
 828     static const uint16 CMD_DVD_SET_HL_BTNN2           = 0x4600;
 829     static const uint16 CMD_DVD_SET_HL_BTNN_LINKPGCN1  = 0x4604;
 830     static const uint16 CMD_DVD_SET_STREAM             = 0x5100;
 831     static const uint16 CMD_DVD_SET_GPRMMD             = 0x5300;
 832     static const uint16 CMD_DVD_SET_HL_BTNN1           = 0x5600;
 833     static const uint16 CMD_DVD_SET_HL_BTNN_LINKPGCN2  = 0x5604;
 834     static const uint16 CMD_DVD_SET_HL_BTNN_LINKCN     = 0x5607;
 835     // Operations
 836     static const uint16 CMD_DVD_MOV_SPREG_PREG         = 0x6100;
 837     static const uint16 CMD_DVD_GPREG_MOV_VALUE        = 0x7100;
 838     static const uint16 CMD_DVD_SUB_GPREG              = 0x7400;
 839     static const uint16 CMD_DVD_MULT_GPREG             = 0x7500;
 840     static const uint16 CMD_DVD_GPREG_DIV_VALUE        = 0x7600;
 841     static const uint16 CMD_DVD_GPREG_AND_VALUE        = 0x7900;
 842
 843     // callbacks when browsing inside CodecPrivate
 844     static bool MatchIsDomain     ( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size );
 845     static bool MatchIsVMG        ( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size );
 846     static bool MatchVTSNumber    ( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size );
 847     static bool MatchVTSMNumber   ( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size );
 848     static bool MatchTitleNumber  ( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size );
 849     static bool MatchPgcType      ( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size );
 850     static bool MatchPgcNumber    ( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size );
 851     static bool MatchChapterNumber( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size );
 852     static bool MatchCellNumber   ( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size );
 853 };
 854
 855 class dvd_chapter_codec_c : public chapter_codec_cmds_c
 856 {
 857 public:
 858     dvd_chapter_codec_c( demux_sys_t & sys )
 859     :chapter_codec_cmds_c( sys, 1 )
 860     {}
 861
 862     bool Enter();
 863     bool Leave();
 864     std::string GetCodecName( bool f_for_title = false ) const;
 865     int16 GetTitleNumber();
 866 };
 867
 868 class matroska_script_interpretor_c
 869 {
 870 public:
 871     matroska_script_interpretor_c( demux_sys_t & demuxer )
 872     :sys( demuxer )
 873     {}
 874
 875     bool Interpret( const binary * p_command, size_t i_size );
 876
 877     // DVD command IDs
 878     static const std::string CMD_MS_GOTO_AND_PLAY;
 879
 880 protected:
 881     demux_sys_t  & sys;
 882 };
 883
 884 const std::string matroska_script_interpretor_c::CMD_MS_GOTO_AND_PLAY = "GotoAndPlay";
 885
 886
 887 class matroska_script_codec_c : public chapter_codec_cmds_c
 888 {
 889 public:
 890     matroska_script_codec_c( demux_sys_t & sys )
 891     :chapter_codec_cmds_c( sys, 0 )
 892     ,interpretor( sys )
 893     {}
 894
 895     bool Enter();
 896     bool Leave();
 897
 898 protected:
 899     matroska_script_interpretor_c interpretor;
 900 };
 901
 902 class chapter_translation_c
 903 {
 904 public:
 905     chapter_translation_c()
 906         :p_translated(NULL)
 907     {}
 908
 909     ~chapter_translation_c()
 910     {
 911         delete p_translated;
 912     }
 913
 914     KaxChapterTranslateID  *p_translated;
 915     unsigned int           codec_id;
 916     std::vector<uint64_t>  editions;
 917 };
 918
 919 class chapter_item_c
 920 {
 921 public:
 922     chapter_item_c()
 923     :i_start_time(0)
 924     ,i_end_time(-1)
 925     ,i_user_start_time(-1)
 926     ,i_user_end_time(-1)
 927     ,i_seekpoint_num(-1)
 928     ,b_display_seekpoint(true)
 929     ,b_user_display(false)
 930     ,psz_parent(NULL)
 931     ,b_is_leaving(false)
 932     {}
 933
 934     virtual ~chapter_item_c()
 935     {
 936         std::vector<chapter_codec_cmds_c*>::iterator index = codecs.begin();
 937         while ( index != codecs.end() )
 938         {
 939             delete (*index);
 940             index++;
 941         }
 942         std::vector<chapter_item_c*>::iterator index_ = sub_chapters.begin();
 943         while ( index_ != sub_chapters.end() )
 944         {
 945             delete (*index_);
 946             index_++;
 947         }
 948     }
 949
 950     int64_t RefreshChapters( bool b_ordered, int64_t i_prev_user_time );
 951     int PublishChapters( input_title_t & title, int & i_user_chapters, int i_level = 0 );
 952     virtual chapter_item_c * FindTimecode( mtime_t i_timecode, const chapter_item_c * p_current, bool & b_found );
 953     void Append( const chapter_item_c & edition );
 954     chapter_item_c * FindChapter( int64_t i_find_uid );
 955     virtual chapter_item_c *BrowseCodecPrivate( unsigned int codec_id,
 956                                     bool (*match)(const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size ),
 957                                     const void *p_cookie,
 958                                     size_t i_cookie_size );
 959     std::string                 GetCodecName( bool f_for_title = false ) const;
 960     bool                        ParentOf( const chapter_item_c & item ) const;
 961     int16                       GetTitleNumber( ) const;
 962
 963     int64_t                     i_start_time, i_end_time;
 964     int64_t                     i_user_start_time, i_user_end_time; /* the time in the stream when an edition is ordered */
 965     std::vector<chapter_item_c*> sub_chapters;
 966     int                         i_seekpoint_num;
 967     int64_t                     i_uid;
 968     bool                        b_display_seekpoint;
 969     bool                        b_user_display;
 970     std::string                 psz_name;
 971     chapter_item_c              *psz_parent;
 972     bool                        b_is_leaving;
 973
 974     std::vector<chapter_codec_cmds_c*> codecs;
 975
 976     static bool CompareTimecode( const chapter_item_c * itemA, const chapter_item_c * itemB )
 977     {
 978         return ( itemA->i_user_start_time < itemB->i_user_start_time || (itemA->i_user_start_time == itemB->i_user_start_time && itemA->i_user_end_time < itemB->i_user_end_time) );
 979     }
 980
 981     bool Enter( bool b_do_subchapters );
 982     bool Leave( bool b_do_subchapters );
 983     bool EnterAndLeave( chapter_item_c *p_item, bool b_enter = true );
 984 };
 985
 986 class chapter_edition_c : public chapter_item_c
 987 {
 988 public:
 989     chapter_edition_c()
 990     :b_ordered(false)
 991     {}
 992
 993     void RefreshChapters( );
 994     mtime_t Duration() const;
 995     std::string GetMainName() const;
 996     chapter_item_c * FindTimecode( mtime_t i_timecode, const chapter_item_c * p_current );
 997
 998     bool                        b_ordered;
 999 };
1000
1001 class matroska_segment_c
1002 {
1003 public:
1004     matroska_segment_c( demux_sys_t & demuxer, EbmlStream & estream )
1005         :segment(NULL)
1006         ,es(estream)
1007         ,i_timescale(MKVD_TIMECODESCALE)
1008         ,i_duration(-1)
1009         ,i_start_time(0)
1010         ,i_cues_position(-1)
1011         ,i_chapters_position(-1)
1012         ,i_tags_position(-1)
1013         ,cluster(NULL)
1014         ,i_block_pos(0)
1015         ,i_cluster_pos(0)
1016         ,i_start_pos(0)
1017         ,p_segment_uid(NULL)
1018         ,p_prev_segment_uid(NULL)
1019         ,p_next_segment_uid(NULL)
1020         ,b_cues(VLC_FALSE)
1021         ,i_index(0)
1022         ,i_index_max(1024)
1023         ,psz_muxing_application(NULL)
1024         ,psz_writing_application(NULL)
1025         ,psz_segment_filename(NULL)
1026         ,psz_title(NULL)
1027         ,psz_date_utc(NULL)
1028         ,i_default_edition(0)
1029         ,sys(demuxer)
1030         ,ep(NULL)
1031         ,b_preloaded(false)
1032     {
1033         p_indexes = (mkv_index_t*)malloc( sizeof( mkv_index_t ) * i_index_max );
1034     }
1035
1036     virtual ~matroska_segment_c()
1037     {
1038         for( size_t i_track = 0; i_track < tracks.size(); i_track++ )
1039         {
1040             if ( tracks[i_track]->p_compression_data )
1041             {
1042                 delete tracks[i_track]->p_compression_data;
1043             }
1044             if( tracks[i_track]->fmt.psz_description )
1045             {
1046                 free( tracks[i_track]->fmt.psz_description );
1047             }
1048             if( tracks[i_track]->psz_codec )
1049             {
1050                 free( tracks[i_track]->psz_codec );
1051             }
1052             if( tracks[i_track]->fmt.psz_language )
1053             {
1054                 free( tracks[i_track]->fmt.psz_language );
1055             }
1056             delete tracks[i_track];
1057         }
1058
1059         if( psz_writing_application )
1060         {
1061             free( psz_writing_application );
1062         }
1063         if( psz_muxing_application )
1064         {
1065             free( psz_muxing_application );
1066         }
1067         if( psz_segment_filename )
1068         {
1069             free( psz_segment_filename );
1070         }
1071         if( psz_title )
1072         {
1073             free( psz_title );
1074         }
1075         if( psz_date_utc )
1076         {
1077             free( psz_date_utc );
1078         }
1079         if ( p_indexes )
1080             free( p_indexes );
1081
1082         delete ep;
1083         delete segment;
1084         delete p_segment_uid;
1085         delete p_prev_segment_uid;
1086         delete p_next_segment_uid;
1087
1088         std::vector<chapter_edition_c*>::iterator index = stored_editions.begin();
1089         while ( index != stored_editions.end() )
1090         {
1091             delete (*index);
1092             index++;
1093         }
1094         std::vector<chapter_translation_c*>::iterator indext = translations.begin();
1095         while ( indext != translations.end() )
1096         {
1097             delete (*indext);
1098             indext++;
1099         }
1100         std::vector<KaxSegmentFamily*>::iterator indexf = families.begin();
1101         while ( indexf != families.end() )
1102         {
1103             delete (*indexf);
1104             indexf++;
1105         }
1106     }
1107
1108     KaxSegment              *segment;
1109     EbmlStream              & es;
1110
1111     /* time scale */
1112     uint64_t                i_timescale;
1113
1114     /* duration of the segment */
1115     mtime_t                 i_duration;
1116     mtime_t                 i_start_time;
1117
1118     /* all tracks */
1119     std::vector<mkv_track_t*> tracks;
1120
1121     /* from seekhead */
1122     int64_t                 i_cues_position;
1123     int64_t                 i_chapters_position;
1124     int64_t                 i_tags_position;
1125
1126     KaxCluster              *cluster;
1127     uint64                  i_block_pos;
1128     uint64                  i_cluster_pos;
1129     int64_t                 i_start_pos;
1130     KaxSegmentUID           *p_segment_uid;
1131     KaxPrevUID              *p_prev_segment_uid;
1132     KaxNextUID              *p_next_segment_uid;
1133
1134     vlc_bool_t              b_cues;
1135     int                     i_index;
1136     int                     i_index_max;
1137     mkv_index_t             *p_indexes;
1138
1139     /* info */
1140     char                    *psz_muxing_application;
1141     char                    *psz_writing_application;
1142     char                    *psz_segment_filename;
1143     char                    *psz_title;
1144     char                    *psz_date_utc;
1145
1146     /* !!!!! GCC 3.3 bug on Darwin !!!!! */
1147     /* when you remove this variable the compiler issues an atomicity error */
1148     /* this variable only works when using std::vector<chapter_edition_c> */
1149     std::vector<chapter_edition_c*> stored_editions;
1150     int                             i_default_edition;
1151
1152     std::vector<chapter_translation_c*> translations;
1153     std::vector<KaxSegmentFamily*>  families;
1154
1155     demux_sys_t                    & sys;
1156     EbmlParser                     *ep;
1157     bool                           b_preloaded;
1158
1159     bool Preload( );
1160     bool PreloadFamily( const matroska_segment_c & segment );
1161     void ParseInfo( KaxInfo *info );
1162     void ParseChapters( KaxChapters *chapters );
1163     void ParseSeekHead( KaxSeekHead *seekhead );
1164     void ParseTracks( KaxTracks *tracks );
1165     void ParseChapterAtom( int i_level, KaxChapterAtom *ca, chapter_item_c & chapters );
1166     void ParseTrackEntry( KaxTrackEntry *m );
1167     void ParseCluster( );
1168     void IndexAppendCluster( KaxCluster *cluster );
1169     void LoadCues( );
1170     void LoadTags( );
1171     void InformationCreate( );
1172     void Seek( mtime_t i_date, mtime_t i_time_offset );
1173 #if LIBMATROSKA_VERSION >= 0x000800
1174     int BlockGet( KaxBlock * &, KaxSimpleBlock * &, int64_t *, int64_t *, int64_t *);
1175 #else
1176     int BlockGet( KaxBlock * &, int64_t *, int64_t *, int64_t *);
1177 #endif
1178     bool Select( mtime_t i_start_time );
1179     void UnSelect( );
1180
1181     static bool CompareSegmentUIDs( const matroska_segment_c * item_a, const matroska_segment_c * item_b );
1182 };
1183
1184 // class holding hard-linked segment together in the playback order
1185 class virtual_segment_c
1186 {
1187 public:
1188     virtual_segment_c( matroska_segment_c *p_segment )
1189         :p_editions(NULL)
1190         ,i_sys_title(0)
1191         ,i_current_segment(0)
1192         ,i_current_edition(-1)
1193         ,psz_current_chapter(NULL)
1194     {
1195         linked_segments.push_back( p_segment );
1196
1197         AppendUID( p_segment->p_segment_uid );
1198         AppendUID( p_segment->p_prev_segment_uid );
1199         AppendUID( p_segment->p_next_segment_uid );
1200     }
1201
1202     void Sort();
1203     size_t AddSegment( matroska_segment_c *p_segment );
1204     void PreloadLinked( );
1205     mtime_t Duration( ) const;
1206     void LoadCues( );
1207     void Seek( demux_t & demuxer, mtime_t i_date, mtime_t i_time_offset, chapter_item_c *psz_chapter );
1208
1209     inline chapter_edition_c *Edition()
1210     {
1211         if ( i_current_edition >= 0 && size_t(i_current_edition) < p_editions->size() )
1212             return (*p_editions)[i_current_edition];
1213         return NULL;
1214     }
1215
1216     matroska_segment_c * Segment() const
1217     {
1218         if ( linked_segments.size() == 0 || i_current_segment >= linked_segments.size() )
1219             return NULL;
1220         return linked_segments[i_current_segment];
1221     }
1222
1223     inline chapter_item_c *CurrentChapter() {
1224         return psz_current_chapter;
1225     }
1226
1227     bool SelectNext()
1228     {
1229         if ( i_current_segment < linked_segments.size()-1 )
1230         {
1231             i_current_segment++;
1232             return true;
1233         }
1234         return false;
1235     }
1236
1237     bool FindUID( KaxSegmentUID & uid ) const
1238     {
1239         for ( size_t i=0; i<linked_uids.size(); i++ )
1240         {
1241             if ( linked_uids[i] == uid )
1242                 return true;
1243         }
1244         return false;
1245     }
1246
1247     bool UpdateCurrentToChapter( demux_t & demux );
1248     void PrepareChapters( );
1249
1250     chapter_item_c *BrowseCodecPrivate( unsigned int codec_id,
1251                                         bool (*match)(const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size ),
1252                                         const void *p_cookie,
1253                                         size_t i_cookie_size );
1254     chapter_item_c *FindChapter( int64_t i_find_uid );
1255
1256     std::vector<chapter_edition_c*>  *p_editions;
1257     int                              i_sys_title;
1258
1259 protected:
1260     std::vector<matroska_segment_c*> linked_segments;
1261     std::vector<KaxSegmentUID>       linked_uids;
1262     size_t                           i_current_segment;
1263
1264     int                              i_current_edition;
1265     chapter_item_c                   *psz_current_chapter;
1266
1267     void                             AppendUID( const EbmlBinary * UID );
1268 };
1269
1270 class matroska_stream_c
1271 {
1272 public:
1273     matroska_stream_c( demux_sys_t & demuxer )
1274         :p_in(NULL)
1275         ,p_es(NULL)
1276         ,sys(demuxer)
1277     {}
1278
1279     virtual ~matroska_stream_c()
1280     {
1281         delete p_in;
1282         delete p_es;
1283     }
1284
1285     IOCallback         *p_in;
1286     EbmlStream         *p_es;
1287
1288     std::vector<matroska_segment_c*> segments;
1289
1290     demux_sys_t                      & sys;
1291 };
1292
1293 typedef struct
1294 {
1295     VLC_COMMON_MEMBERS
1296
1297     demux_t        *p_demux;
1298     vlc_mutex_t     lock;
1299
1300     vlc_bool_t      b_moved;
1301     vlc_bool_t      b_clicked;
1302     vlc_bool_t      b_key;
1303
1304 } event_thread_t;
1305
1306 class demux_sys_t
1307 {
1308 public:
1309     demux_sys_t( demux_t & demux )
1310         :demuxer(demux)
1311         ,i_pts(0)
1312         ,i_start_pts(0)
1313         ,i_chapter_time(0)
1314         ,meta(NULL)
1315         ,i_current_title(0)
1316         ,p_current_segment(NULL)
1317         ,dvd_interpretor( *this )
1318         ,f_duration(-1.0)
1319         ,b_ui_hooked(false)
1320         ,p_input(NULL)
1321         ,b_pci_packet_set(false)
1322         ,p_ev(NULL)
1323     {
1324         vlc_mutex_init( &demuxer, &lock_demuxer );
1325     }
1326
1327     virtual ~demux_sys_t()
1328     {
1329         StopUiThread();
1330         size_t i;
1331         for ( i=0; i<streams.size(); i++ )
1332             delete streams[i];
1333         for ( i=0; i<opened_segments.size(); i++ )
1334             delete opened_segments[i];
1335         for ( i=0; i<used_segments.size(); i++ )
1336             delete used_segments[i];
1337         vlc_mutex_destroy( &lock_demuxer );
1338     }
1339
1340     /* current data */
1341     demux_t                 & demuxer;
1342
1343     mtime_t                 i_pts;
1344     mtime_t                 i_start_pts;
1345     mtime_t                 i_chapter_time;
1346
1347     vlc_meta_t              *meta;
1348
1349     std::vector<input_title_t*>      titles; // matroska editions
1350     size_t                           i_current_title;
1351
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;
1356
1357     dvd_command_interpretor_c        dvd_interpretor;
1358
1359     /* duration of the stream */
1360     float                   f_duration;
1361
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 );
1369
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 );
1375
1376     void StartUiThread();
1377     void StopUiThread();
1378     bool b_ui_hooked;
1379     inline void SwapButtons();
1380
1381     /* for spu variables */
1382     input_thread_t *p_input;
1383     pci_t          pci_packet;
1384     bool           b_pci_packet_set;
1385     uint8_t        palette[4][4];
1386     vlc_mutex_t    lock_demuxer;
1387
1388     /* event */
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 );
1395
1396
1397
1398 protected:
1399     virtual_segment_c *VirtualFromSegments( matroska_segment_c *p_segment ) const;
1400     bool IsUsedSegment( matroska_segment_c &p_segment ) const;
1401 };
1402
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 );
1406
1407 #define MKV_IS_ID( el, C ) ( EbmlId( (*el) ) == C::ClassInfos.GlobalId )
1408
1409 static inline char * ToUTF8( const UTFstring &u )
1410 {
1411     return strdup( u.GetUTF8().c_str() );
1412 }
1413
1414 /*****************************************************************************
1415  * Open: initializes matroska demux structures
1416  *****************************************************************************/
1417 static int Open( vlc_object_t * p_this )
1418 {
1419     demux_t            *p_demux = (demux_t*)p_this;
1420     demux_sys_t        *p_sys;
1421     matroska_stream_c  *p_stream;
1422     matroska_segment_c *p_segment;
1423     uint8_t            *p_peek;
1424     std::string        s_path, s_filename;
1425     vlc_stream_io_callback *p_io_callback;
1426     EbmlStream         *p_io_stream;
1427
1428     /* peek the begining */
1429     if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) return VLC_EGENERIC;
1430
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;
1434
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 );
1439
1440     p_io_callback = new vlc_stream_io_callback( p_demux->s, VLC_FALSE );
1441     p_io_stream = new EbmlStream( *p_io_callback );
1442
1443     if( p_io_stream == NULL )
1444     {
1445         msg_Err( p_demux, "failed to create EbmlStream" );
1446         delete p_io_callback;
1447         delete p_sys;
1448         return VLC_EGENERIC;
1449     }
1450
1451     p_stream = p_sys->AnalyseAllSegmentsFound( p_demux, p_io_stream, true );
1452     if( p_stream == NULL )
1453     {
1454         msg_Err( p_demux, "cannot find KaxSegment" );
1455         goto error;
1456     }
1457     p_sys->streams.push_back( p_stream );
1458
1459     p_stream->p_in = p_io_callback;
1460     p_stream->p_es = p_io_stream;
1461
1462     for (size_t i=0; i<p_stream->segments.size(); i++)
1463     {
1464         p_stream->segments[i]->Preload();
1465     }
1466
1467     p_segment = p_stream->segments[0];
1468     if( p_segment->cluster != NULL )
1469     {
1470         msg_Warn( p_demux, "cannot find any cluster, damaged file ?" );
1471
1472         // reset the stream reading to the first cluster of the segment used
1473         p_stream->p_in->setFilePointer( p_segment->cluster->GetElementPosition() );
1474     }
1475
1476     if (config_GetInt( p_demux, "mkv-preload-local-dir" ))
1477     {
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, ""))
1480         {
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)
1485             {
1486                 s_path = s_path.substr(0,s_path.length()-1);
1487             }
1488             else
1489             {
1490                 if (s_path.find_last_of(DIRECTORY_SEPARATOR) > 0)
1491                 {
1492                     s_path = s_path.substr(0,s_path.find_last_of(DIRECTORY_SEPARATOR));
1493                 }
1494             }
1495
1496             struct dirent *p_file_item;
1497             DIR *p_src_dir = opendir(s_path.c_str());
1498
1499             if (p_src_dir != NULL)
1500             {
1501                 while ((p_file_item = (dirent *) readdir(p_src_dir)))
1502                 {
1503                     if (strlen(p_file_item->d_name) > 4)
1504                     {
1505                         s_filename = s_path + DIRECTORY_SEPARATOR + p_file_item->d_name;
1506
1507 #ifdef WIN32
1508                         if (!strcasecmp(s_filename.c_str(), p_demux->psz_path))
1509 #else
1510                         if (!s_filename.compare(p_demux->psz_path))
1511 #endif
1512                             continue; // don't reuse the original opened file
1513
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))
1517 #else
1518                         if (!s_filename.compare(s_filename.length() - 3, 3, "mkv") ||
1519                             !s_filename.compare(s_filename.length() - 3, 3, "mka"))
1520 #endif
1521                         {
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 )
1525                             {
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);
1528
1529                                 p_stream = p_sys->AnalyseAllSegmentsFound( p_demux, p_estream );
1530
1531                                 if ( p_stream == NULL )
1532                                 {
1533                                     msg_Dbg( p_demux, "the file '%s' will not be used", s_filename.c_str() );
1534                                     delete p_estream;
1535                                     delete p_file_io;
1536                                 }
1537                                 else
1538                                 {
1539                                     p_stream->p_in = p_file_io;
1540                                     p_stream->p_es = p_estream;
1541                                     p_sys->streams.push_back( p_stream );
1542                                 }
1543                             }
1544                             else
1545                             {
1546                                 msg_Dbg( p_demux, "the file '%s' cannot be opened", s_filename.c_str() );
1547                             }
1548                         }
1549                     }
1550                 }
1551                 closedir( p_src_dir );
1552             }
1553         }
1554
1555         p_sys->PreloadFamily( *p_segment );
1556     }
1557
1558     p_sys->PreloadLinked( p_segment );
1559
1560     if ( !p_sys->PreparePlayback( NULL ) )
1561     {
1562         msg_Err( p_demux, "cannot use the segment" );
1563         goto error;
1564     }
1565
1566     p_sys->StartUiThread();
1567
1568     return VLC_SUCCESS;
1569
1570 error:
1571     delete p_sys;
1572     return VLC_EGENERIC;
1573 }
1574
1575 /*****************************************************************************
1576  * Close: frees unused data
1577  *****************************************************************************/
1578 static void Close( vlc_object_t *p_this )
1579 {
1580     demux_t     *p_demux = (demux_t*)p_this;
1581     demux_sys_t *p_sys   = p_demux->p_sys;
1582
1583     delete p_sys;
1584 }
1585
1586 /*****************************************************************************
1587  * Control:
1588  *****************************************************************************/
1589 static int Control( demux_t *p_demux, int i_query, va_list args )
1590 {
1591     demux_sys_t        *p_sys = p_demux->p_sys;
1592     int64_t     *pi64;
1593     double      *pf, f;
1594     int         i_skp;
1595     size_t      i_idx;
1596
1597     vlc_meta_t **pp_meta;
1598
1599     switch( i_query )
1600     {
1601         case DEMUX_GET_META:
1602             pp_meta = (vlc_meta_t**)va_arg( args, vlc_meta_t** );
1603             *pp_meta = vlc_meta_Duplicate( p_sys->meta );
1604             return VLC_SUCCESS;
1605
1606         case DEMUX_GET_LENGTH:
1607             pi64 = (int64_t*)va_arg( args, int64_t * );
1608             if( p_sys->f_duration > 0.0 )
1609             {
1610                 *pi64 = (int64_t)(p_sys->f_duration * 1000);
1611                 return VLC_SUCCESS;
1612             }
1613             return VLC_EGENERIC;
1614
1615         case DEMUX_GET_POSITION:
1616             pf = (double*)va_arg( args, double * );
1617             if ( p_sys->f_duration > 0.0 )
1618                 *pf = (double)(p_sys->i_pts >= p_sys->i_start_pts ? p_sys->i_pts : p_sys->i_start_pts ) / (1000.0 * p_sys->f_duration);
1619             return VLC_SUCCESS;
1620
1621         case DEMUX_SET_POSITION:
1622             f = (double)va_arg( args, double );
1623             Seek( p_demux, -1, f, NULL );
1624             return VLC_SUCCESS;
1625
1626         case DEMUX_GET_TIME:
1627             pi64 = (int64_t*)va_arg( args, int64_t * );
1628             *pi64 = p_sys->i_pts;
1629             return VLC_SUCCESS;
1630
1631         case DEMUX_GET_TITLE_INFO:
1632             if( p_sys->titles.size() )
1633             {
1634                 input_title_t ***ppp_title = (input_title_t***)va_arg( args, input_title_t*** );
1635                 int *pi_int    = (int*)va_arg( args, int* );
1636
1637                 *pi_int = p_sys->titles.size();
1638                 *ppp_title = (input_title_t**)malloc( sizeof( input_title_t**) * p_sys->titles.size() );
1639
1640                 for( size_t i = 0; i < p_sys->titles.size(); i++ )
1641                 {
1642                     (*ppp_title)[i] = vlc_input_title_Duplicate( p_sys->titles[i] );
1643                 }
1644
1645                 return VLC_SUCCESS;
1646             }
1647             return VLC_EGENERIC;
1648
1649         case DEMUX_SET_TITLE:
1650             /* TODO handle editions as titles */
1651             i_idx = (int)va_arg( args, int );
1652             if( i_idx < p_sys->used_segments.size() )
1653             {
1654                 p_sys->JumpTo( *p_sys->used_segments[i_idx], NULL );
1655                 return VLC_SUCCESS;
1656             }
1657             return VLC_EGENERIC;
1658
1659         case DEMUX_SET_SEEKPOINT:
1660             i_skp = (int)va_arg( args, int );
1661
1662             // TODO change the way it works with the << & >> buttons on the UI (+1/-1 instead of a number)
1663             if( p_sys->titles.size() && i_skp < p_sys->titles[p_sys->i_current_title]->i_seekpoint)
1664             {
1665                 Seek( p_demux, (int64_t)p_sys->titles[p_sys->i_current_title]->seekpoint[i_skp]->i_time_offset, -1, NULL);
1666                 p_demux->info.i_seekpoint |= INPUT_UPDATE_SEEKPOINT;
1667                 p_demux->info.i_seekpoint = i_skp;
1668                 return VLC_SUCCESS;
1669             }
1670             return VLC_EGENERIC;
1671
1672         case DEMUX_SET_TIME:
1673         case DEMUX_GET_FPS:
1674         default:
1675             return VLC_EGENERIC;
1676     }
1677 }
1678
1679 #if LIBMATROSKA_VERSION >= 0x000800
1680 int matroska_segment_c::BlockGet( KaxBlock * & pp_block, KaxSimpleBlock * & pp_simpleblock, int64_t *pi_ref1, int64_t *pi_ref2, int64_t *pi_duration )
1681 #else
1682 int matroska_segment_c::BlockGet( KaxBlock * & pp_block, int64_t *pi_ref1, int64_t *pi_ref2, int64_t *pi_duration )
1683 #endif
1684 {
1685 #if LIBMATROSKA_VERSION >= 0x000800
1686     pp_simpleblock = NULL;
1687 #endif
1688     pp_block = NULL;
1689     *pi_ref1  = 0;
1690     *pi_ref2  = 0;
1691
1692     for( ;; )
1693     {
1694         EbmlElement *el = NULL;
1695         int         i_level;
1696
1697         if ( ep == NULL )
1698             return VLC_EGENERIC;
1699
1700 #if LIBMATROSKA_VERSION >= 0x000800
1701         if( pp_simpleblock != NULL || ((el = ep->Get()) == NULL && pp_block != NULL) )
1702 #else
1703         if( (el = ep->Get()) == NULL && pp_block != NULL )
1704 #endif
1705         {
1706             /* update the index */
1707 #define idx p_indexes[i_index - 1]
1708             if( i_index > 0 && idx.i_time == -1 )
1709             {
1710 #if LIBMATROSKA_VERSION >= 0x000800
1711                 if ( pp_simpleblock != NULL )
1712                     idx.i_time        = pp_simpleblock->GlobalTimecode() / (mtime_t)1000;
1713                 else
1714 #endif
1715                     idx.i_time        = (*pp_block).GlobalTimecode() / (mtime_t)1000;
1716                 idx.b_key         = *pi_ref1 == 0 ? VLC_TRUE : VLC_FALSE;
1717             }
1718 #undef idx
1719             return VLC_SUCCESS;
1720         }
1721
1722         i_level = ep->GetLevel();
1723
1724         if( el == NULL )
1725         {
1726             if( i_level > 1 )
1727             {
1728                 ep->Up();
1729                 continue;
1730             }
1731             msg_Warn( &sys.demuxer, "EOF" );
1732             return VLC_EGENERIC;
1733         }
1734
1735         /* do parsing */
1736         switch ( i_level )
1737         {
1738         case 1:
1739             if( MKV_IS_ID( el, KaxCluster ) )
1740             {
1741                 cluster = (KaxCluster*)el;
1742                 i_cluster_pos = cluster->GetElementPosition();
1743
1744                 /* add it to the index */
1745                 if( i_index == 0 ||
1746                     ( i_index > 0 && p_indexes[i_index - 1].i_position < (int64_t)cluster->GetElementPosition() ) )
1747                 {
1748                     IndexAppendCluster( cluster );
1749                 }
1750
1751                 // reset silent tracks
1752                 for (size_t i=0; i<tracks.size(); i++)
1753                 {
1754                     tracks[i]->b_silent = VLC_FALSE;
1755                 }
1756
1757                 ep->Down();
1758             }
1759             else if( MKV_IS_ID( el, KaxCues ) )
1760             {
1761                 msg_Warn( &sys.demuxer, "find KaxCues FIXME" );
1762                 return VLC_EGENERIC;
1763             }
1764             else
1765             {
1766                 msg_Dbg( &sys.demuxer, "unknown (%s)", typeid( el ).name() );
1767             }
1768             break;
1769         case 2:
1770             if( MKV_IS_ID( el, KaxClusterTimecode ) )
1771             {
1772                 KaxClusterTimecode &ctc = *(KaxClusterTimecode*)el;
1773
1774                 ctc.ReadData( es.I_O(), SCOPE_ALL_DATA );
1775                 cluster->InitTimecode( uint64( ctc ), i_timescale );
1776             }
1777             else if( MKV_IS_ID( el, KaxClusterSilentTracks ) )
1778             {
1779                 ep->Down();
1780             }
1781             else if( MKV_IS_ID( el, KaxBlockGroup ) )
1782             {
1783                 i_block_pos = el->GetElementPosition();
1784                 ep->Down();
1785             }
1786 #if LIBMATROSKA_VERSION >= 0x000800
1787             else if( MKV_IS_ID( el, KaxSimpleBlock ) )
1788             {
1789                 pp_simpleblock = (KaxSimpleBlock*)el;
1790
1791                 pp_simpleblock->ReadData( es.I_O() );
1792                 pp_simpleblock->SetParent( *cluster );
1793             }
1794 #endif
1795             break;
1796         case 3:
1797             if( MKV_IS_ID( el, KaxBlock ) )
1798             {
1799                 pp_block = (KaxBlock*)el;
1800
1801                 pp_block->ReadData( es.I_O() );
1802                 pp_block->SetParent( *cluster );
1803
1804                 ep->Keep();
1805             }
1806             else if( MKV_IS_ID( el, KaxBlockDuration ) )
1807             {
1808                 KaxBlockDuration &dur = *(KaxBlockDuration*)el;
1809
1810                 dur.ReadData( es.I_O() );
1811                 *pi_duration = uint64( dur );
1812             }
1813             else if( MKV_IS_ID( el, KaxReferenceBlock ) )
1814             {
1815                 KaxReferenceBlock &ref = *(KaxReferenceBlock*)el;
1816
1817                 ref.ReadData( es.I_O() );
1818                 if( *pi_ref1 == 0 )
1819                 {
1820                     *pi_ref1 = int64( ref ) * cluster->GlobalTimecodeScale();
1821                 }
1822                 else if( *pi_ref2 == 0 )
1823                 {
1824                     *pi_ref2 = int64( ref ) * cluster->GlobalTimecodeScale();
1825                 }
1826             }
1827             else if( MKV_IS_ID( el, KaxClusterSilentTrackNumber ) )
1828             {
1829                 KaxClusterSilentTrackNumber &track_num = *(KaxClusterSilentTrackNumber*)el;
1830                 track_num.ReadData( es.I_O() );
1831                 // find the track
1832                 for (size_t i=0; i<tracks.size(); i++)
1833                 {
1834                     if ( tracks[i]->i_number == uint32(track_num))
1835                     {
1836                         tracks[i]->b_silent = VLC_TRUE;
1837                         break;
1838                     }
1839                 }
1840             }
1841             break;
1842         default:
1843             msg_Err( &sys.demuxer, "invalid level = %d", i_level );
1844             return VLC_EGENERIC;
1845         }
1846     }
1847 }
1848
1849 static block_t *MemToBlock( demux_t *p_demux, uint8_t *p_mem, int i_mem, size_t offset)
1850 {
1851     block_t *p_block;
1852     if( !(p_block = block_New( p_demux, i_mem + offset ) ) ) return NULL;
1853     memcpy( p_block->p_buffer + offset, p_mem, i_mem );
1854     //p_block->i_rate = p_input->stream.control.i_rate;
1855     return p_block;
1856 }
1857
1858 #if LIBMATROSKA_VERSION >= 0x000800
1859 static void BlockDecode( demux_t *p_demux, KaxBlock *block, KaxSimpleBlock *simpleblock,
1860                          mtime_t i_pts, mtime_t i_duration, bool f_mandatory )
1861 #else
1862 static void BlockDecode( demux_t *p_demux, KaxBlock *block, mtime_t i_pts,
1863                          mtime_t i_duration, bool f_mandatory )
1864 #endif
1865 {
1866     demux_sys_t        *p_sys = p_demux->p_sys;
1867     matroska_segment_c *p_segment = p_sys->p_current_segment->Segment();
1868
1869     size_t          i_track;
1870     unsigned int    i;
1871     vlc_bool_t      b;
1872
1873 #define tk  p_segment->tracks[i_track]
1874     for( i_track = 0; i_track < p_segment->tracks.size(); i_track++ )
1875     {
1876 #if LIBMATROSKA_VERSION >= 0x000800
1877         if( (block != NULL && tk->i_number == block->TrackNum()) ||
1878             (simpleblock != NULL && tk->i_number == simpleblock->TrackNum()))
1879 #else
1880         if( tk->i_number == block->TrackNum() )
1881 #endif
1882         {
1883             break;
1884         }
1885     }
1886
1887     if( i_track >= p_segment->tracks.size() )
1888     {
1889         msg_Err( p_demux, "invalid track number=%d", block->TrackNum() );
1890         return;
1891     }
1892     if( tk->fmt.i_cat != NAV_ES && tk->p_es == NULL )
1893     {
1894         msg_Err( p_demux, "unknown track number=%d", block->TrackNum() );
1895         return;
1896     }
1897     if( i_pts + i_duration < p_sys->i_start_pts && tk->fmt.i_cat == AUDIO_ES )
1898     {
1899         return; /* discard audio packets that shouldn't be rendered */
1900     }
1901
1902     if ( tk->fmt.i_cat != NAV_ES )
1903     {
1904         es_out_Control( p_demux->out, ES_OUT_GET_ES_STATE, tk->p_es, &b );
1905
1906         if( !b )
1907         {
1908             tk->b_inited = VLC_FALSE;
1909             return;
1910         }
1911     }
1912
1913
1914     /* First send init data */
1915     if( !tk->b_inited && tk->i_data_init > 0 )
1916     {
1917         block_t *p_init;
1918
1919         msg_Dbg( p_demux, "sending header (%d bytes)", tk->i_data_init );
1920         p_init = MemToBlock( p_demux, tk->p_data_init, tk->i_data_init, 0 );
1921         if( p_init ) es_out_Send( p_demux->out, tk->p_es, p_init );
1922     }
1923     tk->b_inited = VLC_TRUE;
1924
1925
1926 #if LIBMATROSKA_VERSION >= 0x000800
1927     for( i = 0;
1928         (block != NULL && i < block->NumberFrames()) || (simpleblock != NULL && i < simpleblock->NumberFrames());
1929         i++ )
1930 #else
1931     for( i = 0; i < block->NumberFrames(); i++ )
1932 #endif
1933     {
1934         block_t *p_block;
1935         DataBuffer *data;
1936 #if LIBMATROSKA_VERSION >= 0x000800
1937         if ( simpleblock != NULL )
1938         {
1939             data = &simpleblock->GetBuffer(i);
1940             // condition when the DTS is correct (keyframe or B frame == NOT P frame)
1941             f_mandatory = simpleblock->IsDiscardable() || simpleblock->IsKeyframe();
1942         }
1943         else
1944 #endif
1945         data = &block->GetBuffer(i);
1946
1947         if( tk->i_compression_type == MATROSKA_COMPRESSION_HEADER && tk->p_compression_data != NULL )
1948             p_block = MemToBlock( p_demux, data->Buffer(), data->Size(), tk->p_compression_data->GetSize() );
1949         else
1950             p_block = MemToBlock( p_demux, data->Buffer(), data->Size(), 0 );
1951
1952         if( p_block == NULL )
1953         {
1954             break;
1955         }
1956
1957 #if defined(HAVE_ZLIB_H)
1958         if( tk->i_compression_type == MATROSKA_COMPRESSION_ZLIB )
1959         {
1960             p_block = block_zlib_decompress( VLC_OBJECT(p_demux), p_block );
1961         }
1962         else
1963 #endif
1964         if( tk->i_compression_type == MATROSKA_COMPRESSION_HEADER )
1965         {
1966             memcpy( p_block->p_buffer, tk->p_compression_data->GetBuffer(), tk->p_compression_data->GetSize() );
1967         }
1968
1969         if ( tk->fmt.i_cat == NAV_ES )
1970         {
1971             // TODO handle the start/stop times of this packet
1972             if ( p_sys->b_ui_hooked )
1973             {
1974                 vlc_mutex_lock( &p_sys->p_ev->lock );
1975                 memcpy( &p_sys->pci_packet, &p_block->p_buffer[1], sizeof(pci_t) );
1976                 p_sys->SwapButtons();
1977                 p_sys->b_pci_packet_set = true;
1978                 vlc_mutex_unlock( &p_sys->p_ev->lock );
1979                 block_Release( p_block );
1980             }
1981             return;
1982         }
1983         // correct timestamping when B frames are used
1984         if( tk->fmt.i_cat != VIDEO_ES )
1985         {
1986             p_block->i_dts = p_block->i_pts = i_pts;
1987         }
1988         else
1989         {
1990             if( !strcmp( tk->psz_codec, "V_MS/VFW/FOURCC" ) )
1991             {
1992                 // in VFW we have no idea about B frames
1993                 p_block->i_pts = 0;
1994                 p_block->i_dts = i_pts;
1995             }
1996             else
1997             {
1998                 p_block->i_pts = i_pts;
1999                 if ( f_mandatory )
2000                     p_block->i_dts = p_block->i_pts;
2001                 else
2002                     p_block->i_dts = min( i_pts, tk->i_last_dts + (tk->i_default_duration >> 10));
2003                 p_sys->i_pts = p_block->i_dts;
2004             }
2005         }
2006         tk->i_last_dts = p_block->i_dts;
2007
2008 #if 0
2009 msg_Dbg( p_demux, "block i_dts: "I64Fd" / i_pts: "I64Fd, p_block->i_dts, p_block->i_pts);
2010 #endif
2011         if( strcmp( tk->psz_codec, "S_VOBSUB" ) )
2012         {
2013             p_block->i_length = i_duration * 1000;
2014         }
2015
2016         es_out_Send( p_demux->out, tk->p_es, p_block );
2017
2018         /* use time stamp only for first block */
2019         i_pts = 0;
2020     }
2021
2022 #undef tk
2023 }
2024
2025 matroska_stream_c *demux_sys_t::AnalyseAllSegmentsFound( demux_t *p_demux, EbmlStream *p_estream, bool b_initial )
2026 {
2027     int i_upper_lvl = 0;
2028     size_t i;
2029     EbmlElement *p_l0, *p_l1, *p_l2;
2030     bool b_keep_stream = false, b_keep_segment;
2031
2032     // verify the EBML Header
2033     p_l0 = p_estream->FindNextID(EbmlHead::ClassInfos, 0xFFFFFFFFL);
2034     if (p_l0 == NULL)
2035     {
2036         msg_Err( p_demux, "No EBML header found" );
2037         return NULL;
2038     }
2039
2040     // verify we can read this Segment, we only support Matroska version 1 for now
2041     p_l0->Read(*p_estream, EbmlHead::ClassInfos.Context, i_upper_lvl, p_l0, true);
2042
2043     EDocType doc_type = GetChild<EDocType>(*static_cast<EbmlHead*>(p_l0));
2044     if (std::string(doc_type) != "matroska")
2045     {
2046         msg_Err( p_demux, "Not a Matroska file : DocType = %s ", std::string(doc_type).c_str());
2047         return NULL;
2048     }
2049
2050     EDocTypeReadVersion doc_read_version = GetChild<EDocTypeReadVersion>(*static_cast<EbmlHead*>(p_l0));
2051 #if LIBMATROSKA_VERSION >= 0x000800
2052     if (uint64(doc_read_version) > 2)
2053     {
2054         msg_Err( p_demux, "This matroska file is needs version "I64Fd" and this VLC only supports version 1 & 2", uint64(doc_read_version));
2055         return NULL;
2056     }
2057 #else
2058     if (uint64(doc_read_version) != 1)
2059     {
2060         msg_Err( p_demux, "This matroska file is needs version "I64Fd" and this VLC only supports version 1", uint64(doc_read_version));
2061         return NULL;
2062     }
2063 #endif
2064
2065     delete p_l0;
2066
2067
2068     // find all segments in this file
2069     p_l0 = p_estream->FindNextID(KaxSegment::ClassInfos, 0xFFFFFFFFFLL);
2070     if (p_l0 == NULL)
2071     {
2072         return NULL;
2073     }
2074
2075     matroska_stream_c *p_stream1 = new matroska_stream_c( *this );
2076
2077     while (p_l0 != 0)
2078     {
2079         if (EbmlId(*p_l0) == KaxSegment::ClassInfos.GlobalId)
2080         {
2081             EbmlParser  *ep;
2082             matroska_segment_c *p_segment1 = new matroska_segment_c( *this, *p_estream );
2083             b_keep_segment = b_initial;
2084
2085             ep = new EbmlParser(p_estream, p_l0, &demuxer );
2086             p_segment1->ep = ep;
2087             p_segment1->segment = (KaxSegment*)p_l0;
2088
2089             while ((p_l1 = ep->Get()))
2090             {
2091                 if (MKV_IS_ID(p_l1, KaxInfo))
2092                 {
2093                     // find the families of this segment
2094                     KaxInfo *p_info = static_cast<KaxInfo*>(p_l1);
2095
2096                     p_info->Read(*p_estream, KaxInfo::ClassInfos.Context, i_upper_lvl, p_l2, true);
2097                     for( i = 0; i < p_info->ListSize(); i++ )
2098                     {
2099                         EbmlElement *l = (*p_info)[i];
2100
2101                         if( MKV_IS_ID( l, KaxSegmentUID ) )
2102                         {
2103                             KaxSegmentUID *p_uid = static_cast<KaxSegmentUID*>(l);
2104                             b_keep_segment = (FindSegment( *p_uid ) == NULL);
2105                             if ( !b_keep_segment )
2106                                 break; // this segment is already known
2107                             opened_segments.push_back( p_segment1 );
2108                             delete p_segment1->p_segment_uid;
2109                             p_segment1->p_segment_uid = new KaxSegmentUID(*p_uid);
2110                         }
2111                         else if( MKV_IS_ID( l, KaxPrevUID ) )
2112                         {
2113                             p_segment1->p_prev_segment_uid = new KaxPrevUID( *static_cast<KaxPrevUID*>(l) );
2114                         }
2115                         else if( MKV_IS_ID( l, KaxNextUID ) )
2116                         {
2117                             p_segment1->p_next_segment_uid = new KaxNextUID( *static_cast<KaxNextUID*>(l) );
2118                         }
2119                         else if( MKV_IS_ID( l, KaxSegmentFamily ) )
2120                         {
2121                             KaxSegmentFamily *p_fam = new KaxSegmentFamily( *static_cast<KaxSegmentFamily*>(l) );
2122                             p_segment1->families.push_back( p_fam );
2123                         }
2124                     }
2125                     break;
2126                 }
2127             }
2128             if ( b_keep_segment )
2129             {
2130                 b_keep_stream = true;
2131                 p_stream1->segments.push_back( p_segment1 );
2132             }
2133             else
2134                 delete p_segment1;
2135         }
2136         if (p_l0->IsFiniteSize() )
2137         {
2138             p_l0->SkipData(*p_estream, KaxMatroska_Context);
2139             p_l0 = p_estream->FindNextID(KaxSegment::ClassInfos, 0xFFFFFFFFL);
2140         }
2141         else
2142             p_l0 = p_l0->SkipData(*p_estream, KaxSegment_Context);
2143     }
2144
2145     if ( !b_keep_stream )
2146     {
2147         delete p_stream1;
2148         p_stream1 = NULL;
2149     }
2150
2151     return p_stream1;
2152 }
2153
2154 bool matroska_segment_c::Select( mtime_t i_start_time )
2155 {
2156     size_t i_track;
2157
2158     /* add all es */
2159     msg_Dbg( &sys.demuxer, "found %d es", (int)tracks.size() );
2160     sys.b_pci_packet_set = false;
2161
2162     for( i_track = 0; i_track < tracks.size(); i_track++ )
2163     {
2164         if( tracks[i_track]->fmt.i_cat == UNKNOWN_ES )
2165         {
2166             msg_Warn( &sys.demuxer, "invalid track[%d, n=%d]", (int)i_track, tracks[i_track]->i_number );
2167             tracks[i_track]->p_es = NULL;
2168             continue;
2169         }
2170
2171         if( !strcmp( tracks[i_track]->psz_codec, "V_MS/VFW/FOURCC" ) )
2172         {
2173             if( tracks[i_track]->i_extra_data < (int)sizeof( BITMAPINFOHEADER ) )
2174             {
2175                 msg_Err( &sys.demuxer, "missing/invalid BITMAPINFOHEADER" );
2176                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 'n', 'd', 'f' );
2177             }
2178             else
2179             {
2180                 BITMAPINFOHEADER *p_bih = (BITMAPINFOHEADER*)tracks[i_track]->p_extra_data;
2181
2182                 tracks[i_track]->fmt.video.i_width = GetDWLE( &p_bih->biWidth );
2183                 tracks[i_track]->fmt.video.i_height= GetDWLE( &p_bih->biHeight );
2184                 tracks[i_track]->fmt.i_codec       = GetFOURCC( &p_bih->biCompression );
2185
2186                 tracks[i_track]->fmt.i_extra       = GetDWLE( &p_bih->biSize ) - sizeof( BITMAPINFOHEADER );
2187                 if( tracks[i_track]->fmt.i_extra > 0 )
2188                 {
2189                     tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
2190                     memcpy( tracks[i_track]->fmt.p_extra, &p_bih[1], tracks[i_track]->fmt.i_extra );
2191                 }
2192             }
2193         }
2194         else if( !strcmp( tracks[i_track]->psz_codec, "V_MPEG1" ) ||
2195                  !strcmp( tracks[i_track]->psz_codec, "V_MPEG2" ) )
2196         {
2197             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'm', 'p', 'g', 'v' );
2198         }
2199         else if( !strncmp( tracks[i_track]->psz_codec, "V_MPEG4", 7 ) )
2200         {
2201             if( !strcmp( tracks[i_track]->psz_codec, "V_MPEG4/MS/V3" ) )
2202             {
2203                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'D', 'I', 'V', '3' );
2204             }
2205             else if( !strcmp( tracks[i_track]->psz_codec, "V_MPEG4/ISO/AVC" ) )
2206             {
2207                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'a', 'v', 'c', '1' );
2208                 tracks[i_track]->fmt.i_extra = tracks[i_track]->i_extra_data;
2209                 tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->i_extra_data );
2210                 memcpy( tracks[i_track]->fmt.p_extra,tracks[i_track]->p_extra_data, tracks[i_track]->i_extra_data );
2211             }
2212             else
2213             {
2214                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'v' );
2215             }
2216         }
2217         else if( !strcmp( tracks[i_track]->psz_codec, "V_QUICKTIME" ) )
2218         {
2219             MP4_Box_t *p_box = (MP4_Box_t*)malloc( sizeof( MP4_Box_t ) );
2220             stream_t *p_mp4_stream = stream_MemoryNew( VLC_OBJECT(&sys.demuxer),
2221                                                        tracks[i_track]->p_extra_data,
2222                                                        tracks[i_track]->i_extra_data,
2223                                                        VLC_FALSE );
2224             MP4_ReadBoxCommon( p_mp4_stream, p_box );
2225             MP4_ReadBox_sample_vide( p_mp4_stream, p_box );
2226             tracks[i_track]->fmt.i_codec = p_box->i_type;
2227             tracks[i_track]->fmt.video.i_width = p_box->data.p_sample_vide->i_width;
2228             tracks[i_track]->fmt.video.i_height = p_box->data.p_sample_vide->i_height;
2229             tracks[i_track]->fmt.i_extra = p_box->data.p_sample_vide->i_qt_image_description;
2230             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
2231             memcpy( tracks[i_track]->fmt.p_extra, p_box->data.p_sample_vide->p_qt_image_description, tracks[i_track]->fmt.i_extra );
2232             MP4_FreeBox_sample_vide( p_box );
2233             stream_Delete( p_mp4_stream );
2234         }
2235         else if( !strcmp( tracks[i_track]->psz_codec, "A_MS/ACM" ) )
2236         {
2237             if( tracks[i_track]->i_extra_data < (int)sizeof( WAVEFORMATEX ) )
2238             {
2239                 msg_Err( &sys.demuxer, "missing/invalid WAVEFORMATEX" );
2240                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 'n', 'd', 'f' );
2241             }
2242             else
2243             {
2244                 WAVEFORMATEX *p_wf = (WAVEFORMATEX*)tracks[i_track]->p_extra_data;
2245
2246                 wf_tag_to_fourcc( GetWLE( &p_wf->wFormatTag ), &tracks[i_track]->fmt.i_codec, NULL );
2247
2248                 tracks[i_track]->fmt.audio.i_channels   = GetWLE( &p_wf->nChannels );
2249                 tracks[i_track]->fmt.audio.i_rate = GetDWLE( &p_wf->nSamplesPerSec );
2250                 tracks[i_track]->fmt.i_bitrate    = GetDWLE( &p_wf->nAvgBytesPerSec ) * 8;
2251                 tracks[i_track]->fmt.audio.i_blockalign = GetWLE( &p_wf->nBlockAlign );;
2252                 tracks[i_track]->fmt.audio.i_bitspersample = GetWLE( &p_wf->wBitsPerSample );
2253
2254                 tracks[i_track]->fmt.i_extra            = GetWLE( &p_wf->cbSize );
2255                 if( tracks[i_track]->fmt.i_extra > 0 )
2256                 {
2257                     tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
2258                     memcpy( tracks[i_track]->fmt.p_extra, &p_wf[1], tracks[i_track]->fmt.i_extra );
2259                 }
2260             }
2261         }
2262         else if( !strcmp( tracks[i_track]->psz_codec, "A_MPEG/L3" ) ||
2263                  !strcmp( tracks[i_track]->psz_codec, "A_MPEG/L2" ) ||
2264                  !strcmp( tracks[i_track]->psz_codec, "A_MPEG/L1" ) )
2265         {
2266             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'm', 'p', 'g', 'a' );
2267         }
2268         else if( !strcmp( tracks[i_track]->psz_codec, "A_AC3" ) )
2269         {
2270             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'a', '5', '2', ' ' );
2271         }
2272         else if( !strcmp( tracks[i_track]->psz_codec, "A_DTS" ) )
2273         {
2274             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'd', 't', 's', ' ' );
2275         }
2276         else if( !strcmp( tracks[i_track]->psz_codec, "A_FLAC" ) )
2277         {
2278             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'f', 'l', 'a', 'c' );
2279             tracks[i_track]->fmt.i_extra = tracks[i_track]->i_extra_data;
2280             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->i_extra_data );
2281             memcpy( tracks[i_track]->fmt.p_extra,tracks[i_track]->p_extra_data, tracks[i_track]->i_extra_data );
2282         }
2283         else if( !strcmp( tracks[i_track]->psz_codec, "A_VORBIS" ) )
2284         {
2285             int i, i_offset = 1, i_size[3], i_extra;
2286             uint8_t *p_extra;
2287
2288             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'v', 'o', 'r', 'b' );
2289
2290             /* Split the 3 headers */
2291             if( tracks[i_track]->p_extra_data[0] != 0x02 )
2292                 msg_Err( &sys.demuxer, "invalid vorbis header" );
2293
2294             for( i = 0; i < 2; i++ )
2295             {
2296                 i_size[i] = 0;
2297                 while( i_offset < tracks[i_track]->i_extra_data )
2298                 {
2299                     i_size[i] += tracks[i_track]->p_extra_data[i_offset];
2300                     if( tracks[i_track]->p_extra_data[i_offset++] != 0xff ) break;
2301                 }
2302             }
2303
2304             i_size[0] = __MIN(i_size[0], tracks[i_track]->i_extra_data - i_offset);
2305             i_size[1] = __MIN(i_size[1], tracks[i_track]->i_extra_data -i_offset -i_size[0]);
2306             i_size[2] = tracks[i_track]->i_extra_data - i_offset - i_size[0] - i_size[1];
2307
2308             tracks[i_track]->fmt.i_extra = 3 * 2 + i_size[0] + i_size[1] + i_size[2];
2309             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
2310             p_extra = (uint8_t *)tracks[i_track]->fmt.p_extra; i_extra = 0;
2311             for( i = 0; i < 3; i++ )
2312             {
2313                 *(p_extra++) = i_size[i] >> 8;
2314                 *(p_extra++) = i_size[i] & 0xFF;
2315                 memcpy( p_extra, tracks[i_track]->p_extra_data + i_offset + i_extra,
2316                         i_size[i] );
2317                 p_extra += i_size[i];
2318                 i_extra += i_size[i];
2319             }
2320         }
2321         else if( !strncmp( tracks[i_track]->psz_codec, "A_AAC/MPEG2/", strlen( "A_AAC/MPEG2/" ) ) ||
2322                  !strncmp( tracks[i_track]->psz_codec, "A_AAC/MPEG4/", strlen( "A_AAC/MPEG4/" ) ) )
2323         {
2324             int i_profile, i_srate, sbr = 0;
2325             static unsigned int i_sample_rates[] =
2326             {
2327                     96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
2328                         16000, 12000, 11025, 8000,  7350,  0,     0,     0
2329             };
2330
2331             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'a' );
2332             /* create data for faad (MP4DecSpecificDescrTag)*/
2333
2334             if( !strcmp( &tracks[i_track]->psz_codec[12], "MAIN" ) )
2335             {
2336                 i_profile = 0;
2337             }
2338             else if( !strcmp( &tracks[i_track]->psz_codec[12], "LC" ) )
2339             {
2340                 i_profile = 1;
2341             }
2342             else if( !strcmp( &tracks[i_track]->psz_codec[12], "SSR" ) )
2343             {
2344                 i_profile = 2;
2345             }
2346             else if( !strcmp( &tracks[i_track]->psz_codec[12], "LC/SBR" ) )
2347             {
2348                 i_profile = 1;
2349                 sbr = 1;
2350             }
2351             else
2352             {
2353                 i_profile = 3;
2354             }
2355
2356             for( i_srate = 0; i_srate < 13; i_srate++ )
2357             {
2358                 if( i_sample_rates[i_srate] == tracks[i_track]->i_original_rate )
2359                 {
2360                     break;
2361                 }
2362             }
2363             msg_Dbg( &sys.demuxer, "profile=%d srate=%d", i_profile, i_srate );
2364
2365             tracks[i_track]->fmt.i_extra = sbr ? 5 : 2;
2366             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
2367             ((uint8_t*)tracks[i_track]->fmt.p_extra)[0] = ((i_profile + 1) << 3) | ((i_srate&0xe) >> 1);
2368             ((uint8_t*)tracks[i_track]->fmt.p_extra)[1] = ((i_srate & 0x1) << 7) | (tracks[i_track]->fmt.audio.i_channels << 3);
2369             if (sbr != 0)
2370             {
2371                 int syncExtensionType = 0x2B7;
2372                 int iDSRI;
2373                 for (iDSRI=0; iDSRI<13; iDSRI++)
2374                     if( i_sample_rates[iDSRI] == tracks[i_track]->fmt.audio.i_rate )
2375                         break;
2376                 ((uint8_t*)tracks[i_track]->fmt.p_extra)[2] = (syncExtensionType >> 3) & 0xFF;
2377                 ((uint8_t*)tracks[i_track]->fmt.p_extra)[3] = ((syncExtensionType & 0x7) << 5) | 5;
2378                 ((uint8_t*)tracks[i_track]->fmt.p_extra)[4] = ((1 & 0x1) << 7) | (iDSRI << 3);
2379             }
2380         }
2381         else if( !strcmp( tracks[i_track]->psz_codec, "A_AAC" ) )
2382         {
2383             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'a' );
2384             tracks[i_track]->fmt.i_extra = tracks[i_track]->i_extra_data;
2385             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->i_extra_data );
2386             memcpy( tracks[i_track]->fmt.p_extra, tracks[i_track]->p_extra_data, tracks[i_track]->i_extra_data );
2387         }
2388         else if( !strcmp( tracks[i_track]->psz_codec, "A_PCM/INT/BIG" ) ||
2389                  !strcmp( tracks[i_track]->psz_codec, "A_PCM/INT/LIT" ) ||
2390                  !strcmp( tracks[i_track]->psz_codec, "A_PCM/FLOAT/IEEE" ) )
2391         {
2392             if( !strcmp( tracks[i_track]->psz_codec, "A_PCM/INT/BIG" ) )
2393             {
2394                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 't', 'w', 'o', 's' );
2395             }
2396             else
2397             {
2398                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'a', 'r', 'a', 'w' );
2399             }
2400             tracks[i_track]->fmt.audio.i_blockalign = ( tracks[i_track]->fmt.audio.i_bitspersample + 7 ) / 8 * tracks[i_track]->fmt.audio.i_channels;
2401         }
2402         else if( !strcmp( tracks[i_track]->psz_codec, "A_TTA1" ) )
2403         {
2404             /* FIXME: support this codec */
2405             msg_Err( &sys.demuxer, "TTA not supported yet[%d, n=%d]", (int)i_track, tracks[i_track]->i_number );
2406             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 'n', 'd', 'f' );
2407         }
2408         else if( !strcmp( tracks[i_track]->psz_codec, "A_WAVPACK4" ) )
2409         {
2410             /* FIXME: support this codec */
2411             msg_Err( &sys.demuxer, "Wavpack not supported yet[%d, n=%d]", (int)i_track, tracks[i_track]->i_number );
2412             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 'n', 'd', 'f' );
2413         }
2414         else if( !strcmp( tracks[i_track]->psz_codec, "S_TEXT/UTF8" ) )
2415         {
2416             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 's', 'u', 'b', 't' );
2417             tracks[i_track]->fmt.subs.psz_encoding = strdup( "UTF-8" );
2418         }
2419         else if( !strcmp( tracks[i_track]->psz_codec, "S_TEXT/SSA" ) ||
2420                  !strcmp( tracks[i_track]->psz_codec, "S_TEXT/ASS" ) ||
2421                  !strcmp( tracks[i_track]->psz_codec, "S_SSA" ) ||
2422                  !strcmp( tracks[i_track]->psz_codec, "S_ASS" ))
2423         {
2424             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 's', 's', 'a', ' ' );
2425             tracks[i_track]->fmt.subs.psz_encoding = strdup( "UTF-8" );
2426         }
2427         else if( !strcmp( tracks[i_track]->psz_codec, "S_VOBSUB" ) )
2428         {
2429             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 's','p','u',' ' );
2430             if( tracks[i_track]->i_extra_data )
2431             {
2432                 char *p_start;
2433                 char *p_buf = (char *)malloc( tracks[i_track]->i_extra_data + 1);
2434                 memcpy( p_buf, tracks[i_track]->p_extra_data , tracks[i_track]->i_extra_data );
2435                 p_buf[tracks[i_track]->i_extra_data] = '\0';
2436
2437                 p_start = strstr( p_buf, "size:" );
2438                 if( sscanf( p_start, "size: %dx%d",
2439                         &tracks[i_track]->fmt.subs.spu.i_original_frame_width, &tracks[i_track]->fmt.subs.spu.i_original_frame_height ) == 2 )
2440                 {
2441                     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 );
2442                 }
2443                 else
2444                 {
2445                     msg_Warn( &sys.demuxer, "reading original frame size for vobsub failed" );
2446                 }
2447                 free( p_buf );
2448             }
2449         }
2450         else if( !strcmp( tracks[i_track]->psz_codec, "B_VOBBTN" ) )
2451         {
2452             tracks[i_track]->fmt.i_cat = NAV_ES;
2453             continue;
2454         }
2455         else
2456         {
2457             msg_Err( &sys.demuxer, "unknow codec id=`%s'", tracks[i_track]->psz_codec );
2458             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 'n', 'd', 'f' );
2459         }
2460         if( tracks[i_track]->b_default )
2461         {
2462             tracks[i_track]->fmt.i_priority = 1000;
2463         }
2464
2465         tracks[i_track]->p_es = es_out_Add( sys.demuxer.out, &tracks[i_track]->fmt );
2466
2467         es_out_Control( sys.demuxer.out, ES_OUT_SET_NEXT_DISPLAY_TIME, tracks[i_track]->p_es, i_start_time );
2468     }
2469
2470     sys.i_start_pts = i_start_time;
2471     // reset the stream reading to the first cluster of the segment used
2472     es.I_O().setFilePointer( i_start_pos );
2473
2474     delete ep;
2475     ep = new EbmlParser( &es, segment, &sys.demuxer );
2476
2477     return true;
2478 }
2479
2480 void demux_sys_t::StartUiThread()
2481 {
2482     if ( !b_ui_hooked )
2483     {
2484         msg_Dbg( &demuxer, "Starting the UI Hook" );
2485         b_ui_hooked = true;
2486         /* FIXME hack hack hack hack FIXME */
2487         /* Get p_input and create variable */
2488         p_input = (input_thread_t *) vlc_object_find( &demuxer, VLC_OBJECT_INPUT, FIND_PARENT );
2489         var_Create( p_input, "x-start", VLC_VAR_INTEGER );
2490         var_Create( p_input, "y-start", VLC_VAR_INTEGER );
2491         var_Create( p_input, "x-end", VLC_VAR_INTEGER );
2492         var_Create( p_input, "y-end", VLC_VAR_INTEGER );
2493         var_Create( p_input, "color", VLC_VAR_ADDRESS );
2494         var_Create( p_input, "menu-palette", VLC_VAR_ADDRESS );
2495         var_Create( p_input, "highlight", VLC_VAR_BOOL );
2496         var_Create( p_input, "highlight-mutex", VLC_VAR_MUTEX );
2497
2498         /* Now create our event thread catcher */
2499         p_ev = (event_thread_t *) vlc_object_create( &demuxer, sizeof( event_thread_t ) );
2500         p_ev->p_demux = &demuxer;
2501         p_ev->b_die = VLC_FALSE;
2502         vlc_mutex_init( p_ev, &p_ev->lock );
2503         vlc_thread_create( p_ev, "mkv event thread handler", EventThread,
2504                         VLC_THREAD_PRIORITY_LOW, VLC_FALSE );
2505     }
2506 }
2507
2508 void demux_sys_t::StopUiThread()
2509 {
2510     if ( b_ui_hooked )
2511     {
2512         p_ev->b_die = VLC_TRUE;
2513
2514         vlc_thread_join( p_ev );
2515         vlc_object_destroy( p_ev );
2516
2517         p_ev = NULL;
2518
2519         var_Destroy( p_input, "highlight-mutex" );
2520         var_Destroy( p_input, "highlight" );
2521         var_Destroy( p_input, "x-start" );
2522         var_Destroy( p_input, "x-end" );
2523         var_Destroy( p_input, "y-start" );
2524         var_Destroy( p_input, "y-end" );
2525         var_Destroy( p_input, "color" );
2526         var_Destroy( p_input, "menu-palette" );
2527
2528         vlc_object_release( p_input );
2529
2530         msg_Dbg( &demuxer, "Stopping the UI Hook" );
2531     }
2532     b_ui_hooked = false;
2533 }
2534
2535 int demux_sys_t::EventMouse( vlc_object_t *p_this, char const *psz_var,
2536                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
2537 {
2538     event_thread_t *p_ev = (event_thread_t *) p_data;
2539     vlc_mutex_lock( &p_ev->lock );
2540     if( psz_var[6] == 'c' )
2541     {
2542         p_ev->b_clicked = VLC_TRUE;
2543         msg_Dbg( p_this, "Event Mouse: clicked");
2544     }
2545     else if( psz_var[6] == 'm' )
2546         p_ev->b_moved = VLC_TRUE;
2547     vlc_mutex_unlock( &p_ev->lock );
2548
2549     return VLC_SUCCESS;
2550 }
2551
2552 int demux_sys_t::EventKey( vlc_object_t *p_this, char const *psz_var,
2553                      vlc_value_t oldval, vlc_value_t newval, void *p_data )
2554 {
2555     event_thread_t *p_ev = (event_thread_t *) p_data;
2556     vlc_mutex_lock( &p_ev->lock );
2557     p_ev->b_key = VLC_TRUE;
2558     vlc_mutex_unlock( &p_ev->lock );
2559     msg_Dbg( p_this, "Event Key");
2560
2561     return VLC_SUCCESS;
2562 }
2563
2564 int demux_sys_t::EventThread( vlc_object_t *p_this )
2565 {
2566     event_thread_t *p_ev = (event_thread_t*)p_this;
2567     demux_sys_t    *p_sys = p_ev->p_demux->p_sys;
2568     vlc_object_t   *p_vout = NULL;
2569
2570     p_ev->b_moved   = VLC_FALSE;
2571     p_ev->b_clicked = VLC_FALSE;
2572     p_ev->b_key     = VLC_FALSE;
2573
2574     /* catch all key event */
2575     var_AddCallback( p_ev->p_vlc, "key-pressed", EventKey, p_ev );
2576
2577     /* main loop */
2578     while( !p_ev->b_die )
2579     {
2580         if ( !p_sys->b_pci_packet_set )
2581         {
2582             /* Wait 100ms */
2583             msleep( 100000 );
2584             continue;
2585         }
2586
2587         vlc_bool_t b_activated = VLC_FALSE;
2588
2589         /* KEY part */
2590         if( p_ev->b_key )
2591         {
2592             vlc_value_t valk;
2593             struct vlc_t::hotkey *p_hotkeys = p_ev->p_vlc->p_hotkeys;
2594             int i, i_action = -1;
2595
2596             msg_Dbg( p_ev->p_demux, "Handle Key Event");
2597
2598             vlc_mutex_lock( &p_ev->lock );
2599
2600             pci_t *pci = (pci_t *) &p_sys->pci_packet;
2601
2602             var_Get( p_ev->p_vlc, "key-pressed", &valk );
2603             for( i = 0; p_hotkeys[i].psz_action != NULL; i++ )
2604             {
2605                 if( p_hotkeys[i].i_key == valk.i_int )
2606                 {
2607                     i_action = p_hotkeys[i].i_action;
2608                 }
2609             }
2610
2611             uint16 i_curr_button = p_sys->dvd_interpretor.GetSPRM( 0x88 );
2612
2613             switch( i_action )
2614             {
2615             case ACTIONID_NAV_LEFT:
2616                 if ( i_curr_button > 0 && i_curr_button <= pci->hli.hl_gi.btn_ns )
2617                 {
2618                     btni_t *p_button_ptr = &(pci->hli.btnit[i_curr_button-1]);
2619                     if ( p_button_ptr->left > 0 && p_button_ptr->left <= pci->hli.hl_gi.btn_ns )
2620                     {
2621                         i_curr_button = p_button_ptr->left;
2622                         p_sys->dvd_interpretor.SetSPRM( 0x88, i_curr_button );
2623                         btni_t button_ptr = pci->hli.btnit[i_curr_button-1];
2624                         if ( button_ptr.auto_action_mode )
2625                         {
2626                             vlc_mutex_unlock( &p_ev->lock );
2627                             vlc_mutex_lock( &p_sys->lock_demuxer );
2628
2629                             // process the button action
2630                             p_sys->dvd_interpretor.Interpret( button_ptr.cmd.bytes, 8 );
2631
2632                             vlc_mutex_unlock( &p_sys->lock_demuxer );
2633                             vlc_mutex_lock( &p_ev->lock );
2634                         }
2635                     }
2636                 }
2637                 break;
2638             case ACTIONID_NAV_RIGHT:
2639                 if ( i_curr_button > 0 && i_curr_button <= pci->hli.hl_gi.btn_ns )
2640                 {
2641                     btni_t *p_button_ptr = &(pci->hli.btnit[i_curr_button-1]);
2642                     if ( p_button_ptr->right > 0 && p_button_ptr->right <= pci->hli.hl_gi.btn_ns )
2643                     {
2644                         i_curr_button = p_button_ptr->right;
2645                         p_sys->dvd_interpretor.SetSPRM( 0x88, i_curr_button );
2646                         btni_t button_ptr = pci->hli.btnit[i_curr_button-1];
2647                         if ( button_ptr.auto_action_mode )
2648                         {
2649                             vlc_mutex_unlock( &p_ev->lock );
2650                             vlc_mutex_lock( &p_sys->lock_demuxer );
2651
2652                             // process the button action
2653                             p_sys->dvd_interpretor.Interpret( button_ptr.cmd.bytes, 8 );
2654
2655                             vlc_mutex_unlock( &p_sys->lock_demuxer );
2656                             vlc_mutex_lock( &p_ev->lock );
2657                         }
2658                     }
2659                 }
2660                 break;
2661             case ACTIONID_NAV_UP:
2662                 if ( i_curr_button > 0 && i_curr_button <= pci->hli.hl_gi.btn_ns )
2663                 {
2664                     btni_t *p_button_ptr = &(pci->hli.btnit[i_curr_button-1]);
2665                     if ( p_button_ptr->up > 0 && p_button_ptr->up <= pci->hli.hl_gi.btn_ns )
2666                     {
2667                         i_curr_button = p_button_ptr->up;
2668                         p_sys->dvd_interpretor.SetSPRM( 0x88, i_curr_button );
2669                         btni_t button_ptr = pci->hli.btnit[i_curr_button-1];
2670                         if ( button_ptr.auto_action_mode )
2671                         {
2672                             vlc_mutex_unlock( &p_ev->lock );
2673                             vlc_mutex_lock( &p_sys->lock_demuxer );
2674
2675                             // process the button action
2676                             p_sys->dvd_interpretor.Interpret( button_ptr.cmd.bytes, 8 );
2677
2678                             vlc_mutex_unlock( &p_sys->lock_demuxer );
2679                             vlc_mutex_lock( &p_ev->lock );
2680                         }
2681                     }
2682                 }
2683                 break;
2684             case ACTIONID_NAV_DOWN:
2685                 if ( i_curr_button > 0 && i_curr_button <= pci->hli.hl_gi.btn_ns )
2686                 {
2687                     btni_t *p_button_ptr = &(pci->hli.btnit[i_curr_button-1]);
2688                     if ( p_button_ptr->down > 0 && p_button_ptr->down <= pci->hli.hl_gi.btn_ns )
2689                     {
2690                         i_curr_button = p_button_ptr->down;
2691                         p_sys->dvd_interpretor.SetSPRM( 0x88, i_curr_button );
2692                         btni_t button_ptr = pci->hli.btnit[i_curr_button-1];
2693                         if ( button_ptr.auto_action_mode )
2694                         {
2695                             vlc_mutex_unlock( &p_ev->lock );
2696                             vlc_mutex_lock( &p_sys->lock_demuxer );
2697
2698                             // process the button action
2699                             p_sys->dvd_interpretor.Interpret( button_ptr.cmd.bytes, 8 );
2700
2701                             vlc_mutex_unlock( &p_sys->lock_demuxer );
2702                             vlc_mutex_lock( &p_ev->lock );
2703                         }
2704                     }
2705                 }
2706                 break;
2707             case ACTIONID_NAV_ACTIVATE:
2708                 b_activated = VLC_TRUE;
2709
2710                 if ( i_curr_button > 0 && i_curr_button <= pci->hli.hl_gi.btn_ns )
2711                 {
2712                     btni_t button_ptr = pci->hli.btnit[i_curr_button-1];
2713
2714                     vlc_mutex_unlock( &p_ev->lock );
2715                     vlc_mutex_lock( &p_sys->lock_demuxer );
2716
2717                     // process the button action
2718                     p_sys->dvd_interpretor.Interpret( button_ptr.cmd.bytes, 8 );
2719
2720                     vlc_mutex_unlock( &p_sys->lock_demuxer );
2721                     vlc_mutex_lock( &p_ev->lock );
2722                 }
2723                 break;
2724             default:
2725                 break;
2726             }
2727             p_ev->b_key = VLC_FALSE;
2728             vlc_mutex_unlock( &p_ev->lock );
2729         }
2730
2731         /* MOUSE part */
2732         if( p_vout && ( p_ev->b_moved || p_ev->b_clicked ) )
2733         {
2734             vlc_value_t valx, valy;
2735
2736             vlc_mutex_lock( &p_ev->lock );
2737             pci_t *pci = (pci_t *) &p_sys->pci_packet;
2738             var_Get( p_vout, "mouse-x", &valx );
2739             var_Get( p_vout, "mouse-y", &valy );
2740
2741             if( p_ev->b_clicked )
2742             {
2743                 int32_t button;
2744                 int32_t best,dist,d;
2745                 int32_t mx,my,dx,dy;
2746
2747                 msg_Dbg( p_ev->p_demux, "Handle Mouse Event: Mouse clicked x(%d)*y(%d)", (unsigned)valx.i_int, (unsigned)valy.i_int);
2748
2749                 b_activated = VLC_TRUE;
2750                 // get current button
2751                 best = 0;
2752                 dist = 0x08000000; /* >> than  (720*720)+(567*567); */
2753                 for(button = 1; button <= pci->hli.hl_gi.btn_ns; button++)
2754                 {
2755                     btni_t *button_ptr = &(pci->hli.btnit[button-1]);
2756
2757                     if(((unsigned)valx.i_int >= button_ptr->x_start)
2758                      && ((unsigned)valx.i_int <= button_ptr->x_end)
2759                      && ((unsigned)valy.i_int >= button_ptr->y_start)
2760                      && ((unsigned)valy.i_int <= button_ptr->y_end))
2761                     {
2762                         mx = (button_ptr->x_start + button_ptr->x_end)/2;
2763                         my = (button_ptr->y_start + button_ptr->y_end)/2;
2764                         dx = mx - valx.i_int;
2765                         dy = my - valy.i_int;
2766                         d = (dx*dx) + (dy*dy);
2767                         /* If the mouse is within the button and the mouse is closer
2768                         * to the center of this button then it is the best choice. */
2769                         if(d < dist) {
2770                             dist = d;
2771                             best = button;
2772                         }
2773                     }
2774                 }
2775
2776                 if ( best != 0)
2777                 {
2778                     btni_t button_ptr = pci->hli.btnit[best-1];
2779                     uint16 i_curr_button = p_sys->dvd_interpretor.GetSPRM( 0x88 );
2780
2781                     msg_Dbg( &p_sys->demuxer, "Clicked button %d", best );
2782                     vlc_mutex_unlock( &p_ev->lock );
2783                     vlc_mutex_lock( &p_sys->lock_demuxer );
2784
2785                     // process the button action
2786                     p_sys->dvd_interpretor.SetSPRM( 0x88, best );
2787                     p_sys->dvd_interpretor.Interpret( button_ptr.cmd.bytes, 8 );
2788
2789                     msg_Dbg( &p_sys->demuxer, "Processed button %d", best );
2790
2791                     // select new button
2792                     if ( best != i_curr_button )
2793                     {
2794                         vlc_value_t val;
2795
2796                         if( var_Get( p_sys->p_input, "highlight-mutex", &val ) == VLC_SUCCESS )
2797                         {
2798                             vlc_mutex_t *p_mutex = (vlc_mutex_t *) val.p_address;
2799                             uint32_t i_palette;
2800
2801                             if(button_ptr.btn_coln != 0) {
2802                                 i_palette = pci->hli.btn_colit.btn_coli[button_ptr.btn_coln-1][1];
2803                             } else {
2804                                 i_palette = 0;
2805                             }
2806
2807                             for( int i = 0; i < 4; i++ )
2808                             {
2809                                 uint32_t i_yuv = 0xFF;//p_sys->clut[(hl.palette>>(16+i*4))&0x0f];
2810                                 uint8_t i_alpha = (i_palette>>(i*4))&0x0f;
2811                                 i_alpha = i_alpha == 0xf ? 0xff : i_alpha << 4;
2812
2813                                 p_sys->palette[i][0] = (i_yuv >> 16) & 0xff;
2814                                 p_sys->palette[i][1] = (i_yuv >> 0) & 0xff;
2815                                 p_sys->palette[i][2] = (i_yuv >> 8) & 0xff;
2816                                 p_sys->palette[i][3] = i_alpha;
2817                             }
2818
2819                             vlc_mutex_lock( p_mutex );
2820                             val.i_int = button_ptr.x_start; var_Set( p_sys->p_input, "x-start", val );
2821                             val.i_int = button_ptr.x_end;   var_Set( p_sys->p_input, "x-end",   val );
2822                             val.i_int = button_ptr.y_start; var_Set( p_sys->p_input, "y-start", val );
2823                             val.i_int = button_ptr.y_end;   var_Set( p_sys->p_input, "y-end",   val );
2824
2825                             val.p_address = (void *)p_sys->palette;
2826                             var_Set( p_sys->p_input, "menu-palette", val );
2827
2828                             val.b_bool = VLC_TRUE; var_Set( p_sys->p_input, "highlight", val );
2829                             vlc_mutex_unlock( p_mutex );
2830                         }
2831                     }
2832                     vlc_mutex_unlock( &p_sys->lock_demuxer );
2833                     vlc_mutex_lock( &p_ev->lock );
2834                 }
2835             }
2836             else if( p_ev->b_moved )
2837             {
2838 //                dvdnav_mouse_select( NULL, pci, valx.i_int, valy.i_int );
2839             }
2840
2841             p_ev->b_moved = VLC_FALSE;
2842             p_ev->b_clicked = VLC_FALSE;
2843             vlc_mutex_unlock( &p_ev->lock );
2844         }
2845
2846         /* VOUT part */
2847         if( p_vout && p_vout->b_die )
2848         {
2849             var_DelCallback( p_vout, "mouse-moved", EventMouse, p_ev );
2850             var_DelCallback( p_vout, "mouse-clicked", EventMouse, p_ev );
2851             vlc_object_release( p_vout );
2852             p_vout = NULL;
2853         }
2854
2855         else if( p_vout == NULL )
2856         {
2857             p_vout = (vlc_object_t*) vlc_object_find( p_sys->p_input, VLC_OBJECT_VOUT,
2858                                       FIND_CHILD );
2859             if( p_vout)
2860             {
2861                 var_AddCallback( p_vout, "mouse-moved", EventMouse, p_ev );
2862                 var_AddCallback( p_vout, "mouse-clicked", EventMouse, p_ev );
2863             }
2864         }
2865
2866         /* Wait a bit, 10ms */
2867         msleep( 10000 );
2868     }
2869
2870     /* Release callback */
2871     if( p_vout )
2872     {
2873         var_DelCallback( p_vout, "mouse-moved", EventMouse, p_ev );
2874         var_DelCallback( p_vout, "mouse-clicked", EventMouse, p_ev );
2875         vlc_object_release( p_vout );
2876     }
2877     var_DelCallback( p_ev->p_vlc, "key-pressed", EventKey, p_ev );
2878
2879     vlc_mutex_destroy( &p_ev->lock );
2880
2881     return VLC_SUCCESS;
2882 }
2883
2884 void matroska_segment_c::UnSelect( )
2885 {
2886     size_t i_track;
2887
2888     for( i_track = 0; i_track < tracks.size(); i_track++ )
2889     {
2890         if ( tracks[i_track]->p_es != NULL )
2891         {
2892 //            es_format_Clean( &tracks[i_track]->fmt );
2893             es_out_Del( sys.demuxer.out, tracks[i_track]->p_es );
2894             tracks[i_track]->p_es = NULL;
2895         }
2896     }
2897     delete ep;
2898     ep = NULL;
2899 }
2900
2901 void virtual_segment_c::PrepareChapters( )
2902 {
2903     if ( linked_segments.size() == 0 )
2904         return;
2905
2906     // !!! should be called only once !!!
2907     matroska_segment_c *p_segment;
2908     size_t i, j;
2909
2910     // copy editions from the first segment
2911     p_segment = linked_segments[0];
2912     p_editions = &p_segment->stored_editions;
2913
2914     for ( i=1 ; i<linked_segments.size(); i++ )
2915     {
2916         p_segment = linked_segments[i];
2917         // FIXME assume we have the same editions in all segments
2918         for (j=0; j<p_segment->stored_editions.size(); j++)
2919             (*p_editions)[j]->Append( *p_segment->stored_editions[j] );
2920     }
2921 }
2922
2923 std::string chapter_edition_c::GetMainName() const
2924 {
2925     if ( sub_chapters.size() )
2926     {
2927         return sub_chapters[0]->GetCodecName( true );
2928     }
2929     return "";
2930 }
2931
2932 int chapter_item_c::PublishChapters( input_title_t & title, int & i_user_chapters, int i_level )
2933 {
2934     // add support for meta-elements from codec like DVD Titles
2935     if ( !b_display_seekpoint || psz_name == "" )
2936     {
2937         psz_name = GetCodecName();
2938         if ( psz_name != "" )
2939             b_display_seekpoint = true;
2940     }
2941
2942     if (b_display_seekpoint)
2943     {
2944         seekpoint_t *sk = vlc_seekpoint_New();
2945
2946         sk->i_level = i_level;
2947         sk->i_time_offset = i_start_time;
2948         sk->psz_name = strdup( psz_name.c_str() );
2949
2950         // A start time of '0' is ok. A missing ChapterTime element is ok, too, because '0' is its default value.
2951         title.i_seekpoint++;
2952         title.seekpoint = (seekpoint_t**)realloc( title.seekpoint, title.i_seekpoint * sizeof( seekpoint_t* ) );
2953         title.seekpoint[title.i_seekpoint-1] = sk;
2954
2955         if ( b_user_display )
2956             i_user_chapters++;
2957     }
2958
2959     for ( size_t i=0; i<sub_chapters.size() ; i++)
2960     {
2961         sub_chapters[i]->PublishChapters( title, i_user_chapters, i_level+1 );
2962     }
2963
2964     i_seekpoint_num = i_user_chapters;
2965
2966     return i_user_chapters;
2967 }
2968
2969 bool virtual_segment_c::UpdateCurrentToChapter( demux_t & demux )
2970 {
2971     demux_sys_t & sys = *demux.p_sys;
2972     chapter_item_c *psz_curr_chapter;
2973     bool b_has_seeked = false;
2974
2975     /* update current chapter/seekpoint */
2976     if ( p_editions->size() )
2977     {
2978         /* 1st, we need to know in which chapter we are */
2979         psz_curr_chapter = (*p_editions)[i_current_edition]->FindTimecode( sys.i_pts, psz_current_chapter );
2980
2981         /* we have moved to a new chapter */
2982         if (psz_curr_chapter != NULL && psz_current_chapter != psz_curr_chapter)
2983         {
2984             if ( (*p_editions)[i_current_edition]->b_ordered )
2985             {
2986                 // Leave/Enter up to the link point
2987                 b_has_seeked = psz_curr_chapter->EnterAndLeave( psz_current_chapter );
2988                 if ( !b_has_seeked )
2989                 {
2990                     // only physically seek if necessary
2991                     if ( psz_current_chapter == NULL || (psz_current_chapter->i_end_time != psz_curr_chapter->i_start_time) )
2992                         Seek( demux, sys.i_pts, 0, psz_curr_chapter );
2993                 }
2994             }
2995
2996             if ( !b_has_seeked )
2997             {
2998                 psz_current_chapter = psz_curr_chapter;
2999                 if ( psz_curr_chapter->i_seekpoint_num > 0 )
3000                 {
3001                     demux.info.i_update |= INPUT_UPDATE_TITLE | INPUT_UPDATE_SEEKPOINT;
3002                     demux.info.i_title = sys.i_current_title = i_sys_title;
3003                     demux.info.i_seekpoint = psz_curr_chapter->i_seekpoint_num - 1;
3004                 }
3005             }
3006
3007             return true;
3008         }
3009         else if (psz_curr_chapter == NULL)
3010         {
3011             // out of the scope of the data described by chapters, leave the edition
3012             if ( (*p_editions)[i_current_edition]->b_ordered && psz_current_chapter != NULL )
3013             {
3014                 if ( !(*p_editions)[i_current_edition]->EnterAndLeave( psz_current_chapter, false ) )
3015                     psz_current_chapter = NULL;
3016                 else
3017                     return true;
3018             }
3019         }
3020     }
3021     return false;
3022 }
3023
3024 chapter_item_c *virtual_segment_c::BrowseCodecPrivate( unsigned int codec_id,
3025                                     bool (*match)(const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size ),
3026                                     const void *p_cookie,
3027                                     size_t i_cookie_size )
3028 {
3029     // FIXME don't assume it is the first edition
3030     std::vector<chapter_edition_c*>::iterator index = p_editions->begin();
3031     if ( index != p_editions->end() )
3032     {
3033         chapter_item_c *p_result = (*index)->BrowseCodecPrivate( codec_id, match, p_cookie, i_cookie_size );
3034         if ( p_result != NULL )
3035             return p_result;
3036     }
3037     return NULL;
3038 }
3039
3040 chapter_item_c *virtual_segment_c::FindChapter( int64_t i_find_uid )
3041 {
3042     // FIXME don't assume it is the first edition
3043     std::vector<chapter_edition_c*>::iterator index = p_editions->begin();
3044     if ( index != p_editions->end() )
3045     {
3046         chapter_item_c *p_result = (*index)->FindChapter( i_find_uid );
3047         if ( p_result != NULL )
3048             return p_result;
3049     }
3050     return NULL;
3051 }
3052
3053 chapter_item_c *chapter_item_c::BrowseCodecPrivate( unsigned int codec_id,
3054                                     bool (*match)(const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size ),
3055                                     const void *p_cookie,
3056                                     size_t i_cookie_size )
3057 {
3058     // this chapter
3059     std::vector<chapter_codec_cmds_c*>::const_iterator index = codecs.begin();
3060     while ( index != codecs.end() )
3061     {
3062         if ( match( **index ,p_cookie, i_cookie_size ) )
3063             return this;
3064         index++;
3065     }
3066
3067     // sub-chapters
3068     chapter_item_c *p_result = NULL;
3069     std::vector<chapter_item_c*>::const_iterator index2 = sub_chapters.begin();
3070     while ( index2 != sub_chapters.end() )
3071     {
3072         p_result = (*index2)->BrowseCodecPrivate( codec_id, match, p_cookie, i_cookie_size );
3073         if ( p_result != NULL )
3074             return p_result;
3075         index2++;
3076     }
3077
3078     return p_result;
3079 }
3080
3081 void chapter_item_c::Append( const chapter_item_c & chapter )
3082 {
3083     // we are appending content for the same chapter UID
3084     size_t i;
3085     chapter_item_c *p_chapter;
3086
3087     for ( i=0; i<chapter.sub_chapters.size(); i++ )
3088     {
3089         p_chapter = FindChapter( chapter.sub_chapters[i]->i_uid );
3090         if ( p_chapter != NULL )
3091         {
3092             p_chapter->Append( *chapter.sub_chapters[i] );
3093         }
3094         else
3095         {
3096             sub_chapters.push_back( chapter.sub_chapters[i] );
3097         }
3098     }
3099
3100     i_user_start_time = min( i_user_start_time, chapter.i_user_start_time );
3101     i_user_end_time = max( i_user_end_time, chapter.i_user_end_time );
3102 }
3103
3104 chapter_item_c * chapter_item_c::FindChapter( int64_t i_find_uid )
3105 {
3106     size_t i;
3107     chapter_item_c *p_result = NULL;
3108
3109     if ( i_uid == i_find_uid )
3110         return this;
3111
3112     for ( i=0; i<sub_chapters.size(); i++)
3113     {
3114         p_result = sub_chapters[i]->FindChapter( i_find_uid );
3115         if ( p_result != NULL )
3116             break;
3117     }
3118     return p_result;
3119 }
3120
3121 std::string chapter_item_c::GetCodecName( bool f_for_title ) const
3122 {
3123     std::string result;
3124
3125     std::vector<chapter_codec_cmds_c*>::const_iterator index = codecs.begin();
3126     while ( index != codecs.end() )
3127     {
3128         result = (*index)->GetCodecName( f_for_title );
3129         if ( result != "" )
3130             break;
3131         index++;
3132     }
3133
3134     return result;
3135 }
3136
3137 std::string dvd_chapter_codec_c::GetCodecName( bool f_for_title ) const
3138 {
3139     std::string result;
3140     if ( p_private_data->GetSize() >= 3)
3141     {
3142         const binary* p_data = p_private_data->GetBuffer();
3143 /*        if ( p_data[0] == MATROSKA_DVD_LEVEL_TT )
3144         {
3145             uint16_t i_title = (p_data[1] << 8) + p_data[2];
3146             char psz_str[11];
3147             sprintf( psz_str, " %d  ---", i_title );
3148             result = N_("---  DVD Title");
3149             result += psz_str;
3150         }
3151         else */ if ( p_data[0] == MATROSKA_DVD_LEVEL_LU )
3152         {
3153             char psz_str[11];
3154             sprintf( psz_str, " (%c%c)  ---", p_data[1], p_data[2] );
3155             result = N_("---  DVD Menu");
3156             result += psz_str;
3157         }
3158         else if ( p_data[0] == MATROSKA_DVD_LEVEL_SS && f_for_title )
3159         {
3160             if ( p_data[1] == 0x00 )
3161                 result = N_("First Played");
3162             else if ( p_data[1] == 0xC0 )
3163                 result = N_("Video Manager");
3164             else if ( p_data[1] == 0x80 )
3165             {
3166                 uint16_t i_title = (p_data[2] << 8) + p_data[3];
3167                 char psz_str[20];
3168                 sprintf( psz_str, " %d -----", i_title );
3169                 result = N_("----- Title");
3170                 result += psz_str;
3171             }
3172         }
3173     }
3174
3175     return result;
3176 }
3177
3178 int16 chapter_item_c::GetTitleNumber( ) const
3179 {
3180     int result = -1;
3181
3182     std::vector<chapter_codec_cmds_c*>::const_iterator index = codecs.begin();
3183     while ( index != codecs.end() )
3184     {
3185         result = (*index)->GetTitleNumber( );
3186         if ( result >= 0 )
3187             break;
3188         index++;
3189     }
3190
3191     return result;
3192 }
3193
3194 int16 dvd_chapter_codec_c::GetTitleNumber()
3195 {
3196     if ( p_private_data->GetSize() >= 3)
3197     {
3198         const binary* p_data = p_private_data->GetBuffer();
3199         if ( p_data[0] == MATROSKA_DVD_LEVEL_SS )
3200         {
3201             return int16( (p_data[2] << 8) + p_data[3] );
3202         }
3203     }
3204     return -1;
3205 }
3206
3207 static void Seek( demux_t *p_demux, mtime_t i_date, double f_percent, chapter_item_c *psz_chapter )
3208 {
3209     demux_sys_t        *p_sys = p_demux->p_sys;
3210     virtual_segment_c  *p_vsegment = p_sys->p_current_segment;
3211     matroska_segment_c *p_segment = p_vsegment->Segment();
3212     mtime_t            i_time_offset = 0;
3213
3214     int         i_index;
3215
3216     msg_Dbg( p_demux, "seek request to "I64Fd" (%f%%)", i_date, f_percent );
3217     if( i_date < 0 && f_percent < 0 )
3218     {
3219         msg_Warn( p_demux, "cannot seek nowhere !" );
3220         return;
3221     }
3222     if( f_percent > 1.0 )
3223     {
3224         msg_Warn( p_demux, "cannot seek so far !" );
3225         return;
3226     }
3227
3228     /* seek without index or without date */
3229     if( f_percent >= 0 && (config_GetInt( p_demux, "mkv-seek-percent" ) || !p_segment->b_cues || i_date < 0 ))
3230     {
3231         if (p_sys->f_duration >= 0)
3232         {
3233             i_date = int64_t( f_percent * p_sys->f_duration * 1000.0 );
3234         }
3235         else
3236         {
3237             int64_t i_pos = int64_t( f_percent * stream_Size( p_demux->s ) );
3238
3239             msg_Dbg( p_demux, "inacurate way of seeking" );
3240             for( i_index = 0; i_index < p_segment->i_index; i_index++ )
3241             {
3242                 if( p_segment->p_indexes[i_index].i_position >= i_pos)
3243                 {
3244                     break;
3245                 }
3246             }
3247             if( i_index == p_segment->i_index )
3248             {
3249                 i_index--;
3250             }
3251
3252             i_date = p_segment->p_indexes[i_index].i_time;
3253
3254 #if 0
3255             if( p_segment->p_indexes[i_index].i_position < i_pos )
3256             {
3257                 EbmlElement *el;
3258
3259                 msg_Warn( p_demux, "searching for cluster, could take some time" );
3260
3261                 /* search a cluster */
3262                 while( ( el = p_sys->ep->Get() ) != NULL )
3263                 {
3264                     if( MKV_IS_ID( el, KaxCluster ) )
3265                     {
3266                         KaxCluster *cluster = (KaxCluster*)el;
3267
3268                         /* add it to the index */
3269                         p_segment->IndexAppendCluster( cluster );
3270
3271                         if( (int64_t)cluster->GetElementPosition() >= i_pos )
3272                         {
3273                             p_sys->cluster = cluster;
3274                             p_sys->ep->Down();
3275                             break;
3276                         }
3277                     }
3278                 }
3279             }
3280 #endif
3281         }
3282     }
3283
3284     p_vsegment->Seek( *p_demux, i_date, i_time_offset, psz_chapter );
3285 }
3286
3287 /*****************************************************************************
3288  * Demux: reads and demuxes data packets
3289  *****************************************************************************
3290  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
3291  *****************************************************************************/
3292 static int Demux( demux_t *p_demux)
3293 {
3294     demux_sys_t        *p_sys = p_demux->p_sys;
3295
3296     vlc_mutex_lock( &p_sys->lock_demuxer );
3297
3298     virtual_segment_c  *p_vsegment = p_sys->p_current_segment;
3299     matroska_segment_c *p_segment = p_vsegment->Segment();
3300     if ( p_segment == NULL ) return 0;
3301     int                i_block_count = 0;
3302     int                i_return = 0;
3303
3304     for( ;; )
3305     {
3306         if ( p_sys->demuxer.b_die )
3307             break;
3308
3309         if( p_sys->i_pts >= p_sys->i_start_pts  )
3310             if ( p_vsegment->UpdateCurrentToChapter( *p_demux ) )
3311             {
3312                 i_return = 1;
3313                 break;
3314             }
3315
3316         if ( p_vsegment->Edition() && p_vsegment->Edition()->b_ordered && p_vsegment->CurrentChapter() == NULL )
3317         {
3318             /* nothing left to read in this ordered edition */
3319             if ( !p_vsegment->SelectNext() )
3320                 break;
3321             p_segment->UnSelect( );
3322
3323             es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
3324
3325             /* switch to the next segment */
3326             p_segment = p_vsegment->Segment();
3327             if ( !p_segment->Select( 0 ) )
3328             {
3329                 msg_Err( p_demux, "Failed to select new segment" );
3330                 break;
3331             }
3332             continue;
3333         }
3334
3335         KaxBlock *block;
3336         int64_t i_block_duration = 0;
3337         int64_t i_block_ref1;
3338         int64_t i_block_ref2;
3339
3340 #if LIBMATROSKA_VERSION >= 0x000800
3341         KaxSimpleBlock *simpleblock;
3342
3343         if( p_segment->BlockGet( block, simpleblock, &i_block_ref1, &i_block_ref2, &i_block_duration ) )
3344 #else
3345         if( p_segment->BlockGet( block, &i_block_ref1, &i_block_ref2, &i_block_duration ) )
3346 #endif
3347         {
3348             if ( p_vsegment->Edition() && p_vsegment->Edition()->b_ordered )
3349             {
3350                 const chapter_item_c *p_chap = p_vsegment->CurrentChapter();
3351                 // check if there are more chapters to read
3352                 if ( p_chap != NULL )
3353                 {
3354                     /* TODO handle successive chapters with the same user_start_time/user_end_time
3355                     if ( p_chap->i_user_start_time == p_chap->i_user_start_time )
3356                         p_vsegment->SelectNext();
3357                     */
3358                     p_sys->i_pts = p_chap->i_user_end_time;
3359                     p_sys->i_pts++; // trick to avoid staying on segments with no duration and no content
3360
3361                     i_return = 1;
3362                 }
3363
3364                 break;
3365             }
3366             else
3367             {
3368                 msg_Warn( p_demux, "cannot get block EOF?" );
3369                 p_segment->UnSelect( );
3370
3371                 es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
3372
3373                 /* switch to the next segment */
3374                 if ( !p_vsegment->SelectNext() )
3375                     // no more segments in this stream
3376                     break;
3377                 p_segment = p_vsegment->Segment();
3378                 if ( !p_segment->Select( 0 ) )
3379                 {
3380                     msg_Err( p_demux, "Failed to select new segment" );
3381                     break;
3382                 }
3383
3384                 continue;
3385             }
3386         }
3387
3388 #if LIBMATROSKA_VERSION >= 0x000800
3389         if ( simpleblock != NULL )
3390             p_sys->i_pts = (p_sys->i_chapter_time + simpleblock->GlobalTimecode()) / (mtime_t) 1000;
3391         else
3392 #endif
3393         p_sys->i_pts = (p_sys->i_chapter_time + block->GlobalTimecode()) / (mtime_t) 1000;
3394
3395         if( p_sys->i_pts >= p_sys->i_start_pts  )
3396         {
3397             es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_pts );
3398
3399             if ( p_vsegment->UpdateCurrentToChapter( *p_demux ) )
3400             {
3401                 i_return = 1;
3402                 delete block;
3403                 break;
3404             }
3405         }
3406
3407         if ( p_vsegment->Edition() && p_vsegment->Edition()->b_ordered && p_vsegment->CurrentChapter() == NULL )
3408         {
3409             /* nothing left to read in this ordered edition */
3410             if ( !p_vsegment->SelectNext() )
3411             {
3412                 delete block;
3413                 break;
3414             }
3415             p_segment->UnSelect( );
3416
3417             es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
3418
3419             /* switch to the next segment */
3420             p_segment = p_vsegment->Segment();
3421             if ( !p_segment->Select( 0 ) )
3422             {
3423                 msg_Err( p_demux, "Failed to select new segment" );
3424                 delete block;
3425                 break;
3426             }
3427             delete block;
3428             continue;
3429         }
3430
3431 #if LIBMATROSKA_VERSION >= 0x000800
3432         BlockDecode( p_demux, block, simpleblock, p_sys->i_pts, i_block_duration, i_block_ref1 >= 0 || i_block_ref2 > 0 );
3433 #else
3434         BlockDecode( p_demux, block, p_sys->i_pts, i_block_duration, i_block_ref1 >= 0 || i_block_ref2 > 0 );
3435 #endif
3436
3437         delete block;
3438         i_block_count++;
3439
3440         // TODO optimize when there is need to leave or when seeking has been called
3441         if( i_block_count > 5 )
3442         {
3443             i_return = 1;
3444             break;
3445         }
3446     }
3447
3448     vlc_mutex_unlock( &p_sys->lock_demuxer );
3449
3450     return i_return;
3451 }
3452
3453
3454
3455 /*****************************************************************************
3456  * Stream managment
3457  *****************************************************************************/
3458 vlc_stream_io_callback::vlc_stream_io_callback( stream_t *s_, vlc_bool_t b_owner_ )
3459 {
3460     s = s_;
3461     b_owner = b_owner_;
3462     mb_eof = VLC_FALSE;
3463 }
3464
3465 uint32 vlc_stream_io_callback::read( void *p_buffer, size_t i_size )
3466 {
3467     if( i_size <= 0 || mb_eof )
3468     {
3469         return 0;
3470     }
3471
3472     return stream_Read( s, p_buffer, i_size );
3473 }
3474 void vlc_stream_io_callback::setFilePointer(int64_t i_offset, seek_mode mode )
3475 {
3476     int64_t i_pos;
3477
3478     switch( mode )
3479     {
3480         case seek_beginning:
3481             i_pos = i_offset;
3482             break;
3483         case seek_end:
3484             i_pos = stream_Size( s ) - i_offset;
3485             break;
3486         default:
3487             i_pos= stream_Tell( s ) + i_offset;
3488             break;
3489     }
3490
3491     if( i_pos < 0 || i_pos >= stream_Size( s ) )
3492     {
3493         mb_eof = VLC_TRUE;
3494         return;
3495     }
3496
3497     mb_eof = VLC_FALSE;
3498     if( stream_Seek( s, i_pos ) )
3499     {
3500         mb_eof = VLC_TRUE;
3501     }
3502     return;
3503 }
3504 size_t vlc_stream_io_callback::write( const void *p_buffer, size_t i_size )
3505 {
3506     return 0;
3507 }
3508 uint64 vlc_stream_io_callback::getFilePointer( void )
3509 {
3510     if ( s == NULL )
3511         return 0;
3512     return stream_Tell( s );
3513 }
3514 void vlc_stream_io_callback::close( void )
3515 {
3516     return;
3517 }
3518
3519
3520 /*****************************************************************************
3521  * Ebml Stream parser
3522  *****************************************************************************/
3523 EbmlParser::EbmlParser( EbmlStream *es, EbmlElement *el_start, demux_t *p_demux )
3524 {
3525     int i;
3526
3527     m_es = es;
3528     m_got = NULL;
3529     m_el[0] = el_start;
3530     mi_remain_size[0] = el_start->GetSize();
3531
3532     for( i = 1; i < 6; i++ )
3533     {
3534         m_el[i] = NULL;
3535     }
3536     mi_level = 1;
3537     mi_user_level = 1;
3538     mb_keep = VLC_FALSE;
3539     mb_dummy = config_GetInt( p_demux, "mkv-use-dummy" );
3540 }
3541
3542 EbmlParser::~EbmlParser( void )
3543 {
3544     int i;
3545
3546     for( i = 1; i < mi_level; i++ )
3547     {
3548         if( !mb_keep )
3549         {
3550             delete m_el[i];
3551         }
3552         mb_keep = VLC_FALSE;
3553     }
3554 }
3555
3556 EbmlElement* EbmlParser::UnGet( uint64 i_block_pos, uint64 i_cluster_pos )
3557 {
3558     if ( mi_user_level > mi_level )
3559     {
3560         while ( mi_user_level != mi_level )
3561         {
3562             delete m_el[mi_user_level];
3563             m_el[mi_user_level] = NULL;
3564             mi_user_level--;
3565         }
3566     }
3567     m_got = NULL;
3568     mb_keep = VLC_FALSE;
3569     if ( m_el[1]->GetElementPosition() == i_cluster_pos )
3570     {
3571         m_es->I_O().setFilePointer( i_block_pos, seek_beginning );
3572         return (EbmlMaster*) m_el[1];
3573     }
3574     else
3575     {
3576         // seek to the previous Cluster
3577         m_es->I_O().setFilePointer( i_cluster_pos, seek_beginning );
3578         mi_level--;
3579         mi_user_level--;
3580         delete m_el[mi_level];
3581         m_el[mi_level] = NULL;
3582         return NULL;
3583     }
3584 }
3585
3586 void EbmlParser::Up( void )
3587 {
3588     if( mi_user_level == mi_level )
3589     {
3590         fprintf( stderr," arrrrrrrrrrrrrg Up cannot escape itself\n" );
3591     }
3592
3593     mi_user_level--;
3594 }
3595
3596 void EbmlParser::Down( void )
3597 {
3598     mi_user_level++;
3599     mi_level++;
3600 }
3601
3602 void EbmlParser::Keep( void )
3603 {
3604     mb_keep = VLC_TRUE;
3605 }
3606
3607 int EbmlParser::GetLevel( void )
3608 {
3609     return mi_user_level;
3610 }
3611
3612 void EbmlParser::Reset( demux_t *p_demux )
3613 {
3614     while ( mi_level > 0)
3615     {
3616         delete m_el[mi_level];
3617         m_el[mi_level] = NULL;
3618         mi_level--;
3619     }
3620     mi_user_level = mi_level = 1;
3621 #if LIBEBML_VERSION >= 0x000704
3622     // a little faster and cleaner
3623     m_es->I_O().setFilePointer( static_cast<KaxSegment*>(m_el[0])->GetGlobalPosition(0) );
3624 #else
3625     m_es->I_O().setFilePointer( m_el[0]->GetElementPosition() + m_el[0]->ElementSize(true) - m_el[0]->GetSize() );
3626 #endif
3627     mb_dummy = config_GetInt( p_demux, "mkv-use-dummy" );
3628 }
3629
3630 EbmlElement *EbmlParser::Get( void )
3631 {
3632     int i_ulev = 0;
3633
3634     if( mi_user_level != mi_level )
3635     {
3636         return NULL;
3637     }
3638     if( m_got )
3639     {
3640         EbmlElement *ret = m_got;
3641         m_got = NULL;
3642
3643         return ret;
3644     }
3645
3646     if( m_el[mi_level] )
3647     {
3648         m_el[mi_level]->SkipData( *m_es, m_el[mi_level]->Generic().Context );
3649         if( !mb_keep )
3650         {
3651             delete m_el[mi_level];
3652         }
3653         mb_keep = VLC_FALSE;
3654     }
3655
3656     m_el[mi_level] = m_es->FindNextElement( m_el[mi_level - 1]->Generic().Context, i_ulev, 0xFFFFFFFFL, mb_dummy != 0, 1 );
3657 //    mi_remain_size[mi_level] = m_el[mi_level]->GetSize();
3658     if( i_ulev > 0 )
3659     {
3660         while( i_ulev > 0 )
3661         {
3662             if( mi_level == 1 )
3663             {
3664                 mi_level = 0;
3665                 return NULL;
3666             }
3667
3668             delete m_el[mi_level - 1];
3669             m_got = m_el[mi_level -1] = m_el[mi_level];
3670             m_el[mi_level] = NULL;
3671
3672             mi_level--;
3673             i_ulev--;
3674         }
3675         return NULL;
3676     }
3677     else if( m_el[mi_level] == NULL )
3678     {
3679         fprintf( stderr," m_el[mi_level] == NULL\n" );
3680     }
3681
3682     return m_el[mi_level];
3683 }
3684
3685
3686 /*****************************************************************************
3687  * Tools
3688  *  * LoadCues : load the cues element and update index
3689  *
3690  *  * LoadTags : load ... the tags element
3691  *
3692  *  * InformationCreate : create all information, load tags if present
3693  *
3694  *****************************************************************************/
3695 void matroska_segment_c::LoadCues( )
3696 {
3697     int64_t     i_sav_position = es.I_O().getFilePointer();
3698     EbmlParser  *ep;
3699     EbmlElement *el, *cues;
3700
3701     /* *** Load the cue if found *** */
3702     if( i_cues_position < 0 )
3703     {
3704         msg_Warn( &sys.demuxer, "no cues/empty cues found->seek won't be precise" );
3705
3706 //        IndexAppendCluster( cluster );
3707     }
3708
3709     vlc_bool_t b_seekable;
3710
3711     stream_Control( sys.demuxer.s, STREAM_CAN_FASTSEEK, &b_seekable );
3712     if( !b_seekable )
3713         return;
3714
3715     msg_Dbg( &sys.demuxer, "loading cues" );
3716     es.I_O().setFilePointer( i_cues_position, seek_beginning );
3717     cues = es.FindNextID( KaxCues::ClassInfos, 0xFFFFFFFFL);
3718
3719     if( cues == NULL )
3720     {
3721         msg_Err( &sys.demuxer, "cannot load cues (broken seekhead or file)" );
3722         es.I_O().setFilePointer( i_sav_position, seek_beginning );
3723         return;
3724     }
3725
3726     ep = new EbmlParser( &es, cues, &sys.demuxer );
3727     while( ( el = ep->Get() ) != NULL )
3728     {
3729         if( MKV_IS_ID( el, KaxCuePoint ) )
3730         {
3731 #define idx p_indexes[i_index]
3732
3733             idx.i_track       = -1;
3734             idx.i_block_number= -1;
3735             idx.i_position    = -1;
3736             idx.i_time        = 0;
3737             idx.b_key         = VLC_TRUE;
3738
3739             ep->Down();
3740             while( ( el = ep->Get() ) != NULL )
3741             {
3742                 if( MKV_IS_ID( el, KaxCueTime ) )
3743                 {
3744                     KaxCueTime &ctime = *(KaxCueTime*)el;
3745
3746                     ctime.ReadData( es.I_O() );
3747
3748                     idx.i_time = uint64( ctime ) * i_timescale / (mtime_t)1000;
3749                 }
3750                 else if( MKV_IS_ID( el, KaxCueTrackPositions ) )
3751                 {
3752                     ep->Down();
3753                     while( ( el = ep->Get() ) != NULL )
3754                     {
3755                         if( MKV_IS_ID( el, KaxCueTrack ) )
3756                         {
3757                             KaxCueTrack &ctrack = *(KaxCueTrack*)el;
3758
3759                             ctrack.ReadData( es.I_O() );
3760                             idx.i_track = uint16( ctrack );
3761                         }
3762                         else if( MKV_IS_ID( el, KaxCueClusterPosition ) )
3763                         {
3764                             KaxCueClusterPosition &ccpos = *(KaxCueClusterPosition*)el;
3765
3766                             ccpos.ReadData( es.I_O() );
3767                             idx.i_position = segment->GetGlobalPosition( uint64( ccpos ) );
3768                         }
3769                         else if( MKV_IS_ID( el, KaxCueBlockNumber ) )
3770                         {
3771                             KaxCueBlockNumber &cbnum = *(KaxCueBlockNumber*)el;
3772
3773                             cbnum.ReadData( es.I_O() );
3774                             idx.i_block_number = uint32( cbnum );
3775                         }
3776                         else
3777                         {
3778                             msg_Dbg( &sys.demuxer, "         * Unknown (%s)", typeid(*el).name() );
3779                         }
3780                     }
3781                     ep->Up();
3782                 }
3783                 else
3784                 {
3785                     msg_Dbg( &sys.demuxer, "     * Unknown (%s)", typeid(*el).name() );
3786                 }
3787             }
3788             ep->Up();
3789
3790 #if 0
3791             msg_Dbg( &sys.demuxer, " * added time="I64Fd" pos="I64Fd
3792                      " track=%d bnum=%d", idx.i_time, idx.i_position,
3793                      idx.i_track, idx.i_block_number );
3794 #endif
3795
3796             i_index++;
3797             if( i_index >= i_index_max )
3798             {
3799                 i_index_max += 1024;
3800                 p_indexes = (mkv_index_t*)realloc( p_indexes, sizeof( mkv_index_t ) * i_index_max );
3801             }
3802 #undef idx
3803         }
3804         else
3805         {
3806             msg_Dbg( &sys.demuxer, " * Unknown (%s)", typeid(*el).name() );
3807         }
3808     }
3809     delete ep;
3810     delete cues;
3811
3812     b_cues = VLC_TRUE;
3813
3814     msg_Dbg( &sys.demuxer, "loading cues done." );
3815     es.I_O().setFilePointer( i_sav_position, seek_beginning );
3816 }
3817
3818 void matroska_segment_c::LoadTags( )
3819 {
3820     int64_t     i_sav_position = es.I_O().getFilePointer();
3821     EbmlParser  *ep;
3822     EbmlElement *el, *tags;
3823
3824     msg_Dbg( &sys.demuxer, "loading tags" );
3825     es.I_O().setFilePointer( i_tags_position, seek_beginning );
3826     tags = es.FindNextID( KaxTags::ClassInfos, 0xFFFFFFFFL);
3827
3828     if( tags == NULL )
3829     {
3830         msg_Err( &sys.demuxer, "cannot load tags (broken seekhead or file)" );
3831         es.I_O().setFilePointer( i_sav_position, seek_beginning );
3832         return;
3833     }
3834
3835     msg_Dbg( &sys.demuxer, "Tags" );
3836     ep = new EbmlParser( &es, tags, &sys.demuxer );
3837     while( ( el = ep->Get() ) != NULL )
3838     {
3839         if( MKV_IS_ID( el, KaxTag ) )
3840         {
3841             msg_Dbg( &sys.demuxer, "+ Tag" );
3842             ep->Down();
3843             while( ( el = ep->Get() ) != NULL )
3844             {
3845                 if( MKV_IS_ID( el, KaxTagTargets ) )
3846                 {
3847                     msg_Dbg( &sys.demuxer, "|   + Targets" );
3848                     ep->Down();
3849                     while( ( el = ep->Get() ) != NULL )
3850                     {
3851                         msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid( *el ).name() );
3852                     }
3853                     ep->Up();
3854                 }
3855                 else if( MKV_IS_ID( el, KaxTagGeneral ) )
3856                 {
3857                     msg_Dbg( &sys.demuxer, "|   + General" );
3858                     ep->Down();
3859                     while( ( el = ep->Get() ) != NULL )
3860                     {
3861                         msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid( *el ).name() );
3862                     }
3863                     ep->Up();
3864                 }
3865                 else if( MKV_IS_ID( el, KaxTagGenres ) )
3866                 {
3867                     msg_Dbg( &sys.demuxer, "|   + Genres" );
3868                     ep->Down();
3869                     while( ( el = ep->Get() ) != NULL )
3870                     {
3871                         msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid( *el ).name() );
3872                     }
3873                     ep->Up();
3874                 }
3875                 else if( MKV_IS_ID( el, KaxTagAudioSpecific ) )
3876                 {
3877                     msg_Dbg( &sys.demuxer, "|   + Audio Specific" );
3878                     ep->Down();
3879                     while( ( el = ep->Get() ) != NULL )
3880                     {
3881                         msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid( *el ).name() );
3882                     }
3883                     ep->Up();
3884                 }
3885                 else if( MKV_IS_ID( el, KaxTagImageSpecific ) )
3886                 {
3887                     msg_Dbg( &sys.demuxer, "|   + Images Specific" );
3888                     ep->Down();
3889                     while( ( el = ep->Get() ) != NULL )
3890                     {
3891                         msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid( *el ).name() );
3892                     }
3893                     ep->Up();
3894                 }
3895                 else if( MKV_IS_ID( el, KaxTagMultiComment ) )
3896                 {
3897                     msg_Dbg( &sys.demuxer, "|   + Multi Comment" );
3898                 }
3899                 else if( MKV_IS_ID( el, KaxTagMultiCommercial ) )
3900                 {
3901                     msg_Dbg( &sys.demuxer, "|   + Multi Commercial" );
3902                 }
3903                 else if( MKV_IS_ID( el, KaxTagMultiDate ) )
3904                 {
3905                     msg_Dbg( &sys.demuxer, "|   + Multi Date" );
3906                 }
3907                 else if( MKV_IS_ID( el, KaxTagMultiEntity ) )
3908                 {
3909                     msg_Dbg( &sys.demuxer, "|   + Multi Entity" );
3910                 }
3911                 else if( MKV_IS_ID( el, KaxTagMultiIdentifier ) )
3912                 {
3913                     msg_Dbg( &sys.demuxer, "|   + Multi Identifier" );
3914                 }
3915                 else if( MKV_IS_ID( el, KaxTagMultiLegal ) )
3916                 {
3917                     msg_Dbg( &sys.demuxer, "|   + Multi Legal" );
3918                 }
3919                 else if( MKV_IS_ID( el, KaxTagMultiTitle ) )
3920                 {
3921                     msg_Dbg( &sys.demuxer, "|   + Multi Title" );
3922                 }
3923                 else
3924                 {
3925                     msg_Dbg( &sys.demuxer, "|   + Unknown (%s)", typeid( *el ).name() );
3926                 }
3927             }
3928             ep->Up();
3929         }
3930         else
3931         {
3932             msg_Dbg( &sys.demuxer, "+ Unknown (%s)", typeid( *el ).name() );
3933         }
3934     }
3935     delete ep;
3936     delete tags;
3937
3938     msg_Dbg( &sys.demuxer, "loading tags done." );
3939     es.I_O().setFilePointer( i_sav_position, seek_beginning );
3940 }
3941
3942 /*****************************************************************************
3943  * ParseSeekHead:
3944  *****************************************************************************/
3945 void matroska_segment_c::ParseSeekHead( KaxSeekHead *seekhead )
3946 {
3947     EbmlElement *el;
3948     size_t i, j;
3949     int i_upper_level = 0;
3950
3951     msg_Dbg( &sys.demuxer, "|   + Seek head" );
3952
3953     /* Master elements */
3954     seekhead->Read( es, seekhead->Generic().Context, i_upper_level, el, true );
3955
3956     for( i = 0; i < seekhead->ListSize(); i++ )
3957     {
3958         EbmlElement *l = (*seekhead)[i];
3959
3960         if( MKV_IS_ID( l, KaxSeek ) )
3961         {
3962             EbmlMaster *sk = static_cast<EbmlMaster *>(l);
3963             EbmlId id = EbmlVoid::ClassInfos.GlobalId;
3964             int64_t i_pos = -1;
3965
3966             for( j = 0; j < sk->ListSize(); j++ )
3967             {
3968                 EbmlElement *l = (*sk)[j];
3969
3970                 if( MKV_IS_ID( l, KaxSeekID ) )
3971                 {
3972                     KaxSeekID &sid = *(KaxSeekID*)l;
3973                     id = EbmlId( sid.GetBuffer(), sid.GetSize() );
3974                 }
3975                 else if( MKV_IS_ID( l, KaxSeekPosition ) )
3976                 {
3977                     KaxSeekPosition &spos = *(KaxSeekPosition*)l;
3978                     i_pos = uint64( spos );
3979                 }
3980                 else
3981                 {
3982                     msg_Dbg( &sys.demuxer, "|   |   |   + Unknown (%s)", typeid(*l).name() );
3983                 }
3984             }
3985
3986             if( i_pos >= 0 )
3987             {
3988                 if( id == KaxCues::ClassInfos.GlobalId )
3989                 {
3990                     msg_Dbg( &sys.demuxer, "|   |   |   = cues at "I64Fd, i_pos );
3991                     i_cues_position = segment->GetGlobalPosition( i_pos );
3992                 }
3993                 else if( id == KaxChapters::ClassInfos.GlobalId )
3994                 {
3995                     msg_Dbg( &sys.demuxer, "|   |   |   = chapters at "I64Fd, i_pos );
3996                     i_chapters_position = segment->GetGlobalPosition( i_pos );
3997                 }
3998                 else if( id == KaxTags::ClassInfos.GlobalId )
3999                 {
4000                     msg_Dbg( &sys.demuxer, "|   |   |   = tags at "I64Fd, i_pos );
4001                     i_tags_position = segment->GetGlobalPosition( i_pos );
4002                 }
4003             }
4004         }
4005         else
4006         {
4007             msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid(*l).name() );
4008         }
4009     }
4010 }
4011
4012 /*****************************************************************************
4013  * ParseTrackEntry:
4014  *****************************************************************************/
4015 void matroska_segment_c::ParseTrackEntry( KaxTrackEntry *m )
4016 {
4017     size_t i, j, k, n;
4018     bool bSupported = true;
4019
4020     mkv_track_t *tk;
4021
4022     msg_Dbg( &sys.demuxer, "|   |   + Track Entry" );
4023
4024     tk = new mkv_track_t();
4025
4026     /* Init the track */
4027     memset( tk, 0, sizeof( mkv_track_t ) );
4028
4029     es_format_Init( &tk->fmt, UNKNOWN_ES, 0 );
4030     tk->fmt.psz_language = strdup("English");
4031     tk->fmt.psz_description = NULL;
4032
4033     tk->b_default = VLC_TRUE;
4034     tk->b_enabled = VLC_TRUE;
4035     tk->b_silent = VLC_FALSE;
4036     tk->i_number = tracks.size() - 1;
4037     tk->i_extra_data = 0;
4038     tk->p_extra_data = NULL;
4039     tk->psz_codec = NULL;
4040     tk->i_default_duration = 0;
4041     tk->f_timecodescale = 1.0;
4042
4043     tk->b_inited = VLC_FALSE;
4044     tk->i_data_init = 0;
4045     tk->p_data_init = NULL;
4046
4047     tk->psz_codec_name = NULL;
4048     tk->psz_codec_settings = NULL;
4049     tk->psz_codec_info_url = NULL;
4050     tk->psz_codec_download_url = NULL;
4051
4052     tk->i_compression_type = MATROSKA_COMPRESSION_NONE;
4053     tk->p_compression_data = NULL;
4054
4055     for( i = 0; i < m->ListSize(); i++ )
4056     {
4057         EbmlElement *l = (*m)[i];
4058
4059         if( MKV_IS_ID( l, KaxTrackNumber ) )
4060         {
4061             KaxTrackNumber &tnum = *(KaxTrackNumber*)l;
4062
4063             tk->i_number = uint32( tnum );
4064             msg_Dbg( &sys.demuxer, "|   |   |   + Track Number=%u", uint32( tnum ) );
4065         }
4066         else  if( MKV_IS_ID( l, KaxTrackUID ) )
4067         {
4068             KaxTrackUID &tuid = *(KaxTrackUID*)l;
4069
4070             msg_Dbg( &sys.demuxer, "|   |   |   + Track UID=%u",  uint32( tuid ) );
4071         }
4072         else  if( MKV_IS_ID( l, KaxTrackType ) )
4073         {
4074             char *psz_type;
4075             KaxTrackType &ttype = *(KaxTrackType*)l;
4076
4077             switch( uint8(ttype) )
4078             {
4079                 case track_audio:
4080                     psz_type = "audio";
4081                     tk->fmt.i_cat = AUDIO_ES;
4082                     break;
4083                 case track_video:
4084                     psz_type = "video";
4085                     tk->fmt.i_cat = VIDEO_ES;
4086                     break;
4087                 case track_subtitle:
4088                     psz_type = "subtitle";
4089                     tk->fmt.i_cat = SPU_ES;
4090                     break;
4091                 case track_buttons:
4092                     psz_type = "buttons";
4093                     tk->fmt.i_cat = SPU_ES;
4094                     break;
4095                 default:
4096                     psz_type = "unknown";
4097                     tk->fmt.i_cat = UNKNOWN_ES;
4098                     break;
4099             }
4100
4101             msg_Dbg( &sys.demuxer, "|   |   |   + Track Type=%s", psz_type );
4102         }
4103 //        else  if( EbmlId( *l ) == KaxTrackFlagEnabled::ClassInfos.GlobalId )
4104 //        {
4105 //            KaxTrackFlagEnabled &fenb = *(KaxTrackFlagEnabled*)l;
4106
4107 //            tk->b_enabled = uint32( fenb );
4108 //            msg_Dbg( &sys.demuxer, "|   |   |   + Track Enabled=%u",
4109 //                     uint32( fenb )  );
4110 //        }
4111         else  if( MKV_IS_ID( l, KaxTrackFlagDefault ) )
4112         {
4113             KaxTrackFlagDefault &fdef = *(KaxTrackFlagDefault*)l;
4114
4115             tk->b_default = uint32( fdef );
4116             msg_Dbg( &sys.demuxer, "|   |   |   + Track Default=%u", uint32( fdef )  );
4117         }
4118         else  if( MKV_IS_ID( l, KaxTrackFlagLacing ) )
4119         {
4120             KaxTrackFlagLacing &lac = *(KaxTrackFlagLacing*)l;
4121
4122             msg_Dbg( &sys.demuxer, "|   |   |   + Track Lacing=%d", uint32( lac ) );
4123         }
4124         else  if( MKV_IS_ID( l, KaxTrackMinCache ) )
4125         {
4126             KaxTrackMinCache &cmin = *(KaxTrackMinCache*)l;
4127
4128             msg_Dbg( &sys.demuxer, "|   |   |   + Track MinCache=%d", uint32( cmin ) );
4129         }
4130         else  if( MKV_IS_ID( l, KaxTrackMaxCache ) )
4131         {
4132             KaxTrackMaxCache &cmax = *(KaxTrackMaxCache*)l;
4133
4134             msg_Dbg( &sys.demuxer, "|   |   |   + Track MaxCache=%d", uint32( cmax ) );
4135         }
4136         else  if( MKV_IS_ID( l, KaxTrackDefaultDuration ) )
4137         {
4138             KaxTrackDefaultDuration &defd = *(KaxTrackDefaultDuration*)l;
4139
4140             tk->i_default_duration = uint64(defd);
4141             msg_Dbg( &sys.demuxer, "|   |   |   + Track Default Duration="I64Fd, uint64(defd) );
4142         }
4143         else  if( MKV_IS_ID( l, KaxTrackTimecodeScale ) )
4144         {
4145             KaxTrackTimecodeScale &ttcs = *(KaxTrackTimecodeScale*)l;
4146
4147             tk->f_timecodescale = float( ttcs );
4148             msg_Dbg( &sys.demuxer, "|   |   |   + Track TimeCodeScale=%f", tk->f_timecodescale );
4149         }
4150         else if( MKV_IS_ID( l, KaxTrackName ) )
4151         {
4152             KaxTrackName &tname = *(KaxTrackName*)l;
4153
4154             tk->fmt.psz_description = ToUTF8( UTFstring( tname ) );
4155             msg_Dbg( &sys.demuxer, "|   |   |   + Track Name=%s", tk->fmt.psz_description );
4156         }
4157         else  if( MKV_IS_ID( l, KaxTrackLanguage ) )
4158         {
4159             KaxTrackLanguage &lang = *(KaxTrackLanguage*)l;
4160
4161             if ( tk->fmt.psz_language != NULL )
4162                 free( tk->fmt.psz_language );
4163             tk->fmt.psz_language = strdup( string( lang ).c_str() );
4164             msg_Dbg( &sys.demuxer,
4165                      "|   |   |   + Track Language=`%s'", tk->fmt.psz_language );
4166         }
4167         else  if( MKV_IS_ID( l, KaxCodecID ) )
4168         {
4169             KaxCodecID &codecid = *(KaxCodecID*)l;
4170
4171             tk->psz_codec = strdup( string( codecid ).c_str() );
4172             msg_Dbg( &sys.demuxer, "|   |   |   + Track CodecId=%s", string( codecid ).c_str() );
4173         }
4174         else  if( MKV_IS_ID( l, KaxCodecPrivate ) )
4175         {
4176             KaxCodecPrivate &cpriv = *(KaxCodecPrivate*)l;
4177
4178             tk->i_extra_data = cpriv.GetSize();
4179             if( tk->i_extra_data > 0 )
4180             {
4181                 tk->p_extra_data = (uint8_t*)malloc( tk->i_extra_data );
4182                 memcpy( tk->p_extra_data, cpriv.GetBuffer(), tk->i_extra_data );
4183             }
4184             msg_Dbg( &sys.demuxer, "|   |   |   + Track CodecPrivate size="I64Fd, cpriv.GetSize() );
4185         }
4186         else if( MKV_IS_ID( l, KaxCodecName ) )
4187         {
4188             KaxCodecName &cname = *(KaxCodecName*)l;
4189
4190             tk->psz_codec_name = ToUTF8( UTFstring( cname ) );
4191             msg_Dbg( &sys.demuxer, "|   |   |   + Track Codec Name=%s", tk->psz_codec_name );
4192         }
4193         else if( MKV_IS_ID( l, KaxContentEncodings ) )
4194         {
4195             EbmlMaster *cencs = static_cast<EbmlMaster*>(l);
4196             MkvTree( sys.demuxer, 3, "Content Encodings" );
4197             if ( cencs->ListSize() > 1 )
4198             {
4199                 msg_Err( &sys.demuxer, "Multiple Compression method not supported" );
4200                 bSupported = false;
4201             }
4202             for( j = 0; j < cencs->ListSize(); j++ )
4203             {
4204                 EbmlElement *l2 = (*cencs)[j];
4205                 if( MKV_IS_ID( l2, KaxContentEncoding ) )
4206                 {
4207                     MkvTree( sys.demuxer, 4, "Content Encoding" );
4208                     EbmlMaster *cenc = static_cast<EbmlMaster*>(l2);
4209                     for( k = 0; k < cenc->ListSize(); k++ )
4210                     {
4211                         EbmlElement *l3 = (*cenc)[k];
4212                         if( MKV_IS_ID( l3, KaxContentEncodingOrder ) )
4213                         {
4214                             KaxContentEncodingOrder &encord = *(KaxContentEncodingOrder*)l3;
4215                             MkvTree( sys.demuxer, 5, "Order: %i", uint32( encord ) );
4216                         }
4217                         else if( MKV_IS_ID( l3, KaxContentEncodingScope ) )
4218                         {
4219                             KaxContentEncodingScope &encscope = *(KaxContentEncodingScope*)l3;
4220                             MkvTree( sys.demuxer, 5, "Scope: %i", uint32( encscope ) );
4221                         }
4222                         else if( MKV_IS_ID( l3, KaxContentEncodingType ) )
4223                         {
4224                             KaxContentEncodingType &enctype = *(KaxContentEncodingType*)l3;
4225                             MkvTree( sys.demuxer, 5, "Type: %i", uint32( enctype ) );
4226                         }
4227                         else if( MKV_IS_ID( l3, KaxContentCompression ) )
4228                         {
4229                             EbmlMaster *compr = static_cast<EbmlMaster*>(l3);
4230                             MkvTree( sys.demuxer, 5, "Content Compression" );
4231                             for( n = 0; n < compr->ListSize(); n++ )
4232                             {
4233                                 EbmlElement *l4 = (*compr)[n];
4234                                 if( MKV_IS_ID( l4, KaxContentCompAlgo ) )
4235                                 {
4236                                     KaxContentCompAlgo &compalg = *(KaxContentCompAlgo*)l4;
4237                                     MkvTree( sys.demuxer, 6, "Compression Algorithm: %i", uint32(compalg) );
4238                                     tk->i_compression_type = uint32( compalg );
4239                                     if ( ( tk->i_compression_type != MATROSKA_COMPRESSION_ZLIB ) &&
4240                                          ( tk->i_compression_type != MATROSKA_COMPRESSION_HEADER ) )
4241                                     {
4242                                         msg_Err( &sys.demuxer, "Track Compression method %d not supported", tk->i_compression_type );
4243                                         bSupported = false;
4244                                     }
4245                                 }
4246                                 else if( MKV_IS_ID( l4, KaxContentCompSettings ) )
4247                                 {
4248                                     tk->p_compression_data = new KaxContentCompSettings( *(KaxContentCompSettings*)l4 );
4249                                 }
4250                                 else
4251                                 {
4252                                     MkvTree( sys.demuxer, 6, "Unknown (%s)", typeid(*l4).name() );
4253                                 }
4254                             }
4255                         }
4256
4257                         else
4258                         {
4259                             MkvTree( sys.demuxer, 5, "Unknown (%s)", typeid(*l3).name() );
4260                         }
4261                     }
4262
4263                 }
4264                 else
4265                 {
4266                     MkvTree( sys.demuxer, 4, "Unknown (%s)", typeid(*l2).name() );
4267                 }
4268             }
4269
4270         }
4271 //        else if( EbmlId( *l ) == KaxCodecSettings::ClassInfos.GlobalId )
4272 //        {
4273 //            KaxCodecSettings &cset = *(KaxCodecSettings*)l;
4274
4275 //            tk->psz_codec_settings = ToUTF8( UTFstring( cset ) );
4276 //            msg_Dbg( &sys.demuxer, "|   |   |   + Track Codec Settings=%s", tk->psz_codec_settings );
4277 //        }
4278 //        else if( EbmlId( *l ) == KaxCodecInfoURL::ClassInfos.GlobalId )
4279 //        {
4280 //            KaxCodecInfoURL &ciurl = *(KaxCodecInfoURL*)l;
4281
4282 //            tk->psz_codec_info_url = strdup( string( ciurl ).c_str() );
4283 //            msg_Dbg( &sys.demuxer, "|   |   |   + Track Codec Info URL=%s", tk->psz_codec_info_url );
4284 //        }
4285 //        else if( EbmlId( *l ) == KaxCodecDownloadURL::ClassInfos.GlobalId )
4286 //        {
4287 //            KaxCodecDownloadURL &cdurl = *(KaxCodecDownloadURL*)l;
4288
4289 //            tk->psz_codec_download_url = strdup( string( cdurl ).c_str() );
4290 //            msg_Dbg( &sys.demuxer, "|   |   |   + Track Codec Info URL=%s", tk->psz_codec_download_url );
4291 //        }
4292 //        else if( EbmlId( *l ) == KaxCodecDecodeAll::ClassInfos.GlobalId )
4293 //        {
4294 //            KaxCodecDecodeAll &cdall = *(KaxCodecDecodeAll*)l;
4295
4296 //            msg_Dbg( &sys.demuxer, "|   |   |   + Track Codec Decode All=%u <== UNUSED", uint8( cdall ) );
4297 //        }
4298 //        else if( EbmlId( *l ) == KaxTrackOverlay::ClassInfos.GlobalId )
4299 //        {
4300 //            KaxTrackOverlay &tovr = *(KaxTrackOverlay*)l;
4301
4302 //            msg_Dbg( &sys.demuxer, "|   |   |   + Track Overlay=%u <== UNUSED", uint32( tovr ) );
4303 //        }
4304         else  if( MKV_IS_ID( l, KaxTrackVideo ) )
4305         {
4306             EbmlMaster *tkv = static_cast<EbmlMaster*>(l);
4307             unsigned int j;
4308
4309             msg_Dbg( &sys.demuxer, "|   |   |   + Track Video" );
4310             tk->f_fps = 0.0;
4311
4312             tk->fmt.video.i_frame_rate_base = (unsigned int)(tk->i_default_duration / 1000);
4313             tk->fmt.video.i_frame_rate = 1000000;
4314
4315             for( j = 0; j < tkv->ListSize(); j++ )
4316             {
4317                 EbmlElement *l = (*tkv)[j];
4318 //                if( EbmlId( *el4 ) == KaxVideoFlagInterlaced::ClassInfos.GlobalId )
4319 //                {
4320 //                    KaxVideoFlagInterlaced &fint = *(KaxVideoFlagInterlaced*)el4;
4321
4322 //                    msg_Dbg( &sys.demuxer, "|   |   |   |   + Track Video Interlaced=%u", uint8( fint ) );
4323 //                }
4324 //                else if( EbmlId( *el4 ) == KaxVideoStereoMode::ClassInfos.GlobalId )
4325 //                {
4326 //                    KaxVideoStereoMode &stereo = *(KaxVideoStereoMode*)el4;
4327
4328 //                    msg_Dbg( &sys.demuxer, "|   |   |   |   + Track Video Stereo Mode=%u", uint8( stereo ) );
4329 //                }
4330 //                else
4331                 if( MKV_IS_ID( l, KaxVideoPixelWidth ) )
4332                 {
4333                     KaxVideoPixelWidth &vwidth = *(KaxVideoPixelWidth*)l;
4334
4335                     tk->fmt.video.i_width += uint16( vwidth );
4336                     msg_Dbg( &sys.demuxer, "|   |   |   |   + width=%d", uint16( vwidth ) );
4337                 }
4338                 else if( MKV_IS_ID( l, KaxVideoPixelHeight ) )
4339                 {
4340                     KaxVideoPixelWidth &vheight = *(KaxVideoPixelWidth*)l;
4341
4342                     tk->fmt.video.i_height += uint16( vheight );
4343                     msg_Dbg( &sys.demuxer, "|   |   |   |   + height=%d", uint16( vheight ) );
4344                 }
4345                 else if( MKV_IS_ID( l, KaxVideoDisplayWidth ) )
4346                 {
4347                     KaxVideoDisplayWidth &vwidth = *(KaxVideoDisplayWidth*)l;
4348
4349                     tk->fmt.video.i_visible_width = uint16( vwidth );
4350                     msg_Dbg( &sys.demuxer, "|   |   |   |   + display width=%d", uint16( vwidth ) );
4351                 }
4352                 else if( MKV_IS_ID( l, KaxVideoDisplayHeight ) )
4353                 {
4354                     KaxVideoDisplayWidth &vheight = *(KaxVideoDisplayWidth*)l;
4355
4356                     tk->fmt.video.i_visible_height = uint16( vheight );
4357                     msg_Dbg( &sys.demuxer, "|   |   |   |   + display height=%d", uint16( vheight ) );
4358                 }
4359                 else if( MKV_IS_ID( l, KaxVideoPixelCropBottom ) )
4360                 {
4361                     KaxVideoPixelCropBottom &cropval = *(KaxVideoPixelCropBottom*)l;
4362
4363                     tk->fmt.video.i_height -= uint16( cropval );
4364                     msg_Dbg( &sys.demuxer, "|   |   |   |   + crop pixel bottom=%d", uint16( cropval ) );
4365                 }
4366                 else if( MKV_IS_ID( l, KaxVideoPixelCropTop ) )
4367                 {
4368                     KaxVideoPixelCropTop &cropval = *(KaxVideoPixelCropTop*)l;
4369
4370                     tk->fmt.video.i_height -= uint16( cropval );
4371                     tk->fmt.video.i_y_offset += uint16( cropval );
4372                     msg_Dbg( &sys.demuxer, "|   |   |   |   + crop pixel top=%d", uint16( cropval ) );
4373                 }
4374                 else if( MKV_IS_ID( l, KaxVideoPixelCropRight ) )
4375                 {
4376                     KaxVideoPixelCropRight &cropval = *(KaxVideoPixelCropRight*)l;
4377
4378                     tk->fmt.video.i_width -= uint16( cropval );
4379                     msg_Dbg( &sys.demuxer, "|   |   |   |   + crop pixel right=%d", uint16( cropval ) );
4380                 }
4381                 else if( MKV_IS_ID( l, KaxVideoPixelCropLeft ) )
4382                 {
4383                     KaxVideoPixelCropLeft &cropval = *(KaxVideoPixelCropLeft*)l;
4384
4385                     tk->fmt.video.i_width -= uint16( cropval );
4386                     tk->fmt.video.i_x_offset += uint16( cropval );
4387                     msg_Dbg( &sys.demuxer, "|   |   |   |   + crop pixel left=%d", uint16( cropval ) );
4388                 }
4389                 else if( MKV_IS_ID( l, KaxVideoFrameRate ) )
4390                 {
4391                     KaxVideoFrameRate &vfps = *(KaxVideoFrameRate*)l;
4392
4393                     tk->f_fps = float( vfps );
4394                     msg_Dbg( &sys.demuxer, "   |   |   |   + fps=%f", float( vfps ) );
4395                 }
4396 //                else if( EbmlId( *l ) == KaxVideoDisplayUnit::ClassInfos.GlobalId )
4397 //                {
4398 //                     KaxVideoDisplayUnit &vdmode = *(KaxVideoDisplayUnit*)l;
4399
4400 //                    msg_Dbg( &sys.demuxer, "|   |   |   |   + Track Video Display Unit=%s",
4401 //                             uint8( vdmode ) == 0 ? "pixels" : ( uint8( vdmode ) == 1 ? "centimeters": "inches" ) );
4402 //                }
4403 //                else if( EbmlId( *l ) == KaxVideoAspectRatio::ClassInfos.GlobalId )
4404 //                {
4405 //                    KaxVideoAspectRatio &ratio = *(KaxVideoAspectRatio*)l;
4406
4407 //                    msg_Dbg( &sys.demuxer, "   |   |   |   + Track Video Aspect Ratio Type=%u", uint8( ratio ) );
4408 //                }
4409 //                else if( EbmlId( *l ) == KaxVideoGamma::ClassInfos.GlobalId )
4410 //                {
4411 //                    KaxVideoGamma &gamma = *(KaxVideoGamma*)l;
4412
4413 //                    msg_Dbg( &sys.demuxer, "   |   |   |   + fps=%f", float( gamma ) );
4414 //                }
4415                 else
4416                 {
4417                     msg_Dbg( &sys.demuxer, "|   |   |   |   + Unknown (%s)", typeid(*l).name() );
4418                 }
4419             }
4420             if ( tk->fmt.video.i_visible_height && tk->fmt.video.i_visible_width )
4421                 tk->fmt.video.i_aspect = VOUT_ASPECT_FACTOR * tk->fmt.video.i_visible_width / tk->fmt.video.i_visible_height;
4422         }
4423         else  if( MKV_IS_ID( l, KaxTrackAudio ) )
4424         {
4425             EbmlMaster *tka = static_cast<EbmlMaster*>(l);
4426             unsigned int j;
4427
4428             msg_Dbg( &sys.demuxer, "|   |   |   + Track Audio" );
4429
4430             for( j = 0; j < tka->ListSize(); j++ )
4431             {
4432                 EbmlElement *l = (*tka)[j];
4433
4434                 if( MKV_IS_ID( l, KaxAudioSamplingFreq ) )
4435                 {
4436                     KaxAudioSamplingFreq &afreq = *(KaxAudioSamplingFreq*)l;
4437
4438                     tk->i_original_rate = tk->fmt.audio.i_rate = (int)float( afreq );
4439                     msg_Dbg( &sys.demuxer, "|   |   |   |   + afreq=%d", tk->fmt.audio.i_rate );
4440                 }
4441                 else if( MKV_IS_ID( l, KaxAudioOutputSamplingFreq ) )
4442                 {
4443                     KaxAudioOutputSamplingFreq &afreq = *(KaxAudioOutputSamplingFreq*)l;
4444
4445                     tk->fmt.audio.i_rate = (int)float( afreq );
4446                     msg_Dbg( &sys.demuxer, "|   |   |   |   + aoutfreq=%d", tk->fmt.audio.i_rate );
4447                 }
4448                 else if( MKV_IS_ID( l, KaxAudioChannels ) )
4449                 {
4450                     KaxAudioChannels &achan = *(KaxAudioChannels*)l;
4451
4452                     tk->fmt.audio.i_channels = uint8( achan );
4453                     msg_Dbg( &sys.demuxer, "|   |   |   |   + achan=%u", uint8( achan ) );
4454                 }
4455                 else if( MKV_IS_ID( l, KaxAudioBitDepth ) )
4456                 {
4457                     KaxAudioBitDepth &abits = *(KaxAudioBitDepth*)l;
4458
4459                     tk->fmt.audio.i_bitspersample = uint8( abits );
4460                     msg_Dbg( &sys.demuxer, "|   |   |   |   + abits=%u", uint8( abits ) );
4461                 }
4462                 else
4463                 {
4464                     msg_Dbg( &sys.demuxer, "|   |   |   |   + Unknown (%s)", typeid(*l).name() );
4465                 }
4466             }
4467         }
4468         else
4469         {
4470             msg_Dbg( &sys.demuxer, "|   |   |   + Unknown (%s)",
4471                      typeid(*l).name() );
4472         }
4473     }
4474
4475     if ( bSupported )
4476     {
4477         tracks.push_back( tk );
4478     }
4479     else
4480     {
4481         msg_Err( &sys.demuxer, "Track Entry %d not supported", tk->i_number );
4482         delete tk;
4483     }
4484 }
4485
4486 /*****************************************************************************
4487  * ParseTracks:
4488  *****************************************************************************/
4489 void matroska_segment_c::ParseTracks( KaxTracks *tracks )
4490 {
4491     EbmlElement *el;
4492     unsigned int i;
4493     int i_upper_level = 0;
4494
4495     msg_Dbg( &sys.demuxer, "|   + Tracks" );
4496
4497     /* Master elements */
4498     tracks->Read( es, tracks->Generic().Context, i_upper_level, el, true );
4499
4500     for( i = 0; i < tracks->ListSize(); i++ )
4501     {
4502         EbmlElement *l = (*tracks)[i];
4503
4504         if( MKV_IS_ID( l, KaxTrackEntry ) )
4505         {
4506             ParseTrackEntry( static_cast<KaxTrackEntry *>(l) );
4507         }
4508         else
4509         {
4510             msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid(*l).name() );
4511         }
4512     }
4513 }
4514
4515 /*****************************************************************************
4516  * ParseInfo:
4517  *****************************************************************************/
4518 void matroska_segment_c::ParseInfo( KaxInfo *info )
4519 {
4520     EbmlElement *el;
4521     EbmlMaster  *m;
4522     size_t i, j;
4523     int i_upper_level = 0;
4524
4525     msg_Dbg( &sys.demuxer, "|   + Information" );
4526
4527     /* Master elements */
4528     m = static_cast<EbmlMaster *>(info);
4529     m->Read( es, info->Generic().Context, i_upper_level, el, true );
4530
4531     for( i = 0; i < m->ListSize(); i++ )
4532     {
4533         EbmlElement *l = (*m)[i];
4534
4535         if( MKV_IS_ID( l, KaxSegmentUID ) )
4536         {
4537             if ( p_segment_uid == NULL )
4538                 p_segment_uid = new KaxSegmentUID(*static_cast<KaxSegmentUID*>(l));
4539
4540             msg_Dbg( &sys.demuxer, "|   |   + UID=%d", *(uint32*)p_segment_uid->GetBuffer() );
4541         }
4542         else if( MKV_IS_ID( l, KaxPrevUID ) )
4543         {
4544             if ( p_prev_segment_uid == NULL )
4545                 p_prev_segment_uid = new KaxPrevUID(*static_cast<KaxPrevUID*>(l));
4546
4547             msg_Dbg( &sys.demuxer, "|   |   + PrevUID=%d", *(uint32*)p_prev_segment_uid->GetBuffer() );
4548         }
4549         else if( MKV_IS_ID( l, KaxNextUID ) )
4550         {
4551             if ( p_next_segment_uid == NULL )
4552                 p_next_segment_uid = new KaxNextUID(*static_cast<KaxNextUID*>(l));
4553
4554             msg_Dbg( &sys.demuxer, "|   |   + NextUID=%d", *(uint32*)p_next_segment_uid->GetBuffer() );
4555         }
4556         else if( MKV_IS_ID( l, KaxTimecodeScale ) )
4557         {
4558             KaxTimecodeScale &tcs = *(KaxTimecodeScale*)l;
4559
4560             i_timescale = uint64(tcs);
4561
4562             msg_Dbg( &sys.demuxer, "|   |   + TimecodeScale="I64Fd,
4563                      i_timescale );
4564         }
4565         else if( MKV_IS_ID( l, KaxDuration ) )
4566         {
4567             KaxDuration &dur = *(KaxDuration*)l;
4568
4569             i_duration = mtime_t( double( dur ) );
4570
4571             msg_Dbg( &sys.demuxer, "|   |   + Duration="I64Fd,
4572                      i_duration );
4573         }
4574         else if( MKV_IS_ID( l, KaxMuxingApp ) )
4575         {
4576             KaxMuxingApp &mapp = *(KaxMuxingApp*)l;
4577
4578             psz_muxing_application = ToUTF8( UTFstring( mapp ) );
4579
4580             msg_Dbg( &sys.demuxer, "|   |   + Muxing Application=%s",
4581                      psz_muxing_application );
4582         }
4583         else if( MKV_IS_ID( l, KaxWritingApp ) )
4584         {
4585             KaxWritingApp &wapp = *(KaxWritingApp*)l;
4586
4587             psz_writing_application = ToUTF8( UTFstring( wapp ) );
4588
4589             msg_Dbg( &sys.demuxer, "|   |   + Writing Application=%s",
4590                      psz_writing_application );
4591         }
4592         else if( MKV_IS_ID( l, KaxSegmentFilename ) )
4593         {
4594             KaxSegmentFilename &sfn = *(KaxSegmentFilename*)l;
4595
4596             psz_segment_filename = ToUTF8( UTFstring( sfn ) );
4597
4598             msg_Dbg( &sys.demuxer, "|   |   + Segment Filename=%s",
4599                      psz_segment_filename );
4600         }
4601         else if( MKV_IS_ID( l, KaxTitle ) )
4602         {
4603             KaxTitle &title = *(KaxTitle*)l;
4604
4605             psz_title = ToUTF8( UTFstring( title ) );
4606
4607             msg_Dbg( &sys.demuxer, "|   |   + Title=%s", psz_title );
4608         }
4609         else if( MKV_IS_ID( l, KaxSegmentFamily ) )
4610         {
4611             KaxSegmentFamily *uid = static_cast<KaxSegmentFamily*>(l);
4612
4613             families.push_back( new KaxSegmentFamily(*uid) );
4614
4615             msg_Dbg( &sys.demuxer, "|   |   + family=%d", *(uint32*)uid->GetBuffer() );
4616         }
4617 #if defined( HAVE_GMTIME_R ) && !defined( SYS_DARWIN )
4618         else if( MKV_IS_ID( l, KaxDateUTC ) )
4619         {
4620             KaxDateUTC &date = *(KaxDateUTC*)l;
4621             time_t i_date;
4622             struct tm tmres;
4623             char   buffer[256];
4624
4625             i_date = date.GetEpochDate();
4626             memset( buffer, 0, 256 );
4627             if( gmtime_r( &i_date, &tmres ) &&
4628                 asctime_r( &tmres, buffer ) )
4629             {
4630                 buffer[strlen( buffer)-1]= '\0';
4631                 psz_date_utc = strdup( buffer );
4632                 msg_Dbg( &sys.demuxer, "|   |   + Date=%s", psz_date_utc );
4633             }
4634         }
4635 #endif
4636 #if LIBMATROSKA_VERSION >= 0x000704
4637         else if( MKV_IS_ID( l, KaxChapterTranslate ) )
4638         {
4639             KaxChapterTranslate *p_trans = static_cast<KaxChapterTranslate*>( l );
4640             chapter_translation_c *p_translate = new chapter_translation_c();
4641
4642             p_trans->Read( es, p_trans->Generic().Context, i_upper_level, el, true );
4643             for( j = 0; j < p_trans->ListSize(); j++ )
4644             {
4645                 EbmlElement *l = (*p_trans)[j];
4646
4647                 if( MKV_IS_ID( l, KaxChapterTranslateEditionUID ) )
4648                 {
4649                     p_translate->editions.push_back( uint64( *static_cast<KaxChapterTranslateEditionUID*>( l ) ) );
4650                 }
4651                 else if( MKV_IS_ID( l, KaxChapterTranslateCodec ) )
4652                 {
4653                     p_translate->codec_id = uint32( *static_cast<KaxChapterTranslateCodec*>( l ) );
4654                 }
4655                 else if( MKV_IS_ID( l, KaxChapterTranslateID ) )
4656                 {
4657                     p_translate->p_translated = new KaxChapterTranslateID( *static_cast<KaxChapterTranslateID*>( l ) );
4658                 }
4659             }
4660
4661             translations.push_back( p_translate );
4662         }
4663 #endif
4664         else
4665         {
4666             msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid(*l).name() );
4667         }
4668     }
4669
4670     double f_dur = double(i_duration) * double(i_timescale) / 1000000.0;
4671     i_duration = mtime_t(f_dur);
4672 }
4673
4674
4675 /*****************************************************************************
4676  * ParseChapterAtom
4677  *****************************************************************************/
4678 void matroska_segment_c::ParseChapterAtom( int i_level, KaxChapterAtom *ca, chapter_item_c & chapters )
4679 {
4680     size_t i, j;
4681
4682     msg_Dbg( &sys.demuxer, "|   |   |   + ChapterAtom (level=%d)", i_level );
4683     for( i = 0; i < ca->ListSize(); i++ )
4684     {
4685         EbmlElement *l = (*ca)[i];
4686
4687         if( MKV_IS_ID( l, KaxChapterUID ) )
4688         {
4689             chapters.i_uid = uint64_t(*(KaxChapterUID*)l);
4690             msg_Dbg( &sys.demuxer, "|   |   |   |   + ChapterUID: %lld", chapters.i_uid );
4691         }
4692         else if( MKV_IS_ID( l, KaxChapterFlagHidden ) )
4693         {
4694             KaxChapterFlagHidden &flag =*(KaxChapterFlagHidden*)l;
4695             chapters.b_display_seekpoint = uint8( flag ) == 0;
4696
4697             msg_Dbg( &sys.demuxer, "|   |   |   |   + ChapterFlagHidden: %s", chapters.b_display_seekpoint ? "no":"yes" );
4698         }
4699         else if( MKV_IS_ID( l, KaxChapterTimeStart ) )
4700         {
4701             KaxChapterTimeStart &start =*(KaxChapterTimeStart*)l;
4702             chapters.i_start_time = uint64( start ) / I64C(1000);
4703
4704             msg_Dbg( &sys.demuxer, "|   |   |   |   + ChapterTimeStart: %lld", chapters.i_start_time );
4705         }
4706         else if( MKV_IS_ID( l, KaxChapterTimeEnd ) )
4707         {
4708             KaxChapterTimeEnd &end =*(KaxChapterTimeEnd*)l;
4709             chapters.i_end_time = uint64( end ) / I64C(1000);
4710
4711             msg_Dbg( &sys.demuxer, "|   |   |   |   + ChapterTimeEnd: %lld", chapters.i_end_time );
4712         }
4713         else if( MKV_IS_ID( l, KaxChapterDisplay ) )
4714         {
4715             EbmlMaster *cd = static_cast<EbmlMaster *>(l);
4716
4717             msg_Dbg( &sys.demuxer, "|   |   |   |   + ChapterDisplay" );
4718             for( j = 0; j < cd->ListSize(); j++ )
4719             {
4720                 EbmlElement *l= (*cd)[j];
4721
4722                 if( MKV_IS_ID( l, KaxChapterString ) )
4723                 {
4724                     int k;
4725
4726                     KaxChapterString &name =*(KaxChapterString*)l;
4727                     for (k = 0; k < i_level; k++)
4728                         chapters.psz_name += '+';
4729                     chapters.psz_name += ' ';
4730                     char *psz_tmp_utf8 = ToUTF8( UTFstring( name ) );
4731                     chapters.psz_name += psz_tmp_utf8;
4732                     chapters.b_user_display = true;
4733
4734                     msg_Dbg( &sys.demuxer, "|   |   |   |   |    + ChapterString '%s'", psz_tmp_utf8 );
4735                     free( psz_tmp_utf8 );
4736                 }
4737                 else if( MKV_IS_ID( l, KaxChapterLanguage ) )
4738                 {
4739                     KaxChapterLanguage &lang =*(KaxChapterLanguage*)l;
4740                     const char *psz = string( lang ).c_str();
4741
4742                     msg_Dbg( &sys.demuxer, "|   |   |   |   |    + ChapterLanguage '%s'", psz );
4743                 }
4744                 else if( MKV_IS_ID( l, KaxChapterCountry ) )
4745                 {
4746                     KaxChapterCountry &ct =*(KaxChapterCountry*)l;
4747                     const char *psz = string( ct ).c_str();
4748
4749                     msg_Dbg( &sys.demuxer, "|   |   |   |   |    + ChapterCountry '%s'", psz );
4750                 }
4751             }
4752         }
4753         else if( MKV_IS_ID( l, KaxChapterProcess ) )
4754         {
4755             msg_Dbg( &sys.demuxer, "|   |   |   |   + ChapterProcess" );
4756
4757             KaxChapterProcess *cp = static_cast<KaxChapterProcess *>(l);
4758             chapter_codec_cmds_c *p_ccodec = NULL;
4759
4760             for( j = 0; j < cp->ListSize(); j++ )
4761             {
4762                 EbmlElement *k= (*cp)[j];
4763
4764                 if( MKV_IS_ID( k, KaxChapterProcessCodecID ) )
4765                 {
4766                     KaxChapterProcessCodecID *p_codec_id = static_cast<KaxChapterProcessCodecID*>( k );
4767                     if ( uint32(*p_codec_id) == 0 )
4768                         p_ccodec = new matroska_script_codec_c( sys );
4769                     else if ( uint32(*p_codec_id) == 1 )
4770                         p_ccodec = new dvd_chapter_codec_c( sys );
4771                     break;
4772                 }
4773             }
4774
4775             if ( p_ccodec != NULL )
4776             {
4777                 for( j = 0; j < cp->ListSize(); j++ )
4778                 {
4779                     EbmlElement *k= (*cp)[j];
4780
4781                     if( MKV_IS_ID( k, KaxChapterProcessPrivate ) )
4782                     {
4783                         KaxChapterProcessPrivate * p_private = static_cast<KaxChapterProcessPrivate*>( k );
4784                         p_ccodec->SetPrivate( *p_private );
4785                     }
4786                     else if( MKV_IS_ID( k, KaxChapterProcessCommand ) )
4787                     {
4788                         p_ccodec->AddCommand( *static_cast<KaxChapterProcessCommand*>( k ) );
4789                     }
4790                 }
4791                 chapters.codecs.push_back( p_ccodec );
4792             }
4793         }
4794         else if( MKV_IS_ID( l, KaxChapterAtom ) )
4795         {
4796             chapter_item_c *new_sub_chapter = new chapter_item_c();
4797             ParseChapterAtom( i_level+1, static_cast<KaxChapterAtom *>(l), *new_sub_chapter );
4798             new_sub_chapter->psz_parent = &chapters;
4799             chapters.sub_chapters.push_back( new_sub_chapter );
4800         }
4801     }
4802 }
4803
4804 /*****************************************************************************
4805  * ParseChapters:
4806  *****************************************************************************/
4807 void matroska_segment_c::ParseChapters( KaxChapters *chapters )
4808 {
4809     EbmlElement *el;
4810     size_t i;
4811     int i_upper_level = 0;
4812     mtime_t i_dur;
4813
4814     /* Master elements */
4815     chapters->Read( es, chapters->Generic().Context, i_upper_level, el, true );
4816
4817     for( i = 0; i < chapters->ListSize(); i++ )
4818     {
4819         EbmlElement *l = (*chapters)[i];
4820
4821         if( MKV_IS_ID( l, KaxEditionEntry ) )
4822         {
4823             chapter_edition_c *p_edition = new chapter_edition_c();
4824
4825             EbmlMaster *E = static_cast<EbmlMaster *>(l );
4826             size_t j;
4827             msg_Dbg( &sys.demuxer, "|   |   + EditionEntry" );
4828             for( j = 0; j < E->ListSize(); j++ )
4829             {
4830                 EbmlElement *l = (*E)[j];
4831
4832                 if( MKV_IS_ID( l, KaxChapterAtom ) )
4833                 {
4834                     chapter_item_c *new_sub_chapter = new chapter_item_c();
4835                     ParseChapterAtom( 0, static_cast<KaxChapterAtom *>(l), *new_sub_chapter );
4836                     p_edition->sub_chapters.push_back( new_sub_chapter );
4837                 }
4838                 else if( MKV_IS_ID( l, KaxEditionUID ) )
4839                 {
4840                     p_edition->i_uid = uint64(*static_cast<KaxEditionUID *>( l ));
4841                 }
4842                 else if( MKV_IS_ID( l, KaxEditionFlagOrdered ) )
4843                 {
4844                     p_edition->b_ordered = config_GetInt( &sys.demuxer, "mkv-use-ordered-chapters" ) ? (uint8(*static_cast<KaxEditionFlagOrdered *>( l )) != 0) : 0;
4845                 }
4846                 else if( MKV_IS_ID( l, KaxEditionFlagDefault ) )
4847                 {
4848                     if (uint8(*static_cast<KaxEditionFlagDefault *>( l )) != 0)
4849                         i_default_edition = stored_editions.size();
4850                 }
4851                 else
4852                 {
4853                     msg_Dbg( &sys.demuxer, "|   |   |   + Unknown (%s)", typeid(*l).name() );
4854                 }
4855             }
4856             stored_editions.push_back( p_edition );
4857         }
4858         else
4859         {
4860             msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid(*l).name() );
4861         }
4862     }
4863
4864     for( i = 0; i < stored_editions.size(); i++ )
4865     {
4866         stored_editions[i]->RefreshChapters( );
4867     }
4868
4869     if ( stored_editions.size() != 0 && stored_editions[i_default_edition]->b_ordered )
4870     {
4871         /* update the duration of the segment according to the sum of all sub chapters */
4872         i_dur = stored_editions[i_default_edition]->Duration() / I64C(1000);
4873         if (i_dur > 0)
4874             i_duration = i_dur;
4875     }
4876 }
4877
4878 void matroska_segment_c::ParseCluster( )
4879 {
4880     EbmlElement *el;
4881     EbmlMaster  *m;
4882     unsigned int i;
4883     int i_upper_level = 0;
4884
4885     /* Master elements */
4886     m = static_cast<EbmlMaster *>( cluster );
4887     m->Read( es, cluster->Generic().Context, i_upper_level, el, true );
4888
4889     for( i = 0; i < m->ListSize(); i++ )
4890     {
4891         EbmlElement *l = (*m)[i];
4892
4893         if( MKV_IS_ID( l, KaxClusterTimecode ) )
4894         {
4895             KaxClusterTimecode &ctc = *(KaxClusterTimecode*)l;
4896
4897             cluster->InitTimecode( uint64( ctc ), i_timescale );
4898             break;
4899         }
4900     }
4901
4902     i_start_time = cluster->GlobalTimecode() / 1000;
4903 }
4904
4905 /*****************************************************************************
4906  * InformationCreate:
4907  *****************************************************************************/
4908 void matroska_segment_c::InformationCreate( )
4909 {
4910     size_t      i_track;
4911
4912     sys.meta = vlc_meta_New();
4913
4914     if( psz_title )
4915     {
4916         vlc_meta_Add( sys.meta, VLC_META_TITLE, psz_title );
4917     }
4918     if( psz_date_utc )
4919     {
4920         vlc_meta_Add( sys.meta, VLC_META_DATE, psz_date_utc );
4921     }
4922     if( psz_segment_filename )
4923     {
4924         vlc_meta_Add( sys.meta, _("Segment filename"), psz_segment_filename );
4925     }
4926     if( psz_muxing_application )
4927     {
4928         vlc_meta_Add( sys.meta, _("Muxing application"), psz_muxing_application );
4929     }
4930     if( psz_writing_application )
4931     {
4932         vlc_meta_Add( sys.meta, _("Writing application"), psz_writing_application );
4933     }
4934
4935     for( i_track = 0; i_track < tracks.size(); i_track++ )
4936     {
4937         mkv_track_t *tk = tracks[i_track];
4938         vlc_meta_t *mtk = vlc_meta_New();
4939
4940         sys.meta->track = (vlc_meta_t**)realloc( sys.meta->track,
4941                                                     sizeof( vlc_meta_t * ) * ( sys.meta->i_track + 1 ) );
4942         sys.meta->track[sys.meta->i_track++] = mtk;
4943
4944         if( tk->fmt.psz_description )
4945         {
4946             vlc_meta_Add( sys.meta, VLC_META_DESCRIPTION, tk->fmt.psz_description );
4947         }
4948         if( tk->psz_codec_name )
4949         {
4950             vlc_meta_Add( sys.meta, VLC_META_CODEC_NAME, tk->psz_codec_name );
4951         }
4952         if( tk->psz_codec_settings )
4953         {
4954             vlc_meta_Add( sys.meta, VLC_META_SETTING, tk->psz_codec_settings );
4955         }
4956         if( tk->psz_codec_info_url )
4957         {
4958             vlc_meta_Add( sys.meta, VLC_META_CODEC_DESCRIPTION, tk->psz_codec_info_url );
4959         }
4960         if( tk->psz_codec_download_url )
4961         {
4962             vlc_meta_Add( sys.meta, VLC_META_URL, tk->psz_codec_download_url );
4963         }
4964     }
4965
4966     if( i_tags_position >= 0 )
4967     {
4968         vlc_bool_t b_seekable;
4969
4970         stream_Control( sys.demuxer.s, STREAM_CAN_FASTSEEK, &b_seekable );
4971         if( b_seekable )
4972         {
4973             LoadTags( );
4974         }
4975     }
4976 }
4977
4978
4979 /*****************************************************************************
4980  * Divers
4981  *****************************************************************************/
4982
4983 void matroska_segment_c::IndexAppendCluster( KaxCluster *cluster )
4984 {
4985 #define idx p_indexes[i_index]
4986     idx.i_track       = -1;
4987     idx.i_block_number= -1;
4988     idx.i_position    = cluster->GetElementPosition();
4989     idx.i_time        = -1;
4990     idx.b_key         = VLC_TRUE;
4991
4992     i_index++;
4993     if( i_index >= i_index_max )
4994     {
4995         i_index_max += 1024;
4996         p_indexes = (mkv_index_t*)realloc( p_indexes, sizeof( mkv_index_t ) * i_index_max );
4997     }
4998 #undef idx
4999 }
5000
5001 void chapter_edition_c::RefreshChapters( )
5002 {
5003     chapter_item_c::RefreshChapters( b_ordered, -1 );
5004     b_display_seekpoint = false;
5005 }
5006
5007 int64_t chapter_item_c::RefreshChapters( bool b_ordered, int64_t i_prev_user_time )
5008 {
5009     int64_t i_user_time = i_prev_user_time;
5010
5011     // first the sub-chapters, and then ourself
5012     std::vector<chapter_item_c*>::iterator index = sub_chapters.begin();
5013     while ( index != sub_chapters.end() )
5014     {
5015         i_user_time = (*index)->RefreshChapters( b_ordered, i_user_time );
5016         index++;
5017     }
5018
5019     if ( b_ordered )
5020     {
5021         // the ordered chapters always start at zero
5022         if ( i_prev_user_time == -1 )
5023         {
5024             if ( i_user_time == -1 )
5025                 i_user_time = 0;
5026             i_prev_user_time = 0;
5027         }
5028
5029         i_user_start_time = i_prev_user_time;
5030         if ( i_end_time != -1 && i_user_time == i_prev_user_time )
5031         {
5032             i_user_end_time = i_user_start_time - i_start_time + i_end_time;
5033         }
5034         else
5035         {
5036             i_user_end_time = i_user_time;
5037         }
5038     }
5039     else
5040     {
5041         if ( sub_chapters.begin() != sub_chapters.end() )
5042             std::sort( sub_chapters.begin(), sub_chapters.end(), chapter_item_c::CompareTimecode );
5043         i_user_start_time = i_start_time;
5044         if ( i_end_time != -1 )
5045             i_user_end_time = i_end_time;
5046         else if ( i_user_time != -1 )
5047             i_user_end_time = i_user_time;
5048         else
5049             i_user_end_time = i_user_start_time;
5050     }
5051
5052     return i_user_end_time;
5053 }
5054
5055 mtime_t chapter_edition_c::Duration() const
5056 {
5057     mtime_t i_result = 0;
5058
5059     if ( sub_chapters.size() )
5060     {
5061         std::vector<chapter_item_c*>::const_iterator index = sub_chapters.end();
5062         index--;
5063         i_result = (*index)->i_user_end_time;
5064     }
5065
5066     return i_result;
5067 }
5068
5069 chapter_item_c * chapter_edition_c::FindTimecode( mtime_t i_timecode, const chapter_item_c * p_current )
5070 {
5071     if ( !b_ordered )
5072         p_current = NULL;
5073     bool b_found_current = false;
5074     return chapter_item_c::FindTimecode( i_timecode, p_current, b_found_current );
5075 }
5076
5077 chapter_item_c *chapter_item_c::FindTimecode( mtime_t i_user_timecode, const chapter_item_c * p_current, bool & b_found )
5078 {
5079     chapter_item_c *psz_result = NULL;
5080
5081     if ( p_current == this )
5082         b_found = true;
5083
5084     if ( i_user_timecode >= i_user_start_time &&
5085         ( i_user_timecode < i_user_end_time ||
5086           ( i_user_start_time == i_user_end_time && i_user_timecode == i_user_end_time )))
5087     {
5088         std::vector<chapter_item_c*>::iterator index = sub_chapters.begin();
5089         while ( index != sub_chapters.end() && ((p_current == NULL && psz_result == NULL) || (p_current != NULL && (!b_found || psz_result == NULL))))
5090         {
5091             psz_result = (*index)->FindTimecode( i_user_timecode, p_current, b_found );
5092             index++;
5093         }
5094
5095         if ( psz_result == NULL )
5096             psz_result = this;
5097     }
5098
5099     return psz_result;
5100 }
5101
5102 bool chapter_item_c::ParentOf( const chapter_item_c & item ) const
5103 {
5104     if ( &item == this )
5105         return true;
5106
5107     std::vector<chapter_item_c*>::const_iterator index = sub_chapters.begin();
5108     while ( index != sub_chapters.end() )
5109     {
5110         if ( (*index)->ParentOf( item ) )
5111             return true;
5112         index++;
5113     }
5114
5115     return false;
5116 }
5117
5118 void demux_sys_t::PreloadFamily( const matroska_segment_c & of_segment )
5119 {
5120     for (size_t i=0; i<opened_segments.size(); i++)
5121     {
5122         opened_segments[i]->PreloadFamily( of_segment );
5123     }
5124 }
5125 bool matroska_segment_c::PreloadFamily( const matroska_segment_c & of_segment )
5126 {
5127     if ( b_preloaded )
5128         return false;
5129
5130     for (size_t i=0; i<families.size(); i++)
5131     {
5132         for (size_t j=0; j<of_segment.families.size(); j++)
5133         {
5134             if ( *(families[i]) == *(of_segment.families[j]) )
5135                 return Preload( );
5136         }
5137     }
5138
5139     return false;
5140 }
5141
5142 // preload all the linked segments for all preloaded segments
5143 void demux_sys_t::PreloadLinked( matroska_segment_c *p_segment )
5144 {
5145     size_t i_preloaded, i, j;
5146     virtual_segment_c *p_seg;
5147
5148     p_current_segment = VirtualFromSegments( p_segment );
5149
5150     used_segments.push_back( p_current_segment );
5151
5152     // create all the other virtual segments of the family
5153     do {
5154         i_preloaded = 0;
5155         for ( i=0; i< opened_segments.size(); i++ )
5156         {
5157             if ( opened_segments[i]->b_preloaded && !IsUsedSegment( *opened_segments[i] ) )
5158             {
5159                 p_seg = VirtualFromSegments( opened_segments[i] );
5160                 used_segments.push_back( p_seg );
5161                 i_preloaded++;
5162             }
5163         }
5164     } while ( i_preloaded ); // worst case: will stop when all segments are found as family related
5165
5166     // publish all editions of all usable segment
5167     for ( i=0; i< used_segments.size(); i++ )
5168     {
5169         p_seg = used_segments[i];
5170         if ( p_seg->p_editions != NULL )
5171         {
5172             std::string sz_name;
5173             input_title_t *p_title = vlc_input_title_New();
5174             p_seg->i_sys_title = i;
5175             int i_chapters;
5176
5177             // TODO use a name for each edition, let the TITLE deal with a codec name
5178             for ( j=0; j<p_seg->p_editions->size(); j++ )
5179             {
5180                 if ( p_title->psz_name == NULL )
5181                 {
5182                     sz_name = (*p_seg->p_editions)[j]->GetMainName();
5183                     if ( sz_name != "" )
5184                         p_title->psz_name = strdup( sz_name.c_str() );
5185                 }
5186
5187                 chapter_edition_c *p_edition = (*p_seg->p_editions)[j];
5188
5189                 i_chapters = 0;
5190                 p_edition->PublishChapters( *p_title, i_chapters, 0 );
5191             }
5192
5193             // create a name if there is none
5194             if ( p_title->psz_name == NULL )
5195             {
5196                 sz_name = N_("Segment");
5197                 char psz_str[6];
5198                 sprintf( psz_str, " %d", (int)i );
5199                 sz_name += psz_str;
5200                 p_title->psz_name = strdup( sz_name.c_str() );
5201             }
5202
5203             titles.push_back( p_title );
5204         }
5205     }
5206
5207     // TODO decide which segment should be first used (VMG for DVD)
5208 }
5209
5210 bool demux_sys_t::IsUsedSegment( matroska_segment_c &segment ) const
5211 {
5212     for ( size_t i=0; i< used_segments.size(); i++ )
5213     {
5214         if ( used_segments[i]->FindUID( *segment.p_segment_uid ) )
5215             return true;
5216     }
5217     return false;
5218 }
5219
5220 virtual_segment_c *demux_sys_t::VirtualFromSegments( matroska_segment_c *p_segment ) const
5221 {
5222     size_t i_preloaded, i;
5223
5224     virtual_segment_c *p_result = new virtual_segment_c( p_segment );
5225
5226     // fill our current virtual segment with all hard linked segments
5227     do {
5228         i_preloaded = 0;
5229         for ( i=0; i< opened_segments.size(); i++ )
5230         {
5231             i_preloaded += p_result->AddSegment( opened_segments[i] );
5232         }
5233     } while ( i_preloaded ); // worst case: will stop when all segments are found as linked
5234
5235     p_result->Sort( );
5236
5237     p_result->PreloadLinked( );
5238
5239     p_result->PrepareChapters( );
5240
5241     return p_result;
5242 }
5243
5244 bool demux_sys_t::PreparePlayback( virtual_segment_c *p_new_segment )
5245 {
5246     if ( p_new_segment != NULL && p_new_segment != p_current_segment )
5247     {
5248         if ( p_current_segment != NULL && p_current_segment->Segment() != NULL )
5249             p_current_segment->Segment()->UnSelect();
5250
5251         p_current_segment = p_new_segment;
5252         i_current_title = p_new_segment->i_sys_title;
5253     }
5254
5255     p_current_segment->LoadCues();
5256     f_duration = p_current_segment->Duration();
5257
5258     /* add information */
5259     p_current_segment->Segment()->InformationCreate( );
5260
5261     p_current_segment->Segment()->Select( 0 );
5262
5263     return true;
5264 }
5265
5266 void demux_sys_t::JumpTo( virtual_segment_c & vsegment, chapter_item_c * p_chapter )
5267 {
5268     // if the segment is not part of the current segment, select the new one
5269     if ( &vsegment != p_current_segment )
5270     {
5271         PreparePlayback( &vsegment );
5272     }
5273
5274     if ( p_chapter != NULL )
5275     {
5276         if ( !p_chapter->Enter( true ) )
5277         {
5278             // jump to the location in the found segment
5279             vsegment.Seek( demuxer, p_chapter->i_user_start_time, -1, p_chapter );
5280         }
5281     }
5282
5283 }
5284
5285 bool matroska_segment_c::CompareSegmentUIDs( const matroska_segment_c * p_item_a, const matroska_segment_c * p_item_b )
5286 {
5287     if ( p_item_a == NULL || p_item_b == NULL )
5288         return false;
5289
5290     EbmlBinary * p_itema = (EbmlBinary *)(p_item_a->p_segment_uid);
5291     if ( p_item_b->p_prev_segment_uid != NULL && *p_itema == *p_item_b->p_prev_segment_uid )
5292         return true;
5293
5294     p_itema = (EbmlBinary *)(&p_item_a->p_next_segment_uid);
5295     if ( p_item_b->p_segment_uid != NULL && *p_itema == *p_item_b->p_segment_uid )
5296         return true;
5297
5298     if ( p_item_b->p_prev_segment_uid != NULL && *p_itema == *p_item_b->p_prev_segment_uid )
5299         return true;
5300
5301     return false;
5302 }
5303
5304 bool matroska_segment_c::Preload( )
5305 {
5306     if ( b_preloaded )
5307         return false;
5308
5309     EbmlElement *el = NULL;
5310
5311     ep->Reset( &sys.demuxer );
5312
5313     while( ( el = ep->Get() ) != NULL )
5314     {
5315         if( MKV_IS_ID( el, KaxInfo ) )
5316         {
5317             ParseInfo( static_cast<KaxInfo*>( el ) );
5318         }
5319         else if( MKV_IS_ID( el, KaxTracks ) )
5320         {
5321             ParseTracks( static_cast<KaxTracks*>( el ) );
5322             if ( tracks.size() == 0 )
5323             {
5324                 msg_Err( &sys.demuxer, "No tracks supported" );
5325                 return false;
5326             }
5327         }
5328         else if( MKV_IS_ID( el, KaxSeekHead ) )
5329         {
5330             ParseSeekHead( static_cast<KaxSeekHead*>( el ) );
5331         }
5332         else if( MKV_IS_ID( el, KaxCues ) )
5333         {
5334             msg_Dbg( &sys.demuxer, "|   + Cues" );
5335         }
5336         else if( MKV_IS_ID( el, KaxCluster ) )
5337         {
5338             msg_Dbg( &sys.demuxer, "|   + Cluster" );
5339
5340             cluster = (KaxCluster*)el;
5341
5342             i_cluster_pos = i_start_pos = cluster->GetElementPosition();
5343             ParseCluster( );
5344
5345             ep->Down();
5346             /* stop parsing the stream */
5347             break;
5348         }
5349         else if( MKV_IS_ID( el, KaxAttachments ) )
5350         {
5351             msg_Dbg( &sys.demuxer, "|   + Attachments FIXME (but probably never supported)" );
5352         }
5353         else if( MKV_IS_ID( el, KaxChapters ) )
5354         {
5355             msg_Dbg( &sys.demuxer, "|   + Chapters" );
5356             ParseChapters( static_cast<KaxChapters*>( el ) );
5357         }
5358         else if( MKV_IS_ID( el, KaxTag ) )
5359         {
5360             msg_Dbg( &sys.demuxer, "|   + Tags FIXME TODO" );
5361         }
5362         else
5363         {
5364             msg_Dbg( &sys.demuxer, "|   + Unknown (%s)", typeid(*el).name() );
5365         }
5366     }
5367
5368     b_preloaded = true;
5369
5370     return true;
5371 }
5372
5373 matroska_segment_c *demux_sys_t::FindSegment( const EbmlBinary & uid ) const
5374 {
5375     for (size_t i=0; i<opened_segments.size(); i++)
5376     {
5377         if ( *opened_segments[i]->p_segment_uid == uid )
5378             return opened_segments[i];
5379     }
5380     return NULL;
5381 }
5382
5383 chapter_item_c *demux_sys_t::BrowseCodecPrivate( unsigned int codec_id,
5384                                         bool (*match)(const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size ),
5385                                         const void *p_cookie,
5386                                         size_t i_cookie_size,
5387                                         virtual_segment_c * &p_segment_found )
5388 {
5389     chapter_item_c *p_result = NULL;
5390     for (size_t i=0; i<used_segments.size(); i++)
5391     {
5392         p_result = used_segments[i]->BrowseCodecPrivate( codec_id, match, p_cookie, i_cookie_size );
5393         if ( p_result != NULL )
5394         {
5395             p_segment_found = used_segments[i];
5396             break;
5397         }
5398     }
5399     return p_result;
5400 }
5401
5402 chapter_item_c *demux_sys_t::FindChapter( int64_t i_find_uid, virtual_segment_c * & p_segment_found )
5403 {
5404     chapter_item_c *p_result = NULL;
5405     for (size_t i=0; i<used_segments.size(); i++)
5406     {
5407         p_result = used_segments[i]->FindChapter( i_find_uid );
5408         if ( p_result != NULL )
5409         {
5410             p_segment_found = used_segments[i];
5411             break;
5412         }
5413     }
5414     return p_result;
5415 }
5416
5417 void virtual_segment_c::Sort()
5418 {
5419     // keep the current segment index
5420     matroska_segment_c *p_segment = linked_segments[i_current_segment];
5421
5422     std::sort( linked_segments.begin(), linked_segments.end(), matroska_segment_c::CompareSegmentUIDs );
5423
5424     for ( i_current_segment=0; i_current_segment<linked_segments.size(); i_current_segment++)
5425         if ( linked_segments[i_current_segment] == p_segment )
5426             break;
5427 }
5428
5429 size_t virtual_segment_c::AddSegment( matroska_segment_c *p_segment )
5430 {
5431     size_t i;
5432     // check if it's not already in here
5433     for ( i=0; i<linked_segments.size(); i++ )
5434     {
5435         if ( linked_segments[i]->p_segment_uid != NULL
5436             && p_segment->p_segment_uid != NULL
5437             && *p_segment->p_segment_uid == *linked_segments[i]->p_segment_uid )
5438             return 0;
5439     }
5440
5441     // find possible mates
5442     for ( i=0; i<linked_uids.size(); i++ )
5443     {
5444         if (   (p_segment->p_segment_uid != NULL && *p_segment->p_segment_uid == linked_uids[i])
5445             || (p_segment->p_prev_segment_uid != NULL && *p_segment->p_prev_segment_uid == linked_uids[i])
5446             || (p_segment->p_next_segment_uid !=NULL && *p_segment->p_next_segment_uid == linked_uids[i]) )
5447         {
5448             linked_segments.push_back( p_segment );
5449
5450             AppendUID( p_segment->p_prev_segment_uid );
5451             AppendUID( p_segment->p_next_segment_uid );
5452
5453             return 1;
5454         }
5455     }
5456     return 0;
5457 }
5458
5459 void virtual_segment_c::PreloadLinked( )
5460 {
5461     for ( size_t i=0; i<linked_segments.size(); i++ )
5462     {
5463         linked_segments[i]->Preload( );
5464     }
5465     i_current_edition = linked_segments[0]->i_default_edition;
5466 }
5467
5468 mtime_t virtual_segment_c::Duration() const
5469 {
5470     mtime_t i_duration;
5471     if ( linked_segments.size() == 0 )
5472         i_duration = 0;
5473     else {
5474         matroska_segment_c *p_last_segment = linked_segments[linked_segments.size()-1];
5475 //        p_last_segment->ParseCluster( );
5476
5477         i_duration = p_last_segment->i_start_time / 1000 + p_last_segment->i_duration;
5478     }
5479     return i_duration;
5480 }
5481
5482 void virtual_segment_c::LoadCues( )
5483 {
5484     for ( size_t i=0; i<linked_segments.size(); i++ )
5485     {
5486         linked_segments[i]->LoadCues();
5487     }
5488 }
5489
5490 void virtual_segment_c::AppendUID( const EbmlBinary * p_UID )
5491 {
5492     if ( p_UID == NULL )
5493         return;
5494     if ( p_UID->GetBuffer() == NULL )
5495         return;
5496
5497     for (size_t i=0; i<linked_uids.size(); i++)
5498     {
5499         if ( *p_UID == linked_uids[i] )
5500             return;
5501     }
5502     linked_uids.push_back( *(KaxSegmentUID*)(p_UID) );
5503 }
5504
5505 void matroska_segment_c::Seek( mtime_t i_date, mtime_t i_time_offset )
5506 {
5507     KaxBlock    *block;
5508 #if LIBMATROSKA_VERSION >= 0x000800
5509     KaxSimpleBlock *simpleblock;
5510 #endif
5511     int         i_track_skipping;
5512     int64_t     i_block_duration;
5513     int64_t     i_block_ref1;
5514     int64_t     i_block_ref2;
5515     size_t      i_track;
5516     int64_t     i_seek_position = i_start_pos;
5517     int64_t     i_seek_time = i_start_time;
5518
5519     if ( i_index > 0 )
5520     {
5521         int i_idx = 0;
5522
5523         for( ; i_idx < i_index; i_idx++ )
5524         {
5525             if( p_indexes[i_idx].i_time + i_time_offset > i_date )
5526             {
5527                 break;
5528             }
5529         }
5530
5531         if( i_idx > 0 )
5532         {
5533             i_idx--;
5534         }
5535
5536         i_seek_position = p_indexes[i_idx].i_position;
5537         i_seek_time = p_indexes[i_idx].i_time;
5538     }
5539
5540     msg_Dbg( &sys.demuxer, "seek got "I64Fd" (%d%%)",
5541                 i_seek_time, (int)( 100 * i_seek_position / stream_Size( sys.demuxer.s ) ) );
5542
5543     es.I_O().setFilePointer( i_seek_position, seek_beginning );
5544
5545     delete ep;
5546     ep = new EbmlParser( &es, segment, &sys.demuxer );
5547     cluster = NULL;
5548
5549     sys.i_start_pts = i_date;
5550
5551     es_out_Control( sys.demuxer.out, ES_OUT_RESET_PCR );
5552
5553     /* now parse until key frame */
5554     i_track_skipping = 0;
5555     for( i_track = 0; i_track < tracks.size(); i_track++ )
5556     {
5557         if( tracks[i_track]->fmt.i_cat == VIDEO_ES )
5558         {
5559             tracks[i_track]->b_search_keyframe = VLC_TRUE;
5560             i_track_skipping++;
5561         }
5562         es_out_Control( sys.demuxer.out, ES_OUT_SET_NEXT_DISPLAY_TIME, tracks[i_track]->p_es, i_date );
5563     }
5564
5565
5566     while( i_track_skipping > 0 )
5567     {
5568 #if LIBMATROSKA_VERSION >= 0x000800
5569         if( BlockGet( block, simpleblock, &i_block_ref1, &i_block_ref2, &i_block_duration ) )
5570 #else
5571         if( BlockGet( block, &i_block_ref1, &i_block_ref2, &i_block_duration ) )
5572 #endif
5573         {
5574             msg_Warn( &sys.demuxer, "cannot get block EOF?" );
5575
5576             return;
5577         }
5578         ep->Down();
5579
5580         for( i_track = 0; i_track < tracks.size(); i_track++ )
5581         {
5582             if( tracks[i_track]->i_number == block->TrackNum() )
5583             {
5584                 break;
5585             }
5586         }
5587
5588         sys.i_pts = (sys.i_chapter_time + block->GlobalTimecode()) / (mtime_t) 1000;
5589
5590         if( i_track < tracks.size() )
5591         {
5592            if( sys.i_pts >= sys.i_start_pts )
5593             {
5594                 cluster = static_cast<KaxCluster*>(ep->UnGet( i_block_pos, i_cluster_pos ));
5595                 i_track_skipping = 0;
5596             }
5597             else if( tracks[i_track]->fmt.i_cat == VIDEO_ES )
5598             {
5599                 if( i_block_ref1 == 0 && tracks[i_track]->b_search_keyframe )
5600                 {
5601                     tracks[i_track]->b_search_keyframe = VLC_FALSE;
5602                     i_track_skipping--;
5603                 }
5604                 if( !tracks[i_track]->b_search_keyframe )
5605                 {
5606 #if LIBMATROSKA_VERSION >= 0x000800
5607                     BlockDecode( &sys.demuxer, block, simpleblock, sys.i_pts, 0, i_block_ref1 >= 0 || i_block_ref2 > 0 );
5608 #else
5609                     BlockDecode( &sys.demuxer, block, sys.i_pts, 0, i_block_ref1 >= 0 || i_block_ref2 > 0 );
5610 #endif
5611                 }
5612             }
5613         }
5614
5615         delete block;
5616     }
5617 }
5618
5619 void virtual_segment_c::Seek( demux_t & demuxer, mtime_t i_date, mtime_t i_time_offset, chapter_item_c *psz_chapter )
5620 {
5621     demux_sys_t *p_sys = demuxer.p_sys;
5622     size_t i;
5623
5624     // find the actual time for an ordered edition
5625     if ( psz_chapter == NULL )
5626     {
5627         if ( Edition() && Edition()->b_ordered )
5628         {
5629             /* 1st, we need to know in which chapter we are */
5630             psz_chapter = (*p_editions)[i_current_edition]->FindTimecode( i_date, psz_current_chapter );
5631         }
5632     }
5633
5634     if ( psz_chapter != NULL )
5635     {
5636         psz_current_chapter = psz_chapter;
5637         p_sys->i_chapter_time = i_time_offset = psz_chapter->i_user_start_time - psz_chapter->i_start_time;
5638         if ( psz_chapter->i_seekpoint_num > 0 )
5639         {
5640             demuxer.info.i_update |= INPUT_UPDATE_TITLE | INPUT_UPDATE_SEEKPOINT;
5641             demuxer.info.i_title = p_sys->i_current_title = i_sys_title;
5642             demuxer.info.i_seekpoint = psz_chapter->i_seekpoint_num - 1;
5643         }
5644     }
5645
5646     // find the best matching segment
5647     for ( i=0; i<linked_segments.size(); i++ )
5648     {
5649         if ( i_date < linked_segments[i]->i_start_time )
5650             break;
5651     }
5652
5653     if ( i > 0 )
5654         i--;
5655
5656     if ( i_current_segment != i  )
5657     {
5658         linked_segments[i_current_segment]->UnSelect();
5659         linked_segments[i]->Select( i_date );
5660         i_current_segment = i;
5661     }
5662
5663     linked_segments[i]->Seek( i_date, i_time_offset );
5664 }
5665
5666 void chapter_codec_cmds_c::AddCommand( const KaxChapterProcessCommand & command )
5667 {
5668     size_t i;
5669
5670     uint32 codec_time = uint32(-1);
5671     for( i = 0; i < command.ListSize(); i++ )
5672     {
5673         const EbmlElement *k = command[i];
5674
5675         if( MKV_IS_ID( k, KaxChapterProcessTime ) )
5676         {
5677             codec_time = uint32( *static_cast<const KaxChapterProcessTime*>( k ) );
5678             break;
5679         }
5680     }
5681
5682     for( i = 0; i < command.ListSize(); i++ )
5683     {
5684         const EbmlElement *k = command[i];
5685
5686         if( MKV_IS_ID( k, KaxChapterProcessData ) )
5687         {
5688             KaxChapterProcessData *p_data =  new KaxChapterProcessData( *static_cast<const KaxChapterProcessData*>( k ) );
5689             switch ( codec_time )
5690             {
5691             case 0:
5692                 during_cmds.push_back( p_data );
5693                 break;
5694             case 1:
5695                 enter_cmds.push_back( p_data );
5696                 break;
5697             case 2:
5698                 leave_cmds.push_back( p_data );
5699                 break;
5700             default:
5701                 delete p_data;
5702             }
5703         }
5704     }
5705 }
5706
5707 bool chapter_item_c::Enter( bool b_do_subs )
5708 {
5709     bool f_result = false;
5710     std::vector<chapter_codec_cmds_c*>::iterator index = codecs.begin();
5711     while ( index != codecs.end() )
5712     {
5713         f_result |= (*index)->Enter();
5714         index++;
5715     }
5716
5717     if ( b_do_subs )
5718     {
5719         // sub chapters
5720         std::vector<chapter_item_c*>::iterator index_ = sub_chapters.begin();
5721         while ( index_ != sub_chapters.end() )
5722         {
5723             f_result |= (*index_)->Enter( true );
5724             index_++;
5725         }
5726     }
5727     return f_result;
5728 }
5729
5730 bool chapter_item_c::Leave( bool b_do_subs )
5731 {
5732     bool f_result = false;
5733     b_is_leaving = true;
5734     std::vector<chapter_codec_cmds_c*>::iterator index = codecs.begin();
5735     while ( index != codecs.end() )
5736     {
5737         f_result |= (*index)->Leave();
5738         index++;
5739     }
5740
5741     if ( b_do_subs )
5742     {
5743         // sub chapters
5744         std::vector<chapter_item_c*>::iterator index_ = sub_chapters.begin();
5745         while ( index_ != sub_chapters.end() )
5746         {
5747             f_result |= (*index_)->Leave( true );
5748             index_++;
5749         }
5750     }
5751     b_is_leaving = false;
5752     return f_result;
5753 }
5754
5755 bool chapter_item_c::EnterAndLeave( chapter_item_c *p_item, bool b_final_enter )
5756 {
5757     chapter_item_c *p_common_parent = p_item;
5758
5759     // leave, up to a common parent
5760     while ( p_common_parent != NULL && !p_common_parent->ParentOf( *this ) )
5761     {
5762         if ( !p_common_parent->b_is_leaving && p_common_parent->Leave( false ) )
5763             return true;
5764         p_common_parent = p_common_parent->psz_parent;
5765     }
5766
5767     // enter from the parent to <this>
5768     if ( p_common_parent != NULL )
5769     {
5770         do
5771         {
5772             if ( p_common_parent == this )
5773                 return Enter( true );
5774
5775             for ( size_t i = 0; i<p_common_parent->sub_chapters.size(); i++ )
5776             {
5777                 if ( p_common_parent->sub_chapters[i]->ParentOf( *this ) )
5778                 {
5779                     p_common_parent = p_common_parent->sub_chapters[i];
5780                     if ( p_common_parent != this )
5781                         if ( p_common_parent->Enter( false ) )
5782                             return true;
5783
5784                     break;
5785                 }
5786             }
5787         } while ( 1 );
5788     }
5789
5790     if ( b_final_enter )
5791         return Enter( true );
5792     else
5793         return false;
5794 }
5795
5796 bool dvd_chapter_codec_c::Enter()
5797 {
5798     bool f_result = false;
5799     std::vector<KaxChapterProcessData*>::iterator index = enter_cmds.begin();
5800     while ( index != enter_cmds.end() )
5801     {
5802         if ( (*index)->GetSize() )
5803         {
5804             binary *p_data = (*index)->GetBuffer();
5805             size_t i_size = *p_data++;
5806             // avoid reading too much from the buffer
5807             i_size = min( i_size, ((*index)->GetSize() - 1) >> 3 );
5808             for ( ; i_size > 0; i_size--, p_data += 8 )
5809             {
5810                 msg_Dbg( &sys.demuxer, "Matroska DVD enter command" );
5811                 f_result |= sys.dvd_interpretor.Interpret( p_data );
5812             }
5813         }
5814         index++;
5815     }
5816     return f_result;
5817 }
5818
5819 bool dvd_chapter_codec_c::Leave()
5820 {
5821     bool f_result = false;
5822     std::vector<KaxChapterProcessData*>::iterator index = leave_cmds.begin();
5823     while ( index != leave_cmds.end() )
5824     {
5825         if ( (*index)->GetSize() )
5826         {
5827             binary *p_data = (*index)->GetBuffer();
5828             size_t i_size = *p_data++;
5829             // avoid reading too much from the buffer
5830             i_size = min( i_size, ((*index)->GetSize() - 1) >> 3 );
5831             for ( ; i_size > 0; i_size--, p_data += 8 )
5832             {
5833                 msg_Dbg( &sys.demuxer, "Matroska DVD leave command" );
5834                 f_result |= sys.dvd_interpretor.Interpret( p_data );
5835             }
5836         }
5837         index++;
5838     }
5839     return f_result;
5840 }
5841
5842 // see http://www.dvd-replica.com/DVD/vmcmdset.php for a description of DVD commands
5843 bool dvd_command_interpretor_c::Interpret( const binary * p_command, size_t i_size )
5844 {
5845     if ( i_size != 8 )
5846         return false;
5847
5848     virtual_segment_c *p_segment = NULL;
5849     chapter_item_c *p_chapter = NULL;
5850     bool f_result = false;
5851     uint16 i_command = ( p_command[0] << 8 ) + p_command[1];
5852
5853     // handle register tests if there are some
5854     if ( (i_command & 0xF0) != 0 )
5855     {
5856         bool b_test_positive = true;//(i_command & CMD_DVD_IF_NOT) == 0;
5857         bool b_test_value    = (i_command & CMD_DVD_TEST_VALUE) != 0;
5858         uint8 i_test = i_command & 0x70;
5859         uint16 i_value;
5860
5861         // see http://dvd.sourceforge.net/dvdinfo/vmi.html
5862         uint8  i_cr1;
5863         uint16 i_cr2;
5864         switch ( i_command >> 12 )
5865         {
5866         default:
5867             i_cr1 = p_command[3];
5868             i_cr2 = (p_command[4] << 8) + p_command[5];
5869             break;
5870         case 3:
5871         case 4:
5872         case 5:
5873             i_cr1 = p_command[6];
5874             i_cr2 = p_command[7];
5875             b_test_value = false;
5876             break;
5877         case 6:
5878         case 7:
5879             if ( ((p_command[1] >> 4) & 0x7) == 0)
5880             {
5881                 i_cr1 = p_command[2];
5882                 i_cr2 = (p_command[6] << 8) + p_command[7];
5883             }
5884             else
5885             {
5886                 i_cr1 = p_command[2];
5887                 i_cr2 = (p_command[6] << 8) + p_command[7];
5888             }
5889             break;
5890         }
5891
5892         if ( b_test_value )
5893             i_value = i_cr2;
5894         else
5895             i_value = GetPRM( i_cr2 );
5896
5897         switch ( i_test )
5898         {
5899         case CMD_DVD_IF_GPREG_EQUAL:
5900             // if equals
5901             msg_Dbg( &sys.demuxer, "IF %s EQUALS %s", GetRegTypeName( false, i_cr1 ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
5902             if (!( GetPRM( i_cr1 ) == i_value ))
5903             {
5904                 b_test_positive = false;
5905             }
5906             break;
5907         case CMD_DVD_IF_GPREG_NOT_EQUAL:
5908             // if not equals
5909             msg_Dbg( &sys.demuxer, "IF %s NOT EQUALS %s", GetRegTypeName( false, i_cr1 ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
5910             if (!( GetPRM( i_cr1 ) != i_value ))
5911             {
5912                 b_test_positive = false;
5913             }
5914             break;
5915         case CMD_DVD_IF_GPREG_INF:
5916             // if inferior
5917             msg_Dbg( &sys.demuxer, "IF %s < %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
5918             if (!( GetPRM( i_cr1 ) < i_value ))
5919             {
5920                 b_test_positive = false;
5921             }
5922             break;
5923         case CMD_DVD_IF_GPREG_INF_EQUAL:
5924             // if inferior or equal
5925             msg_Dbg( &sys.demuxer, "IF %s < %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
5926             if (!( GetPRM( i_cr1 ) <= i_value ))
5927             {
5928                 b_test_positive = false;
5929             }
5930             break;
5931         case CMD_DVD_IF_GPREG_AND:
5932             // if logical and
5933             msg_Dbg( &sys.demuxer, "IF %s & %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
5934             if (!( GetPRM( i_cr1 ) & i_value ))
5935             {
5936                 b_test_positive = false;
5937             }
5938             break;
5939         case CMD_DVD_IF_GPREG_SUP:
5940             // if superior
5941             msg_Dbg( &sys.demuxer, "IF %s >= %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
5942             if (!( GetPRM( i_cr1 ) > i_value ))
5943             {
5944                 b_test_positive = false;
5945             }
5946             break;
5947         case CMD_DVD_IF_GPREG_SUP_EQUAL:
5948             // if superior or equal
5949             msg_Dbg( &sys.demuxer, "IF %s >= %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
5950             if (!( GetPRM( i_cr1 ) >= i_value ))
5951             {
5952                 b_test_positive = false;
5953             }
5954             break;
5955         }
5956
5957         if ( !b_test_positive )
5958             return false;
5959     }
5960
5961     // strip the test command
5962     i_command &= 0xFF0F;
5963
5964     switch ( i_command )
5965     {
5966     case CMD_DVD_NOP:
5967     case CMD_DVD_NOP2:
5968         {
5969             msg_Dbg( &sys.demuxer, "NOP" );
5970             break;
5971         }
5972     case CMD_DVD_BREAK:
5973         {
5974             msg_Dbg( &sys.demuxer, "Break" );
5975             // TODO
5976             break;
5977         }
5978     case CMD_DVD_JUMP_TT:
5979         {
5980             uint8 i_title = p_command[5];
5981             msg_Dbg( &sys.demuxer, "JumpTT %d", i_title );
5982
5983             // find in the ChapProcessPrivate matching this Title level
5984             p_chapter = sys.BrowseCodecPrivate( 1, MatchTitleNumber, &i_title, sizeof(i_title), p_segment );
5985             if ( p_segment != NULL )
5986             {
5987                 sys.JumpTo( *p_segment, p_chapter );
5988                 f_result = true;
5989             }
5990
5991             break;
5992         }
5993     case CMD_DVD_CALLSS_VTSM1:
5994         {
5995             msg_Dbg( &sys.demuxer, "CallSS" );
5996             binary p_type;
5997             switch( (p_command[6] & 0xC0) >> 6 ) {
5998                 case 0:
5999                     p_type = p_command[5] & 0x0F;
6000                     switch ( p_type )
6001                     {
6002                     case 0x00:
6003                         msg_Dbg( &sys.demuxer, "CallSS PGC (rsm_cell %x)", p_command[4]);
6004                         break;
6005                     case 0x02:
6006                         msg_Dbg( &sys.demuxer, "CallSS Title Entry (rsm_cell %x)", p_command[4]);
6007                         break;
6008                     case 0x03:
6009                         msg_Dbg( &sys.demuxer, "CallSS Root Menu (rsm_cell %x)", p_command[4]);
6010                         break;
6011                     case 0x04:
6012                         msg_Dbg( &sys.demuxer, "CallSS Subpicture Menu (rsm_cell %x)", p_command[4]);
6013                         break;
6014                     case 0x05:
6015                         msg_Dbg( &sys.demuxer, "CallSS Audio Menu (rsm_cell %x)", p_command[4]);
6016                         break;
6017                     case 0x06:
6018                         msg_Dbg( &sys.demuxer, "CallSS Angle Menu (rsm_cell %x)", p_command[4]);
6019                         break;
6020                     case 0x07:
6021                         msg_Dbg( &sys.demuxer, "CallSS Chapter Menu (rsm_cell %x)", p_command[4]);
6022                         break;
6023                     default:
6024                         msg_Dbg( &sys.demuxer, "CallSS <unknown> (rsm_cell %x)", p_command[4]);
6025                         break;
6026                     }
6027                     p_chapter = sys.BrowseCodecPrivate( 1, MatchPgcType, &p_type, 1, p_segment );
6028                     if ( p_segment != NULL )
6029                     {
6030                         sys.JumpTo( *p_segment, p_chapter );
6031                         f_result = true;
6032                     }
6033                 break;
6034                 case 1:
6035                     msg_Dbg( &sys.demuxer, "CallSS VMGM (menu %d, rsm_cell %x)", p_command[5] & 0x0F, p_command[4]);
6036                 break;
6037                 case 2:
6038                     msg_Dbg( &sys.demuxer, "CallSS VTSM (menu %d, rsm_cell %x)", p_command[5] & 0x0F, p_command[4]);
6039                 break;
6040                 case 3:
6041                     msg_Dbg( &sys.demuxer, "CallSS VMGM (pgc %d, rsm_cell %x)", (p_command[2] << 8) + p_command[3], p_command[4]);
6042                 break;
6043             }
6044             break;
6045         }
6046     case CMD_DVD_JUMP_SS:
6047         {
6048             msg_Dbg( &sys.demuxer, "JumpSS");
6049             binary p_type;
6050             switch( (p_command[5] & 0xC0) >> 6 ) {
6051                 case 0:
6052                     msg_Dbg( &sys.demuxer, "JumpSS FP");
6053                 break;
6054                 case 1:
6055                     p_type = p_command[5] & 0x0F;
6056                     switch ( p_type )
6057                     {
6058                     case 0x02:
6059                         msg_Dbg( &sys.demuxer, "JumpSS VMGM Title Entry");
6060                         break;
6061                     case 0x03:
6062                         msg_Dbg( &sys.demuxer, "JumpSS VMGM Root Menu");
6063                         break;
6064                     case 0x04:
6065                         msg_Dbg( &sys.demuxer, "JumpSS VMGM Subpicture Menu");
6066                         break;
6067                     case 0x05:
6068                         msg_Dbg( &sys.demuxer, "JumpSS VMGM Audio Menu");
6069                         break;
6070                     case 0x06:
6071                         msg_Dbg( &sys.demuxer, "JumpSS VMGM Angle Menu");
6072                         break;
6073                     case 0x07:
6074                         msg_Dbg( &sys.demuxer, "JumpSS VMGM Chapter Menu");
6075                         break;
6076                     default:
6077                         msg_Dbg( &sys.demuxer, "JumpSS <unknown>");
6078                         break;
6079                     }
6080                     // find the VMG
6081                     p_chapter = sys.BrowseCodecPrivate( 1, MatchIsVMG, NULL, 0, p_segment );
6082                     if ( p_segment != NULL )
6083                     {
6084                         p_chapter = p_segment->BrowseCodecPrivate( 1, MatchPgcType, &p_type, 1 );
6085                         if ( p_chapter != NULL )
6086                         {
6087                             sys.JumpTo( *p_segment, p_chapter );
6088                             f_result = true;
6089                         }
6090                     }
6091                 break;
6092                 case 2:
6093                     p_type = p_command[5] & 0x0F;
6094                     switch ( p_type )
6095                     {
6096                     case 0x02:
6097                         msg_Dbg( &sys.demuxer, "JumpSS VTSM (vts %d, ttn %d) Title Entry", p_command[4], p_command[3]);
6098                         break;
6099                     case 0x03:
6100                         msg_Dbg( &sys.demuxer, "JumpSS VTSM (vts %d, ttn %d) Root Menu", p_command[4], p_command[3]);
6101                         break;
6102                     case 0x04:
6103                         msg_Dbg( &sys.demuxer, "JumpSS VTSM (vts %d, ttn %d) Subpicture Menu", p_command[4], p_command[3]);
6104                         break;
6105                     case 0x05:
6106                         msg_Dbg( &sys.demuxer, "JumpSS VTSM (vts %d, ttn %d) Audio Menu", p_command[4], p_command[3]);
6107                         break;
6108                     case 0x06:
6109                         msg_Dbg( &sys.demuxer, "JumpSS VTSM (vts %d, ttn %d) Angle Menu", p_command[4], p_command[3]);
6110                         break;
6111                     case 0x07:
6112                         msg_Dbg( &sys.demuxer, "JumpSS VTSM (vts %d, ttn %d) Chapter Menu", p_command[4], p_command[3]);
6113                         break;
6114                     default:
6115                         msg_Dbg( &sys.demuxer, "JumpSS VTSM (vts %d, ttn %d) <unknown>", p_command[4], p_command[3]);
6116                         break;
6117                     }
6118
6119                     p_chapter = sys.BrowseCodecPrivate( 1, MatchVTSMNumber, &p_command[4], 1, p_segment );
6120
6121                     if ( p_segment != NULL && p_chapter != NULL )
6122                     {
6123                         // find the title in the VTS
6124                         p_chapter = p_chapter->BrowseCodecPrivate( 1, MatchTitleNumber, &p_command[3], 1 );
6125                         if ( p_chapter != NULL )
6126                         {
6127                             // find the specified menu in the VTSM
6128                             p_chapter = p_segment->BrowseCodecPrivate( 1, MatchPgcType, &p_type, 1 );
6129                             if ( p_chapter != NULL )
6130                             {
6131                                 sys.JumpTo( *p_segment, p_chapter );
6132                                 f_result = true;
6133                             }
6134                         }
6135                         else
6136                             msg_Dbg( &sys.demuxer, "Title (%d) does not exist in this VTS", p_command[3] );
6137                     }
6138                     else
6139                         msg_Dbg( &sys.demuxer, "DVD Domain VTS (%d) not found", p_command[4] );
6140                 break;
6141                 case 3:
6142                     msg_Dbg( &sys.demuxer, "JumpSS VMGM (pgc %d)", (p_command[2] << 8) + p_command[3]);
6143                 break;
6144             }
6145             break;
6146         }
6147     case CMD_DVD_JUMPVTS_PTT:
6148         {
6149             uint8 i_title = p_command[5];
6150             uint8 i_ptt = p_command[3];
6151
6152             msg_Dbg( &sys.demuxer, "JumpVTS Title (%d) PTT (%d)", i_title, i_ptt);
6153
6154             // find the current VTS content segment
6155             p_chapter = sys.p_current_segment->BrowseCodecPrivate( 1, MatchIsDomain, NULL, 0 );
6156             if ( p_chapter != NULL )
6157             {
6158                 int16 i_curr_title = p_chapter->GetTitleNumber( );
6159                 if ( i_curr_title > 0 )
6160                 {
6161                     p_chapter = sys.BrowseCodecPrivate( 1, MatchVTSNumber, &i_curr_title, sizeof(i_curr_title), p_segment );
6162
6163                     if ( p_segment != NULL && p_chapter != NULL )
6164                     {
6165                         // find the title in the VTS
6166                         p_chapter = p_chapter->BrowseCodecPrivate( 1, MatchTitleNumber, &i_title, sizeof(i_title) );
6167                         if ( p_chapter != NULL )
6168                         {
6169                             // find the chapter in the title
6170                             p_chapter = p_chapter->BrowseCodecPrivate( 1, MatchChapterNumber, &i_ptt, sizeof(i_ptt) );
6171                             if ( p_chapter != NULL )
6172                             {
6173                                 sys.JumpTo( *p_segment, p_chapter );
6174                                 f_result = true;
6175                             }
6176                         }
6177                     else
6178                         msg_Dbg( &sys.demuxer, "Title (%d) does not exist in this VTS", i_title );
6179                     }
6180                     else
6181                         msg_Dbg( &sys.demuxer, "DVD Domain VTS (%d) not found", i_curr_title );
6182                 }
6183                 else
6184                     msg_Dbg( &sys.demuxer, "JumpVTS_PTT command found but not in a VTS(M)");
6185             }
6186             else
6187                 msg_Dbg( &sys.demuxer, "JumpVTS_PTT command but the DVD domain wasn't found");
6188             break;
6189         }
6190     case CMD_DVD_SET_GPRMMD:
6191         {
6192             msg_Dbg( &sys.demuxer, "Set GPRMMD [%d]=%d", (p_command[4] << 8) + p_command[5], (p_command[2] << 8) + p_command[3]);
6193
6194             if ( !SetGPRM( (p_command[4] << 8) + p_command[5], (p_command[2] << 8) + p_command[3] ) )
6195                 msg_Dbg( &sys.demuxer, "Set GPRMMD failed" );
6196             break;
6197         }
6198     case CMD_DVD_LINKPGCN:
6199         {
6200             uint16 i_pgcn = (p_command[6] << 8) + p_command[7];
6201
6202             msg_Dbg( &sys.demuxer, "Link PGCN(%d)", i_pgcn );
6203             p_chapter = sys.p_current_segment->BrowseCodecPrivate( 1, MatchPgcNumber, &i_pgcn, 2 );
6204             if ( p_chapter != NULL )
6205             {
6206                 if ( !p_chapter->Enter( true ) )
6207                     // jump to the location in the found segment
6208                     sys.p_current_segment->Seek( sys.demuxer, p_chapter->i_user_start_time, -1, p_chapter );
6209
6210                 f_result = true;
6211             }
6212             break;
6213         }
6214     case CMD_DVD_LINKCN:
6215         {
6216             uint8 i_cn = p_command[7];
6217
6218             p_chapter = sys.p_current_segment->CurrentChapter();
6219
6220             msg_Dbg( &sys.demuxer, "LinkCN (cell %d)", i_cn );
6221             p_chapter = p_chapter->BrowseCodecPrivate( 1, MatchCellNumber, &i_cn, 1 );
6222             if ( p_chapter != NULL )
6223             {
6224                 if ( !p_chapter->Enter( true ) )
6225                     // jump to the location in the found segment
6226                     sys.p_current_segment->Seek( sys.demuxer, p_chapter->i_user_start_time, -1, p_chapter );
6227
6228                 f_result = true;
6229             }
6230             break;
6231         }
6232     case CMD_DVD_GOTO_LINE:
6233         {
6234             msg_Dbg( &sys.demuxer, "GotoLine (%d)", (p_command[6] << 8) + p_command[7] );
6235             // TODO
6236             break;
6237         }
6238     case CMD_DVD_SET_HL_BTNN1:
6239         {
6240             msg_Dbg( &sys.demuxer, "SetHL_BTN (%d)", p_command[4] );
6241             SetSPRM( 0x88, p_command[4] );
6242             break;
6243         }
6244     default:
6245         {
6246             msg_Dbg( &sys.demuxer, "unsupported command : %02X %02X %02X %02X %02X %02X %02X %02X"
6247                      ,p_command[0]
6248                      ,p_command[1]
6249                      ,p_command[2]
6250                      ,p_command[3]
6251                      ,p_command[4]
6252                      ,p_command[5]
6253                      ,p_command[6]
6254                      ,p_command[7]);
6255             break;
6256         }
6257     }
6258
6259     return f_result;
6260 }
6261
6262 bool dvd_command_interpretor_c::MatchIsDomain( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size )
6263 {
6264     return ( data.p_private_data != NULL && data.p_private_data->GetBuffer()[0] == MATROSKA_DVD_LEVEL_SS );
6265 }
6266
6267 bool dvd_command_interpretor_c::MatchIsVMG( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size )
6268 {
6269     if ( data.p_private_data == NULL || data.p_private_data->GetSize() < 2 )
6270         return false;
6271
6272     return ( data.p_private_data->GetBuffer()[0] == MATROSKA_DVD_LEVEL_SS && data.p_private_data->GetBuffer()[1] == 0xC0);
6273 }
6274
6275 bool dvd_command_interpretor_c::MatchVTSNumber( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size )
6276 {
6277     if ( i_cookie_size != 2 || data.p_private_data == NULL || data.p_private_data->GetSize() < 4 )
6278         return false;
6279
6280     if ( data.p_private_data->GetBuffer()[0] != MATROSKA_DVD_LEVEL_SS || data.p_private_data->GetBuffer()[1] != 0x80 )
6281         return false;
6282
6283     uint16 i_gtitle = (data.p_private_data->GetBuffer()[2] << 8 ) + data.p_private_data->GetBuffer()[3];
6284     uint16 i_title = *(uint16*)p_cookie;
6285
6286     return (i_gtitle == i_title);
6287 }
6288
6289 bool dvd_command_interpretor_c::MatchVTSMNumber( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size )
6290 {
6291     if ( i_cookie_size != 1 || data.p_private_data == NULL || data.p_private_data->GetSize() < 4 )
6292         return false;
6293
6294     if ( data.p_private_data->GetBuffer()[0] != MATROSKA_DVD_LEVEL_SS || data.p_private_data->GetBuffer()[1] != 0x40 )
6295         return false;
6296
6297     uint8 i_gtitle = data.p_private_data->GetBuffer()[3];
6298     uint8 i_title = *(uint8*)p_cookie;
6299
6300     return (i_gtitle == i_title);
6301 }
6302
6303 bool dvd_command_interpretor_c::MatchTitleNumber( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size )
6304 {
6305     if ( i_cookie_size != 1 || data.p_private_data == NULL || data.p_private_data->GetSize() < 4 )
6306         return false;
6307
6308     if ( data.p_private_data->GetBuffer()[0] != MATROSKA_DVD_LEVEL_TT )
6309         return false;
6310
6311     uint16 i_gtitle = (data.p_private_data->GetBuffer()[1] << 8 ) + data.p_private_data->GetBuffer()[2];
6312     uint8 i_title = *(uint8*)p_cookie;
6313
6314     return (i_gtitle == i_title);
6315 }
6316
6317 bool dvd_command_interpretor_c::MatchPgcType( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size )
6318 {
6319     if ( i_cookie_size != 1 || data.p_private_data == NULL || data.p_private_data->GetSize() < 8 )
6320         return false;
6321
6322     if ( data.p_private_data->GetBuffer()[0] != MATROSKA_DVD_LEVEL_PGC )
6323         return false;
6324
6325     uint8 i_pgc_type = data.p_private_data->GetBuffer()[3] & 0x0F;
6326     uint8 i_pgc = *(uint8*)p_cookie;
6327
6328     return (i_pgc_type == i_pgc);
6329 }
6330
6331 bool dvd_command_interpretor_c::MatchPgcNumber( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size )
6332 {
6333     if ( i_cookie_size != 2 || data.p_private_data == NULL || data.p_private_data->GetSize() < 8 )
6334         return false;
6335
6336     if ( data.p_private_data->GetBuffer()[0] != MATROSKA_DVD_LEVEL_PGC )
6337         return false;
6338
6339     uint16 *i_pgc_n = (uint16 *)p_cookie;
6340     uint16 i_pgc_num = (data.p_private_data->GetBuffer()[1] << 8) + data.p_private_data->GetBuffer()[2];
6341
6342     return (i_pgc_num == *i_pgc_n);
6343 }
6344
6345 bool dvd_command_interpretor_c::MatchChapterNumber( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size )
6346 {
6347     if ( i_cookie_size != 1 || data.p_private_data == NULL || data.p_private_data->GetSize() < 2 )
6348         return false;
6349
6350     if ( data.p_private_data->GetBuffer()[0] != MATROSKA_DVD_LEVEL_PTT )
6351         return false;
6352
6353     uint8 i_chapter = data.p_private_data->GetBuffer()[1];
6354     uint8 i_ptt = *(uint8*)p_cookie;
6355
6356     return (i_chapter == i_ptt);
6357 }
6358
6359 bool dvd_command_interpretor_c::MatchCellNumber( const chapter_codec_cmds_c &data, const void *p_cookie, size_t i_cookie_size )
6360 {
6361     if ( i_cookie_size != 1 || data.p_private_data == NULL || data.p_private_data->GetSize() < 5 )
6362         return false;
6363
6364     if ( data.p_private_data->GetBuffer()[0] != MATROSKA_DVD_LEVEL_CN )
6365         return false;
6366
6367     uint8 *i_cell_n = (uint8 *)p_cookie;
6368     uint8 i_cell_num = data.p_private_data->GetBuffer()[3];
6369
6370     return (i_cell_num == *i_cell_n);
6371 }
6372
6373 bool matroska_script_codec_c::Enter()
6374 {
6375     bool f_result = false;
6376     std::vector<KaxChapterProcessData*>::iterator index = enter_cmds.begin();
6377     while ( index != enter_cmds.end() )
6378     {
6379         if ( (*index)->GetSize() )
6380         {
6381             msg_Dbg( &sys.demuxer, "Matroska Script enter command" );
6382             f_result |= interpretor.Interpret( (*index)->GetBuffer(), (*index)->GetSize() );
6383         }
6384         index++;
6385     }
6386     return f_result;
6387 }
6388
6389 bool matroska_script_codec_c::Leave()
6390 {
6391     bool f_result = false;
6392     std::vector<KaxChapterProcessData*>::iterator index = leave_cmds.begin();
6393     while ( index != leave_cmds.end() )
6394     {
6395         if ( (*index)->GetSize() )
6396         {
6397             msg_Dbg( &sys.demuxer, "Matroska Script leave command" );
6398             f_result |= interpretor.Interpret( (*index)->GetBuffer(), (*index)->GetSize() );
6399         }
6400         index++;
6401     }
6402     return f_result;
6403 }
6404
6405 // see http://www.matroska.org/technical/specs/chapters/index.html#mscript
6406 //  for a description of existing commands
6407 bool matroska_script_interpretor_c::Interpret( const binary * p_command, size_t i_size )
6408 {
6409     bool b_result = false;
6410
6411     char *psz_str = (char*) malloc( i_size + 1 );
6412     memcpy( psz_str, p_command, i_size );
6413     psz_str[ i_size ] = '\0';
6414
6415     std::string sz_command = psz_str;
6416     free( psz_str );
6417
6418     msg_Dbg( &sys.demuxer, "command : %s", sz_command.c_str() );
6419
6420 #if defined(__GNUC__) && (__GNUC__ < 3)
6421     if ( sz_command.compare( CMD_MS_GOTO_AND_PLAY, 0, CMD_MS_GOTO_AND_PLAY.size() ) == 0 )
6422 #else
6423     if ( sz_command.compare( 0, CMD_MS_GOTO_AND_PLAY.size(), CMD_MS_GOTO_AND_PLAY ) == 0 )
6424 #endif
6425     {
6426         size_t i,j;
6427
6428         // find the (
6429         for ( i=CMD_MS_GOTO_AND_PLAY.size(); i<sz_command.size(); i++)
6430         {
6431             if ( sz_command[i] == '(' )
6432             {
6433                 i++;
6434                 break;
6435             }
6436         }
6437         // find the )
6438         for ( j=i; j<sz_command.size(); j++)
6439         {
6440             if ( sz_command[j] == ')' )
6441             {
6442                 i--;
6443                 break;
6444             }
6445         }
6446
6447         std::string st = sz_command.substr( i+1, j-i-1 );
6448         int64_t i_chapter_uid = atoi( st.c_str() );
6449
6450         virtual_segment_c *p_segment;
6451         chapter_item_c *p_chapter = sys.FindChapter( i_chapter_uid, p_segment );
6452
6453         if ( p_chapter == NULL )
6454             msg_Dbg( &sys.demuxer, "Chapter "I64Fd" not found", i_chapter_uid);
6455         else
6456         {
6457             if ( !p_chapter->EnterAndLeave( sys.p_current_segment->CurrentChapter() ) )
6458                 p_segment->Seek( sys.demuxer, p_chapter->i_user_start_time, -1, p_chapter );
6459             b_result = true;
6460         }
6461     }
6462
6463     return b_result;
6464 }
6465
6466 void demux_sys_t::SwapButtons()
6467 {
6468 #ifndef WORDS_BIGENDIAN
6469     uint8_t button, i, j;
6470
6471     for( button = 1; button <= pci_packet.hli.hl_gi.btn_ns; button++) {
6472         btni_t *button_ptr = &(pci_packet.hli.btnit[button-1]);
6473         binary *p_data = (binary*) button_ptr;
6474
6475         uint16 i_x_start = ((p_data[0] & 0x3F) << 4 ) + ( p_data[1] >> 4 );
6476         uint16 i_x_end   = ((p_data[1] & 0x03) << 8 ) + p_data[2];
6477         uint16 i_y_start = ((p_data[3] & 0x3F) << 4 ) + ( p_data[4] >> 4 );
6478         uint16 i_y_end   = ((p_data[4] & 0x03) << 8 ) + p_data[5];
6479         button_ptr->x_start = i_x_start;
6480         button_ptr->x_end   = i_x_end;
6481         button_ptr->y_start = i_y_start;
6482         button_ptr->y_end   = i_y_end;
6483
6484     }
6485     for ( i = 0; i<3; i++ )
6486     {
6487         for ( j = 0; j<2; j++ )
6488         {
6489             pci_packet.hli.btn_colit.btn_coli[i][j] = U32_AT( &pci_packet.hli.btn_colit.btn_coli[i][j] );
6490         }
6491     }
6492 #endif
6493 }