void libvlc_media_player_set_pause( libvlc_media_player_t *p_mi, int paused )
{
input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi );
if( !p_input_thread )
return;
libvlc_state_t state = libvlc_media_player_get_state( p_mi );
if( state == libvlc_Playing || state == libvlc_Buffering )
{
if( paused )
{
if( libvlc_media_player_can_pause( p_mi ) )
input_Control( p_input_thread, INPUT_SET_STATE, PAUSE_S );
else
input_Stop( p_input_thread, true );
}
}
else
{
if( !paused )
input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S );
}
vlc_object_release( p_input_thread );
}
void BookmarksDialog::add()
{
input_thread_t *p_input = THEMIM->getInput();
if( !p_input ) return;
seekpoint_t bookmark;
if( !input_Control( p_input, INPUT_GET_BOOKMARK, &bookmark ) )
{
bookmark.psz_name = const_cast<char *>qtu( THEMIM->getIM()->getName() +
QString::number( bookmarksList->topLevelItemCount() ) );
input_Control( p_input, INPUT_ADD_BOOKMARK, &bookmark );
}
void InputManager::UpdateVout()
{
if( hasInput() )
{
/* Get current vout lists from input */
size_t i_vout;
vout_thread_t **pp_vout;
if( input_Control( p_input, INPUT_GET_VOUTS, &pp_vout, &i_vout ) )
{
i_vout = 0;
pp_vout = NULL;
}
/* */
emit voutListChanged( pp_vout, i_vout );
/* */
bool b_old_video = b_video;
b_video = i_vout > 0;
if( !!b_old_video != !!b_video )
emit voutChanged( b_video );
/* Release the vout list */
for( size_t i = 0; i < i_vout; i++ )
vlc_object_release( (vlc_object_t*)pp_vout[i] );
free( pp_vout );
}
}
void
VCDUpdateTitle( access_t *p_access )
{
vcdplayer_t *p_vcdplayer= (vcdplayer_t *)p_access->p_sys;
size_t psz_mrl_max = strlen(VCD_MRL_PREFIX)
+ strlen(p_vcdplayer->psz_source) + sizeof("@E999")+3;
char *psz_mrl = malloc( psz_mrl_max );
if( psz_mrl )
{
char *psz_name;
char *psz_tfmt = var_InheritString( p_access, MODULE_STRING "-title-format" );
snprintf( psz_mrl, psz_mrl_max, "%s%s",
VCD_MRL_PREFIX, p_vcdplayer->psz_source );
if( psz_tfmt )
{
psz_name = VCDFormatStr( p_vcdplayer, psz_tfmt, psz_mrl,
&(p_vcdplayer->play_item) );
free(psz_tfmt);
input_Control( p_vcdplayer->p_input, INPUT_SET_NAME, psz_name );
free(psz_name);
}
free(psz_mrl);
}
}
static int Open(vlc_object_t *object)
{
access_t *access = (access_t *)object;
input_thread_t *input = access->p_input;
if (!input)
return VLC_EGENERIC;
access_sys_t *sys = malloc(sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
if (input_Control(input, INPUT_GET_ATTACHMENT, &sys->attachment,
access->psz_location))
sys->attachment = NULL;
if (sys->attachment == NULL) {
msg_Err(access, "Failed to find the attachment '%s'",
access->psz_location);
free(sys);
return VLC_EGENERIC;
}
sys->offset = 0;
/* */
access_InitFields(access);
access->pf_read = Read;
access->pf_block = NULL;
access->pf_control = Control;
access->pf_seek = Seek;
access->p_sys = sys;
return VLC_SUCCESS;
}
/**************************************************************************
* Tell media player to start playing.
**************************************************************************/
int libvlc_media_player_play( libvlc_media_player_t *p_mi )
{
lock_input( p_mi );
input_thread_t *p_input_thread = p_mi->input.p_thread;
if( p_input_thread )
{
/* A thread already exists, send it a play message */
input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S );
unlock_input( p_mi );
return 0;
}
/* Ignore previous exception */
lock(p_mi);
if( !p_mi->p_md )
{
unlock(p_mi);
unlock_input( p_mi );
libvlc_printerr( "No associated media descriptor" );
return -1;
}
p_input_thread = input_Create( p_mi, p_mi->p_md->p_input_item, NULL,
p_mi->input.p_resource );
unlock(p_mi);
if( !p_input_thread )
{
unlock_input(p_mi);
libvlc_printerr( "Not enough memory" );
return -1;
}
var_AddCallback( p_input_thread, "can-seek", input_seekable_changed, p_mi );
var_AddCallback( p_input_thread, "can-pause", input_pausable_changed, p_mi );
var_AddCallback( p_input_thread, "program-scrambled", input_scrambled_changed, p_mi );
var_AddCallback( p_input_thread, "intf-event", input_event_changed, p_mi );
if( input_Start( p_input_thread ) )
{
unlock_input(p_mi);
var_DelCallback( p_input_thread, "intf-event", input_event_changed, p_mi );
var_DelCallback( p_input_thread, "can-pause", input_pausable_changed, p_mi );
var_DelCallback( p_input_thread, "program-scrambled", input_scrambled_changed, p_mi );
var_DelCallback( p_input_thread, "can-seek", input_seekable_changed, p_mi );
vlc_object_release( p_input_thread );
libvlc_printerr( "Input initialization failure" );
return -1;
}
p_mi->input.p_thread = p_input_thread;
unlock_input(p_mi);
return 0;
}
float libvlc_media_player_get_fps( libvlc_media_player_t *p_mi )
{
input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi );
double f_fps = 0.0;
if( p_input_thread )
{
if( input_Control( p_input_thread, INPUT_GET_VIDEO_FPS, &f_fps ) )
f_fps = 0.0;
vlc_object_release( p_input_thread );
}
return f_fps;
}
void libvlc_media_player_navigate( libvlc_media_player_t* p_mi,
unsigned navigate )
{
static const vlc_action_t map[] =
{
INPUT_NAV_ACTIVATE, INPUT_NAV_UP, INPUT_NAV_DOWN,
INPUT_NAV_LEFT, INPUT_NAV_RIGHT,
};
if( navigate >= sizeof(map) / sizeof(map[0]) )
return;
input_thread_t *p_input = libvlc_get_input_thread ( p_mi );
if ( p_input == NULL )
return;
input_Control( p_input, map[navigate], NULL );
vlc_object_release( p_input );
}
void InputManager::UpdateNavigation()
{
/* Update navigation status */
vlc_value_t val;
val.i_int = 0;
vlc_value_t val2;
val2.i_int = 0;
var_Change( p_input, "title", VLC_VAR_CHOICESCOUNT, &val, NULL );
if( val.i_int > 0 )
{
bool b_menu = false;
if( val.i_int > 1 )
{
input_title_t **pp_title = NULL;
int i_title = 0;
if( input_Control( p_input, INPUT_GET_FULL_TITLE_INFO, &pp_title, &i_title ) == VLC_SUCCESS )
{
for( int i = 0; i < i_title; i++ )
{
if( pp_title[i]->i_flags & INPUT_TITLE_MENU )
b_menu = true;
vlc_input_title_Delete(pp_title[i]);
}
free( pp_title );
}
}
/* p_input != NULL since val.i_int != 0 */
var_Change( p_input, "chapter", VLC_VAR_CHOICESCOUNT, &val2, NULL );
emit titleChanged( b_menu );
emit chapterChanged( val2.i_int > 1 );
}
else
emit chapterChanged( false );
if( hasInput() )
emit inputCanSeek( var_GetBool( p_input, "can-seek" ) );
else
emit inputCanSeek( false );
}
static int VideoSplitterCallback( vlc_object_t *p_this, char const *psz_cmd,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
playlist_t *p_playlist = (playlist_t*)p_this;
VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_data); VLC_UNUSED(newval);
PL_LOCK;
/* Force the input to restart the video ES to force a vout recreation */
input_thread_t *p_input = pl_priv( p_playlist )->p_input;
if( p_input )
{
const double f_position = var_GetFloat( p_input, "position" );
input_Control( p_input, INPUT_RESTART_ES, -VIDEO_ES );
var_SetFloat( p_input, "position", f_position );
}
PL_UNLOCK;
return VLC_SUCCESS;
}
static int Open(vlc_object_t *object)
{
access_t *access = (access_t *)object;
access_sys_t *sys;
input_thread_t *input = access_GetParentInput(access);
if (!input)
return VLC_EGENERIC;
input_attachment_t *a;
if (input_Control(input, INPUT_GET_ATTACHMENT, &a, access->psz_location))
a = NULL;
vlc_object_release(input);
if (!a) {
msg_Err(access, "Failed to find the attachment '%s'",
access->psz_location);
return VLC_EGENERIC;
}
/* */
access->p_sys = sys = malloc(sizeof(*sys));
if (!sys) {
vlc_input_attachment_Delete(a);
return VLC_ENOMEM;
}
sys->a = a;
/* */
access_InitFields(access);
access->pf_read = Read;
access->pf_block = NULL;
access->pf_control = Control;
access->pf_seek = Seek;
return VLC_SUCCESS;
}
void BookmarksDialog::update()
{
if ( b_ignore_updates ) return;
input_thread_t *p_input = THEMIM->getInput();
if( !p_input ) return;
seekpoint_t **pp_bookmarks;
int i_bookmarks = 0;
if( bookmarksList->topLevelItemCount() > 0 )
{
bookmarksList->model()->removeRows( 0, bookmarksList->topLevelItemCount() );
}
if( input_Control( p_input, INPUT_GET_BOOKMARKS, &pp_bookmarks,
&i_bookmarks ) != VLC_SUCCESS )
return;
for( int i = 0; i < i_bookmarks; i++ )
{
mtime_t total = pp_bookmarks[i]->i_time_offset;
unsigned hours = ( total / ( CLOCK_FREQ * 3600 ) );
unsigned minutes = ( total % ( CLOCK_FREQ * 3600 ) ) / ( CLOCK_FREQ * 60 );
float seconds = ( total % ( CLOCK_FREQ * 60 ) ) / ( CLOCK_FREQ * 1. );
QStringList row;
row << QString( qfu( pp_bookmarks[i]->psz_name ) );
row << qfu("-");
row << QString().sprintf( "%02u:%02u:%06.3f", hours, minutes, seconds );
QTreeWidgetItem *item = new QTreeWidgetItem( bookmarksList, row );
item->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEditable |
Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
bookmarksList->insertTopLevelItem( i, item );
vlc_seekpoint_Delete( pp_bookmarks[i] );
}
free( pp_bookmarks );
}
void BookmarksDialog::update()
{
input_thread_t *p_input = THEMIM->getInput();
if( !p_input ) return;
seekpoint_t **pp_bookmarks;
int i_bookmarks;
if( bookmarksList->topLevelItemCount() > 0 )
{
bookmarksList->model()->removeRows( 0, bookmarksList->topLevelItemCount() );
}
if( input_Control( p_input, INPUT_GET_BOOKMARKS, &pp_bookmarks,
&i_bookmarks ) != VLC_SUCCESS )
return;
for( int i = 0; i < i_bookmarks; i++ )
{
// List with the differents elements of the row
QStringList row;
row << QString( qfu( pp_bookmarks[i]->psz_name ) );
row << QString::number( pp_bookmarks[i]->i_byte_offset );
int total = pp_bookmarks[i]->i_time_offset/ 1000000;
int hour = total / (60*60);
int min = (total - hour*60*60) / 60;
int sec = total - hour*60*60 - min*60;
QString str;
row << str.sprintf("%02d:%02d:%02d", hour, min, sec );
QTreeWidgetItem *item = new QTreeWidgetItem( bookmarksList, row );
item->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEditable |
Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
bookmarksList->insertTopLevelItem( i, item );
vlc_seekpoint_Delete( pp_bookmarks[i] );
}
free( pp_bookmarks );
}
void
VCDMetaInfo( access_t *p_access, /*const*/ char *psz_mrl )
{
vcdplayer_t *p_vcdplayer = (vcdplayer_t *) p_access->p_sys;
input_thread_t *p_input = p_vcdplayer->p_input;
vcdinfo_obj_t *p_vcdev = p_vcdplayer->vcd;
size_t i_entries = vcdinfo_get_num_entries(p_vcdev);
size_t last_entry = 0;
char *psz_cat = _("Disc");
track_t i_track;
# define addstr(t,v) input_Control(p_input,INPUT_ADD_INFO,psz_cat,t,"%s",v)
# define addnum(t,v) input_Control(p_input,INPUT_ADD_INFO,psz_cat,t,"%d",v)
# define addhex(t,v) input_Control(p_input,INPUT_ADD_INFO,psz_cat,t,"%x",v)
addstr(_("VCD Format"), vcdinfo_get_format_version_str(p_vcdev));
addstr(_("Album"), vcdinfo_get_album_id (p_vcdev));
addstr(_("Application"), vcdinfo_get_application_id (p_vcdev));
addstr(_("Preparer"), vcdinfo_get_preparer_id (p_vcdev));
addnum(_("Vol #"), vcdinfo_get_volume_num (p_vcdev));
addnum(_("Vol max #"), vcdinfo_get_volume_count (p_vcdev));
addstr(_("Volume Set"), vcdinfo_get_volumeset_id (p_vcdev));
addstr(_("Volume"), vcdinfo_get_volume_id (p_vcdev));
addstr(_("Publisher"), vcdinfo_get_publisher_id (p_vcdev));
addstr(_("System Id"), vcdinfo_get_system_id (p_vcdev));
addnum("LIDs", vcdinfo_get_num_LIDs (p_vcdev));
addnum(_("Entries"), vcdinfo_get_num_entries (p_vcdev));
addnum(_("Segments"), vcdinfo_get_num_segments (p_vcdev));
addnum(_("Tracks"), vcdinfo_get_num_tracks (p_vcdev));
/* Spit out track information. Could also include MSF info.
Also build title table.
*/
for( i_track = 1 ; i_track < p_vcdplayer->i_tracks ; i_track++ ) {
unsigned int audio_type = vcdinfo_get_track_audio_type(p_vcdev, i_track);
uint32_t i_secsize = vcdinfo_get_track_sect_count(p_vcdev, i_track);
if (p_vcdplayer->b_svd) {
addnum(_("Audio Channels"),
vcdinfo_audio_type_num_channels(p_vcdev, audio_type) );
}
addnum(_("First Entry Point"), 0 );
for ( last_entry = 0 ; last_entry < i_entries
&& vcdinfo_get_track(p_vcdev, last_entry) == i_track; last_entry++ ) ;
addnum(_("Last Entry Point"), last_entry-1 );
addnum(_("Track size (in sectors)"), i_secsize );
}
{
lid_t i_lid;
for( i_lid = 1 ; i_lid <= p_vcdplayer->i_lids ; i_lid++ ) {
PsdListDescriptor_t pxd;
if (vcdinfo_lid_get_pxd(p_vcdev, &pxd, i_lid)) {
switch (pxd.descriptor_type) {
case PSD_TYPE_END_LIST:
addstr(_("type"), _("end"));
break;
case PSD_TYPE_PLAY_LIST:
addstr(_("type"), _("play list"));
addnum("items", vcdinf_pld_get_noi(pxd.pld));
addhex("next", vcdinf_pld_get_next_offset(pxd.pld));
addhex("previous", vcdinf_pld_get_prev_offset(pxd.pld));
addhex("return", vcdinf_pld_get_return_offset(pxd.pld));
addnum("wait time", vcdinf_get_wait_time(pxd.pld));
break;
case PSD_TYPE_SELECTION_LIST:
case PSD_TYPE_EXT_SELECTION_LIST:
addstr(_("type"), PSD_TYPE_SELECTION_LIST == pxd.descriptor_type
? _("extended selection list") : _("selection list") );
addhex("default", vcdinf_psd_get_default_offset(pxd.psd));
addhex("loop count", vcdinf_get_loop_count(pxd.psd));
addhex("next", vcdinf_psd_get_next_offset(pxd.psd));
addhex("previous", vcdinf_psd_get_prev_offset(pxd.psd));
addhex("return", vcdinf_psd_get_return_offset(pxd.psd));
addhex("rejected", vcdinf_psd_get_lid_rejected(pxd.psd));
addhex("time-out offset", vcdinf_get_timeout_offset(pxd.psd));
addnum("time-out time", vcdinf_get_timeout_time(pxd.psd));
break;
default:
addstr(_("type"), _("unknown type"));
break;
}
}
}
}
# undef addstr
# undef addnum
# undef addhex
if ( CDIO_INVALID_TRACK != i_track )
{
char *psz_tfmt = var_InheritString( p_access, MODULE_STRING "-title-format" );
char *psz_name = VCDFormatStr( p_vcdplayer, psz_tfmt, psz_mrl,
&(p_vcdplayer->play_item) );
free( psz_tfmt );
input_Control( p_input, INPUT_SET_NAME, psz_name );
free( psz_name );
}
}
static int
input_event_changed( vlc_object_t * p_this, char const * psz_cmd,
vlc_value_t oldval, vlc_value_t newval,
void * p_userdata )
{
VLC_UNUSED(oldval);
input_thread_t * p_input = (input_thread_t *)p_this;
libvlc_media_player_t * p_mi = p_userdata;
libvlc_event_t event;
assert( !strcmp( psz_cmd, "intf-event" ) );
if( newval.i_int == INPUT_EVENT_STATE )
{
libvlc_state_t libvlc_state;
switch ( var_GetInteger( p_input, "state" ) )
{
case INIT_S:
libvlc_state = libvlc_NothingSpecial;
event.type = libvlc_MediaPlayerNothingSpecial;
break;
case OPENING_S:
libvlc_state = libvlc_Opening;
event.type = libvlc_MediaPlayerOpening;
break;
case PLAYING_S:
libvlc_state = libvlc_Playing;
event.type = libvlc_MediaPlayerPlaying;
break;
case PAUSE_S:
libvlc_state = libvlc_Paused;
event.type = libvlc_MediaPlayerPaused;
break;
case END_S:
libvlc_state = libvlc_Ended;
event.type = libvlc_MediaPlayerEndReached;
break;
case ERROR_S:
libvlc_state = libvlc_Error;
event.type = libvlc_MediaPlayerEncounteredError;
break;
default:
return VLC_SUCCESS;
}
set_state( p_mi, libvlc_state, false );
libvlc_event_send( p_mi->p_event_manager, &event );
}
else if( newval.i_int == INPUT_EVENT_ABORT )
{
libvlc_state_t libvlc_state = libvlc_Stopped;
event.type = libvlc_MediaPlayerStopped;
set_state( p_mi, libvlc_state, false );
libvlc_event_send( p_mi->p_event_manager, &event );
}
else if( newval.i_int == INPUT_EVENT_POSITION )
{
if( var_GetInteger( p_input, "state" ) != PLAYING_S )
return VLC_SUCCESS; /* Don't send the position while stopped */
/* */
event.type = libvlc_MediaPlayerPositionChanged;
event.u.media_player_position_changed.new_position =
var_GetFloat( p_input, "position" );
libvlc_event_send( p_mi->p_event_manager, &event );
/* */
event.type = libvlc_MediaPlayerTimeChanged;
event.u.media_player_time_changed.new_time =
from_mtime(var_GetTime( p_input, "time" ));
libvlc_event_send( p_mi->p_event_manager, &event );
}
else if( newval.i_int == INPUT_EVENT_LENGTH )
{
event.type = libvlc_MediaPlayerLengthChanged;
event.u.media_player_length_changed.new_length =
from_mtime(var_GetTime( p_input, "length" ));
libvlc_event_send( p_mi->p_event_manager, &event );
}
else if( newval.i_int == INPUT_EVENT_CACHE )
{
event.type = libvlc_MediaPlayerBuffering;
event.u.media_player_buffering.new_cache = (int)(100 *
var_GetFloat( p_input, "cache" ));
libvlc_event_send( p_mi->p_event_manager, &event );
}
else if( newval.i_int == INPUT_EVENT_VOUT )
{
vout_thread_t **pp_vout;
size_t i_vout;
if( input_Control( p_input, INPUT_GET_VOUTS, &pp_vout, &i_vout ) )
{
i_vout = 0;
}
else
{
for( size_t i = 0; i < i_vout; i++ )
vlc_object_release( pp_vout[i] );
free( pp_vout );
}
event.type = libvlc_MediaPlayerVout;
event.u.media_player_vout.new_count = i_vout;
libvlc_event_send( p_mi->p_event_manager, &event );
}
return VLC_SUCCESS;
}
/* Get current time in play (in us) */
static inline int64_t MoviesoapGetNow(input_thread_t * p_input)
{ int64_t us = 0; if (p_input) input_Control( p_input, INPUT_GET_TIME, &us ); return us; }