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