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

   1 /*****************************************************************************
   2  * mkv.cpp : matroska demuxer
   3  *****************************************************************************
   4  * Copyright (C) 2003-2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Steve Lhomme <steve.lhomme@free.fr>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #include "mkv.hpp"
  26 #include "util.hpp"
  27
  28 #include "matroska_segment.hpp"
  29 #include "demux.hpp"
  30
  31 #include "chapters.hpp"
  32 #include "Ebml_parser.hpp"
  33
  34 #include "stream_io_callback.hpp"
  35
  36 /*****************************************************************************
  37  * Module descriptor
  38  *****************************************************************************/
  39 static int  Open ( vlc_object_t * );
  40 static void Close( vlc_object_t * );
  41
  42 vlc_module_begin ()
  43     set_shortname( "Matroska" )
  44     set_description( N_("Matroska stream demuxer" ) )
  45     set_capability( "demux", 50 )
  46     set_callbacks( Open, Close )
  47     set_category( CAT_INPUT )
  48     set_subcategory( SUBCAT_INPUT_DEMUX )
  49
  50     add_bool( "mkv-use-ordered-chapters", true, NULL,
  51             N_("Ordered chapters"),
  52             N_("Play ordered chapters as specified in the segment."), true );
  53
  54     add_bool( "mkv-use-chapter-codec", true, NULL,
  55             N_("Chapter codecs"),
  56             N_("Use chapter codecs found in the segment."), true );
  57
  58     add_bool( "mkv-preload-local-dir", false, NULL,
  59             N_("Preload Directory"),
  60             N_("Preload matroska files from the same family in the same directory (not good for broken files)."), true );
  61
  62     add_bool( "mkv-seek-percent", false, NULL,
  63             N_("Seek based on percent not time"),
  64             N_("Seek based on percent not time."), true );
  65
  66     add_bool( "mkv-use-dummy", false, NULL,
  67             N_("Dummy Elements"),
  68             N_("Read and discard unknown EBML elements (not good for broken files)."), true );
  69
  70     add_shortcut( "mka" )
  71     add_shortcut( "mkv" )
  72 vlc_module_end ()
  73
  74 class demux_sys_t;
  75
  76 static int  Demux  ( demux_t * );
  77 static int  Control( demux_t *, int, va_list );
  78 static void Seek   ( demux_t *, mtime_t i_date, double f_percent, chapter_item_c *psz_chapter );
  79
  80 /*****************************************************************************
  81  * Open: initializes matroska demux structures
  82  *****************************************************************************/
  83 static int Open( vlc_object_t * p_this )
  84 {
  85     demux_t            *p_demux = (demux_t*)p_this;
  86     demux_sys_t        *p_sys;
  87     matroska_stream_c  *p_stream;
  88     matroska_segment_c *p_segment;
  89     const uint8_t      *p_peek;
  90     std::string         s_path, s_filename;
  91     vlc_stream_io_callback *p_io_callback;
  92     EbmlStream         *p_io_stream;
  93
  94     /* peek the begining */
  95     if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) return VLC_EGENERIC;
  96
  97     /* is a valid file */
  98     if( p_peek[0] != 0x1a || p_peek[1] != 0x45 ||
  99         p_peek[2] != 0xdf || p_peek[3] != 0xa3 ) return VLC_EGENERIC;
 100
 101     /* Set the demux function */
 102     p_demux->pf_demux   = Demux;
 103     p_demux->pf_control = Control;
 104     p_demux->p_sys      = p_sys = new demux_sys_t( *p_demux );
 105
 106     p_io_callback = new vlc_stream_io_callback( p_demux->s, false );
 107     p_io_stream = new EbmlStream( *p_io_callback );
 108
 109     if( p_io_stream == NULL )
 110     {
 111         msg_Err( p_demux, "failed to create EbmlStream" );
 112         delete p_io_callback;
 113         delete p_sys;
 114         return VLC_EGENERIC;
 115     }
 116
 117     p_stream = p_sys->AnalyseAllSegmentsFound( p_demux, p_io_stream, true );
 118     if( p_stream == NULL )
 119     {
 120         msg_Err( p_demux, "cannot find KaxSegment" );
 121         goto error;
 122     }
 123     p_sys->streams.push_back( p_stream );
 124
 125     p_stream->p_in = p_io_callback;
 126     p_stream->p_es = p_io_stream;
 127
 128     for (size_t i=0; i<p_stream->segments.size(); i++)
 129     {
 130         p_stream->segments[i]->Preload();
 131     }
 132
 133     p_segment = p_stream->segments[0];
 134     if( p_segment->cluster == NULL )
 135     {
 136         msg_Err( p_demux, "cannot find any cluster, damaged file ?" );
 137         goto error;
 138     }
 139
 140     if (var_InheritInteger( p_demux, "mkv-preload-local-dir" ))
 141     {
 142         /* get the files from the same dir from the same family (based on p_demux->psz_path) */
 143         if (p_demux->psz_path[0] != '\0' && !strcmp(p_demux->psz_access, ""))
 144         {
 145             // assume it's a regular file
 146             // get the directory path
 147             s_path = p_demux->psz_path;
 148             if (s_path.at(s_path.length() - 1) == DIR_SEP_CHAR)
 149             {
 150                 s_path = s_path.substr(0,s_path.length()-1);
 151             }
 152             else
 153             {
 154                 if (s_path.find_last_of(DIR_SEP_CHAR) > 0)
 155                 {
 156                     s_path = s_path.substr(0,s_path.find_last_of(DIR_SEP_CHAR));
 157                 }
 158             }
 159
 160             DIR *p_src_dir = utf8_opendir(s_path.c_str());
 161
 162             if (p_src_dir != NULL)
 163             {
 164                 char *psz_file;
 165                 while ((psz_file = utf8_readdir(p_src_dir)) != NULL)
 166                 {
 167                     if (strlen(psz_file) > 4)
 168                     {
 169                         s_filename = s_path + DIR_SEP_CHAR + psz_file;
 170
 171 #ifdef WIN32
 172                         if (!strcasecmp(s_filename.c_str(), p_demux->psz_path))
 173 #else
 174                         if (!s_filename.compare(p_demux->psz_path))
 175 #endif
 176                         {
 177                             free (psz_file);
 178                             continue; // don't reuse the original opened file
 179                         }
 180
 181 #if defined(__GNUC__) && (__GNUC__ < 3)
 182                         if (!s_filename.compare("mkv", s_filename.length() - 3, 3) ||
 183                             !s_filename.compare("mka", s_filename.length() - 3, 3))
 184 #else
 185                         if (!s_filename.compare(s_filename.length() - 3, 3, "mkv") ||
 186                             !s_filename.compare(s_filename.length() - 3, 3, "mka"))
 187 #endif
 188                         {
 189                             // test wether this file belongs to our family
 190                             const uint8_t *p_peek;
 191                             bool          file_ok = false;
 192                             stream_t      *p_file_stream = stream_UrlNew(
 193                                                             p_demux,
 194                                                             s_filename.c_str());
 195                             /* peek the begining */
 196                             if( p_file_stream &&
 197                                 stream_Peek( p_file_stream, &p_peek, 4 ) >= 4
 198                                 && p_peek[0] == 0x1a && p_peek[1] == 0x45 &&
 199                                 p_peek[2] == 0xdf && p_peek[3] == 0xa3 ) file_ok = true;
 200
 201                             if ( file_ok )
 202                             {
 203                                 vlc_stream_io_callback *p_file_io = new vlc_stream_io_callback( p_file_stream, true );
 204                                 EbmlStream *p_estream = new EbmlStream(*p_file_io);
 205
 206                                 p_stream = p_sys->AnalyseAllSegmentsFound( p_demux, p_estream );
 207
 208                                 if ( p_stream == NULL )
 209                                 {
 210                                     msg_Dbg( p_demux, "the file '%s' will not be used", s_filename.c_str() );
 211                                     delete p_estream;
 212                                     delete p_file_io;
 213                                 }
 214                                 else
 215                                 {
 216                                     p_stream->p_in = p_file_io;
 217                                     p_stream->p_es = p_estream;
 218                                     p_sys->streams.push_back( p_stream );
 219                                 }
 220                             }
 221                             else
 222                             {
 223                                 if( p_file_stream ) {
 224                                     stream_Delete( p_file_stream );
 225                                 }
 226                                 msg_Dbg( p_demux, "the file '%s' cannot be opened", s_filename.c_str() );
 227                             }
 228                         }
 229                     }
 230                     free (psz_file);
 231                 }
 232                 closedir( p_src_dir );
 233             }
 234         }
 235
 236         p_sys->PreloadFamily( *p_segment );
 237     }
 238
 239     p_sys->PreloadLinked( p_segment );
 240
 241     if ( !p_sys->PreparePlayback( NULL ) )
 242     {
 243         msg_Err( p_demux, "cannot use the segment" );
 244         goto error;
 245     }
 246
 247     p_sys->StartUiThread();
 248
 249     return VLC_SUCCESS;
 250
 251 error:
 252     delete p_sys;
 253     return VLC_EGENERIC;
 254 }
 255
 256 /*****************************************************************************
 257  * Close: frees unused data
 258  *****************************************************************************/
 259 static void Close( vlc_object_t *p_this )
 260 {
 261     demux_t     *p_demux = (demux_t*)p_this;
 262     demux_sys_t *p_sys   = p_demux->p_sys;
 263
 264     delete p_sys;
 265 }
 266
 267 /*****************************************************************************
 268  * Control:
 269  *****************************************************************************/
 270 static int Control( demux_t *p_demux, int i_query, va_list args )
 271 {
 272     demux_sys_t        *p_sys = p_demux->p_sys;
 273     int64_t     *pi64;
 274     double      *pf, f;
 275     int         i_skp;
 276     size_t      i_idx;
 277
 278     vlc_meta_t *p_meta;
 279     input_attachment_t ***ppp_attach;
 280     int *pi_int;
 281
 282     switch( i_query )
 283     {
 284         case DEMUX_GET_ATTACHMENTS:
 285             ppp_attach = (input_attachment_t***)va_arg( args, input_attachment_t*** );
 286             pi_int = (int*)va_arg( args, int * );
 287
 288             if( p_sys->stored_attachments.size() <= 0 )
 289                 return VLC_EGENERIC;
 290
 291             *pi_int = p_sys->stored_attachments.size();
 292             *ppp_attach = (input_attachment_t**)malloc( sizeof(input_attachment_t**) *
 293                                                         p_sys->stored_attachments.size() );
 294             if( !(*ppp_attach) )
 295                 return VLC_ENOMEM;
 296             for( size_t i = 0; i < p_sys->stored_attachments.size(); i++ )
 297             {
 298                 attachment_c *a = p_sys->stored_attachments[i];
 299                 (*ppp_attach)[i] = vlc_input_attachment_New( a->psz_file_name.c_str(), a->psz_mime_type.c_str(), NULL,
 300                                                              a->p_data, a->i_size );
 301             }
 302             return VLC_SUCCESS;
 303
 304         case DEMUX_GET_META:
 305             p_meta = (vlc_meta_t*)va_arg( args, vlc_meta_t* );
 306             vlc_meta_Merge( p_meta, p_sys->meta );
 307             return VLC_SUCCESS;
 308
 309         case DEMUX_GET_LENGTH:
 310             pi64 = (int64_t*)va_arg( args, int64_t * );
 311             if( p_sys->f_duration > 0.0 )
 312             {
 313                 *pi64 = (int64_t)(p_sys->f_duration * 1000);
 314                 return VLC_SUCCESS;
 315             }
 316             return VLC_EGENERIC;
 317
 318         case DEMUX_GET_POSITION:
 319             pf = (double*)va_arg( args, double * );
 320             if ( p_sys->f_duration > 0.0 )
 321                 *pf = (double)(p_sys->i_pts >= p_sys->i_start_pts ? p_sys->i_pts : p_sys->i_start_pts ) / (1000.0 * p_sys->f_duration);
 322             return VLC_SUCCESS;
 323
 324         case DEMUX_SET_POSITION:
 325             f = (double)va_arg( args, double );
 326             Seek( p_demux, -1, f, NULL );
 327             return VLC_SUCCESS;
 328
 329         case DEMUX_GET_TIME:
 330             pi64 = (int64_t*)va_arg( args, int64_t * );
 331             *pi64 = p_sys->i_pts;
 332             return VLC_SUCCESS;
 333
 334         case DEMUX_GET_TITLE_INFO:
 335             if( p_sys->titles.size() > 1 || ( p_sys->titles.size() == 1 && p_sys->titles[0]->i_seekpoint > 0 ) )
 336             {
 337                 input_title_t ***ppp_title = (input_title_t***)va_arg( args, input_title_t*** );
 338                 int *pi_int    = (int*)va_arg( args, int* );
 339
 340                 *pi_int = p_sys->titles.size();
 341                 *ppp_title = (input_title_t**)malloc( sizeof( input_title_t**) * p_sys->titles.size() );
 342
 343                 for( size_t i = 0; i < p_sys->titles.size(); i++ )
 344                 {
 345                     (*ppp_title)[i] = vlc_input_title_Duplicate( p_sys->titles[i] );
 346                 }
 347                 return VLC_SUCCESS;
 348             }
 349             return VLC_EGENERIC;
 350
 351         case DEMUX_SET_TITLE:
 352             /* TODO handle editions as titles */
 353             i_idx = (int)va_arg( args, int );
 354             if( i_idx < p_sys->used_segments.size() )
 355             {
 356                 p_sys->JumpTo( *p_sys->used_segments[i_idx], NULL );
 357                 return VLC_SUCCESS;
 358             }
 359             return VLC_EGENERIC;
 360
 361         case DEMUX_SET_SEEKPOINT:
 362             i_skp = (int)va_arg( args, int );
 363
 364             // TODO change the way it works with the << & >> buttons on the UI (+1/-1 instead of a number)
 365             if( p_sys->titles.size() && i_skp < p_sys->titles[p_sys->i_current_title]->i_seekpoint)
 366             {
 367                 Seek( p_demux, (int64_t)p_sys->titles[p_sys->i_current_title]->seekpoint[i_skp]->i_time_offset, -1, NULL);
 368                 p_demux->info.i_seekpoint |= INPUT_UPDATE_SEEKPOINT;
 369                 p_demux->info.i_seekpoint = i_skp;
 370                 return VLC_SUCCESS;
 371             }
 372             return VLC_EGENERIC;
 373
 374         case DEMUX_GET_FPS:
 375             pf = (double *)va_arg( args, double * );
 376             *pf = 0.0;
 377             if( p_sys->p_current_segment && p_sys->p_current_segment->Segment() )
 378             {
 379                 const matroska_segment_c *p_segment = p_sys->p_current_segment->Segment();
 380                 for( size_t i = 0; i < p_segment->tracks.size(); i++ )
 381                 {
 382                     mkv_track_t *tk = p_segment->tracks[i];
 383                     if( tk->fmt.i_cat == VIDEO_ES && tk->fmt.video.i_frame_rate_base > 0 )
 384                     {
 385                         *pf = (double)tk->fmt.video.i_frame_rate / tk->fmt.video.i_frame_rate_base;
 386                         break;
 387                     }
 388                 }
 389             }
 390             return VLC_SUCCESS;
 391
 392         case DEMUX_SET_TIME:
 393         default:
 394             return VLC_EGENERIC;
 395     }
 396 }
 397
 398 /* Seek */
 399 static void Seek( demux_t *p_demux, mtime_t i_date, double f_percent, chapter_item_c *psz_chapter )
 400 {
 401     demux_sys_t        *p_sys = p_demux->p_sys;
 402     virtual_segment_c  *p_vsegment = p_sys->p_current_segment;
 403     matroska_segment_c *p_segment = p_vsegment->Segment();
 404     mtime_t            i_time_offset = 0;
 405     int64_t            i_global_position = -1;
 406
 407     int         i_index;
 408
 409     msg_Dbg( p_demux, "seek request to %"PRId64" (%f%%)", i_date, f_percent );
 410     if( i_date < 0 && f_percent < 0 )
 411     {
 412         msg_Warn( p_demux, "cannot seek nowhere !" );
 413         return;
 414     }
 415     if( f_percent > 1.0 )
 416     {
 417         msg_Warn( p_demux, "cannot seek so far !" );
 418         return;
 419     }
 420
 421     /* seek without index or without date */
 422     if( f_percent >= 0 && (var_InheritInteger( p_demux, "mkv-seek-percent" ) || !p_segment->b_cues || i_date < 0 ))
 423     {
 424         if( p_sys->f_duration >= 0 && p_segment->b_cues )
 425         {
 426             i_date = int64_t( f_percent * p_sys->f_duration * 1000.0 );
 427         }
 428         else
 429         {
 430             int64_t i_pos = int64_t( f_percent * stream_Size( p_demux->s ) );
 431
 432             msg_Dbg( p_demux, "inaccurate way of seeking for pos:%"PRId64, i_pos );
 433             for( i_index = 0; i_index < p_segment->i_index; i_index++ )
 434             {
 435                 if( p_segment->b_cues && p_segment->p_indexes[i_index].i_position < i_pos )
 436                     break;
 437                 if( !p_segment->b_cues && p_segment->p_indexes[i_index].i_position >= i_pos && p_segment->p_indexes[i_index].i_time > 0 )
 438                     break;
 439             }
 440             if( i_index == p_segment->i_index )
 441             {
 442                 i_index--;
 443             }
 444
 445             i_date = p_segment->p_indexes[i_index].i_time;
 446
 447             if( !p_segment->b_cues && ( p_segment->p_indexes[i_index].i_position < i_pos || p_segment->p_indexes[i_index].i_position - i_pos > 2000000 ))
 448             {
 449                 msg_Dbg( p_demux, "no cues, seek request to global pos: %"PRId64, i_pos );
 450                 i_global_position = i_pos;
 451             }
 452         }
 453     }
 454
 455     p_vsegment->Seek( *p_demux, i_date, i_time_offset, psz_chapter, i_global_position );
 456 }
 457
 458 /* Utility function for BlockDecode */
 459 static block_t *MemToBlock( demux_t *p_demux, uint8_t *p_mem, int i_mem, size_t offset)
 460 {
 461     block_t *p_block;
 462     if( !(p_block = block_New( p_demux, i_mem + offset ) ) ) return NULL;
 463     memcpy( p_block->p_buffer + offset, p_mem, i_mem );
 464     //p_block->i_rate = p_input->stream.control.i_rate;
 465     return p_block;
 466 }
 467
 468 /* Needed by matroska_segment::Seek() */
 469 static void BlockDecode( demux_t *p_demux, KaxBlock *block, KaxSimpleBlock *simpleblock,
 470                          mtime_t i_pts, mtime_t i_duration, bool f_mandatory )
 471 {
 472     demux_sys_t        *p_sys = p_demux->p_sys;
 473     matroska_segment_c *p_segment = p_sys->p_current_segment->Segment();
 474
 475     size_t          i_track;
 476     unsigned int    i;
 477     bool            b;
 478
 479     if( p_segment->BlockFindTrackIndex( &i_track, block, simpleblock ) )
 480     {
 481         msg_Err( p_demux, "invalid track number" );
 482         return;
 483     }
 484
 485     mkv_track_t *tk = p_segment->tracks[i_track];
 486
 487     if( tk->fmt.i_cat != NAV_ES && tk->p_es == NULL )
 488     {
 489         msg_Err( p_demux, "unknown track number" );
 490         return;
 491     }
 492     if( i_pts + i_duration < p_sys->i_start_pts && tk->fmt.i_cat == AUDIO_ES )
 493     {
 494         return; /* discard audio packets that shouldn't be rendered */
 495     }
 496
 497     if ( tk->fmt.i_cat != NAV_ES )
 498     {
 499         es_out_Control( p_demux->out, ES_OUT_GET_ES_STATE, tk->p_es, &b );
 500
 501         if( !b )
 502         {
 503             tk->b_inited = false;
 504             return;
 505         }
 506     }
 507
 508
 509     /* First send init data */
 510     if( !tk->b_inited && tk->i_data_init > 0 )
 511     {
 512         block_t *p_init;
 513
 514         msg_Dbg( p_demux, "sending header (%d bytes)", tk->i_data_init );
 515         p_init = MemToBlock( p_demux, tk->p_data_init, tk->i_data_init, 0 );
 516         if( p_init ) es_out_Send( p_demux->out, tk->p_es, p_init );
 517     }
 518     tk->b_inited = true;
 519
 520
 521     for( i = 0;
 522          (block != NULL && i < block->NumberFrames()) || (simpleblock != NULL && i < simpleblock->NumberFrames());
 523          i++ )
 524     {
 525         block_t *p_block;
 526         DataBuffer *data;
 527         if( simpleblock != NULL )
 528         {
 529             data = &simpleblock->GetBuffer(i);
 530             // condition when the DTS is correct (keyframe or B frame == NOT P frame)
 531             f_mandatory = simpleblock->IsDiscardable() || simpleblock->IsKeyframe();
 532         }
 533         else
 534         {
 535             data = &block->GetBuffer(i);
 536         }
 537
 538         if( tk->i_compression_type == MATROSKA_COMPRESSION_HEADER && tk->p_compression_data != NULL )
 539             p_block = MemToBlock( p_demux, data->Buffer(), data->Size(), tk->p_compression_data->GetSize() );
 540         else
 541             p_block = MemToBlock( p_demux, data->Buffer(), data->Size(), 0 );
 542
 543         if( p_block == NULL )
 544         {
 545             break;
 546         }
 547
 548 #if defined(HAVE_ZLIB_H)
 549         if( tk->i_compression_type == MATROSKA_COMPRESSION_ZLIB )
 550         {
 551             p_block = block_zlib_decompress( VLC_OBJECT(p_demux), p_block );
 552         }
 553         else
 554 #endif
 555         if( tk->i_compression_type == MATROSKA_COMPRESSION_HEADER )
 556         {
 557             memcpy( p_block->p_buffer, tk->p_compression_data->GetBuffer(), tk->p_compression_data->GetSize() );
 558         }
 559
 560         if ( tk->fmt.i_cat == NAV_ES )
 561         {
 562             // TODO handle the start/stop times of this packet
 563             if ( p_sys->b_ui_hooked )
 564             {
 565                 vlc_mutex_lock( &p_sys->p_ev->lock );
 566                 memcpy( &p_sys->pci_packet, &p_block->p_buffer[1], sizeof(pci_t) );
 567                 p_sys->SwapButtons();
 568                 p_sys->b_pci_packet_set = true;
 569                 vlc_mutex_unlock( &p_sys->p_ev->lock );
 570                 block_Release( p_block );
 571             }
 572             return;
 573         }
 574         // correct timestamping when B frames are used
 575         if( tk->fmt.i_cat != VIDEO_ES )
 576         {
 577             p_block->i_dts = p_block->i_pts = i_pts;
 578         }
 579         else
 580         {
 581             if( tk->b_dts_only )
 582             {
 583                 p_block->i_pts = VLC_TS_INVALID;
 584                 p_block->i_dts = i_pts;
 585             }
 586             else
 587             {
 588                 p_block->i_pts = i_pts;
 589                 if ( f_mandatory )
 590                     p_block->i_dts = p_block->i_pts;
 591                 else
 592                     p_block->i_dts = min( i_pts, tk->i_last_dts + (mtime_t)(tk->i_default_duration >> 10));
 593                 p_sys->i_pts = p_block->i_dts;
 594             }
 595         }
 596         tk->i_last_dts = p_block->i_dts;
 597
 598 #if 0
 599 msg_Dbg( p_demux, "block i_dts: %"PRId64" / i_pts: %"PRId64, p_block->i_dts, p_block->i_pts);
 600 #endif
 601         if( strcmp( tk->psz_codec, "S_VOBSUB" ) )
 602         {
 603             p_block->i_length = i_duration * 1000;
 604         }
 605
 606         /* FIXME remove when VLC_TS_INVALID work is done */
 607         if( i == 0 || p_block->i_dts > VLC_TS_INVALID )
 608             p_block->i_dts += VLC_TS_0;
 609         if( !tk->b_dts_only && ( i == 0 || p_block->i_pts > VLC_TS_INVALID ) )
 610             p_block->i_pts += VLC_TS_0;
 611
 612         es_out_Send( p_demux->out, tk->p_es, p_block );
 613
 614         /* use time stamp only for first block */
 615         i_pts = VLC_TS_INVALID;
 616     }
 617 }
 618
 619
 620 void matroska_segment_c::Seek( mtime_t i_date, mtime_t i_time_offset, int64_t i_global_position )
 621 {
 622     KaxBlock    *block;
 623     KaxSimpleBlock *simpleblock;
 624     int         i_track_skipping;
 625     int64_t     i_block_duration;
 626     int64_t     i_block_ref1;
 627     int64_t     i_block_ref2;
 628     size_t      i_track;
 629     int64_t     i_seek_position = i_start_pos;
 630     int64_t     i_seek_time = i_start_time;
 631
 632     if( i_global_position >= 0 )
 633     {
 634         /* Special case for seeking in files with no cues */
 635         EbmlElement *el = NULL;
 636         es.I_O().setFilePointer( i_start_pos, seek_beginning );
 637         delete ep;
 638         ep = new EbmlParser( &es, segment, &sys.demuxer );
 639         cluster = NULL;
 640
 641         while( ( el = ep->Get() ) != NULL )
 642         {
 643             if( MKV_IS_ID( el, KaxCluster ) )
 644             {
 645                 cluster = (KaxCluster *)el;
 646                 i_cluster_pos = cluster->GetElementPosition();
 647                 if( i_index == 0 ||
 648                         ( i_index > 0 && p_indexes[i_index - 1].i_position < (int64_t)cluster->GetElementPosition() ) )
 649                 {
 650                     IndexAppendCluster( cluster );
 651                 }
 652                 if( es.I_O().getFilePointer() >= i_global_position )
 653                 {
 654                     ParseCluster();
 655                     msg_Dbg( &sys.demuxer, "we found a cluster that is in the neighbourhood" );
 656                     return;
 657                 }
 658             }
 659         }
 660         msg_Err( &sys.demuxer, "This file has no cues, and we were unable to seek to the requested position by parsing." );
 661         return;
 662     }
 663
 664     if ( i_index > 0 )
 665     {
 666         int i_idx = 0;
 667
 668         for( ; i_idx < i_index; i_idx++ )
 669         {
 670             if( p_indexes[i_idx].i_time + i_time_offset > i_date )
 671             {
 672                 break;
 673             }
 674         }
 675
 676         if( i_idx > 0 )
 677         {
 678             i_idx--;
 679         }
 680
 681         i_seek_position = p_indexes[i_idx].i_position;
 682         i_seek_time = p_indexes[i_idx].i_time;
 683     }
 684
 685     msg_Dbg( &sys.demuxer, "seek got %"PRId64" (%d%%)",
 686                 i_seek_time, (int)( 100 * i_seek_position / stream_Size( sys.demuxer.s ) ) );
 687
 688     es.I_O().setFilePointer( i_seek_position, seek_beginning );
 689
 690     delete ep;
 691     ep = new EbmlParser( &es, segment, &sys.demuxer );
 692     cluster = NULL;
 693
 694     sys.i_start_pts = i_date;
 695
 696     /* now parse until key frame */
 697     i_track_skipping = 0;
 698     for( i_track = 0; i_track < tracks.size(); i_track++ )
 699     {
 700         if( tracks[i_track]->fmt.i_cat == VIDEO_ES )
 701         {
 702             tracks[i_track]->b_search_keyframe = true;
 703             i_track_skipping++;
 704         }
 705     }
 706     es_out_Control( sys.demuxer.out, ES_OUT_SET_NEXT_DISPLAY_TIME, i_date );
 707
 708     while( i_track_skipping > 0 )
 709     {
 710         if( BlockGet( block, simpleblock, &i_block_ref1, &i_block_ref2, &i_block_duration ) )
 711         {
 712             msg_Warn( &sys.demuxer, "cannot get block EOF?" );
 713
 714             return;
 715         }
 716         ep->Down();
 717
 718         for( i_track = 0; i_track < tracks.size(); i_track++ )
 719         {
 720             if( (simpleblock && tracks[i_track]->i_number == simpleblock->TrackNum()) ||
 721                 (block && tracks[i_track]->i_number == block->TrackNum()) )
 722             {
 723                 break;
 724             }
 725         }
 726
 727         if( simpleblock )
 728             sys.i_pts = (sys.i_chapter_time + simpleblock->GlobalTimecode()) / (mtime_t) 1000;
 729         else
 730             sys.i_pts = (sys.i_chapter_time + block->GlobalTimecode()) / (mtime_t) 1000;
 731
 732         if( i_track < tracks.size() )
 733         {
 734             if( sys.i_pts >= sys.i_start_pts )
 735             {
 736                 cluster = static_cast<KaxCluster*>(ep->UnGet( i_block_pos, i_cluster_pos ));
 737                 i_track_skipping = 0;
 738             }
 739             else if( tracks[i_track]->fmt.i_cat == VIDEO_ES )
 740             {
 741                 if( i_block_ref1 == 0 && tracks[i_track]->b_search_keyframe )
 742                 {
 743                     tracks[i_track]->b_search_keyframe = false;
 744                     i_track_skipping--;
 745                 }
 746                 if( !tracks[i_track]->b_search_keyframe )
 747                 {
 748                     BlockDecode( &sys.demuxer, block, simpleblock, sys.i_pts, 0, i_block_ref1 >= 0 || i_block_ref2 > 0 );
 749                 }
 750             }
 751         }
 752
 753         delete block;
 754     }
 755
 756     /* FIXME current ES_OUT_SET_NEXT_DISPLAY_TIME does not work that well if
 757      * the delay is too high. */
 758     if( sys.i_pts + 500*1000 < sys.i_start_pts )
 759     {
 760         sys.i_start_pts = sys.i_pts;
 761
 762         es_out_Control( sys.demuxer.out, ES_OUT_SET_NEXT_DISPLAY_TIME, sys.i_start_pts );
 763     }
 764 }
 765
 766
 767 /*****************************************************************************
 768  * Demux: reads and demuxes data packets
 769  *****************************************************************************
 770  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
 771  *****************************************************************************/
 772 static int Demux( demux_t *p_demux)
 773 {
 774     demux_sys_t        *p_sys = p_demux->p_sys;
 775
 776     vlc_mutex_lock( &p_sys->lock_demuxer );
 777
 778     virtual_segment_c  *p_vsegment = p_sys->p_current_segment;
 779     matroska_segment_c *p_segment = p_vsegment->Segment();
 780     if ( p_segment == NULL ) return 0;
 781     int                i_block_count = 0;
 782     int                i_return = 0;
 783
 784     for( ;; )
 785     {
 786         if ( p_sys->demuxer.b_die )
 787             break;
 788
 789         if( p_sys->i_pts >= p_sys->i_start_pts  )
 790             if ( p_vsegment->UpdateCurrentToChapter( *p_demux ) )
 791             {
 792                 i_return = 1;
 793                 break;
 794             }
 795
 796         if ( p_vsegment->Edition() && p_vsegment->Edition()->b_ordered && p_vsegment->CurrentChapter() == NULL )
 797         {
 798             /* nothing left to read in this ordered edition */
 799             if ( !p_vsegment->SelectNext() )
 800                 break;
 801             p_segment->UnSelect( );
 802
 803             es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
 804
 805             /* switch to the next segment */
 806             p_segment = p_vsegment->Segment();
 807             if ( !p_segment->Select( 0 ) )
 808             {
 809                 msg_Err( p_demux, "Failed to select new segment" );
 810                 break;
 811             }
 812             continue;
 813         }
 814
 815         KaxBlock *block;
 816         KaxSimpleBlock *simpleblock;
 817         int64_t i_block_duration = 0;
 818         int64_t i_block_ref1;
 819         int64_t i_block_ref2;
 820
 821         if( p_segment->BlockGet( block, simpleblock, &i_block_ref1, &i_block_ref2, &i_block_duration ) )
 822         {
 823             if ( p_vsegment->Edition() && p_vsegment->Edition()->b_ordered )
 824             {
 825                 const chapter_item_c *p_chap = p_vsegment->CurrentChapter();
 826                 // check if there are more chapters to read
 827                 if ( p_chap != NULL )
 828                 {
 829                     /* TODO handle successive chapters with the same user_start_time/user_end_time
 830                     if ( p_chap->i_user_start_time == p_chap->i_user_start_time )
 831                         p_vsegment->SelectNext();
 832                     */
 833                     p_sys->i_pts = p_chap->i_user_end_time;
 834                     p_sys->i_pts++; // trick to avoid staying on segments with no duration and no content
 835
 836                     i_return = 1;
 837                 }
 838
 839                 break;
 840             }
 841             else
 842             {
 843                 msg_Warn( p_demux, "cannot get block EOF?" );
 844                 p_segment->UnSelect( );
 845
 846                 es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
 847
 848                 /* switch to the next segment */
 849                 if ( !p_vsegment->SelectNext() )
 850                     // no more segments in this stream
 851                     break;
 852                 p_segment = p_vsegment->Segment();
 853                 if ( !p_segment->Select( 0 ) )
 854                 {
 855                     msg_Err( p_demux, "Failed to select new segment" );
 856                     break;
 857                 }
 858
 859                 continue;
 860             }
 861         }
 862
 863         if( simpleblock != NULL )
 864             p_sys->i_pts = (p_sys->i_chapter_time + simpleblock->GlobalTimecode()) / (mtime_t) 1000;
 865         else
 866             p_sys->i_pts = (p_sys->i_chapter_time + block->GlobalTimecode()) / (mtime_t) 1000;
 867
 868         /* */
 869         es_out_Control( p_demux->out, ES_OUT_SET_PCR, VLC_TS_0 + p_sys->i_pts );
 870
 871         if( p_sys->i_pts >= p_sys->i_start_pts  )
 872         {
 873             if ( p_vsegment->UpdateCurrentToChapter( *p_demux ) )
 874             {
 875                 i_return = 1;
 876                 delete block;
 877                 break;
 878             }
 879         }
 880
 881         if ( p_vsegment->Edition() && p_vsegment->Edition()->b_ordered && p_vsegment->CurrentChapter() == NULL )
 882         {
 883             /* nothing left to read in this ordered edition */
 884             if ( !p_vsegment->SelectNext() )
 885             {
 886                 delete block;
 887                 break;
 888             }
 889             p_segment->UnSelect( );
 890
 891             es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
 892
 893             /* switch to the next segment */
 894             p_segment = p_vsegment->Segment();
 895             if ( !p_segment->Select( 0 ) )
 896             {
 897                 msg_Err( p_demux, "Failed to select new segment" );
 898                 delete block;
 899                 break;
 900             }
 901             delete block;
 902             continue;
 903         }
 904
 905         BlockDecode( p_demux, block, simpleblock, p_sys->i_pts, i_block_duration, i_block_ref1 >= 0 || i_block_ref2 > 0 );
 906
 907         delete block;
 908         i_block_count++;
 909
 910         // TODO optimize when there is need to leave or when seeking has been called
 911         if( i_block_count > 5 )
 912         {
 913             i_return = 1;
 914             break;
 915         }
 916     }
 917
 918     vlc_mutex_unlock( &p_sys->lock_demuxer );
 919
 920     return i_return;
 921 }
 922