git.sesse.net Git - vlc/blob - modules/demux/mkv/matroska_segment.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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #include "matroska_segment.hpp"
  26
  27 #include "chapters.hpp"
  28
  29 #include "demux.hpp"
  30
  31 /* Destructor */
  32 matroska_segment_c::~matroska_segment_c()
  33 {
  34     for( size_t i_track = 0; i_track < tracks.size(); i_track++ )
  35     {
  36         delete tracks[i_track]->p_compression_data;
  37         es_format_Clean( &tracks[i_track]->fmt );
  38         free( tracks[i_track]->p_extra_data );
  39         free( tracks[i_track]->psz_codec );
  40         delete tracks[i_track];
  41     }
  42
  43     free( psz_writing_application );
  44     free( psz_muxing_application );
  45     free( psz_segment_filename );
  46     free( psz_title );
  47     free( psz_date_utc );
  48     free( p_indexes );
  49
  50     delete ep;
  51     delete segment;
  52     delete p_segment_uid;
  53     delete p_prev_segment_uid;
  54     delete p_next_segment_uid;
  55
  56     std::vector<chapter_edition_c*>::iterator index = stored_editions.begin();
  57     while ( index != stored_editions.end() )
  58     {
  59         delete (*index);
  60         index++;
  61     }
  62     std::vector<chapter_translation_c*>::iterator indext = translations.begin();
  63     while ( indext != translations.end() )
  64     {
  65         delete (*indext);
  66         indext++;
  67     }
  68     std::vector<KaxSegmentFamily*>::iterator indexf = families.begin();
  69     while ( indexf != families.end() )
  70     {
  71         delete (*indexf);
  72         indexf++;
  73    }
  74 }
  75
  76
  77 /*****************************************************************************
  78  * Tools
  79  *  * LoadCues : load the cues element and update index
  80  *
  81  *  * LoadTags : load ... the tags element
  82  *
  83  *  * InformationCreate : create all information, load tags if present
  84  *
  85  *****************************************************************************/
  86 void matroska_segment_c::LoadCues( KaxCues *cues )
  87 {
  88     EbmlParser  *ep;
  89     EbmlElement *el;
  90     size_t i, j;
  91
  92     if( b_cues )
  93     {
  94         msg_Err( &sys.demuxer, "There can be only 1 Cues per section." );
  95         return;
  96     }
  97
  98     ep = new EbmlParser( &es, cues, &sys.demuxer );
  99     while( ( el = ep->Get() ) != NULL )
 100     {
 101         if( MKV_IS_ID( el, KaxCuePoint ) )
 102         {
 103 #define idx p_indexes[i_index]
 104
 105             idx.i_track       = -1;
 106             idx.i_block_number= -1;
 107             idx.i_position    = -1;
 108             idx.i_time        = 0;
 109             idx.b_key         = true;
 110
 111             ep->Down();
 112             while( ( el = ep->Get() ) != NULL )
 113             {
 114                 if( MKV_IS_ID( el, KaxCueTime ) )
 115                 {
 116                     KaxCueTime &ctime = *(KaxCueTime*)el;
 117
 118                     ctime.ReadData( es.I_O() );
 119
 120                     idx.i_time = uint64( ctime ) * i_timescale / (mtime_t)1000;
 121                 }
 122                 else if( MKV_IS_ID( el, KaxCueTrackPositions ) )
 123                 {
 124                     ep->Down();
 125                     while( ( el = ep->Get() ) != NULL )
 126                     {
 127                         if( MKV_IS_ID( el, KaxCueTrack ) )
 128                         {
 129                             KaxCueTrack &ctrack = *(KaxCueTrack*)el;
 130
 131                             ctrack.ReadData( es.I_O() );
 132                             idx.i_track = uint16( ctrack );
 133                         }
 134                         else if( MKV_IS_ID( el, KaxCueClusterPosition ) )
 135                         {
 136                             KaxCueClusterPosition &ccpos = *(KaxCueClusterPosition*)el;
 137
 138                             ccpos.ReadData( es.I_O() );
 139                             idx.i_position = segment->GetGlobalPosition( uint64( ccpos ) );
 140                         }
 141                         else if( MKV_IS_ID( el, KaxCueBlockNumber ) )
 142                         {
 143                             KaxCueBlockNumber &cbnum = *(KaxCueBlockNumber*)el;
 144
 145                             cbnum.ReadData( es.I_O() );
 146                             idx.i_block_number = uint32( cbnum );
 147                         }
 148                         else
 149                         {
 150                             msg_Dbg( &sys.demuxer, "         * Unknown (%s)", typeid(*el).name() );
 151                         }
 152                     }
 153                     ep->Up();
 154                 }
 155                 else
 156                 {
 157                     msg_Dbg( &sys.demuxer, "     * Unknown (%s)", typeid(*el).name() );
 158                 }
 159             }
 160             ep->Up();
 161
 162 #if 0
 163             msg_Dbg( &sys.demuxer, " * added time=%"PRId64" pos=%"PRId64
 164                      " track=%d bnum=%d", idx.i_time, idx.i_position,
 165                      idx.i_track, idx.i_block_number );
 166 #endif
 167
 168             i_index++;
 169             if( i_index >= i_index_max )
 170             {
 171                 i_index_max += 1024;
 172                 p_indexes = (mkv_index_t*)realloc( p_indexes, sizeof( mkv_index_t ) * i_index_max );
 173             }
 174 #undef idx
 175         }
 176         else
 177         {
 178             msg_Dbg( &sys.demuxer, " * Unknown (%s)", typeid(*el).name() );
 179         }
 180     }
 181     delete ep;
 182     b_cues = true;
 183     msg_Dbg( &sys.demuxer, "|   - loading cues done." );
 184 }
 185
 186 void matroska_segment_c::LoadTags( KaxTags *tags )
 187 {
 188     EbmlParser  *ep;
 189     EbmlElement *el;
 190     size_t i, j;
 191
 192     /* Master elements */
 193     ep = new EbmlParser( &es, tags, &sys.demuxer );
 194
 195     while( ( el = ep->Get() ) != NULL )
 196     {
 197         if( MKV_IS_ID( el, KaxTag ) )
 198         {
 199             msg_Dbg( &sys.demuxer, "+ Tag" );
 200             ep->Down();
 201             while( ( el = ep->Get() ) != NULL )
 202             {
 203                 if( MKV_IS_ID( el, KaxTagTargets ) )
 204                 {
 205                     msg_Dbg( &sys.demuxer, "|   + Targets" );
 206                     ep->Down();
 207                     while( ( el = ep->Get() ) != NULL )
 208                     {
 209                         msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid( *el ).name() );
 210                     }
 211                     ep->Up();
 212                 }
 213                 else if( MKV_IS_ID( el, KaxTagGeneral ) )
 214                 {
 215                     msg_Dbg( &sys.demuxer, "|   + General" );
 216                     ep->Down();
 217                     while( ( el = ep->Get() ) != NULL )
 218                     {
 219                         msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid( *el ).name() );
 220                     }
 221                     ep->Up();
 222                 }
 223                 else if( MKV_IS_ID( el, KaxTagGenres ) )
 224                 {
 225                     msg_Dbg( &sys.demuxer, "|   + Genres" );
 226                     ep->Down();
 227                     while( ( el = ep->Get() ) != NULL )
 228                     {
 229                         msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid( *el ).name() );
 230                     }
 231                     ep->Up();
 232                 }
 233                 else if( MKV_IS_ID( el, KaxTagAudioSpecific ) )
 234                 {
 235                     msg_Dbg( &sys.demuxer, "|   + Audio Specific" );
 236                     ep->Down();
 237                     while( ( el = ep->Get() ) != NULL )
 238                     {
 239                         msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid( *el ).name() );
 240                     }
 241                     ep->Up();
 242                 }
 243                 else if( MKV_IS_ID( el, KaxTagImageSpecific ) )
 244                 {
 245                     msg_Dbg( &sys.demuxer, "|   + Images Specific" );
 246                     ep->Down();
 247                     while( ( el = ep->Get() ) != NULL )
 248                     {
 249                         msg_Dbg( &sys.demuxer, "|   |   + Unknown (%s)", typeid( *el ).name() );
 250                     }
 251                     ep->Up();
 252                 }
 253                 else if( MKV_IS_ID( el, KaxTagMultiComment ) )
 254                 {
 255                     msg_Dbg( &sys.demuxer, "|   + Multi Comment" );
 256                 }
 257                 else if( MKV_IS_ID( el, KaxTagMultiCommercial ) )
 258                 {
 259                     msg_Dbg( &sys.demuxer, "|   + Multi Commercial" );
 260                 }
 261                 else if( MKV_IS_ID( el, KaxTagMultiDate ) )
 262                 {
 263                     msg_Dbg( &sys.demuxer, "|   + Multi Date" );
 264                 }
 265                 else if( MKV_IS_ID( el, KaxTagMultiEntity ) )
 266                 {
 267                     msg_Dbg( &sys.demuxer, "|   + Multi Entity" );
 268                 }
 269                 else if( MKV_IS_ID( el, KaxTagMultiIdentifier ) )
 270                 {
 271                     msg_Dbg( &sys.demuxer, "|   + Multi Identifier" );
 272                 }
 273                 else if( MKV_IS_ID( el, KaxTagMultiLegal ) )
 274                 {
 275                     msg_Dbg( &sys.demuxer, "|   + Multi Legal" );
 276                 }
 277                 else if( MKV_IS_ID( el, KaxTagMultiTitle ) )
 278                 {
 279                     msg_Dbg( &sys.demuxer, "|   + Multi Title" );
 280                 }
 281                 else
 282                 {
 283                     msg_Dbg( &sys.demuxer, "|   + LoadTag Unknown (%s)", typeid( *el ).name() );
 284                 }
 285             }
 286             ep->Up();
 287         }
 288         else
 289         {
 290             msg_Dbg( &sys.demuxer, "+ Unknown (%s)", typeid( *el ).name() );
 291         }
 292     }
 293     delete ep;
 294
 295     msg_Dbg( &sys.demuxer, "loading tags done." );
 296 }
 297
 298 /*****************************************************************************
 299  * InformationCreate:
 300  *****************************************************************************/
 301 void matroska_segment_c::InformationCreate( )
 302 {
 303     sys.meta = vlc_meta_New();
 304
 305     if( psz_title )
 306     {
 307         vlc_meta_SetTitle( sys.meta, psz_title );
 308     }
 309     if( psz_date_utc )
 310     {
 311         vlc_meta_SetDate( sys.meta, psz_date_utc );
 312     }
 313 #if 0
 314     if( psz_segment_filename )
 315     {
 316         fprintf( stderr, "***** WARNING: Unhandled meta - Use custom\n" );
 317     }
 318     if( psz_muxing_application )
 319     {
 320         fprintf( stderr, "***** WARNING: Unhandled meta - Use custom\n" );
 321     }
 322     if( psz_writing_application )
 323     {
 324         fprintf( stderr, "***** WARNING: Unhandled meta - Use custom\n" );
 325     }
 326
 327     for( size_t i_track = 0; i_track < tracks.size(); i_track++ )
 328     {
 329 //        mkv_track_t *tk = tracks[i_track];
 330 //        vlc_meta_t *mtk = vlc_meta_New();
 331         fprintf( stderr, "***** WARNING: Unhandled child meta\n");
 332     }
 333 #endif
 334 #if 0
 335     if( i_tags_position >= 0 )
 336     {
 337         bool b_seekable;
 338
 339         stream_Control( sys.demuxer.s, STREAM_CAN_FASTSEEK, &b_seekable );
 340         if( b_seekable )
 341         {
 342             LoadTags( );
 343         }
 344     }
 345 #endif
 346 }
 347
 348
 349 /*****************************************************************************
 350  * Misc
 351  *****************************************************************************/
 352
 353 void matroska_segment_c::IndexAppendCluster( KaxCluster *cluster )
 354 {
 355 #define idx p_indexes[i_index]
 356     idx.i_track       = -1;
 357     idx.i_block_number= -1;
 358     idx.i_position    = cluster->GetElementPosition();
 359     idx.i_time        = -1;
 360     idx.b_key         = true;
 361
 362     i_index++;
 363     if( i_index >= i_index_max )
 364     {
 365         i_index_max += 1024;
 366         p_indexes = (mkv_index_t*)realloc( p_indexes, sizeof( mkv_index_t ) * i_index_max );
 367     }
 368 #undef idx
 369 }
 370
 371
 372 bool matroska_segment_c::PreloadFamily( const matroska_segment_c & of_segment )
 373 {
 374     if ( b_preloaded )
 375         return false;
 376
 377     for (size_t i=0; i<families.size(); i++)
 378     {
 379         for (size_t j=0; j<of_segment.families.size(); j++)
 380         {
 381             if ( *(families[i]) == *(of_segment.families[j]) )
 382                 return Preload( );
 383         }
 384     }
 385
 386     return false;
 387 }
 388
 389 bool matroska_segment_c::CompareSegmentUIDs( const matroska_segment_c * p_item_a, const matroska_segment_c * p_item_b )
 390 {
 391     EbmlBinary *p_tmp;
 392
 393     if ( p_item_a == NULL || p_item_b == NULL )
 394         return false;
 395
 396     p_tmp = (EbmlBinary *)p_item_a->p_segment_uid;
 397     if ( p_item_b->p_prev_segment_uid != NULL
 398           && *p_tmp == *p_item_b->p_prev_segment_uid )
 399         return true;
 400
 401     p_tmp = (EbmlBinary *)p_item_a->p_next_segment_uid;
 402     if ( !p_tmp )
 403         return false;
 404
 405     if ( p_item_b->p_segment_uid != NULL
 406           && *p_tmp == *p_item_b->p_segment_uid )
 407         return true;
 408
 409     if ( p_item_b->p_prev_segment_uid != NULL
 410           && *p_tmp == *p_item_b->p_prev_segment_uid )
 411         return true;
 412
 413     return false;
 414 }
 415
 416 bool matroska_segment_c::Preload( )
 417 {
 418     if ( b_preloaded )
 419         return false;
 420
 421     EbmlElement *el = NULL;
 422
 423     ep->Reset( &sys.demuxer );
 424
 425     while( ( el = ep->Get() ) != NULL )
 426     {
 427         if( MKV_IS_ID( el, KaxSeekHead ) )
 428         {
 429             /* Multiple allowed */
 430             /* We bail at 10, to prevent possible recursion */
 431             msg_Dbg(  &sys.demuxer, "|   + Seek head" );
 432             if( i_seekhead_count < 10 )
 433             {
 434                 i_seekhead_position = (int64_t) es.I_O().getFilePointer();
 435                 ParseSeekHead( static_cast<KaxSeekHead*>( el ) );
 436             }
 437         }
 438         else if( MKV_IS_ID( el, KaxInfo ) )
 439         {
 440             /* Multiple allowed, mandatory */
 441             msg_Dbg(  &sys.demuxer, "|   + Information" );
 442             if( i_info_position < 0 ) // FIXME
 443                 ParseInfo( static_cast<KaxInfo*>( el ) );
 444             i_info_position = (int64_t) es.I_O().getFilePointer();
 445         }
 446         else if( MKV_IS_ID( el, KaxTracks ) )
 447         {
 448             /* Multiple allowed */
 449             msg_Dbg(  &sys.demuxer, "|   + Tracks" );
 450             if( i_tracks_position < 0 ) // FIXME
 451                 ParseTracks( static_cast<KaxTracks*>( el ) );
 452             if ( tracks.size() == 0 )
 453             {
 454                 msg_Err( &sys.demuxer, "No tracks supported" );
 455                 return false;
 456             }
 457             i_tracks_position = (int64_t) es.I_O().getFilePointer();
 458         }
 459         else if( MKV_IS_ID( el, KaxCues ) )
 460         {
 461             msg_Dbg(  &sys.demuxer, "|   + Cues" );
 462             if( i_cues_position < 0 )
 463                 LoadCues( static_cast<KaxCues*>( el ) );
 464             i_cues_position = (int64_t) es.I_O().getFilePointer();
 465         }
 466         else if( MKV_IS_ID( el, KaxCluster ) )
 467         {
 468             msg_Dbg( &sys.demuxer, "|   + Cluster" );
 469
 470             cluster = (KaxCluster*)el;
 471
 472             i_cluster_pos = i_start_pos = cluster->GetElementPosition();
 473             ParseCluster( );
 474
 475             ep->Down();
 476             /* stop pre-parsing the stream */
 477             break;
 478         }
 479         else if( MKV_IS_ID( el, KaxAttachments ) )
 480         {
 481             msg_Dbg( &sys.demuxer, "|   + Attachments" );
 482             if( i_attachments_position < 0 )
 483                 ParseAttachments( static_cast<KaxAttachments*>( el ) );
 484             i_attachments_position = (int64_t) es.I_O().getFilePointer();
 485         }
 486         else if( MKV_IS_ID( el, KaxChapters ) )
 487         {
 488             msg_Dbg( &sys.demuxer, "|   + Chapters" );
 489             if( i_chapters_position < 0 )
 490                 ParseChapters( static_cast<KaxChapters*>( el ) );
 491             i_chapters_position = (int64_t) es.I_O().getFilePointer();
 492         }
 493         else if( MKV_IS_ID( el, KaxTag ) )
 494         {
 495             msg_Dbg( &sys.demuxer, "|   + Tags" );
 496             if( i_tags_position < 0) // FIXME
 497                 ;//LoadTags( static_cast<KaxTags*>( el ) );
 498             i_tags_position = (int64_t) es.I_O().getFilePointer();
 499         }
 500         else
 501             msg_Dbg( &sys.demuxer, "|   + Preload Unknown (%s)", typeid(*el).name() );
 502     }
 503
 504     b_preloaded = true;
 505
 506     return true;
 507 }
 508
 509 /* Here we try to load elements that were found in Seek Heads, but not yet parsed */
 510 bool matroska_segment_c::LoadSeekHeadItem( const EbmlCallbacks & ClassInfos, int64_t i_element_position )
 511 {
 512     int64_t     i_sav_position = (int64_t)es.I_O().getFilePointer();
 513     EbmlElement *el;
 514
 515     es.I_O().setFilePointer( i_element_position, seek_beginning );
 516     el = es.FindNextID( ClassInfos, 0xFFFFFFFFL);
 517
 518     if( el == NULL )
 519     {
 520         msg_Err( &sys.demuxer, "cannot load some cues/chapters/tags etc. (broken seekhead or file)" );
 521         es.I_O().setFilePointer( i_sav_position, seek_beginning );
 522         return false;
 523     }
 524
 525     if( MKV_IS_ID( el, KaxSeekHead ) )
 526     {
 527         /* Multiple allowed */
 528         msg_Dbg( &sys.demuxer, "|   + Seek head" );
 529         if( i_seekhead_count < 10 )
 530         {
 531             i_seekhead_position = i_element_position;
 532             ParseSeekHead( static_cast<KaxSeekHead*>( el ) );
 533         }
 534     }
 535     else if( MKV_IS_ID( el, KaxInfo ) ) // FIXME
 536     {
 537         /* Multiple allowed, mandatory */
 538         msg_Dbg( &sys.demuxer, "|   + Information" );
 539         if( i_info_position < 0 )
 540             ParseInfo( static_cast<KaxInfo*>( el ) );
 541         i_info_position = i_element_position;
 542     }
 543     else if( MKV_IS_ID( el, KaxTracks ) ) // FIXME
 544     {
 545         /* Multiple allowed */
 546         msg_Dbg( &sys.demuxer, "|   + Tracks" );
 547         if( i_tracks_position < 0 )
 548             ParseTracks( static_cast<KaxTracks*>( el ) );
 549         if ( tracks.size() == 0 )
 550         {
 551             msg_Err( &sys.demuxer, "No tracks supported" );
 552             delete el;
 553             es.I_O().setFilePointer( i_sav_position, seek_beginning );
 554             return false;
 555         }
 556         i_tracks_position = i_element_position;
 557     }
 558     else if( MKV_IS_ID( el, KaxCues ) )
 559     {
 560         msg_Dbg( &sys.demuxer, "|   + Cues" );
 561         if( i_cues_position < 0 )
 562             LoadCues( static_cast<KaxCues*>( el ) );
 563         i_cues_position = i_element_position;
 564     }
 565     else if( MKV_IS_ID( el, KaxAttachments ) )
 566     {
 567         msg_Dbg( &sys.demuxer, "|   + Attachments" );
 568         if( i_attachments_position < 0 )
 569             ParseAttachments( static_cast<KaxAttachments*>( el ) );
 570         i_attachments_position = i_element_position;
 571     }
 572     else if( MKV_IS_ID( el, KaxChapters ) )
 573     {
 574         msg_Dbg( &sys.demuxer, "|   + Chapters" );
 575         if( i_chapters_position < 0 )
 576             ParseChapters( static_cast<KaxChapters*>( el ) );
 577         i_chapters_position = i_element_position;
 578     }
 579     else if( MKV_IS_ID( el, KaxTag ) ) // FIXME
 580     {
 581         msg_Dbg( &sys.demuxer, "|   + Tags" );
 582         if( i_tags_position < 0 )
 583             ;//LoadTags( static_cast<KaxTags*>( el ) );
 584         i_tags_position = i_element_position;
 585     }
 586     else
 587     {
 588         msg_Dbg( &sys.demuxer, "|   + LoadSeekHeadItem Unknown (%s)", typeid(*el).name() );
 589     }
 590     delete el;
 591
 592     es.I_O().setFilePointer( i_sav_position, seek_beginning );
 593     return true;
 594 }
 595
 596 int matroska_segment_c::BlockFindTrackIndex( size_t *pi_track,
 597                                              const KaxBlock *p_block, const KaxSimpleBlock *p_simpleblock )
 598 {
 599     size_t          i_track;
 600     unsigned int    i;
 601     bool            b;
 602
 603     for( i_track = 0; i_track < tracks.size(); i_track++ )
 604     {
 605         const mkv_track_t *tk = tracks[i_track];
 606
 607         if( ( p_block != NULL && tk->i_number == p_block->TrackNum() ) ||
 608             ( p_simpleblock != NULL && tk->i_number == p_simpleblock->TrackNum() ) )
 609         {
 610             break;
 611         }
 612     }
 613
 614     if( i_track >= tracks.size() )
 615         return VLC_EGENERIC;
 616
 617     if( pi_track )
 618         *pi_track = i_track;
 619     return VLC_SUCCESS;
 620 }
 621
 622 bool matroska_segment_c::Select( mtime_t i_start_time )
 623 {
 624     size_t i_track;
 625
 626     /* add all es */
 627     msg_Dbg( &sys.demuxer, "found %d es", (int)tracks.size() );
 628     sys.b_pci_packet_set = false;
 629
 630     for( i_track = 0; i_track < tracks.size(); i_track++ )
 631     {
 632         if( tracks[i_track]->fmt.i_cat == UNKNOWN_ES )
 633         {
 634             msg_Warn( &sys.demuxer, "invalid track[%d, n=%d]", (int)i_track, tracks[i_track]->i_number );
 635             tracks[i_track]->p_es = NULL;
 636             continue;
 637         }
 638
 639         if( !strcmp( tracks[i_track]->psz_codec, "V_MS/VFW/FOURCC" ) )
 640         {
 641             if( tracks[i_track]->i_extra_data < (int)sizeof( BITMAPINFOHEADER ) )
 642             {
 643                 msg_Err( &sys.demuxer, "missing/invalid BITMAPINFOHEADER" );
 644                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 'n', 'd', 'f' );
 645             }
 646             else
 647             {
 648                 BITMAPINFOHEADER *p_bih = (BITMAPINFOHEADER*)tracks[i_track]->p_extra_data;
 649
 650                 tracks[i_track]->fmt.video.i_width = GetDWLE( &p_bih->biWidth );
 651                 tracks[i_track]->fmt.video.i_height= GetDWLE( &p_bih->biHeight );
 652                 tracks[i_track]->fmt.i_codec       = GetFOURCC( &p_bih->biCompression );
 653
 654                 tracks[i_track]->fmt.i_extra       = GetDWLE( &p_bih->biSize ) - sizeof( BITMAPINFOHEADER );
 655                 if( tracks[i_track]->fmt.i_extra > 0 )
 656                 {
 657                     tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
 658                     memcpy( tracks[i_track]->fmt.p_extra, &p_bih[1], tracks[i_track]->fmt.i_extra );
 659                 }
 660             }
 661         }
 662         else if( !strcmp( tracks[i_track]->psz_codec, "V_MPEG1" ) ||
 663                  !strcmp( tracks[i_track]->psz_codec, "V_MPEG2" ) )
 664         {
 665             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'm', 'p', 'g', 'v' );
 666         }
 667         else if( !strncmp( tracks[i_track]->psz_codec, "V_THEORA", 8 ) )
 668         {
 669             uint8_t *p_data = tracks[i_track]->p_extra_data;
 670             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 't', 'h', 'e', 'o' );
 671             if( tracks[i_track]->i_extra_data >= 4 ) {
 672                 if( p_data[0] == 2 ) {
 673                     int i = 1;
 674                     int i_size1 = 0, i_size2 = 0;
 675                     p_data++;
 676                     /* read size of first header packet */
 677                     while( *p_data == 0xFF &&
 678                            i < tracks[i_track]->i_extra_data )
 679                     {
 680                         i_size1 += *p_data;
 681                         p_data++;
 682                         i++;
 683                     }
 684                     i_size1 += *p_data;
 685                     p_data++;
 686                     i++;
 687                     msg_Dbg( &sys.demuxer, "first theora header size %d", i_size1 );
 688                     /* read size of second header packet */
 689                     while( *p_data == 0xFF &&
 690                            i < tracks[i_track]->i_extra_data )
 691                     {
 692                         i_size2 += *p_data;
 693                         p_data++;
 694                         i++;
 695                     }
 696                     i_size2 += *p_data;
 697                     p_data++;
 698                     i++;
 699                     int i_size3 = tracks[i_track]->i_extra_data - i - i_size1
 700                         - i_size2;
 701                     msg_Dbg( &sys.demuxer, "second theora header size %d", i_size2 );
 702                     msg_Dbg( &sys.demuxer, "third theora header size %d", i_size3 );
 703                     tracks[i_track]->fmt.i_extra = i_size1 + i_size2 + i_size3
 704                         + 6;
 705                     if( i_size1 > 0 && i_size2 > 0 && i_size3 > 0  ) {
 706                         tracks[i_track]->fmt.p_extra =
 707                             malloc( tracks[i_track]->fmt.i_extra );
 708                         uint8_t *p_out = (uint8_t*)tracks[i_track]->fmt.p_extra;
 709                         *p_out++ = (i_size1>>8) & 0xFF;
 710                         *p_out++ = i_size1 & 0xFF;
 711                         memcpy( p_out, p_data, i_size1 );
 712                         p_data += i_size1;
 713                         p_out += i_size1;
 714
 715                         *p_out++ = (i_size2>>8) & 0xFF;
 716                         *p_out++ = i_size2 & 0xFF;
 717                         memcpy( p_out, p_data, i_size2 );
 718                         p_data += i_size2;
 719                         p_out += i_size2;
 720
 721                         *p_out++ = (i_size3>>8) & 0xFF;
 722                         *p_out++ = i_size3 & 0xFF;
 723                         memcpy( p_out, p_data, i_size3 );
 724                         p_data += i_size3;
 725                         p_out += i_size3;
 726                     }
 727                     else
 728                     {
 729                         msg_Err( &sys.demuxer, "inconsistant theora extradata" );
 730                     }
 731                 }
 732                 else {
 733                     msg_Err( &sys.demuxer, "Wrong number of ogg packets with theora headers (%d)", p_data[0] + 1 );
 734                 }
 735             }
 736         }
 737         else if( !strncmp( tracks[i_track]->psz_codec, "V_REAL/RV", 9 ) )
 738         {
 739             if( !strcmp( tracks[i_track]->psz_codec, "V_REAL/RV10" ) )
 740                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'R', 'V', '1', '0' );
 741             else if( !strcmp( tracks[i_track]->psz_codec, "V_REAL/RV20" ) )
 742                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'R', 'V', '2', '0' );
 743             else if( !strcmp( tracks[i_track]->psz_codec, "V_REAL/RV30" ) )
 744                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'R', 'V', '3', '0' );
 745             else if( !strcmp( tracks[i_track]->psz_codec, "V_REAL/RV40" ) )
 746                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'R', 'V', '4', '0' );
 747         }
 748         else if( !strncmp( tracks[i_track]->psz_codec, "V_MPEG4", 7 ) )
 749         {
 750             if( !strcmp( tracks[i_track]->psz_codec, "V_MPEG4/MS/V3" ) )
 751             {
 752                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'D', 'I', 'V', '3' );
 753             }
 754             else if( !strncmp( tracks[i_track]->psz_codec, "V_MPEG4/ISO", 11 ) )
 755             {
 756                 /* A MPEG 4 codec, SP, ASP, AP or AVC */
 757                 if( !strcmp( tracks[i_track]->psz_codec, "V_MPEG4/ISO/AVC" ) )
 758                     tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'a', 'v', 'c', '1' );
 759                 else
 760                     tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'v' );
 761                 tracks[i_track]->fmt.i_extra = tracks[i_track]->i_extra_data;
 762                 tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->i_extra_data );
 763                 memcpy( tracks[i_track]->fmt.p_extra,tracks[i_track]->p_extra_data, tracks[i_track]->i_extra_data );
 764             }
 765         }
 766         else if( !strcmp( tracks[i_track]->psz_codec, "V_QUICKTIME" ) )
 767         {
 768             MP4_Box_t *p_box = (MP4_Box_t*)malloc( sizeof( MP4_Box_t ) );
 769             stream_t *p_mp4_stream = stream_MemoryNew( VLC_OBJECT(&sys.demuxer),
 770                                                        tracks[i_track]->p_extra_data,
 771                                                        tracks[i_track]->i_extra_data,
 772                                                        true );
 773             MP4_ReadBoxCommon( p_mp4_stream, p_box );
 774             MP4_ReadBox_sample_vide( p_mp4_stream, p_box );
 775             tracks[i_track]->fmt.i_codec = p_box->i_type;
 776             tracks[i_track]->fmt.video.i_width = p_box->data.p_sample_vide->i_width;
 777             tracks[i_track]->fmt.video.i_height = p_box->data.p_sample_vide->i_height;
 778             tracks[i_track]->fmt.i_extra = p_box->data.p_sample_vide->i_qt_image_description;
 779             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
 780             memcpy( tracks[i_track]->fmt.p_extra, p_box->data.p_sample_vide->p_qt_image_description, tracks[i_track]->fmt.i_extra );
 781             MP4_FreeBox_sample_vide( p_box );
 782             stream_Delete( p_mp4_stream );
 783         }
 784         else if( !strcmp( tracks[i_track]->psz_codec, "A_MS/ACM" ) )
 785         {
 786             if( tracks[i_track]->i_extra_data < (int)sizeof( WAVEFORMATEX ) )
 787             {
 788                 msg_Err( &sys.demuxer, "missing/invalid WAVEFORMATEX" );
 789                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 'n', 'd', 'f' );
 790             }
 791             else
 792             {
 793                 WAVEFORMATEX *p_wf = (WAVEFORMATEX*)tracks[i_track]->p_extra_data;
 794
 795                 wf_tag_to_fourcc( GetWLE( &p_wf->wFormatTag ), &tracks[i_track]->fmt.i_codec, NULL );
 796
 797                 tracks[i_track]->fmt.audio.i_channels   = GetWLE( &p_wf->nChannels );
 798                 tracks[i_track]->fmt.audio.i_rate = GetDWLE( &p_wf->nSamplesPerSec );
 799                 tracks[i_track]->fmt.i_bitrate    = GetDWLE( &p_wf->nAvgBytesPerSec ) * 8;
 800                 tracks[i_track]->fmt.audio.i_blockalign = GetWLE( &p_wf->nBlockAlign );;
 801                 tracks[i_track]->fmt.audio.i_bitspersample = GetWLE( &p_wf->wBitsPerSample );
 802
 803                 tracks[i_track]->fmt.i_extra            = GetWLE( &p_wf->cbSize );
 804                 if( tracks[i_track]->fmt.i_extra > 0 )
 805                 {
 806                     tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
 807                     memcpy( tracks[i_track]->fmt.p_extra, &p_wf[1], tracks[i_track]->fmt.i_extra );
 808                 }
 809             }
 810         }
 811         else if( !strcmp( tracks[i_track]->psz_codec, "A_MPEG/L3" ) ||
 812                  !strcmp( tracks[i_track]->psz_codec, "A_MPEG/L2" ) ||
 813                  !strcmp( tracks[i_track]->psz_codec, "A_MPEG/L1" ) )
 814         {
 815             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'm', 'p', 'g', 'a' );
 816         }
 817         else if( !strcmp( tracks[i_track]->psz_codec, "A_AC3" ) )
 818         {
 819             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'a', '5', '2', ' ' );
 820         }
 821         else if( !strcmp( tracks[i_track]->psz_codec, "A_EAC3" ) )
 822         {
 823             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'e', 'a', 'c', '3' );
 824         }
 825         else if( !strcmp( tracks[i_track]->psz_codec, "A_DTS" ) )
 826         {
 827             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'd', 't', 's', ' ' );
 828         }
 829         else if( !strcmp( tracks[i_track]->psz_codec, "A_FLAC" ) )
 830         {
 831             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'f', 'l', 'a', 'c' );
 832             tracks[i_track]->fmt.i_extra = tracks[i_track]->i_extra_data;
 833             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->i_extra_data );
 834             memcpy( tracks[i_track]->fmt.p_extra,tracks[i_track]->p_extra_data, tracks[i_track]->i_extra_data );
 835         }
 836         else if( !strcmp( tracks[i_track]->psz_codec, "A_VORBIS" ) )
 837         {
 838             int i, i_offset = 1, i_size[3], i_extra;
 839             uint8_t *p_extra;
 840
 841             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'v', 'o', 'r', 'b' );
 842
 843             /* Split the 3 headers */
 844             if( tracks[i_track]->p_extra_data[0] != 0x02 )
 845                 msg_Err( &sys.demuxer, "invalid vorbis header" );
 846
 847             for( i = 0; i < 2; i++ )
 848             {
 849                 i_size[i] = 0;
 850                 while( i_offset < tracks[i_track]->i_extra_data )
 851                 {
 852                     i_size[i] += tracks[i_track]->p_extra_data[i_offset];
 853                     if( tracks[i_track]->p_extra_data[i_offset++] != 0xff ) break;
 854                 }
 855             }
 856
 857             i_size[0] = __MIN(i_size[0], tracks[i_track]->i_extra_data - i_offset);
 858             i_size[1] = __MIN(i_size[1], tracks[i_track]->i_extra_data -i_offset -i_size[0]);
 859             i_size[2] = tracks[i_track]->i_extra_data - i_offset - i_size[0] - i_size[1];
 860
 861             tracks[i_track]->fmt.i_extra = 3 * 2 + i_size[0] + i_size[1] + i_size[2];
 862             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
 863             p_extra = (uint8_t *)tracks[i_track]->fmt.p_extra; i_extra = 0;
 864             for( i = 0; i < 3; i++ )
 865             {
 866                 *(p_extra++) = i_size[i] >> 8;
 867                 *(p_extra++) = i_size[i] & 0xFF;
 868                 memcpy( p_extra, tracks[i_track]->p_extra_data + i_offset + i_extra,
 869                         i_size[i] );
 870                 p_extra += i_size[i];
 871                 i_extra += i_size[i];
 872             }
 873         }
 874         else if( !strncmp( tracks[i_track]->psz_codec, "A_AAC/MPEG2/", strlen( "A_AAC/MPEG2/" ) ) ||
 875                  !strncmp( tracks[i_track]->psz_codec, "A_AAC/MPEG4/", strlen( "A_AAC/MPEG4/" ) ) )
 876         {
 877             int i_profile, i_srate, sbr = 0;
 878             static const unsigned int i_sample_rates[] =
 879             {
 880                     96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
 881                         16000, 12000, 11025, 8000,  7350,  0,     0,     0
 882             };
 883
 884             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'a' );
 885             /* create data for faad (MP4DecSpecificDescrTag)*/
 886
 887             if( !strcmp( &tracks[i_track]->psz_codec[12], "MAIN" ) )
 888             {
 889                 i_profile = 0;
 890             }
 891             else if( !strcmp( &tracks[i_track]->psz_codec[12], "LC" ) )
 892             {
 893                 i_profile = 1;
 894             }
 895             else if( !strcmp( &tracks[i_track]->psz_codec[12], "SSR" ) )
 896             {
 897                 i_profile = 2;
 898             }
 899             else if( !strcmp( &tracks[i_track]->psz_codec[12], "LC/SBR" ) )
 900             {
 901                 i_profile = 1;
 902                 sbr = 1;
 903             }
 904             else
 905             {
 906                 i_profile = 3;
 907             }
 908
 909             for( i_srate = 0; i_srate < 13; i_srate++ )
 910             {
 911                 if( i_sample_rates[i_srate] == tracks[i_track]->i_original_rate )
 912                 {
 913                     break;
 914                 }
 915             }
 916             msg_Dbg( &sys.demuxer, "profile=%d srate=%d", i_profile, i_srate );
 917
 918             tracks[i_track]->fmt.i_extra = sbr ? 5 : 2;
 919             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
 920             ((uint8_t*)tracks[i_track]->fmt.p_extra)[0] = ((i_profile + 1) << 3) | ((i_srate&0xe) >> 1);
 921             ((uint8_t*)tracks[i_track]->fmt.p_extra)[1] = ((i_srate & 0x1) << 7) | (tracks[i_track]->fmt.audio.i_channels << 3);
 922             if (sbr != 0)
 923             {
 924                 int syncExtensionType = 0x2B7;
 925                 int iDSRI;
 926                 for (iDSRI=0; iDSRI<13; iDSRI++)
 927                     if( i_sample_rates[iDSRI] == tracks[i_track]->fmt.audio.i_rate )
 928                         break;
 929                 ((uint8_t*)tracks[i_track]->fmt.p_extra)[2] = (syncExtensionType >> 3) & 0xFF;
 930                 ((uint8_t*)tracks[i_track]->fmt.p_extra)[3] = ((syncExtensionType & 0x7) << 5) | 5;
 931                 ((uint8_t*)tracks[i_track]->fmt.p_extra)[4] = ((1 & 0x1) << 7) | (iDSRI << 3);
 932             }
 933         }
 934         else if( !strcmp( tracks[i_track]->psz_codec, "A_AAC" ) )
 935         {
 936             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'a' );
 937             tracks[i_track]->fmt.i_extra = tracks[i_track]->i_extra_data;
 938             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->i_extra_data );
 939             memcpy( tracks[i_track]->fmt.p_extra, tracks[i_track]->p_extra_data, tracks[i_track]->i_extra_data );
 940         }
 941         else if( !strcmp( tracks[i_track]->psz_codec, "A_WAVPACK4" ) )
 942         {
 943             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'W', 'V', 'P', 'K' );
 944             tracks[i_track]->fmt.i_extra = tracks[i_track]->i_extra_data;
 945             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->i_extra_data );
 946             memcpy( tracks[i_track]->fmt.p_extra, tracks[i_track]->p_extra_data, tracks[i_track]->i_extra_data );
 947         }
 948         else if( !strcmp( tracks[i_track]->psz_codec, "A_TTA1" ) )
 949         {
 950             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'T', 'T', 'A', '1' );
 951             tracks[i_track]->fmt.i_extra = tracks[i_track]->i_extra_data;
 952             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->i_extra_data );
 953             memcpy( tracks[i_track]->fmt.p_extra, tracks[i_track]->p_extra_data, tracks[i_track]->i_extra_data );
 954         }
 955         else if( !strcmp( tracks[i_track]->psz_codec, "A_PCM/INT/BIG" ) ||
 956                  !strcmp( tracks[i_track]->psz_codec, "A_PCM/INT/LIT" ) ||
 957                  !strcmp( tracks[i_track]->psz_codec, "A_PCM/FLOAT/IEEE" ) )
 958         {
 959             if( !strcmp( tracks[i_track]->psz_codec, "A_PCM/INT/BIG" ) )
 960             {
 961                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 't', 'w', 'o', 's' );
 962             }
 963             else
 964             {
 965                 tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'a', 'r', 'a', 'w' );
 966             }
 967             tracks[i_track]->fmt.audio.i_blockalign = ( tracks[i_track]->fmt.audio.i_bitspersample + 7 ) / 8 * tracks[i_track]->fmt.audio.i_channels;
 968         }
 969         /* disabled due to the potential "S_KATE" namespace issue */
 970         else if( !strcmp( tracks[i_track]->psz_codec, "S_KATE" ) )
 971         {
 972             int i, i_offset = 1, *i_size, i_extra, num_headers, size_so_far;
 973             uint8_t *p_extra;
 974
 975             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'k', 'a', 't', 'e' );
 976             tracks[i_track]->fmt.subs.psz_encoding = strdup( "UTF-8" );
 977
 978             /* Recover the number of headers to expect */
 979             num_headers = tracks[i_track]->p_extra_data[0]+1;
 980             msg_Dbg( &sys.demuxer, "kate in mkv detected: %d headers in %u bytes",
 981                 num_headers, tracks[i_track]->i_extra_data);
 982
 983             /* this won't overflow the stack as is can allocate only 1020 bytes max */
 984             i_size = (int*)alloca(num_headers*sizeof(int));
 985
 986             /* Split the headers */
 987             size_so_far = 0;
 988             for( i = 0; i < num_headers-1; i++ )
 989             {
 990                 i_size[i] = 0;
 991                 while( i_offset < tracks[i_track]->i_extra_data )
 992                 {
 993                     i_size[i] += tracks[i_track]->p_extra_data[i_offset];
 994                     if( tracks[i_track]->p_extra_data[i_offset++] != 0xff ) break;
 995                 }
 996                 msg_Dbg( &sys.demuxer, "kate header %d is %d bytes", i, i_size[i]);
 997                 size_so_far += i_size[i];
 998             }
 999             i_size[num_headers-1] = tracks[i_track]->i_extra_data - (size_so_far+i_offset);
