1 /*****************************************************************************
2 * mkv.cpp : matroska demuxer
3 *****************************************************************************
4 * Copyright (C) 2003-2005, 2008, 2010 the VideoLAN team
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Steve Lhomme <steve.lhomme@free.fr>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
28 #include "matroska_segment.hpp"
31 #include "chapters.hpp"
32 #include "Ebml_parser.hpp"
34 #include "stream_io_callback.hpp"
38 /*****************************************************************************
40 *****************************************************************************/
41 static int Open ( vlc_object_t * );
42 static void Close( vlc_object_t * );
45 set_shortname( "Matroska" )
46 set_description( N_("Matroska stream demuxer" ) )
47 set_capability( "demux", 50 )
48 set_callbacks( Open, Close )
49 set_category( CAT_INPUT )
50 set_subcategory( SUBCAT_INPUT_DEMUX )
52 add_bool( "mkv-use-ordered-chapters", true, NULL,
53 N_("Ordered chapters"),
54 N_("Play ordered chapters as specified in the segment."), true );
56 add_bool( "mkv-use-chapter-codec", true, NULL,
58 N_("Use chapter codecs found in the segment."), true );
60 add_bool( "mkv-preload-local-dir", false, NULL,
61 N_("Preload Directory"),
62 N_("Preload matroska files from the same family in the same directory (not good for broken files)."), true );
64 add_bool( "mkv-seek-percent", false, NULL,
65 N_("Seek based on percent not time"),
66 N_("Seek based on percent not time."), true );
68 add_bool( "mkv-use-dummy", false, NULL,
70 N_("Read and discard unknown EBML elements (not good for broken files)."), true );
72 add_shortcut( "mka", "mkv" )
77 static int Demux ( demux_t * );
78 static int Control( demux_t *, int, va_list );
79 static void Seek ( demux_t *, mtime_t i_date, double f_percent, chapter_item_c *psz_chapter );
81 /*****************************************************************************
82 * Open: initializes matroska demux structures
83 *****************************************************************************/
84 static int Open( vlc_object_t * p_this )
86 demux_t *p_demux = (demux_t*)p_this;
88 matroska_stream_c *p_stream;
89 matroska_segment_c *p_segment;
90 const uint8_t *p_peek;
91 std::string s_path, s_filename;
92 vlc_stream_io_callback *p_io_callback;
93 EbmlStream *p_io_stream;
95 /* peek the begining */
96 if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) return VLC_EGENERIC;
99 if( p_peek[0] != 0x1a || p_peek[1] != 0x45 ||
100 p_peek[2] != 0xdf || p_peek[3] != 0xa3 ) return VLC_EGENERIC;
102 /* Set the demux function */
103 p_demux->pf_demux = Demux;
104 p_demux->pf_control = Control;
105 p_demux->p_sys = p_sys = new demux_sys_t( *p_demux );
107 p_io_callback = new vlc_stream_io_callback( p_demux->s, false );
108 p_io_stream = new EbmlStream( *p_io_callback );
110 if( p_io_stream == NULL )
112 msg_Err( p_demux, "failed to create EbmlStream" );
113 delete p_io_callback;
118 p_stream = p_sys->AnalyseAllSegmentsFound( p_demux, p_io_stream, true );
119 if( p_stream == NULL )
121 msg_Err( p_demux, "cannot find KaxSegment" );
124 p_sys->streams.push_back( p_stream );
126 p_stream->p_in = p_io_callback;
127 p_stream->p_es = p_io_stream;
129 for (size_t i=0; i<p_stream->segments.size(); i++)
131 p_stream->segments[i]->Preload();
134 p_segment = p_stream->segments[0];
135 if( p_segment->cluster == NULL )
137 msg_Err( p_demux, "cannot find any cluster, damaged file ?" );
141 if (var_InheritBool( p_demux, "mkv-preload-local-dir" ))
143 /* get the files from the same dir from the same family (based on p_demux->psz_path) */
144 if (p_demux->psz_path[0] != '\0' && !strcmp(p_demux->psz_access, ""))
146 // assume it's a regular file
147 // get the directory path
148 s_path = p_demux->psz_path;
149 if (s_path.at(s_path.length() - 1) == DIR_SEP_CHAR)
151 s_path = s_path.substr(0,s_path.length()-1);
155 if (s_path.find_last_of(DIR_SEP_CHAR) > 0)
157 s_path = s_path.substr(0,s_path.find_last_of(DIR_SEP_CHAR));
161 DIR *p_src_dir = vlc_opendir(s_path.c_str());
163 if (p_src_dir != NULL)
166 while ((psz_file = vlc_readdir(p_src_dir)) != NULL)
168 if (strlen(psz_file) > 4)
170 s_filename = s_path + DIR_SEP_CHAR + psz_file;
173 if (!strcasecmp(s_filename.c_str(), p_demux->psz_path))
175 if (!s_filename.compare(p_demux->psz_path))
179 continue; // don't reuse the original opened file
182 #if defined(__GNUC__) && (__GNUC__ < 3)
183 if (!s_filename.compare("mkv", s_filename.length() - 3, 3) ||
184 !s_filename.compare("mka", s_filename.length() - 3, 3))
186 if (!s_filename.compare(s_filename.length() - 3, 3, "mkv") ||
187 !s_filename.compare(s_filename.length() - 3, 3, "mka"))
190 // test wether this file belongs to our family
191 const uint8_t *p_peek;
192 bool file_ok = false;
193 stream_t *p_file_stream = stream_UrlNew(
196 /* peek the begining */
198 stream_Peek( p_file_stream, &p_peek, 4 ) >= 4
199 && p_peek[0] == 0x1a && p_peek[1] == 0x45 &&
200 p_peek[2] == 0xdf && p_peek[3] == 0xa3 ) file_ok = true;
204 vlc_stream_io_callback *p_file_io = new vlc_stream_io_callback( p_file_stream, true );
205 EbmlStream *p_estream = new EbmlStream(*p_file_io);
207 p_stream = p_sys->AnalyseAllSegmentsFound( p_demux, p_estream );
209 if ( p_stream == NULL )
211 msg_Dbg( p_demux, "the file '%s' will not be used", s_filename.c_str() );
217 p_stream->p_in = p_file_io;
218 p_stream->p_es = p_estream;
219 p_sys->streams.push_back( p_stream );
224 if( p_file_stream ) {
225 stream_Delete( p_file_stream );
227 msg_Dbg( p_demux, "the file '%s' cannot be opened", s_filename.c_str() );
233 closedir( p_src_dir );
237 p_sys->PreloadFamily( *p_segment );
240 p_sys->PreloadLinked( p_segment );
242 if ( !p_sys->PreparePlayback( NULL ) )
244 msg_Err( p_demux, "cannot use the segment" );
248 p_sys->StartUiThread();
257 /*****************************************************************************
258 * Close: frees unused data
259 *****************************************************************************/
260 static void Close( vlc_object_t *p_this )
262 demux_t *p_demux = (demux_t*)p_this;
263 demux_sys_t *p_sys = p_demux->p_sys;
268 /*****************************************************************************
270 *****************************************************************************/
271 static int Control( demux_t *p_demux, int i_query, va_list args )
273 demux_sys_t *p_sys = p_demux->p_sys;
280 input_attachment_t ***ppp_attach;
285 case DEMUX_GET_ATTACHMENTS:
286 ppp_attach = (input_attachment_t***)va_arg( args, input_attachment_t*** );
287 pi_int = (int*)va_arg( args, int * );
289 if( p_sys->stored_attachments.size() <= 0 )
292 *pi_int = p_sys->stored_attachments.size();
293 *ppp_attach = (input_attachment_t**)malloc( sizeof(input_attachment_t**) *
294 p_sys->stored_attachments.size() );
297 for( size_t i = 0; i < p_sys->stored_attachments.size(); i++ )
299 attachment_c *a = p_sys->stored_attachments[i];
300 (*ppp_attach)[i] = vlc_input_attachment_New( a->psz_file_name.c_str(), a->psz_mime_type.c_str(), NULL,
301 a->p_data, a->i_size );
306 p_meta = (vlc_meta_t*)va_arg( args, vlc_meta_t* );
307 vlc_meta_Merge( p_meta, p_sys->meta );
310 case DEMUX_GET_LENGTH:
311 pi64 = (int64_t*)va_arg( args, int64_t * );
312 if( p_sys->f_duration > 0.0 )
314 *pi64 = (int64_t)(p_sys->f_duration * 1000);
319 case DEMUX_GET_POSITION:
320 pf = (double*)va_arg( args, double * );
321 if ( p_sys->f_duration > 0.0 )
322 *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);
325 case DEMUX_SET_POSITION:
326 f = (double)va_arg( args, double );
327 Seek( p_demux, -1, f, NULL );
331 pi64 = (int64_t*)va_arg( args, int64_t * );
332 *pi64 = p_sys->i_pts;
335 case DEMUX_GET_TITLE_INFO:
336 if( p_sys->titles.size() > 1 || ( p_sys->titles.size() == 1 && p_sys->titles[0]->i_seekpoint > 0 ) )
338 input_title_t ***ppp_title = (input_title_t***)va_arg( args, input_title_t*** );
339 int *pi_int = (int*)va_arg( args, int* );
341 *pi_int = p_sys->titles.size();
342 *ppp_title = (input_title_t**)malloc( sizeof( input_title_t**) * p_sys->titles.size() );
344 for( size_t i = 0; i < p_sys->titles.size(); i++ )
346 (*ppp_title)[i] = vlc_input_title_Duplicate( p_sys->titles[i] );
352 case DEMUX_SET_TITLE:
353 /* TODO handle editions as titles */
354 i_idx = (int)va_arg( args, int );
355 if( i_idx < p_sys->used_segments.size() )
357 p_sys->JumpTo( *p_sys->used_segments[i_idx], NULL );
362 case DEMUX_SET_SEEKPOINT:
363 i_skp = (int)va_arg( args, int );
365 // TODO change the way it works with the << & >> buttons on the UI (+1/-1 instead of a number)
366 if( p_sys->titles.size() && i_skp < p_sys->titles[p_sys->i_current_title]->i_seekpoint)
368 Seek( p_demux, (int64_t)p_sys->titles[p_sys->i_current_title]->seekpoint[i_skp]->i_time_offset, -1, NULL);
369 p_demux->info.i_seekpoint |= INPUT_UPDATE_SEEKPOINT;
370 p_demux->info.i_seekpoint = i_skp;
376 pf = (double *)va_arg( args, double * );
378 if( p_sys->p_current_segment && p_sys->p_current_segment->Segment() )
380 const matroska_segment_c *p_segment = p_sys->p_current_segment->Segment();
381 for( size_t i = 0; i < p_segment->tracks.size(); i++ )
383 mkv_track_t *tk = p_segment->tracks[i];
384 if( tk->fmt.i_cat == VIDEO_ES && tk->fmt.video.i_frame_rate_base > 0 )
386 *pf = (double)tk->fmt.video.i_frame_rate / tk->fmt.video.i_frame_rate_base;
400 static void Seek( demux_t *p_demux, mtime_t i_date, double f_percent, chapter_item_c *psz_chapter )
402 demux_sys_t *p_sys = p_demux->p_sys;
403 virtual_segment_c *p_vsegment = p_sys->p_current_segment;
404 matroska_segment_c *p_segment = p_vsegment->Segment();
405 mtime_t i_time_offset = 0;
406 int64_t i_global_position = -1;
410 msg_Dbg( p_demux, "seek request to %"PRId64" (%f%%)", i_date, f_percent );
411 if( i_date < 0 && f_percent < 0 )
413 msg_Warn( p_demux, "cannot seek nowhere !" );
416 if( f_percent > 1.0 )
418 msg_Warn( p_demux, "cannot seek so far !" );
422 /* seek without index or without date */
423 if( f_percent >= 0 && (var_InheritBool( p_demux, "mkv-seek-percent" ) || !p_segment->b_cues || i_date < 0 ))
425 if( p_sys->f_duration >= 0 && p_segment->b_cues )
427 i_date = int64_t( f_percent * p_sys->f_duration * 1000.0 );
431 int64_t i_pos = int64_t( f_percent * stream_Size( p_demux->s ) );
433 msg_Dbg( p_demux, "inaccurate way of seeking for pos:%"PRId64, i_pos );
434 for( i_index = 0; i_index < p_segment->i_index; i_index++ )
436 if( p_segment->b_cues && p_segment->p_indexes[i_index].i_position < i_pos )
438 if( !p_segment->b_cues && p_segment->p_indexes[i_index].i_position >= i_pos && p_segment->p_indexes[i_index].i_time > 0 )
441 if( i_index == p_segment->i_index )
446 i_date = p_segment->p_indexes[i_index].i_time;
448 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 ))
450 msg_Dbg( p_demux, "no cues, seek request to global pos: %"PRId64, i_pos );
451 i_global_position = i_pos;
456 p_vsegment->Seek( *p_demux, i_date, i_time_offset, psz_chapter, i_global_position );
459 /* Utility function for BlockDecode */
460 static block_t *MemToBlock( demux_t *p_demux, uint8_t *p_mem, size_t i_mem, size_t offset)
463 if( !(p_block = block_New( p_demux, i_mem + offset ) ) ) return NULL;
464 memcpy( p_block->p_buffer + offset, p_mem, i_mem );
465 //p_block->i_rate = p_input->stream.control.i_rate;
469 /* Needed by matroska_segment::Seek() and Seek */
470 void BlockDecode( demux_t *p_demux, KaxBlock *block, KaxSimpleBlock *simpleblock,
471 mtime_t i_pts, mtime_t i_duration, bool f_mandatory )
473 demux_sys_t *p_sys = p_demux->p_sys;
474 matroska_segment_c *p_segment = p_sys->p_current_segment->Segment();
476 if( !p_segment ) return;
479 if( p_segment->BlockFindTrackIndex( &i_track, block, simpleblock ) )
481 msg_Err( p_demux, "invalid track number" );
485 mkv_track_t *tk = p_segment->tracks[i_track];
487 if( tk->fmt.i_cat != NAV_ES && tk->p_es == NULL )
489 msg_Err( p_demux, "unknown track number" );
492 if( i_pts + i_duration < p_sys->i_start_pts && tk->fmt.i_cat == AUDIO_ES )
494 return; /* discard audio packets that shouldn't be rendered */
497 if ( tk->fmt.i_cat != NAV_ES )
500 es_out_Control( p_demux->out, ES_OUT_GET_ES_STATE, tk->p_es, &b );
504 tk->b_inited = false;
510 /* First send init data */
511 if( !tk->b_inited && tk->i_data_init > 0 )
515 msg_Dbg( p_demux, "sending header (%d bytes)", tk->i_data_init );
516 p_init = MemToBlock( p_demux, tk->p_data_init, tk->i_data_init, 0 );
517 if( p_init ) es_out_Send( p_demux->out, tk->p_es, p_init );
522 for( unsigned int i = 0;
523 (block != NULL && i < block->NumberFrames()) || (simpleblock != NULL && i < simpleblock->NumberFrames());
528 if( simpleblock != NULL )
530 data = &simpleblock->GetBuffer(i);
531 // condition when the DTS is correct (keyframe or B frame == NOT P frame)
532 f_mandatory = simpleblock->IsDiscardable() || simpleblock->IsKeyframe();
536 data = &block->GetBuffer(i);
538 if( !data->Buffer() || data->Size() > SIZE_MAX )
541 if( tk->i_compression_type == MATROSKA_COMPRESSION_HEADER && tk->p_compression_data != NULL )
542 p_block = MemToBlock( p_demux, data->Buffer(), data->Size(), tk->p_compression_data->GetSize() );
544 p_block = MemToBlock( p_demux, data->Buffer(), data->Size(), 0 );
546 if( p_block == NULL )
551 #if defined(HAVE_ZLIB_H)
552 if( tk->i_compression_type == MATROSKA_COMPRESSION_ZLIB )
554 p_block = block_zlib_decompress( VLC_OBJECT(p_demux), p_block );
555 if( p_block == NULL )
560 if( tk->i_compression_type == MATROSKA_COMPRESSION_HEADER )
562 memcpy( p_block->p_buffer, tk->p_compression_data->GetBuffer(), tk->p_compression_data->GetSize() );
565 if ( tk->fmt.i_cat == NAV_ES )
567 // TODO handle the start/stop times of this packet
568 if ( p_sys->b_ui_hooked )
570 vlc_mutex_lock( &p_sys->p_ev->lock );
571 memcpy( &p_sys->pci_packet, &p_block->p_buffer[1], sizeof(pci_t) );
572 p_sys->SwapButtons();
573 p_sys->b_pci_packet_set = true;
574 vlc_mutex_unlock( &p_sys->p_ev->lock );
575 block_Release( p_block );
579 // correct timestamping when B frames are used
580 if( tk->fmt.i_cat != VIDEO_ES )
582 p_block->i_dts = p_block->i_pts = i_pts;
588 p_block->i_pts = VLC_TS_INVALID;
589 p_block->i_dts = i_pts;
591 else if( tk->b_pts_only )
593 p_block->i_pts = i_pts;
594 p_block->i_dts = i_pts;
598 p_block->i_pts = i_pts;
600 p_block->i_dts = p_block->i_pts;
602 p_block->i_dts = min( i_pts, tk->i_last_dts + (mtime_t)(tk->i_default_duration >> 10));
605 tk->i_last_dts = p_block->i_dts;
608 msg_Dbg( p_demux, "block i_dts: %"PRId64" / i_pts: %"PRId64, p_block->i_dts, p_block->i_pts);
610 if( strcmp( tk->psz_codec, "S_VOBSUB" ) )
612 p_block->i_length = i_duration * 1000;
615 /* FIXME remove when VLC_TS_INVALID work is done */
616 if( i == 0 || p_block->i_dts > VLC_TS_INVALID )
617 p_block->i_dts += VLC_TS_0;
618 if( !tk->b_dts_only && ( i == 0 || p_block->i_pts > VLC_TS_INVALID ) )
619 p_block->i_pts += VLC_TS_0;
621 es_out_Send( p_demux->out, tk->p_es, p_block );
623 /* use time stamp only for first block */
624 i_pts = VLC_TS_INVALID;
628 /*****************************************************************************
629 * Demux: reads and demuxes data packets
630 *****************************************************************************
631 * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
632 *****************************************************************************/
633 static int Demux( demux_t *p_demux)
635 demux_sys_t *p_sys = p_demux->p_sys;
637 vlc_mutex_lock( &p_sys->lock_demuxer );
639 virtual_segment_c *p_vsegment = p_sys->p_current_segment;
640 matroska_segment_c *p_segment = p_vsegment->Segment();
641 if ( p_segment == NULL ) return 0;
642 int i_block_count = 0;
647 if ( p_sys->demuxer.b_die )
650 if( p_sys->i_pts >= p_sys->i_start_pts )
651 if ( p_vsegment->UpdateCurrentToChapter( *p_demux ) )
657 if ( p_vsegment->Edition() && p_vsegment->Edition()->b_ordered && p_vsegment->CurrentChapter() == NULL )
659 /* nothing left to read in this ordered edition */
660 if ( !p_vsegment->SelectNext() )
662 p_segment->UnSelect( );
664 es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
666 /* switch to the next segment */
667 p_segment = p_vsegment->Segment();
668 if ( !p_segment->Select( 0 ) )
670 msg_Err( p_demux, "Failed to select new segment" );
677 KaxSimpleBlock *simpleblock;
678 int64_t i_block_duration = 0;
680 bool b_discardable_picture;
681 if( p_segment->BlockGet( block, simpleblock, &b_key_picture, &b_discardable_picture, &i_block_duration ) )
683 if ( p_vsegment->Edition() && p_vsegment->Edition()->b_ordered )
685 const chapter_item_c *p_chap = p_vsegment->CurrentChapter();
686 // check if there are more chapters to read
687 if ( p_chap != NULL )
689 /* TODO handle successive chapters with the same user_start_time/user_end_time
690 if ( p_chap->i_user_start_time == p_chap->i_user_start_time )
691 p_vsegment->SelectNext();
693 p_sys->i_pts = p_chap->i_user_end_time;
694 p_sys->i_pts++; // trick to avoid staying on segments with no duration and no content
703 msg_Warn( p_demux, "cannot get block EOF?" );
704 p_segment->UnSelect( );
706 es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
708 /* switch to the next segment */
709 if ( !p_vsegment->SelectNext() )
710 // no more segments in this stream
712 p_segment = p_vsegment->Segment();
713 if ( !p_segment->Select( 0 ) )
715 msg_Err( p_demux, "Failed to select new segment" );
723 if( simpleblock != NULL )
724 p_sys->i_pts = (p_sys->i_chapter_time + simpleblock->GlobalTimecode()) / (mtime_t) 1000;
726 p_sys->i_pts = (p_sys->i_chapter_time + block->GlobalTimecode()) / (mtime_t) 1000;
729 es_out_Control( p_demux->out, ES_OUT_SET_PCR, VLC_TS_0 + p_sys->i_pts );
731 if( p_sys->i_pts >= p_sys->i_start_pts )
733 if ( p_vsegment->UpdateCurrentToChapter( *p_demux ) )
741 if ( p_vsegment->Edition() && p_vsegment->Edition()->b_ordered && p_vsegment->CurrentChapter() == NULL )
743 /* nothing left to read in this ordered edition */
744 if ( !p_vsegment->SelectNext() )
749 p_segment->UnSelect( );
751 es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
753 /* switch to the next segment */
754 p_segment = p_vsegment->Segment();
755 if ( !p_segment->Select( 0 ) )
757 msg_Err( p_demux, "Failed to select new segment" );
765 BlockDecode( p_demux, block, simpleblock, p_sys->i_pts, i_block_duration, b_key_picture || b_discardable_picture );
770 // TODO optimize when there is need to leave or when seeking has been called
771 if( i_block_count > 5 )
778 vlc_mutex_unlock( &p_sys->lock_demuxer );