/***************************************************************************** * 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; }