1000             msg_Dbg( &sys.demuxer, "kate last header (%d) is %d bytes", num_headers-1, i_size[num_headers-1]);
1001
1002             tracks[i_track]->fmt.i_extra = 1 + num_headers * 2 + size_so_far + i_size[num_headers-1];
1003             tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->fmt.i_extra );
1004
1005             p_extra = (uint8_t *)tracks[i_track]->fmt.p_extra;
1006             i_extra = 0;
1007             *(p_extra++) = num_headers;
1008             ++i_extra;
1009             for( i = 0; i < num_headers; i++ )
1010             {
1011                 *(p_extra++) = i_size[i] >> 8;
1012                 *(p_extra++) = i_size[i] & 0xFF;
1013                 memcpy( p_extra, tracks[i_track]->p_extra_data + i_offset + i_extra-1,
1014                         i_size[i] );
1015                 p_extra += i_size[i];
1016                 i_extra += i_size[i];
1017             }
1018         }
1019         else if( !strcmp( tracks[i_track]->psz_codec, "S_TEXT/UTF8" ) )
1020         {
1021             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 's', 'u', 'b', 't' );
1022             tracks[i_track]->fmt.subs.psz_encoding = strdup( "UTF-8" );
1023         }
1024         else if( !strcmp( tracks[i_track]->psz_codec, "S_TEXT/USF" ) )
1025         {
1026             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 's', 'f', ' ' );
1027             tracks[i_track]->fmt.subs.psz_encoding = strdup( "UTF-8" );
1028             if( tracks[i_track]->i_extra_data )
1029             {
1030                 tracks[i_track]->fmt.i_extra = tracks[i_track]->i_extra_data;
1031                 tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->i_extra_data );
1032                 memcpy( tracks[i_track]->fmt.p_extra, tracks[i_track]->p_extra_data, tracks[i_track]->i_extra_data );
1033             }
1034         }
1035         else if( !strcmp( tracks[i_track]->psz_codec, "S_TEXT/SSA" ) ||
1036                  !strcmp( tracks[i_track]->psz_codec, "S_TEXT/ASS" ) ||
1037                  !strcmp( tracks[i_track]->psz_codec, "S_SSA" ) ||
1038                  !strcmp( tracks[i_track]->psz_codec, "S_ASS" ))
1039         {
1040             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 's', 's', 'a', ' ' );
1041             tracks[i_track]->fmt.subs.psz_encoding = strdup( "UTF-8" );
1042             if( tracks[i_track]->i_extra_data )
1043             {
1044                 tracks[i_track]->fmt.i_extra = tracks[i_track]->i_extra_data;
1045                 tracks[i_track]->fmt.p_extra = malloc( tracks[i_track]->i_extra_data );
1046                 memcpy( tracks[i_track]->fmt.p_extra, tracks[i_track]->p_extra_data, tracks[i_track]->i_extra_data );
1047             }
1048         }
1049         else if( !strcmp( tracks[i_track]->psz_codec, "S_VOBSUB" ) )
1050         {
1051             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 's','p','u',' ' );
1052             if( tracks[i_track]->i_extra_data )
1053             {
1054                 char *p_start;
1055                 char *p_buf = (char *)malloc( tracks[i_track]->i_extra_data + 1);
1056                 memcpy( p_buf, tracks[i_track]->p_extra_data , tracks[i_track]->i_extra_data );
1057                 p_buf[tracks[i_track]->i_extra_data] = '\0';
1058
1059                 p_start = strstr( p_buf, "size:" );
1060                 if( sscanf( p_start, "size: %dx%d",
1061                         &tracks[i_track]->fmt.subs.spu.i_original_frame_width, &tracks[i_track]->fmt.subs.spu.i_original_frame_height ) == 2 )
1062                 {
1063                     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 );
1064                 }
1065                 else
1066                 {
1067                     msg_Warn( &sys.demuxer, "reading original frame size for vobsub failed" );
1068                 }
1069                 free( p_buf );
1070             }
1071         }
1072         else if( !strcmp( tracks[i_track]->psz_codec, "B_VOBBTN" ) )
1073         {
1074             tracks[i_track]->fmt.i_cat = NAV_ES;
1075             continue;
1076         }
1077         else
1078         {
1079             msg_Err( &sys.demuxer, "unknown codec id=`%s'", tracks[i_track]->psz_codec );
1080             tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 'n', 'd', 'f' );
1081         }
1082         if( tracks[i_track]->b_default )
1083         {
1084             tracks[i_track]->fmt.i_priority = 1000;
1085         }
1086
1087         tracks[i_track]->p_es = es_out_Add( sys.demuxer.out, &tracks[i_track]->fmt );
1088
1089         /* Turn on a subtitles track if it has been flagged as default -
1090          * but only do this if no subtitles track has already been engaged,
1091          * either by an earlier 'default track' (??) or by default
1092          * language choice behaviour.
1093          */
1094         if( tracks[i_track]->b_default )
1095         {
1096             es_out_Control( sys.demuxer.out,
1097                             ES_OUT_SET_DEFAULT,
1098                             tracks[i_track]->p_es );
1099         }
1100     }
1101     es_out_Control( sys.demuxer.out, ES_OUT_SET_NEXT_DISPLAY_TIME, i_start_time );
1102
1103     sys.i_start_pts = i_start_time;
1104     // reset the stream reading to the first cluster of the segment used
1105     es.I_O().setFilePointer( i_start_pos );
1106
1107     delete ep;
1108     ep = new EbmlParser( &es, segment, &sys.demuxer );
1109
1110     return true;
1111 }
1112
1113 void matroska_segment_c::UnSelect( )
1114 {
1115     size_t i_track;
1116
1117     for( i_track = 0; i_track < tracks.size(); i_track++ )
1118     {
1119         if ( tracks[i_track]->p_es != NULL )
1120         {
1121 //            es_format_Clean( &tracks[i_track]->fmt );
1122             es_out_Del( sys.demuxer.out, tracks[i_track]->p_es );
1123             tracks[i_track]->p_es = NULL;
1124         }
1125     }
1126     delete ep;
1127     ep = NULL;
1128 }
1129
1130 int matroska_segment_c::BlockGet( KaxBlock * & pp_block, KaxSimpleBlock * & pp_simpleblock, int64_t *pi_ref1, int64_t *pi_ref2, int64_t *pi_duration )
1131 {
1132     pp_simpleblock = NULL;
1133     pp_block = NULL;
1134     *pi_ref1  = 0;
1135     *pi_ref2  = 0;
1136
1137     for( ;; )
1138     {
1139         EbmlElement *el = NULL;
1140         int         i_level;
1141
1142         if ( ep == NULL )
1143             return VLC_EGENERIC;
1144
1145         if( pp_simpleblock != NULL || ((el = ep->Get()) == NULL && pp_block != NULL) )
1146         {
1147             /* Check blocks validity to protect againts broken files */
1148             if( BlockFindTrackIndex( NULL, pp_block , pp_simpleblock ) )
1149             {
1150                 delete pp_block;
1151                 pp_simpleblock = NULL;
1152                 pp_block = NULL;
1153                 continue;
1154             }
1155
1156             /* update the index */
1157 #define idx p_indexes[i_index - 1]
1158             if( i_index > 0 && idx.i_time == -1 )
1159             {
1160                 if ( pp_simpleblock != NULL )
1161                     idx.i_time        = pp_simpleblock->GlobalTimecode() / (mtime_t)1000;
1162                 else
1163                     idx.i_time        = (*pp_block).GlobalTimecode() / (mtime_t)1000;
1164                 idx.b_key         = *pi_ref1 == 0 ? true : false;
1165             }
1166 #undef idx
1167             return VLC_SUCCESS;
1168         }
1169
1170         i_level = ep->GetLevel();
1171
1172         if( el == NULL )
1173         {
1174             if( i_level > 1 )
1175             {
1176                 ep->Up();
1177                 continue;
1178             }
1179             msg_Warn( &sys.demuxer, "EOF" );
1180             return VLC_EGENERIC;
1181         }
1182
1183         /* Verify that we are still inside our cluster
1184          * It can happens whith broken files and when seeking
1185          * without index */
1186         if( i_level > 1 )
1187         {
1188             if( cluster && !ep->IsTopPresent( cluster ) )
1189             {
1190                 msg_Warn( &sys.demuxer, "Unexpected escape from current cluster" );
1191                 cluster = NULL;
1192             }
1193             if( !cluster )
1194                 continue;
1195         }
1196
1197         /* do parsing */
1198         switch ( i_level )
1199         {
1200         case 1:
1201             if( MKV_IS_ID( el, KaxCluster ) )
1202             {
1203                 cluster = (KaxCluster*)el;
1204                 i_cluster_pos = cluster->GetElementPosition();
1205
1206                 /* add it to the index */
1207                 if( i_index == 0 ||
1208                     ( i_index > 0 && p_indexes[i_index - 1].i_position < (int64_t)cluster->GetElementPosition() ) )
1209                 {
1210                     IndexAppendCluster( cluster );
1211                 }
1212
1213                 // reset silent tracks
1214                 for (size_t i=0; i<tracks.size(); i++)
1215                 {
1216                     tracks[i]->b_silent = false;
1217                 }
1218
1219                 ep->Down();
1220             }
1221             else if( MKV_IS_ID( el, KaxCues ) )
1222             {
1223                 msg_Warn( &sys.demuxer, "find KaxCues FIXME" );
1224                 return VLC_EGENERIC;
1225             }
1226             else
1227             {
1228                 msg_Dbg( &sys.demuxer, "unknown (%s)", typeid( el ).name() );
1229             }
1230             break;
1231         case 2:
1232             if( MKV_IS_ID( el, KaxClusterTimecode ) )
1233             {
1234                 KaxClusterTimecode &ctc = *(KaxClusterTimecode*)el;
1235
1236                 ctc.ReadData( es.I_O(), SCOPE_ALL_DATA );
1237                 cluster->InitTimecode( uint64( ctc ), i_timescale );
1238             }
1239             else if( MKV_IS_ID( el, KaxClusterSilentTracks ) )
1240             {
1241                 ep->Down();
1242             }
1243             else if( MKV_IS_ID( el, KaxBlockGroup ) )
1244             {
1245                 i_block_pos = el->GetElementPosition();
1246                 ep->Down();
1247             }
1248             else if( MKV_IS_ID( el, KaxSimpleBlock ) )
1249             {
1250                 pp_simpleblock = (KaxSimpleBlock*)el;
1251
1252                 pp_simpleblock->ReadData( es.I_O() );
1253                 pp_simpleblock->SetParent( *cluster );
1254             }
1255             break;
1256         case 3:
1257             if( MKV_IS_ID( el, KaxBlock ) )
1258             {
1259                 pp_block = (KaxBlock*)el;
1260
1261                 pp_block->ReadData( es.I_O() );
1262                 pp_block->SetParent( *cluster );
1263
1264                 ep->Keep();
1265             }
1266             else if( MKV_IS_ID( el, KaxBlockDuration ) )
1267             {
1268                 KaxBlockDuration &dur = *(KaxBlockDuration*)el;
1269
1270                 dur.ReadData( es.I_O() );
1271                 *pi_duration = uint64( dur );
1272             }
1273             else if( MKV_IS_ID( el, KaxReferenceBlock ) )
1274             {
1275                 KaxReferenceBlock &ref = *(KaxReferenceBlock*)el;
1276
1277                 ref.ReadData( es.I_O() );
1278                 if( *pi_ref1 == 0 )
1279                 {
1280                     *pi_ref1 = int64( ref ) * cluster->GlobalTimecodeScale();
1281                 }
1282                 else if( *pi_ref2 == 0 )
1283                 {
1284                     *pi_ref2 = int64( ref ) * cluster->GlobalTimecodeScale();
1285                 }
1286             }
1287             else if( MKV_IS_ID( el, KaxClusterSilentTrackNumber ) )
1288             {
1289                 KaxClusterSilentTrackNumber &track_num = *(KaxClusterSilentTrackNumber*)el;
1290                 track_num.ReadData( es.I_O() );
1291                 // find the track
1292                 for (size_t i=0; i<tracks.size(); i++)
1293                 {
1294                     if ( tracks[i]->i_number == uint32(track_num))
1295                     {
1296                         tracks[i]->b_silent = true;
1297                         break;
1298                     }
1299                 }
1300             }
1301             break;
1302         default:
1303             msg_Err( &sys.demuxer, "invalid level = %d", i_level );
1304             return VLC_EGENERIC;
1305         }
1306     }
1307 }
1308