/*****************************************************************************
* mkv.cpp : matroska demuxer
*****************************************************************************
- * Copyright (C) 2003-2004 VideoLAN
+ * Copyright (C) 2003-2004 the VideoLAN team
* $Id$
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
static void Close( vlc_object_t * );
vlc_module_begin();
- set_shortname( _("Matroska") );
+ set_shortname( "Matroska" );
set_description( _("Matroska stream demuxer" ) );
set_capability( "demux2", 50 );
set_callbacks( Open, Close );
add_bool( "mkv-use-ordered-chapters", 1, NULL,
N_("Ordered chapters"),
- N_("Play ordered chapters as specified in the segment"), VLC_TRUE );
+ N_("Play ordered chapters as specified in the segment."), VLC_TRUE );
add_bool( "mkv-use-chapter-codec", 1, NULL,
N_("Chapter codecs"),
- N_("Use chapter codecs found in the segment"), VLC_TRUE );
+ N_("Use chapter codecs found in the segment."), VLC_TRUE );
add_bool( "mkv-seek-percent", 0, NULL,
- N_("Seek based on percent not time"),
- N_("Seek based on percent not time"), VLC_TRUE );
+ N_("Seek based on percent not time."),
+ N_("Seek based on percent not time."), VLC_TRUE );
add_bool( "mkv-use-dummy", 0, NULL,
N_("Dummy Elements"),
- N_("Read and discard unknown EBML elements (not good for broken files)"), VLC_TRUE );
+ N_("Read and discard unknown EBML elements (not good for broken files)."), VLC_TRUE );
add_shortcut( "mka" );
add_shortcut( "mkv" );
private:
stream_t *s;
vlc_bool_t mb_eof;
+ vlc_bool_t b_owner;
public:
- vlc_stream_io_callback( stream_t * );
+ vlc_stream_io_callback( stream_t *, vlc_bool_t );
+
+ virtual ~vlc_stream_io_callback()
+ {
+ if( b_owner )
+ stream_Delete( s );
+ }
virtual uint32 read ( void *p_buffer, size_t i_size);
virtual void setFilePointer ( int64_t i_offset, seek_mode mode = seek_beginning );
void Reset( demux_t *p_demux );
EbmlElement *Get( void );
void Keep( void );
- void UnGet( uint64 i_restart_pos );
+ EbmlElement *UnGet( uint64 i_block_pos, uint64 i_cluster_pos );
int GetLevel( void );
// DVD command IDs
// Tests
- // wether the test has to be positive or not
- static const uint16 CMD_DVD_IF_NOT = 0x10;
// wether it's a comparison on the value or register
static const uint16 CMD_DVD_TEST_VALUE = 0x80;
- static const uint16 CMD_DVD_IF_GPREG_AND = (0 << 5);
- static const uint16 CMD_DVD_IF_GPREG_EQUAL = (1 << 5);
- static const uint16 CMD_DVD_IF_GPREG_SUP_EQUAL = (2 << 5);
- static const uint16 CMD_DVD_IF_GPREG_INF = (3 << 5);
+ static const uint16 CMD_DVD_IF_GPREG_AND = (1 << 4);
+ static const uint16 CMD_DVD_IF_GPREG_EQUAL = (2 << 4);
+ static const uint16 CMD_DVD_IF_GPREG_NOT_EQUAL = (3 << 4);
+ static const uint16 CMD_DVD_IF_GPREG_SUP_EQUAL = (4 << 4);
+ static const uint16 CMD_DVD_IF_GPREG_SUP = (5 << 4);
+ static const uint16 CMD_DVD_IF_GPREG_INF_EQUAL = (6 << 4);
+ static const uint16 CMD_DVD_IF_GPREG_INF = (7 << 4);
static const uint16 CMD_DVD_NOP = 0x0000;
static const uint16 CMD_DVD_GOTO_LINE = 0x0001;
int64_t RefreshChapters( bool b_ordered, int64_t i_prev_user_time );
int PublishChapters( input_title_t & title, int & i_user_chapters, int i_level = 0 );
- chapter_item_c * FindTimecode( mtime_t i_timecode );
+ virtual chapter_item_c * FindTimecode( mtime_t i_timecode, const chapter_item_c * p_current, bool & b_found );
void Append( const chapter_item_c & edition );
chapter_item_c * FindChapter( int64_t i_find_uid );
virtual chapter_item_c *BrowseCodecPrivate( unsigned int codec_id,
void RefreshChapters( );
mtime_t Duration() const;
std::string GetMainName() const;
+ chapter_item_c * FindTimecode( mtime_t i_timecode, const chapter_item_c * p_current );
bool b_ordered;
};
,i_chapters_position(-1)
,i_tags_position(-1)
,cluster(NULL)
+ ,i_block_pos(0)
+ ,i_cluster_pos(0)
,i_start_pos(0)
,p_segment_uid(NULL)
,p_prev_segment_uid(NULL)
int64_t i_tags_position;
KaxCluster *cluster;
+ uint64 i_block_pos;
+ uint64 i_cluster_pos;
int64_t i_start_pos;
KaxSegmentUID *p_segment_uid;
KaxPrevUID *p_prev_segment_uid;
void LoadTags( );
void InformationCreate( );
void Seek( mtime_t i_date, mtime_t i_time_offset );
- int BlockGet( KaxBlock * & pp_block, uint64 & i_cuepos, int64_t *pi_ref1, int64_t *pi_ref2, int64_t *pi_duration );
+ int BlockGet( KaxBlock * & pp_block, int64_t *pi_ref1, int64_t *pi_ref2, int64_t *pi_duration );
bool Select( mtime_t i_start_time );
void UnSelect( );
demux_sys_t( demux_t & demux )
:demuxer(demux)
,i_pts(0)
+ ,i_last_dts(0)
,i_start_pts(0)
,i_chapter_time(0)
,meta(NULL)
demux_t & demuxer;
mtime_t i_pts;
+ mtime_t i_last_dts;
mtime_t i_start_pts;
mtime_t i_chapter_time;
input_thread_t *p_input;
pci_t pci_packet;
bool b_pci_packet_set;
- uint8_t alpha[4];
+ uint8_t palette[4][4];
vlc_mutex_t lock_demuxer;
/* event */
#define MKV_IS_ID( el, C ) ( EbmlId( (*el) ) == C::ClassInfos.GlobalId )
-static char *UTF8ToStr ( const UTFstring &u );
+static inline char * ToUTF8( const UTFstring &u )
+{
+ return strdup( u.GetUTF8().c_str() );
+}
/*****************************************************************************
* Open: initializes matroska demux structures
p_demux->pf_control = Control;
p_demux->p_sys = p_sys = new demux_sys_t( *p_demux );
- p_io_callback = new vlc_stream_io_callback( p_demux->s );
+ p_io_callback = new vlc_stream_io_callback( p_demux->s, VLC_FALSE );
p_io_stream = new EbmlStream( *p_io_callback );
if( p_io_stream == NULL )
!s_filename.compare(s_filename.length() - 3, 3, "mka"))
#endif
{
- // test wether this file belongs to the our family
- StdIOCallback *p_file_io = new StdIOCallback(s_filename.c_str(), MODE_READ);
+ // test wether this file belongs to our family
+ vlc_stream_io_callback *p_file_io = new vlc_stream_io_callback( stream_UrlNew( p_demux, s_filename.c_str()), VLC_TRUE );
EbmlStream *p_estream = new EbmlStream(*p_file_io);
p_stream = p_sys->AnalyseAllSegmentsFound( p_estream );
}
}
-int matroska_segment_c::BlockGet( KaxBlock * & pp_block, uint64 & i_cuepos, int64_t *pi_ref1, int64_t *pi_ref2, int64_t *pi_duration )
+int matroska_segment_c::BlockGet( KaxBlock * & pp_block, int64_t *pi_ref1, int64_t *pi_ref2, int64_t *pi_duration )
{
pp_block = NULL;
- i_cuepos = 0;
- *pi_ref1 = -1;
- *pi_ref2 = -1;
+ *pi_ref1 = 0;
+ *pi_ref2 = 0;
for( ;; )
{
if( i_index > 0 && idx.i_time == -1 )
{
idx.i_time = (*pp_block).GlobalTimecode() / (mtime_t)1000;
- idx.b_key = *pi_ref1 == -1 ? VLC_TRUE : VLC_FALSE;
+ idx.b_key = *pi_ref1 == 0 ? VLC_TRUE : VLC_FALSE;
}
#undef idx
return VLC_SUCCESS;
if( MKV_IS_ID( el, KaxCluster ) )
{
cluster = (KaxCluster*)el;
+ i_cluster_pos = cluster->GetElementPosition();
/* add it to the index */
if( i_index == 0 ||
}
else if( MKV_IS_ID( el, KaxBlockGroup ) )
{
- i_cuepos = el->GetElementPosition();
+ i_block_pos = el->GetElementPosition();
ep->Down();
}
break;
KaxReferenceBlock &ref = *(KaxReferenceBlock*)el;
ref.ReadData( es.I_O() );
- if( *pi_ref1 == -1 )
+ if( *pi_ref1 == 0 )
{
- *pi_ref1 = int64( ref );
+ *pi_ref1 = int64( ref ) * cluster->GlobalTimecodeScale();
}
else
{
- *pi_ref2 = int64( ref );
+ *pi_ref2 = int64( ref ) * cluster->GlobalTimecodeScale();
}
}
else if( MKV_IS_ID( el, KaxClusterSilentTrackNumber ) )
msg_Err( p_demux, "unknown track number=%d", block->TrackNum() );
return;
}
- if( i_pts < p_sys->i_start_pts && tk->fmt.i_cat == AUDIO_ES )
+ if( i_pts + i_duration < p_sys->i_start_pts && tk->fmt.i_cat == AUDIO_ES )
{
return; /* discard audio packets that shouldn't be rendered */
}
return;
}
// TODO implement correct timestamping when B frames are used
+#if 0
if( tk->fmt.i_cat != VIDEO_ES )
{
p_block->i_dts = p_block->i_pts = i_pts;
}
else
{
- p_block->i_dts = i_pts;
- p_block->i_pts = 0;
+ p_block->i_pts = i_pts;
+ p_block->i_dts = p_sys->i_pts;
}
+#else
+ p_block->i_pts = i_pts;
+ p_block->i_dts = p_sys->i_last_dts;
+#endif
+#if 0
+msg_Dbg( p_demux, "block i_dts: "I64Fd" / i_pts: "I64Fd, p_block->i_dts, p_block->i_pts);
+#endif
if( strcmp( tk->psz_codec, "S_VOBSUB" ) )
{
p_block->i_length = i_duration * 1000;
delete p_l0;
// find all segments in this file
- p_l0 = p_estream->FindNextID(KaxSegment::ClassInfos, 0xFFFFFFFFL);
+ p_l0 = p_estream->FindNextID(KaxSegment::ClassInfos, 0xFFFFFFFFFLL);
if (p_l0 == NULL)
{
return NULL;
size_t i_track;
/* add all es */
- msg_Dbg( &sys.demuxer, "found %d es", tracks.size() );
+ msg_Dbg( &sys.demuxer, "found %d es", (int)tracks.size() );
sys.b_pci_packet_set = false;
for( i_track = 0; i_track < tracks.size(); i_track++ )
{
if( tracks[i_track]->fmt.i_cat == UNKNOWN_ES )
{
- msg_Warn( &sys.demuxer, "invalid track[%d, n=%d]", i_track, tracks[i_track]->i_number );
+ msg_Warn( &sys.demuxer, "invalid track[%d, n=%d]", (int)i_track, tracks[i_track]->i_number );
tracks[i_track]->p_es = NULL;
continue;
}
else if( !strcmp( tracks[i_track]->psz_codec, "A_TTA1" ) )
{
/* FIXME: support this codec */
- msg_Err( &sys.demuxer, "TTA not supported yet[%d, n=%d]", i_track, tracks[i_track]->i_number );
+ msg_Err( &sys.demuxer, "TTA not supported yet[%d, n=%d]", (int)i_track, tracks[i_track]->i_number );
tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 'n', 'd', 'f' );
}
else if( !strcmp( tracks[i_track]->psz_codec, "A_WAVPACK4" ) )
{
/* FIXME: support this codec */
- msg_Err( &sys.demuxer, "Wavpack not supported yet[%d, n=%d]", i_track, tracks[i_track]->i_number );
+ msg_Err( &sys.demuxer, "Wavpack not supported yet[%d, n=%d]", (int)i_track, tracks[i_track]->i_number );
tracks[i_track]->fmt.i_codec = VLC_FOURCC( 'u', 'n', 'd', 'f' );
}
else if( !strcmp( tracks[i_track]->psz_codec, "S_TEXT/UTF8" ) )
var_Create( p_input, "x-end", VLC_VAR_INTEGER );
var_Create( p_input, "y-end", VLC_VAR_INTEGER );
var_Create( p_input, "color", VLC_VAR_ADDRESS );
- var_Create( p_input, "menu-contrast", VLC_VAR_ADDRESS );
+ var_Create( p_input, "menu-palette", VLC_VAR_ADDRESS );
var_Create( p_input, "highlight", VLC_VAR_BOOL );
var_Create( p_input, "highlight-mutex", VLC_VAR_MUTEX );
var_Destroy( p_input, "y-start" );
var_Destroy( p_input, "y-end" );
var_Destroy( p_input, "color" );
- var_Destroy( p_input, "menu-contrast" );
+ var_Destroy( p_input, "menu-palette" );
+
+ vlc_object_release( p_input );
msg_Dbg( &demuxer, "Stopping the UI Hook" );
}
{
btni_t *button_ptr = &(pci->hli.btnit[button-1]);
- if((valx.i_int >= button_ptr->x_start) && (valx.i_int <= button_ptr->x_end) &&
- (valy.i_int >= button_ptr->y_start) && (valy.i_int <= button_ptr->y_end))
+ if(((unsigned)valx.i_int >= button_ptr->x_start)
+ && ((unsigned)valx.i_int <= button_ptr->x_end)
+ && ((unsigned)valy.i_int >= button_ptr->y_start)
+ && ((unsigned)valy.i_int <= button_ptr->y_end))
{
mx = (button_ptr->x_start + button_ptr->x_end)/2;
my = (button_ptr->y_start + button_ptr->y_end)/2;
} else {
i_palette = 0;
}
- p_sys->alpha[0] = i_palette & 0x0f;
- p_sys->alpha[1] = (i_palette>>4) & 0x0f;
- p_sys->alpha[2] = (i_palette>>8) & 0x0f;
- p_sys->alpha[3] = (i_palette>>12)& 0x0f;
+
+ for( int i = 0; i < 4; i++ )
+ {
+ uint32_t i_yuv = 0xFF;//p_sys->clut[(hl.palette>>(16+i*4))&0x0f];
+ uint8_t i_alpha = (i_palette>>(i*4))&0x0f;
+ i_alpha = i_alpha == 0xf ? 0xff : i_alpha << 4;
+
+ p_sys->palette[i][0] = (i_yuv >> 16) & 0xff;
+ p_sys->palette[i][1] = (i_yuv >> 0) & 0xff;
+ p_sys->palette[i][2] = (i_yuv >> 8) & 0xff;
+ p_sys->palette[i][3] = i_alpha;
+ }
vlc_mutex_lock( p_mutex );
val.i_int = button_ptr.x_start; var_Set( p_sys->p_input, "x-start", val );
val.i_int = button_ptr.y_start; var_Set( p_sys->p_input, "y-start", val );
val.i_int = button_ptr.y_end; var_Set( p_sys->p_input, "y-end", val );
- val.p_address = (void *)p_sys->alpha;
- var_Set( p_sys->p_input, "menu-contrast", val );
+ val.p_address = (void *)p_sys->palette;
+ var_Set( p_sys->p_input, "menu-palette", val );
val.b_bool = VLC_TRUE; var_Set( p_sys->p_input, "highlight", val );
vlc_mutex_unlock( p_mutex );
{
demux_sys_t & sys = *demux.p_sys;
chapter_item_c *psz_curr_chapter;
+ bool b_has_seeked = false;
/* update current chapter/seekpoint */
if ( p_editions->size() )
{
/* 1st, we need to know in which chapter we are */
- psz_curr_chapter = (*p_editions)[i_current_edition]->FindTimecode( sys.i_pts );
+ psz_curr_chapter = (*p_editions)[i_current_edition]->FindTimecode( sys.i_pts, psz_current_chapter );
/* we have moved to a new chapter */
if (psz_curr_chapter != NULL && psz_current_chapter != psz_curr_chapter)
if ( (*p_editions)[i_current_edition]->b_ordered )
{
// Leave/Enter up to the link point
- if ( !psz_curr_chapter->EnterAndLeave( psz_current_chapter ) )
+ b_has_seeked = psz_curr_chapter->EnterAndLeave( psz_current_chapter );
+ if ( !b_has_seeked )
{
- // only seek if necessary
+ // only physically seek if necessary
if ( psz_current_chapter == NULL || (psz_current_chapter->i_end_time != psz_curr_chapter->i_start_time) )
Seek( demux, sys.i_pts, 0, psz_curr_chapter );
- psz_current_chapter = psz_curr_chapter;
}
}
- else if ( psz_curr_chapter->i_seekpoint_num > 0 )
- {
- demux.info.i_update |= INPUT_UPDATE_TITLE | INPUT_UPDATE_SEEKPOINT;
- demux.info.i_title = sys.i_current_title = i_sys_title;
- demux.info.i_seekpoint = psz_curr_chapter->i_seekpoint_num - 1;
- psz_current_chapter = psz_curr_chapter;
- }
- else
+
+ if ( !b_has_seeked )
{
psz_current_chapter = psz_curr_chapter;
+ if ( psz_curr_chapter->i_seekpoint_num > 0 )
+ {
+ demux.info.i_update |= INPUT_UPDATE_TITLE | INPUT_UPDATE_SEEKPOINT;
+ demux.info.i_title = sys.i_current_title = i_sys_title;
+ demux.info.i_seekpoint = psz_curr_chapter->i_seekpoint_num - 1;
+ }
}
return true;
}
KaxBlock *block;
- uint64 i_cuepos;
int64_t i_block_duration = 0;
int64_t i_block_ref1;
int64_t i_block_ref2;
- if( p_segment->BlockGet( block, i_cuepos, &i_block_ref1, &i_block_ref2, &i_block_duration ) )
+ if( p_segment->BlockGet( block, &i_block_ref1, &i_block_ref2, &i_block_duration ) )
{
if ( p_vsegment->Edition() && p_vsegment->Edition()->b_ordered )
{
if ( p_chap->i_user_start_time == p_chap->i_user_start_time )
p_vsegment->SelectNext();
*/
- p_sys->i_pts = p_chap->i_user_end_time;
+ p_sys->i_last_dts = p_sys->i_pts = p_chap->i_user_end_time;
p_sys->i_pts++; // trick to avoid staying on segments with no duration and no content
i_return = 1;
}
}
- p_sys->i_pts = p_sys->i_chapter_time + block->GlobalTimecode() / (mtime_t) 1000;
+ mtime_t i_pts, i_dts;
+
+ mtime_t i_time = block->GlobalTimecode();
+ if ( i_block_ref1 != 0 )
+ i_time += min( 0, i_block_ref1 );
+ if ( i_block_ref2 != 0 )
+ i_time += min( 0, i_block_ref2 );
+
+ i_pts = (p_sys->i_chapter_time + block->GlobalTimecode()) / (mtime_t) 1000;
+ i_dts = (p_sys->i_chapter_time + i_time) / (mtime_t) 1000;
+
+ if ( i_dts != i_pts && p_sys->i_last_dts >= i_dts )
+ p_sys->i_last_dts += 200;
+ else
+ p_sys->i_last_dts = i_dts;
+
+ p_sys->i_pts = i_pts;
if( p_sys->i_pts >= p_sys->i_start_pts )
{
es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_pts );
}
- if( p_sys->i_pts >= p_sys->i_start_pts )
+ if( i_pts >= p_sys->i_start_pts )
if ( p_vsegment->UpdateCurrentToChapter( *p_demux ) )
{
i_return = 1;
continue;
}
- BlockDecode( p_demux, block, p_sys->i_pts, i_block_duration );
+ BlockDecode( p_demux, block, i_pts, i_block_duration );
delete block;
i_block_count++;
/*****************************************************************************
* Stream managment
*****************************************************************************/
-vlc_stream_io_callback::vlc_stream_io_callback( stream_t *s_ )
+vlc_stream_io_callback::vlc_stream_io_callback( stream_t *s_, vlc_bool_t b_owner_ )
{
s = s_;
+ b_owner = b_owner_;
mb_eof = VLC_FALSE;
}
}
}
-void EbmlParser::UnGet( uint64 i_restart_pos )
+EbmlElement* EbmlParser::UnGet( uint64 i_block_pos, uint64 i_cluster_pos )
{
- mi_user_level--;
- m_el[mi_level] = NULL;
+ if ( mi_user_level > mi_level )
+ {
+ while ( mi_user_level != mi_level )
+ {
+ delete m_el[mi_user_level];
+ m_el[mi_user_level] = NULL;
+ mi_user_level--;
+ }
+ }
m_got = NULL;
mb_keep = VLC_FALSE;
- m_es->I_O().setFilePointer( i_restart_pos, seek_beginning );
+ if ( m_el[1]->GetElementPosition() == i_cluster_pos )
+ {
+ m_es->I_O().setFilePointer( i_block_pos, seek_beginning );
+ return (EbmlMaster*) m_el[1];
+ }
+ else
+ {
+ // seek to the previous Cluster
+ m_es->I_O().setFilePointer( i_cluster_pos, seek_beginning );
+ mi_level--;
+ mi_user_level--;
+ delete m_el[mi_level];
+ m_el[mi_level] = NULL;
+ return NULL;
+ }
}
void EbmlParser::Up( void )
{
KaxTrackName &tname = *(KaxTrackName*)l;
- tk->fmt.psz_description = UTF8ToStr( UTFstring( tname ) );
+ tk->fmt.psz_description = ToUTF8( UTFstring( tname ) );
msg_Dbg( &sys.demuxer, "| | | + Track Name=%s", tk->fmt.psz_description );
}
else if( MKV_IS_ID( l, KaxTrackLanguage ) )
{
KaxCodecName &cname = *(KaxCodecName*)l;
- tk->psz_codec_name = UTF8ToStr( UTFstring( cname ) );
+ tk->psz_codec_name = ToUTF8( UTFstring( cname ) );
msg_Dbg( &sys.demuxer, "| | | + Track Codec Name=%s", tk->psz_codec_name );
}
else if( MKV_IS_ID( l, KaxContentEncodings ) )
// {
// KaxCodecSettings &cset = *(KaxCodecSettings*)l;
-// tk->psz_codec_settings = UTF8ToStr( UTFstring( cset ) );
+// tk->psz_codec_settings = ToUTF8( UTFstring( cset ) );
// msg_Dbg( &sys.demuxer, "| | | + Track Codec Settings=%s", tk->psz_codec_settings );
// }
// else if( EbmlId( *l ) == KaxCodecInfoURL::ClassInfos.GlobalId )
msg_Dbg( &sys.demuxer, "| | | + Track Video" );
tk->f_fps = 0.0;
+ tk->fmt.video.i_frame_rate_base = (unsigned int)(tk->i_default_duration / 1000);
+ tk->fmt.video.i_frame_rate = 1000000;
+
for( j = 0; j < tkv->ListSize(); j++ )
{
EbmlElement *l = (*tkv)[j];
{
KaxMuxingApp &mapp = *(KaxMuxingApp*)l;
- psz_muxing_application = UTF8ToStr( UTFstring( mapp ) );
+ psz_muxing_application = ToUTF8( UTFstring( mapp ) );
msg_Dbg( &sys.demuxer, "| | + Muxing Application=%s",
psz_muxing_application );
{
KaxWritingApp &wapp = *(KaxWritingApp*)l;
- psz_writing_application = UTF8ToStr( UTFstring( wapp ) );
+ psz_writing_application = ToUTF8( UTFstring( wapp ) );
msg_Dbg( &sys.demuxer, "| | + Writing Application=%s",
psz_writing_application );
{
KaxSegmentFilename &sfn = *(KaxSegmentFilename*)l;
- psz_segment_filename = UTF8ToStr( UTFstring( sfn ) );
+ psz_segment_filename = ToUTF8( UTFstring( sfn ) );
msg_Dbg( &sys.demuxer, "| | + Segment Filename=%s",
psz_segment_filename );
{
KaxTitle &title = *(KaxTitle*)l;
- psz_title = UTF8ToStr( UTFstring( title ) );
+ psz_title = ToUTF8( UTFstring( title ) );
msg_Dbg( &sys.demuxer, "| | + Title=%s", psz_title );
}
for (k = 0; k < i_level; k++)
chapters.psz_name += '+';
chapters.psz_name += ' ';
- chapters.psz_name += UTF8ToStr( UTFstring( name ) );
+ chapters.psz_name += ToUTF8( UTFstring( name ) );
chapters.b_user_display = true;
- msg_Dbg( &sys.demuxer, "| | | | | + ChapterString '%s'", UTF8ToStr(UTFstring(name)) );
+ msg_Dbg( &sys.demuxer, "| | | | | + ChapterString '%s'", ToUTF8(UTFstring(name)) );
}
else if( MKV_IS_ID( l, KaxChapterLanguage ) )
{
stored_editions[i]->RefreshChapters( );
}
- if ( stored_editions[i_default_edition]->b_ordered )
+ if ( stored_editions.size() != 0 && stored_editions[i_default_edition]->b_ordered )
{
/* update the duration of the segment according to the sum of all sub chapters */
i_dur = stored_editions[i_default_edition]->Duration() / I64C(1000);
#undef idx
}
-static char * UTF8ToStr( const UTFstring &u )
-{
- int i_src;
- const wchar_t *src;
- char *dst, *p;
-
- i_src = u.length();
- src = u.c_str();
-
- p = dst = (char*)malloc( i_src + 1);
- while( i_src > 0 )
- {
- if( *src < 255 )
- {
- *p++ = (char)*src;
- }
- else
- {
- *p++ = '?';
- }
- src++;
- i_src--;
- }
- *p++= '\0';
-
- return dst;
-}
-
void chapter_edition_c::RefreshChapters( )
{
chapter_item_c::RefreshChapters( b_ordered, -1 );
return i_result;
}
-chapter_item_c *chapter_item_c::FindTimecode( mtime_t i_user_timecode )
+chapter_item_c * chapter_edition_c::FindTimecode( mtime_t i_timecode, const chapter_item_c * p_current )
+{
+ if ( !b_ordered )
+ p_current = NULL;
+ bool b_found_current = false;
+ return chapter_item_c::FindTimecode( i_timecode, p_current, b_found_current );
+}
+
+chapter_item_c *chapter_item_c::FindTimecode( mtime_t i_user_timecode, const chapter_item_c * p_current, bool & b_found )
{
chapter_item_c *psz_result = NULL;
+ if ( p_current == this )
+ b_found = true;
+
if ( i_user_timecode >= i_user_start_time &&
( i_user_timecode < i_user_end_time ||
( i_user_start_time == i_user_end_time && i_user_timecode == i_user_end_time )))
{
std::vector<chapter_item_c*>::iterator index = sub_chapters.begin();
- while ( index != sub_chapters.end() && psz_result == NULL )
+ while ( index != sub_chapters.end() && ((p_current == NULL && psz_result == NULL) || (p_current != NULL && (!b_found || psz_result == NULL))))
{
- psz_result = (*index)->FindTimecode( i_user_timecode );
+ psz_result = (*index)->FindTimecode( i_user_timecode, p_current, b_found );
index++;
}
{
sz_name = N_("Segment ");
char psz_str[6];
- sprintf( psz_str, "%d", i );
+ sprintf( psz_str, "%d", (int)i );
sz_name += psz_str;
p_title->psz_name = strdup( sz_name.c_str() );
}
if ( !p_chapter->Enter( true ) )
{
// jump to the location in the found segment
- vsegment.Seek( demuxer, p_chapter->i_user_start_time, -1, NULL );
+ vsegment.Seek( demuxer, p_chapter->i_user_start_time, -1, p_chapter );
}
}
cluster = (KaxCluster*)el;
- i_start_pos = cluster->GetElementPosition();
+ i_cluster_pos = i_start_pos = cluster->GetElementPosition();
ParseCluster( );
ep->Down();
void matroska_segment_c::Seek( mtime_t i_date, mtime_t i_time_offset )
{
KaxBlock *block;
- uint64 i_cuepos;
int i_track_skipping;
int64_t i_block_duration;
int64_t i_block_ref1;
while( i_track_skipping > 0 )
{
- if( BlockGet( block, i_cuepos, &i_block_ref1, &i_block_ref2, &i_block_duration ) )
+ if( BlockGet( block, &i_block_ref1, &i_block_ref2, &i_block_duration ) )
{
msg_Warn( &sys.demuxer, "cannot get block EOF?" );
return;
}
+ ep->Down();
for( i_track = 0; i_track < tracks.size(); i_track++ )
{
}
}
- sys.i_pts = sys.i_chapter_time + block->GlobalTimecode() / (mtime_t) 1000;
+ sys.i_last_dts = sys.i_pts = (sys.i_chapter_time + block->GlobalTimecode()) / (mtime_t) 1000;
if( i_track < tracks.size() )
{
if( sys.i_pts >= sys.i_start_pts )
{
- ep->UnGet( i_cuepos );
+ cluster = static_cast<KaxCluster*>(ep->UnGet( i_block_pos, i_cluster_pos ));
i_track_skipping = 0;
}
else if( tracks[i_track]->fmt.i_cat == VIDEO_ES )
{
- if( i_block_ref1 == -1 && tracks[i_track]->b_search_keyframe )
+ if( i_block_ref1 == 0 && tracks[i_track]->b_search_keyframe )
{
tracks[i_track]->b_search_keyframe = VLC_FALSE;
i_track_skipping--;
if ( Edition() && Edition()->b_ordered )
{
/* 1st, we need to know in which chapter we are */
- psz_chapter = (*p_editions)[i_current_edition]->FindTimecode( i_date );
+ psz_chapter = (*p_editions)[i_current_edition]->FindTimecode( i_date, psz_current_chapter );
}
}
// handle register tests if there are some
if ( (i_command & 0xF0) != 0 )
{
- bool b_test_positive = (i_command & CMD_DVD_IF_NOT) == 0;
+ bool b_test_positive = true;//(i_command & CMD_DVD_IF_NOT) == 0;
bool b_test_value = (i_command & CMD_DVD_TEST_VALUE) != 0;
uint8 i_test = i_command & 0x70;
uint16 i_value;
+ // see http://dvd.sourceforge.net/dvdinfo/vmi.html
+ uint8 i_cr1;
+ uint16 i_cr2;
+ switch ( i_command >> 12 )
+ {
+ default:
+ i_cr1 = p_command[3];
+ i_cr2 = (p_command[4] << 8) + p_command[5];
+ break;
+ case 3:
+ case 4:
+ case 5:
+ i_cr1 = p_command[6];
+ i_cr2 = p_command[7];
+ b_test_value = false;
+ break;
+ case 6:
+ case 7:
+ if ( ((p_command[1] >> 4) & 0x7) == 0)
+ {
+ i_cr1 = p_command[2];
+ i_cr2 = (p_command[6] << 8) + p_command[7];
+ }
+ else
+ {
+ i_cr1 = p_command[2];
+ i_cr2 = (p_command[6] << 8) + p_command[7];
+ }
+ break;
+ }
+
if ( b_test_value )
- i_value = ( p_command[4] << 8 ) + p_command[5];
+ i_value = i_cr2;
else
- i_value = GetPRM( p_command[7] );
+ i_value = GetPRM( i_cr2 );
switch ( i_test )
{
case CMD_DVD_IF_GPREG_EQUAL:
// if equals
- msg_Dbg( &sys.demuxer, "IF %s EQUALS %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
- if (!( GetPRM( p_command[3] ) == i_value ))
+ msg_Dbg( &sys.demuxer, "IF %s EQUALS %s", GetRegTypeName( false, i_cr1 ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
+ if (!( GetPRM( i_cr1 ) == i_value ))
{
- b_test_positive = !b_test_positive;
+ b_test_positive = false;
+ }
+ break;
+ case CMD_DVD_IF_GPREG_NOT_EQUAL:
+ // if not equals
+ msg_Dbg( &sys.demuxer, "IF %s NOT EQUALS %s", GetRegTypeName( false, i_cr1 ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
+ if (!( GetPRM( i_cr1 ) != i_value ))
+ {
+ b_test_positive = false;
}
break;
case CMD_DVD_IF_GPREG_INF:
// if inferior
msg_Dbg( &sys.demuxer, "IF %s < %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
- if (!( GetPRM( p_command[3] ) < i_value ))
+ if (!( GetPRM( i_cr1 ) < i_value ))
{
- b_test_positive = !b_test_positive;
+ b_test_positive = false;
+ }
+ break;
+ case CMD_DVD_IF_GPREG_INF_EQUAL:
+ // if inferior or equal
+ msg_Dbg( &sys.demuxer, "IF %s < %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
+ if (!( GetPRM( i_cr1 ) <= i_value ))
+ {
+ b_test_positive = false;
}
break;
case CMD_DVD_IF_GPREG_AND:
// if logical and
msg_Dbg( &sys.demuxer, "IF %s & %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
- if (!( GetPRM( p_command[3] ) & i_value ))
+ if (!( GetPRM( i_cr1 ) & i_value ))
+ {
+ b_test_positive = false;
+ }
+ break;
+ case CMD_DVD_IF_GPREG_SUP:
+ // if superior
+ msg_Dbg( &sys.demuxer, "IF %s >= %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
+ if (!( GetPRM( i_cr1 ) > i_value ))
{
- b_test_positive = !b_test_positive;
+ b_test_positive = false;
}
break;
case CMD_DVD_IF_GPREG_SUP_EQUAL:
// if superior or equal
msg_Dbg( &sys.demuxer, "IF %s >= %s", GetRegTypeName( false, p_command[3] ).c_str(), GetRegTypeName( b_test_value, i_value ).c_str() );
- if (!( GetPRM( p_command[3] ) >= i_value ))
+ if (!( GetPRM( i_cr1 ) >= i_value ))
{
- b_test_positive = !b_test_positive;
+ b_test_positive = false;
}
break;
}
// TODO
break;
}
+ case CMD_DVD_SET_HL_BTNN1:
+ {
+ msg_Dbg( &sys.demuxer, "SetHL_BTN (%d)", p_command[4] );
+ SetSPRM( 0x88, p_command[4] );
+ break;
+ }
default:
{
msg_Dbg( &sys.demuxer, "unsupported command : %02X %02X %02X %02X %02X %02X %02X %02X"