/*****************************************************************************
* StateChange: callback on input "state"
*****************************************************************************/
static int StateChange( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
playlist_t *p_playlist = p_sys->p_playlist;
input_thread_t *p_input;
input_item_t *p_item;
if( p_intf->p_sys->b_dead )
return VLC_SUCCESS;
UpdateCaps( p_intf );
if( !p_sys->b_meta_read && p_sys->i_playing_state == 0)
{
p_input = playlist_CurrentInput( p_playlist );
if( p_input )
{
p_item = input_GetItem( p_input );
if( p_item )
{
p_sys->b_meta_read = true;
TrackChangeEmit( p_intf, p_item );
}
vlc_object_release( p_input );
}
}
StatusChangeEmit( p_intf );
return VLC_SUCCESS;
}
static int Playlist(vlc_object_t *obj, char const *cmd,
vlc_value_t oldval, vlc_value_t newval, void *p_data)
{
intf_thread_t *intf = (intf_thread_t*)obj;
intf_sys_t *sys = intf->p_sys;
playlist_t *playlist = sys->playlist;
input_thread_t * input = playlist_CurrentInput(playlist);
int state;
if(input) {
state = var_GetInteger(input, "state");
vlc_object_release(input);
} else {
return VLC_EGENERIC;
}
if(strcmp(cmd, "pause") == 0) {
msg_Info(intf, "Pause");
if(state == PLAYING_S)
playlist_Pause(sys->playlist);
} else if(strcmp(cmd, "play") == 0) {
msg_Info(intf, "Play");
if(state != PLAYING_S)
playlist_Play(sys->playlist);
}
}
static void
MarshalPlaybackStatus( intf_thread_t *p_intf, DBusMessageIter *container )
{
input_thread_t *p_input;
const char *psz_playback_status;
if( ( p_input = playlist_CurrentInput( p_intf->p_sys->p_playlist ) ) )
{
switch( var_GetInteger( p_input, "state" ) )
{
case OPENING_S:
case PLAYING_S:
psz_playback_status = PLAYBACK_STATUS_PLAYING;
break;
case PAUSE_S:
psz_playback_status = PLAYBACK_STATUS_PAUSED;
break;
default:
psz_playback_status = PLAYBACK_STATUS_STOPPED;
}
vlc_object_release( (vlc_object_t*) p_input );
}
else
psz_playback_status = PLAYBACK_STATUS_STOPPED;
dbus_message_iter_append_basic( container, DBUS_TYPE_STRING,
&psz_playback_status );
}
void CmdPlay::execute()
{
playlist_t *pPlaylist = getIntf()->p_sys->p_playlist;
if( pPlaylist == NULL )
return;
// if already playing an input, reset rate to normal speed
input_thread_t *pInput = playlist_CurrentInput( pPlaylist );
if( pInput )
{
var_SetFloat( pPlaylist, "rate", 1.0 );
vlc_object_release( pInput );
}
playlist_Lock( pPlaylist );
const bool b_empty = playlist_IsEmpty( pPlaylist );
playlist_Unlock( pPlaylist );
if( !b_empty )
{
playlist_Play( pPlaylist );
}
else
{
// If the playlist is empty, open a file requester instead
CmdDlgFile( getIntf() ).execute();
}
}
/*****************************************************************************
* Close: destroy interface stuff
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
playlist_t *p_playlist = pl_Get( p_this );
input_thread_t *p_input = NULL;
var_DelCallback( p_playlist, "item-change", ItemChange, p_intf );
var_DelCallback( p_playlist, "item-current", ItemChange, p_intf );
if( (p_input = playlist_CurrentInput( p_playlist )) )
{
var_DelCallback( p_input, "state", StateChange, p_intf );
vlc_object_release( p_input );
}
/* Clears the Presence message ... else it looks like we're still playing
* something although VLC (or the Telepathy plugin) is closed */
/* Do not check for VLC_ENOMEM as we're closing */
SendToTelepathy( p_intf, "" );
/* we won't use the DBus connection anymore */
dbus_connection_unref( p_intf->p_sys->p_conn );
/* Destroy structure */
free( p_intf->p_sys->psz_format );
free( p_intf->p_sys );
}
/*****************************************************************************
* Close: destroy interface stuff
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
playlist_t *p_playlist = pl_Get( p_this );
input_thread_t *p_input;
intf_thread_t *p_intf = ( intf_thread_t* ) p_this;
intf_sys_t *p_sys = p_intf->p_sys;
var_DelCallback( p_playlist, "item-current", ItemChange, p_intf );
p_input = playlist_CurrentInput( p_playlist );
if ( p_input )
{
if( p_sys->b_state_cb )
var_DelCallback( p_input, "intf-event", PlayingChange, p_intf );
vlc_object_release( p_input );
}
int i;
for( i = 0; i < p_sys->i_songs; i++ )
DeleteSong( &p_sys->p_queue[i] );
free( p_sys->psz_submit_host );
free( p_sys->psz_submit_file );
#if 0 //NOT USED
free( p_sys->psz_nowp_host );
free( p_sys->psz_nowp_file );
#endif
vlc_cond_destroy( &p_sys->wait );
vlc_mutex_destroy( &p_sys->lock );
free( p_sys );
}
/* Sets Moviesoap::p_input */
static void* EP_SetMoviesoapP_Input(void *data)
{
// require Moviesoap::p_playlist
if (Moviesoap::p_playlist == NULL) {
playlist_t * p_playlist = pl_Get( Moviesoap::p_obj );
if (p_playlist) {
vlc_mutex_lock( &Moviesoap::lock );
Moviesoap::p_playlist = p_playlist;
vlc_mutex_unlock( &Moviesoap::lock );
} else {
return NULL;
}
}
// get p_input
input_thread_t * p_input = playlist_CurrentInput( p_playlist );
if (p_input) {
// set Moviesoap::p_input
vlc_mutex_lock( &Moviesoap::lock );
Moviesoap::p_input = p_input;
vlc_mutex_unlock( &Moviesoap::lock );
// Add callback(s) to input thread
var_AddCallback( p_input, "position", InputCbPosition, NULL );
var_AddCallback( p_input, "time", InputCbTime, NULL );
var_AddCallback( p_input, "intf-event", InputCbGeneric, NULL );
var_AddCallback( p_input, "state", InputCbState, NULL );
// start filter object if one exists
if (Moviesoap::p_loadedFilter) Moviesoap::p_loadedFilter->Restart();
}
return p_input;
}
/*****************************************************************************
* UpdateCaps: update p_sys->i_caps
* This function have to be called with the playlist unlocked
****************************************************************************/
int UpdateCaps( intf_thread_t* p_intf )
{
intf_sys_t* p_sys = p_intf->p_sys;
dbus_int32_t i_caps = CAPS_CAN_HAS_TRACKLIST;
playlist_t* p_playlist = p_sys->p_playlist;
PL_LOCK;
if( p_playlist->current.i_size > 0 )
i_caps |= CAPS_CAN_PLAY | CAPS_CAN_GO_PREV | CAPS_CAN_GO_NEXT;
PL_UNLOCK;
input_thread_t* p_input = playlist_CurrentInput( p_playlist );
if( p_input )
{
/* XXX: if UpdateCaps() is called too early, these are
* unconditionnaly true */
if( var_GetBool( p_input, "can-pause" ) )
i_caps |= CAPS_CAN_PAUSE;
if( var_GetBool( p_input, "can-seek" ) )
i_caps |= CAPS_CAN_SEEK;
vlc_object_release( p_input );
}
if( p_sys->b_meta_read )
i_caps |= CAPS_CAN_PROVIDE_METADATA;
if( i_caps != p_intf->p_sys->i_caps )
{
p_sys->i_caps = i_caps;
CapsChangeEmit( p_intf );
}
return VLC_SUCCESS;
}
static void Close ( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
playlist_t *p_playlist = pl_Hold( p_intf );;
input_thread_t *p_input;
var_DelCallback( p_playlist, "item-current", AllCallback, p_intf );
var_DelCallback( p_playlist, "intf-change", AllCallback, p_intf );
var_DelCallback( p_playlist, "playlist-item-append", AllCallback, p_intf );
var_DelCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf );
var_DelCallback( p_playlist, "random", AllCallback, p_intf );
var_DelCallback( p_playlist, "repeat", AllCallback, p_intf );
var_DelCallback( p_playlist, "loop", AllCallback, p_intf );
p_input = playlist_CurrentInput( p_playlist );
if ( p_input )
{
var_DelCallback( p_input, "state", AllCallback, p_intf );
vlc_object_release( p_input );
}
pl_Release( p_intf );
dbus_connection_unref( p_intf->p_sys->p_conn );
// Free the events array
for( int i = 0; i < vlc_array_count( p_intf->p_sys->p_events ); i++ )
{
callback_info_t* info = vlc_array_item_at_index( p_intf->p_sys->p_events, i );
free( info );
}
vlc_mutex_destroy( &p_intf->p_sys->lock );
vlc_array_destroy( p_intf->p_sys->p_events );
free( p_intf->p_sys );
}
/* ****************************************************************************/
static void ReadMetaData(intf_thread_t *p_this)
{
input_thread_t *p_input;
input_item_t *p_item;
intf_sys_t *p_sys = p_this->p_sys;
p_input = playlist_CurrentInput(pl_Get(p_this));
if (!p_input)
return;
p_item = input_GetItem(p_input);
if (!p_item)
{
vlc_object_release(p_input);
return;
}
#define ALLOC_ITEM_META(a, b) do { \
char *psz_meta = input_item_Get##b(p_item); \
if (psz_meta && *psz_meta) \
a = encode_URI_component(psz_meta); \
free(psz_meta); \
} while (0)
vlc_mutex_lock(&p_sys->lock);
p_sys->b_meta_read = true;
ALLOC_ITEM_META(p_sys->p_current_item.psz_n, Name);
if (!p_sys->p_current_item.psz_n)
{
msg_Dbg(p_this, "No name..");
DeleteItem(&p_sys->p_current_item);
goto end;
}
ALLOC_ITEM_META(p_sys->p_current_item.psz_u, URI);
if (!p_sys->p_current_item.psz_u)
{
msg_Dbg(p_this, "No URI..");
DeleteItem(&p_sys->p_current_item);
goto end;
}
/* Now we have read the mandatory meta data, so we can submit that info */
p_sys->b_submit = true;
/* Duration in seconds */
p_sys->p_current_item.i_l = input_item_GetDuration(p_item) / 1000000;
#undef ALLOC_ITEM_META
end:
vlc_mutex_unlock(&p_sys->lock);
vlc_object_release(p_input);
}
void CmdFaster::execute()
{
playlist_t *pPlaylist = getIntf()->p_sys->p_playlist;
input_thread_t *pInput = playlist_CurrentInput( pPlaylist );
if( pInput )
{
var_TriggerCallback( pPlaylist, "rate-faster" );
vlc_object_release( pInput );
}
}
static void Run(intf_thread_t *intf)
{
intf_sys_t *sys = intf->p_sys;
int fd;
int canc = vlc_savecancel();
RegisterCallbacks(intf);
while(1) {
msg_Info(intf, "Creating IRC connection...");
fd = net_ConnectTCP(VLC_OBJECT(intf), sys->server, 6667);
if(fd == -1) {
msg_Err(intf, "Error connecting to server");
return;
}
msg_Info(intf, "Connected to server");
/* initialize context */
sys->fd = fd;
sys->line_loc = 0;
SendBufferInit(intf);
SendBufferAppend(intf, "NICK ");
SendBufferAppend(intf, sys->nick);
SendBufferAppend(intf, "\r\n");
SendBufferAppend(intf, "USER ");
SendBufferAppend(intf, sys->nick);
SendBufferAppend(intf, " 8 * vlc\r\n");
sys->playlist = pl_Get(intf);
#ifdef STOP_HACK
playlist_Pause(sys->playlist);
input_thread_t * input = playlist_CurrentInput(sys->playlist);
var_SetFloat(input, "position", 0.0);
#endif
EventLoop(fd, intf);
free(sys->send_buffer->buffer);
sleep(30);
}
free(sys);
vlc_restorecancel(canc);
}
/*****************************************************************************
* ItemChange: Playlist item change callback
*****************************************************************************/
static int ItemChange( vlc_object_t *p_this, const char *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
input_thread_t *p_input;
intf_thread_t *p_intf = ( intf_thread_t* ) p_data;
intf_sys_t *p_sys = p_intf->p_sys;
input_item_t *p_item;
VLC_UNUSED( p_this ); VLC_UNUSED( psz_var );
VLC_UNUSED( oldval ); VLC_UNUSED( newval );
p_sys->b_state_cb = false;
p_sys->b_meta_read = false;
p_sys->b_submit = false;
p_input = playlist_CurrentInput( pl_Get( p_intf ) );
if( !p_input || p_input->b_dead )
return VLC_SUCCESS;
p_item = input_GetItem( p_input );
if( !p_item )
{
vlc_object_release( p_input );
return VLC_SUCCESS;
}
if( var_CountChoices( p_input, "video-es" ) )
{
msg_Dbg( p_this, "Not an audio-only input, not submitting");
vlc_object_release( p_input );
return VLC_SUCCESS;
}
p_sys->time_total_pauses = 0;
time( &p_sys->p_current_song.date ); /* to be sent to last.fm */
p_sys->p_current_song.i_start = mdate(); /* only used locally */
var_AddCallback( p_input, "intf-event", PlayingChange, p_intf );
p_sys->b_state_cb = true;
if( input_item_IsPreparsed( p_item ) )
ReadMetaData( p_intf );
/* if the input item was not preparsed, we'll do it in PlayingChange()
* callback, when "state" == PLAYING_S */
vlc_object_release( p_input );
return VLC_SUCCESS;
}
static void
MarshalRate( intf_thread_t *p_intf, DBusMessageIter *container )
{
double d_rate;
input_thread_t *p_input;
if( ( p_input = playlist_CurrentInput( p_intf->p_sys->p_playlist ) ) )
{
d_rate = var_GetFloat( p_input, "rate" );
vlc_object_release( (vlc_object_t*) p_input );
}
else
d_rate = 0.;
dbus_message_iter_append_basic( container, DBUS_TYPE_DOUBLE, &d_rate );
}
static void
MarshalCanSeek( intf_thread_t *p_intf, DBusMessageIter *container )
{
dbus_bool_t b_can_seek = FALSE;
input_thread_t *p_input;
p_input = playlist_CurrentInput( p_intf->p_sys->p_playlist );
if( p_input )
{
b_can_seek = var_GetBool( p_input, "can-seek" );
vlc_object_release( p_input );
}
dbus_message_iter_append_basic( container, DBUS_TYPE_BOOLEAN, &b_can_seek );
}
input_thread_t * vlclua_get_input_internal( lua_State *L )
{
extension_t *p_extension = vlclua_extension_get( L );
if( p_extension )
{
input_thread_t *p_input = p_extension->p_sys->p_input;
if( p_input )
{
vlc_object_hold(p_input);
return p_input;
}
}
playlist_t *p_playlist = vlclua_get_playlist_internal( L );
input_thread_t *p_input = playlist_CurrentInput( p_playlist );
return p_input;
}
static int MarshalStatus( intf_thread_t* p_intf, DBusMessageIter* args )
{ /* This is NOT the right way to do that, it would be better to sore
the status information in p_sys and update it on change, thus
avoiding a long lock */
DBusMessageIter status;
dbus_int32_t i_state, i_random, i_repeat, i_loop;
vlc_value_t val;
playlist_t* p_playlist = NULL;
input_thread_t* p_input = NULL;
p_playlist = pl_Hold( p_intf );
i_state = 2;
p_input = playlist_CurrentInput( p_playlist );
if( p_input )
{
var_Get( p_input, "state", &val );
if( val.i_int >= END_S )
i_state = 2;
else if( val.i_int == PAUSE_S )
i_state = 1;
else if( val.i_int <= PLAYING_S )
i_state = 0;
vlc_object_release( p_input );
}
i_random = var_CreateGetBool( p_playlist, "random" );
i_repeat = var_CreateGetBool( p_playlist, "repeat" );
i_loop = var_CreateGetBool( p_playlist, "loop" );
pl_Release( p_intf );
dbus_message_iter_open_container( args, DBUS_TYPE_STRUCT, NULL, &status );
dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_state );
dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_random );
dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_repeat );
dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_loop );
dbus_message_iter_close_container( args, &status );
return VLC_SUCCESS;
}
static int vlclua_playlist_current( lua_State *L )
{
playlist_t *p_playlist = vlclua_get_playlist_internal( L );
input_thread_t *p_input = playlist_CurrentInput( p_playlist );
int id = -1;
if( p_input )
{
input_item_t *p_item = input_GetItem( p_input );
if( p_item )
id = p_item->i_id;
vlc_object_release( p_input );
}
#warning Indexing input items by ID is unsafe,
lua_pushinteger( L, id );
return 1;
}
/*****************************************************************************
* TrackChange: callback on playlist "item-current"
*****************************************************************************/
static int TrackChange( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
playlist_t *p_playlist = p_sys->p_playlist;
input_thread_t *p_input = NULL;
input_item_t *p_item = NULL;
if( p_intf->p_sys->b_dead )
return VLC_SUCCESS;
if( p_sys->p_input )
{
var_DelCallback( p_sys->p_input, "intf-event", AllCallback, p_intf );
var_DelCallback( p_sys->p_input, "can-pause", AllCallback, p_intf );
var_DelCallback( p_sys->p_input, "can-seek", AllCallback, p_intf );
vlc_object_release( p_sys->p_input );
p_sys->p_input = NULL;
}
p_sys->b_meta_read = false;
p_input = playlist_CurrentInput( p_playlist );
if( !p_input )
{
return VLC_SUCCESS;
}
p_item = input_GetItem( p_input );
if( !p_item )
{
vlc_object_release( p_input );
return VLC_EGENERIC;
}
if( input_item_IsPreparsed( p_item ) )
p_sys->b_meta_read = true;
p_sys->p_input = p_input;
var_AddCallback( p_input, "intf-event", AllCallback, p_intf );
var_AddCallback( p_input, "can-pause", AllCallback, p_intf );
var_AddCallback( p_input, "can-seek", AllCallback, p_intf );
return VLC_SUCCESS;
}
/*****************************************************************************
* ItemChange: Playlist item change callback
*****************************************************************************/
static int ItemChange(vlc_object_t *p_this, const char *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data)
{
input_thread_t *p_input;
intf_thread_t *p_intf = (intf_thread_t*) p_data;
intf_sys_t *p_sys = p_intf->p_sys;
input_item_t *p_item;
VLC_UNUSED(p_this); VLC_UNUSED(psz_var);
VLC_UNUSED(oldval); VLC_UNUSED(newval);
p_sys->b_state_cb = false;
p_sys->b_meta_read = false;
p_sys->b_submit = false;
p_input = playlist_CurrentInput(pl_Get(p_intf));
if (!p_input || p_input->b_dead)
return VLC_SUCCESS;
p_item = input_GetItem(p_input);
if (!p_item)
{
vlc_object_release(p_input);
return VLC_SUCCESS;
}
p_sys->time_total_pauses = 0;
time(&p_sys->p_current_item.date); /* to be sent to upstream */
p_sys->p_current_item.i_start = mdate(); /* used to calculate run
* time as fallback */
var_AddCallback(p_input, "intf-event", PlayingChange, p_intf);
p_sys->b_state_cb = true;
if (input_item_IsPreparsed(p_item))
ReadMetaData(p_intf);
vlc_object_release(p_input);
return VLC_SUCCESS;
}
void EpgDialog::updateInfos()
{
timer->stop();
input_item_t *p_input_item = NULL;
playlist_t *p_playlist = THEPL;
input_thread_t *p_input_thread = playlist_CurrentInput( p_playlist ); /* w/hold */
if( p_input_thread )
{
PL_LOCK; /* as input_GetItem still unfixed */
p_input_item = input_GetItem( p_input_thread );
if ( p_input_item ) vlc_gc_incref( p_input_item );
PL_UNLOCK;
vlc_object_release( p_input_thread );
if ( p_input_item )
{
epg->updateEPG( p_input_item );
vlc_gc_decref( p_input_item );
if ( isVisible() ) timer->start();
}
}
}
void CmdUpdateItem::execute()
{
playlist_t *pPlaylist = getIntf()->p_sys->p_playlist;
if( pPlaylist == NULL )
return;
input_thread_t *p_input = playlist_CurrentInput( pPlaylist );
if( !p_input )
return;
// Get playlist item information
input_item_t *pItem = input_GetItem( p_input );
char *pszName = input_item_GetName( pItem );
char *pszUri = input_item_GetURI( pItem );
string name = pszName;
// XXX: This should be done in VLC core, not here...
// Remove path information if any
OSFactory *pFactory = OSFactory::instance( getIntf() );
string::size_type pos = name.rfind( pFactory->getDirSeparator() );
if( pos != string::npos )
{
name = name.substr( pos + 1, name.size() - pos + 1 );
}
UString srcName( getIntf(), name.c_str() );
UString srcURI( getIntf(), pszUri );
free( pszName );
free( pszUri );
// Create commands to update the stream variables
CmdSetText *pCmd1 = new CmdSetText( getIntf(), m_rStreamName, srcName );
CmdSetText *pCmd2 = new CmdSetText( getIntf(), m_rStreamURI, srcURI );
// Push the commands in the asynchronous command queue
AsyncQueue *pQueue = AsyncQueue::instance( getIntf() );
pQueue->push( CmdGenericPtr( pCmd1 ), false );
pQueue->push( CmdGenericPtr( pCmd2 ), false );
vlc_object_release( p_input );
}
/*****************************************************************************
* TrackChange: callback on playlist "item-current"
*****************************************************************************/
static int TrackChange( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
playlist_t *p_playlist;
input_thread_t *p_input = NULL;
input_item_t *p_item = NULL;
if( p_intf->p_sys->b_dead )
return VLC_SUCCESS;
p_sys->b_meta_read = false;
p_playlist = pl_Hold( p_intf );
p_input = playlist_CurrentInput( p_playlist );
if( !p_input )
{
pl_Release( p_intf );
return VLC_SUCCESS;
}
pl_Release( p_intf );
p_item = input_GetItem( p_input );
if( !p_item )
{
vlc_object_release( p_input );
return VLC_EGENERIC;
}
if( input_item_IsPreparsed( p_item ) )
{
p_sys->b_meta_read = true;
TrackChangeSignal( p_sys->p_conn, p_item );
}
var_AddCallback( p_input, "state", AllCallback, p_intf );
vlc_object_release( p_input );
return VLC_SUCCESS;
}
static int InputChange( vlc_object_t *p_playlist, const char *var,
vlc_value_t prev, vlc_value_t value, void *data )
{
intf_thread_t *p_intf = data;
intf_sys_t *p_sys = p_intf->p_sys;
if( p_sys->p_input )
{
var_DelCallback( p_sys->p_input, "state", StateChange, p_intf );
vlc_object_release( p_sys->p_input );
}
p_sys->p_input = VLC_OBJECT(playlist_CurrentInput( p_sys->p_playlist ));
if( p_sys->p_input )
{
Inhibit( p_intf, FREEDESKTOP );
Inhibit( p_intf, GNOME );
var_AddCallback( p_sys->p_input, "state", StateChange, p_intf );
}
(void)var; (void)prev; (void)value; (void)p_playlist;
return VLC_SUCCESS;
}
void EpgDialog::updateInfos()
{
input_item_t *p_input_item = NULL;
playlist_t *p_playlist = THEPL;
input_thread_t *p_input_thread = playlist_CurrentInput( p_playlist ); /* w/hold */
if( p_input_thread )
{
PL_LOCK; /* as input_GetItem still unfixed */
p_input_item = input_GetItem( p_input_thread );
if ( p_input_item ) input_item_Hold( p_input_item );
PL_UNLOCK;
vlc_object_release( p_input_thread );
if ( p_input_item )
{
epg->updateEPG( p_input_item );
input_item_Release( p_input_item );
}
else
{
epg->reset();
}
}
}
//static int StateChange( vlc_object_t *p_this, const char* psz_var,
// vlc_value_t oldval, vlc_value_t newval, void *p_data )
static int StateChange( intf_thread_t *p_intf, int i_input_state )
{
intf_sys_t *p_sys = p_intf->p_sys;
playlist_t *p_playlist;
input_thread_t *p_input;
input_item_t *p_item;
if( p_intf->p_sys->b_dead )
return VLC_SUCCESS;
UpdateCaps( p_intf );
if( !p_sys->b_meta_read && i_input_state == PLAYING_S )
{
p_playlist = pl_Hold( p_intf );
p_input = playlist_CurrentInput( p_playlist );
if( p_input )
{
p_item = input_GetItem( p_input );
if( p_item )
{
p_sys->b_meta_read = true;
TrackChangeSignal( p_sys->p_conn, p_item );
}
vlc_object_release( p_input );
}
pl_Release( p_intf );
}
if( i_input_state == PLAYING_S || i_input_state == PAUSE_S ||
i_input_state == END_S )
{
StatusChangeSignal( p_sys->p_conn, p_intf );
}
return VLC_SUCCESS;
}
static char *TitleGet( vlc_object_t *p_this )
{
input_thread_t *p_input = playlist_CurrentInput( pl_Get( p_this ) );
if( !p_input )
return NULL;
char *psz_title = input_item_GetTitle( input_GetItem( p_input ) );
if( EMPTY_STR( psz_title ) )
{
free( psz_title );
char *psz_uri = input_item_GetURI( input_GetItem( p_input ) );
const char *psz = strrchr( psz_uri, '/' );
if( psz )
{
psz_title = strdup( psz + 1 );
free( psz_uri );
}
else
psz_title = psz_uri;
}
vlc_object_release( p_input );
return psz_title;
}
/**
* PropertiesChangedSignal() synthetizes and sends the
* org.freedesktop.DBus.Properties.PropertiesChanged signal
*/
static DBusHandlerResult
PropertiesChangedSignal( intf_thread_t *p_intf,
vlc_dictionary_t *p_changed_properties )
{
DBusConnection *p_conn = p_intf->p_sys->p_conn;
DBusMessageIter changed_properties, invalidated_properties, entry, variant;
const char *psz_interface_name = DBUS_MPRIS_PLAYER_INTERFACE;
char **ppsz_properties = NULL;
int i_properties = 0;
SIGNAL_INIT( DBUS_INTERFACE_PROPERTIES,
DBUS_MPRIS_OBJECT_PATH,
"PropertiesChanged" );
OUT_ARGUMENTS;
ADD_STRING( &psz_interface_name );
dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "{sv}",
&changed_properties );
i_properties = vlc_dictionary_keys_count( p_changed_properties );
ppsz_properties = vlc_dictionary_all_keys( p_changed_properties );
for( int i = 0; i < i_properties; i++ )
{
dbus_message_iter_open_container( &changed_properties,
DBUS_TYPE_DICT_ENTRY, NULL,
&entry );
dbus_message_iter_append_basic( &entry, DBUS_TYPE_STRING,
&ppsz_properties[i] );
if( !strcmp( ppsz_properties[i], "Metadata" ) )
{
input_thread_t *p_input;
p_input = playlist_CurrentInput( p_intf->p_sys->p_playlist );
dbus_message_iter_open_container( &entry,
DBUS_TYPE_VARIANT, "a{sv}",
&variant );
if( p_input )
{
input_item_t *p_item = input_GetItem( p_input );
GetInputMeta( p_item, &variant );
vlc_object_release( p_input );
}
dbus_message_iter_close_container( &entry, &variant );
}
else if( !strcmp( ppsz_properties[i], "PlaybackStatus" ) )
{
dbus_message_iter_open_container( &entry,
DBUS_TYPE_VARIANT, "s",
&variant );
MarshalPlaybackStatus( p_intf, &variant );
dbus_message_iter_close_container( &entry, &variant );
}
else if( !strcmp( ppsz_properties[i], "LoopStatus" ) )
{
dbus_message_iter_open_container( &entry,
DBUS_TYPE_VARIANT, "s",
&variant );
MarshalLoopStatus( p_intf, &variant );
dbus_message_iter_close_container( &entry, &variant );
}
else if( !strcmp( ppsz_properties[i], "Rate" ) )
{
dbus_message_iter_open_container( &entry,
DBUS_TYPE_VARIANT, "d",
&variant );
MarshalRate( p_intf, &variant );
dbus_message_iter_close_container( &entry, &variant );
}
else if( !strcmp( ppsz_properties[i], "Shuffle" ) )
{
dbus_message_iter_open_container( &entry,
DBUS_TYPE_VARIANT, "b",
&variant );
MarshalShuffle( p_intf, &variant );
dbus_message_iter_close_container( &entry, &variant );
}
else if( !strcmp( ppsz_properties[i], "Volume" ) )
{
dbus_message_iter_open_container( &entry,
DBUS_TYPE_VARIANT, "d",
&variant );
MarshalVolume( p_intf, &variant );
dbus_message_iter_close_container( &entry, &variant );
}
else if( !strcmp( ppsz_properties[i], "CanSeek" ) )
{
dbus_message_iter_open_container( &entry,
DBUS_TYPE_VARIANT, "b",
&variant );
MarshalCanSeek( p_intf, &variant );
dbus_message_iter_close_container( &entry, &variant );
}
else if( !strcmp( ppsz_properties[i], "CanPlay" ) )
{
dbus_message_iter_open_container( &entry,
DBUS_TYPE_VARIANT, "b",
&variant );
MarshalCanPlay( p_intf, &variant );
dbus_message_iter_close_container( &entry, &variant );
}
else if( !strcmp( ppsz_properties[i], "CanPause" ) )
{
dbus_message_iter_open_container( &entry,
DBUS_TYPE_VARIANT, "b",
&variant );
MarshalCanPause( p_intf, &variant );
dbus_message_iter_close_container( &entry, &variant );
}
dbus_message_iter_close_container( &changed_properties, &entry );
free( ppsz_properties[i] );
}
dbus_message_iter_close_container( &args, &changed_properties );
dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "s",
&invalidated_properties );
dbus_message_iter_close_container( &args, &invalidated_properties );
free( ppsz_properties );
SIGNAL_SEND;
}
static void ProcessGesture( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
playlist_t *p_playlist = pl_Get( p_intf );
/* Do something */
/* If you modify this, please try to follow this convention:
Start with LEFT, RIGHT for playback related commands
and UP, DOWN, for other commands */
switch( p_sys->i_pattern )
{
case LEFT:
{
msg_Dbg( p_intf, "Go backward in the movie!" );
input_thread_t *p_input = playlist_CurrentInput( p_playlist );
if( p_input == NULL )
break;
int it = var_InheritInteger( p_intf , "short-jump-size" );
if( it > 0 )
var_SetTime( p_input, "time-offset", -CLOCK_FREQ * it );
vlc_object_release( p_input );
break;
}
case RIGHT:
{
msg_Dbg( p_intf, "Go forward in the movie!" );
input_thread_t *p_input = playlist_CurrentInput( p_playlist );
if( p_input == NULL )
break;
int it = var_InheritInteger( p_intf , "short-jump-size" );
if( it > 0 )
var_SetTime( p_input, "time-offset", CLOCK_FREQ * it );
vlc_object_release( p_input );
break;
}
case GESTURE(LEFT,UP,NONE,NONE):
msg_Dbg( p_intf, "Going slower." );
var_TriggerCallback( p_playlist, "rate-slower" );
break;
case GESTURE(RIGHT,UP,NONE,NONE):
msg_Dbg( p_intf, "Going faster." );
var_TriggerCallback( p_playlist, "rate-faster" );
break;
case GESTURE(LEFT,RIGHT,NONE,NONE):
case GESTURE(RIGHT,LEFT,NONE,NONE):
{
msg_Dbg( p_intf, "Play/Pause" );
input_thread_t *p_input = playlist_CurrentInput( p_playlist );
if( p_input == NULL )
break;
int i_state = var_GetInteger( p_input, "state" );
i_state = (i_state == PLAYING_S) ? PAUSE_S : PLAYING_S;
var_SetInteger( p_input, "state", i_state );
vlc_object_release( p_input );
break;
}
case GESTURE(LEFT,DOWN,NONE,NONE):
playlist_Prev( p_playlist );
break;
case GESTURE(RIGHT,DOWN,NONE,NONE):
playlist_Next( p_playlist );
break;
case UP:
msg_Dbg(p_intf, "Louder");
playlist_VolumeUp( p_playlist, 1, NULL );
break;
case DOWN:
msg_Dbg(p_intf, "Quieter");
playlist_VolumeDown( p_playlist, 1, NULL );
break;
case GESTURE(UP,DOWN,NONE,NONE):
case GESTURE(DOWN,UP,NONE,NONE):
msg_Dbg( p_intf, "Mute sound" );
playlist_MuteToggle( p_playlist );
break;
case GESTURE(UP,RIGHT,NONE,NONE):
{
input_thread_t *p_input = playlist_CurrentInput( p_playlist );
if( p_input == NULL )
break;
vlc_value_t list, list2;
var_Change( p_input, "audio-es", VLC_VAR_GETCHOICES,
&list, &list2 );
if( list.p_list->i_count > 1 )
{
int i_audio_es = var_GetInteger( p_input, "audio-es" );
int i;
for( i = 0; i < list.p_list->i_count; i++ )
if( i_audio_es == list.p_list->p_values[i].i_int )
break;
/* value of audio-es was not in choices list */
if( i == list.p_list->i_count )
{
msg_Warn( p_input,
"invalid current audio track, selecting 0" );
i = 0;
}
else if( i == list.p_list->i_count - 1 )
i = 1;
else
i++;
var_SetInteger( p_input, "audio-es",
list.p_list->p_values[i].i_int );
}
var_FreeList( &list, &list2 );
vlc_object_release( p_input );
break;
}
case GESTURE(DOWN,RIGHT,NONE,NONE):
{
input_thread_t *p_input = playlist_CurrentInput( p_playlist );
if( p_input == NULL )
break;
vlc_value_t list, list2;
var_Change( p_input, "spu-es", VLC_VAR_GETCHOICES,
&list, &list2 );
if( list.p_list->i_count > 1 )
{
int i_audio_es = var_GetInteger( p_input, "spu-es" );
int i;
for( i = 0; i < list.p_list->i_count; i++ )
if( i_audio_es == list.p_list->p_values[i].i_int )
break;
/* value of audio-es was not in choices list */
if( i == list.p_list->i_count )
{
msg_Warn( p_input,
"invalid current subtitle track, selecting 0" );
i = 0;
}
else if( i == list.p_list->i_count - 1 )
i = 1;
else
i++;
var_SetInteger( p_input, "audio-es",
list.p_list->p_values[i].i_int );
}
var_FreeList( &list, &list2 );
vlc_object_release( p_input );
break;
}
case GESTURE(UP,LEFT,NONE,NONE):
{
bool val = var_ToggleBool( pl_Get( p_intf ), "fullscreen" );
if( p_sys->p_vout )
var_SetBool( p_sys->p_vout, "fullscreen", val );
break;
}
case GESTURE(DOWN,LEFT,NONE,NONE):
/* FIXME: Should close the vout!"*/
libvlc_Quit( p_intf->p_libvlc );
break;
case GESTURE(DOWN,LEFT,UP,RIGHT):
case GESTURE(UP,RIGHT,DOWN,LEFT):
msg_Dbg( p_intf, "a square was drawn!" );
break;
}
p_sys->i_num_gestures = 0;
p_sys->i_pattern = 0;
}
/*****************************************************************************
* ReadMetaData : Read meta data when parsed by vlc
*****************************************************************************/
static int ReadMetaData( intf_thread_t *p_this )
{
input_thread_t *p_input;
input_item_t *p_item;
intf_sys_t *p_sys = p_this->p_sys;
p_input = playlist_CurrentInput( pl_Get( p_this ) );
if( !p_input )
return( VLC_SUCCESS );
p_item = input_GetItem( p_input );
if( !p_item )
return VLC_SUCCESS;
char *psz_meta;
#define ALLOC_ITEM_META( a, b ) \
psz_meta = input_item_Get##b( p_item ); \
if( psz_meta && *psz_meta ) \
{ \
a = encode_URI_component( psz_meta ); \
if( !a ) \
{ \
vlc_mutex_unlock( &p_sys->lock ); \
vlc_object_release( p_input ); \
free( psz_meta ); \
return VLC_ENOMEM; \
} \
}
vlc_mutex_lock( &p_sys->lock );
p_sys->b_meta_read = true;
ALLOC_ITEM_META( p_sys->p_current_song.psz_a, Artist )
else
{
vlc_mutex_unlock( &p_sys->lock );
msg_Dbg( p_this, "No artist.." );
vlc_object_release( p_input );
free( psz_meta );
return VLC_EGENERIC;
}
free( psz_meta );
ALLOC_ITEM_META( p_sys->p_current_song.psz_t, Title )
else
{
vlc_mutex_unlock( &p_sys->lock );
msg_Dbg( p_this, "No track name.." );
vlc_object_release( p_input );
free( p_sys->p_current_song.psz_a );
free( psz_meta );
return VLC_EGENERIC;
}
free( psz_meta );
/* Now we have read the mandatory meta data, so we can submit that info */
p_sys->b_submit = true;
ALLOC_ITEM_META( p_sys->p_current_song.psz_b, Album )
else
p_sys->p_current_song.psz_b = calloc( 1, 1 );
free( psz_meta );
ALLOC_ITEM_META( p_sys->p_current_song.psz_m, TrackID )
else
p_sys->p_current_song.psz_m = calloc( 1, 1 );
free( psz_meta );
p_sys->p_current_song.i_l = input_item_GetDuration( p_item ) / 1000000;
ALLOC_ITEM_META( p_sys->p_current_song.psz_n, TrackNum )
else
p_sys->p_current_song.psz_n = calloc( 1, 1 );
free( psz_meta );
#undef ALLOC_ITEM_META
msg_Dbg( p_this, "Meta data registered" );
vlc_mutex_unlock( &p_sys->lock );
vlc_object_release( p_input );
return VLC_SUCCESS;
}
