static int vlclua_input_metas_internal( lua_State *L, input_item_t *p_item ) { if( !p_item ) { lua_pushnil( L ); return 1; } lua_newtable( L ); char *psz_name; const char *psz_meta; psz_name = input_item_GetName( p_item ); lua_pushstring( L, psz_name ); lua_setfield( L, -2, "filename" ); free( psz_name ); #define PUSH_META( n, m ) \ psz_meta = vlc_meta_Get( p_item->p_meta, vlc_meta_ ## n ); \ lua_pushstring( L, psz_meta ); \ lua_setfield( L, -2, m ) vlc_mutex_lock(&p_item->lock); if (p_item->p_meta) { PUSH_META( Title, "title" ); PUSH_META( Artist, "artist" ); PUSH_META( Genre, "genre" ); PUSH_META( Copyright, "copyright" ); PUSH_META( Album, "album" ); PUSH_META( TrackNumber, "track_number" ); PUSH_META( Description, "description" ); PUSH_META( Rating, "rating" ); PUSH_META( Date, "date" ); PUSH_META( Setting, "setting" ); PUSH_META( URL, "url" ); PUSH_META( Language, "language" ); PUSH_META( NowPlaying, "now_playing" ); PUSH_META( Publisher, "publisher" ); PUSH_META( EncodedBy, "encoded_by" ); PUSH_META( ArtworkURL, "artwork_url" ); PUSH_META( TrackID, "track_id" ); #undef PUSH_META char **names = vlc_meta_CopyExtraNames(p_item->p_meta); for(int i = 0; names[i]; i++) { const char *meta = vlc_meta_GetExtra(p_item->p_meta, names[i]); lua_pushstring( L, meta ); lua_setfield( L, -2, names[i] ); free(names[i]); } free(names); } vlc_mutex_unlock(&p_item->lock); return 1; }
void VlcProc::on_item_current_changed( vlc_object_t* p_obj, vlc_value_t newVal ) { (void)p_obj; input_item_t *p_item = static_cast<input_item_t*>(newVal.p_address); // Update short name char *psz_name = input_item_GetName( p_item ); SET_TEXT( m_cVarStreamName, UString( getIntf(), psz_name ) ); free( psz_name ); // Update local path (if possible) or full uri char *psz_uri = input_item_GetURI( p_item ); char *psz_path = make_path( psz_uri ); char *psz_save = psz_path ? psz_path : psz_uri; SET_TEXT( m_cVarStreamURI, UString( getIntf(), psz_save ) ); free( psz_path ); free( psz_uri ); // Update art uri char *psz_art = input_item_GetArtURL( p_item ); SET_STRING( m_cVarStreamArt, string( psz_art ? psz_art : "" ) ); free( psz_art ); // Update playtree getPlaytreeVar().onUpdateCurrent( true ); }
static lua_State * vlclua_meta_init( vlc_object_t *p_this, input_item_t * p_item ) { lua_State * L = luaL_newstate(); if( !L ) { msg_Err( p_this, "Could not create new Lua State" ); return NULL; } char *psz_meta; /* Load Lua libraries */ luaL_openlibs( L ); /* XXX: Don't open all the libs? */ luaL_register( L, "vlc", p_reg ); luaopen_msg( L ); luaopen_stream( L ); luaopen_strings( L ); luaopen_variables( L ); luaopen_object( L ); luaopen_misc( L ); lua_pushlightuserdata( L, p_this ); lua_setfield( L, -2, "private" ); psz_meta = input_item_GetName( p_item ); lua_pushstring( L, psz_meta ); lua_setfield( L, -2, "name" ); free( psz_meta ); psz_meta = input_item_GetArtist( p_item ); lua_pushstring( L, psz_meta ); lua_setfield( L, -2, "artist" ); free( psz_meta ); psz_meta = input_item_GetTitle( p_item ) ; lua_pushstring( L, psz_meta ); lua_setfield( L, -2, "title" ); free( psz_meta ); psz_meta = input_item_GetAlbum( p_item ); lua_pushstring( L, psz_meta ); lua_setfield( L, -2, "album" ); free( psz_meta ); psz_meta = input_item_GetArtURL( p_item ); lua_pushstring( L, psz_meta ); lua_setfield( L, -2, "arturl" ); free( psz_meta ); /* XXX: all should be passed ( could use macro ) */ return L; }
QString PLItem::getTitle() const { QString title; char *fb_name = input_item_GetTitle( p_input ); if( EMPTY_STR( fb_name ) ) { free( fb_name ); fb_name = input_item_GetName( p_input ); } title = qfu(fb_name); free(fb_name); return title; }
/** * Start the input for an item * * \param p_playlist the playlist object * \param p_item the item to play * \return nothing */ static int PlayItem( playlist_t *p_playlist, playlist_item_t *p_item ) { playlist_private_t *p_sys = pl_priv(p_playlist); input_item_t *p_input = p_item->p_input; PL_ASSERT_LOCKED; msg_Dbg( p_playlist, "creating new input thread" ); p_input->i_nb_played++; set_current_status_item( p_playlist, p_item ); p_sys->status.i_status = PLAYLIST_RUNNING; assert( p_sys->p_input == NULL ); input_thread_t *p_input_thread = input_Create( p_playlist, p_input, NULL, p_sys->p_input_resource ); if( p_input_thread ) { p_sys->p_input = p_input_thread; var_AddCallback( p_input_thread, "intf-event", InputEvent, p_playlist ); var_SetAddress( p_playlist, "input-current", p_input_thread ); if( input_Start( p_sys->p_input ) ) { vlc_object_release( p_input_thread ); p_sys->p_input = p_input_thread = NULL; } } /* TODO store art policy in playlist private data */ char *psz_arturl = input_item_GetArtURL( p_input ); char *psz_name = input_item_GetName( p_input ); /* p_input->p_meta should not be null after a successful CreateThread */ bool b_has_art = !EMPTY_STR( psz_arturl ); if( !b_has_art || strncmp( psz_arturl, "attachment://", 13 ) ) { PL_DEBUG( "requesting art for %s", psz_name ); libvlc_ArtRequest( p_playlist->p_libvlc, p_input, META_REQUEST_OPTION_NONE ); } free( psz_arturl ); free( psz_name ); PL_UNLOCK; var_TriggerCallback( p_playlist, "activity" ); PL_LOCK; return VLC_SUCCESS; }
void LocationBar::setIndex( const QModelIndex &index ) { qDeleteAll( buttons ); buttons.clear(); qDeleteAll( actions ); actions.clear(); QModelIndex i = index; bool first = true; while( true ) { PLItem *item = model->getItem( i ); QString text; char *fb_name = input_item_GetTitle( item->inputItem() ); if( EMPTY_STR( fb_name ) ) { free( fb_name ); fb_name = input_item_GetName( item->inputItem() ); } text = qfu(fb_name); free(fb_name); QAbstractButton *btn = new LocationButton( text, first, !first, this ); btn->setSizePolicy( QSizePolicy::Maximum, QSizePolicy::Fixed ); buttons.append( btn ); QAction *action = new QAction( text, this ); actions.append( action ); CONNECT( btn, clicked(), action, trigger() ); mapper->setMapping( action, item->id() ); CONNECT( action, triggered(), mapper, map() ); first = false; if( i.isValid() ) i = i.parent(); else break; } QString prefix; for( int a = actions.count() - 1; a >= 0 ; a-- ) { actions[a]->setText( prefix + actions[a]->text() ); prefix += QString(" "); } if( isVisible() ) layOut( size() ); }
PLSelItem *PLSelector::addPodcastItem( playlist_item_t *p_item ) { vlc_gc_incref( p_item->p_input ); char *psz_name = input_item_GetName( p_item->p_input ); PLSelItem *item = addItem( PL_ITEM_TYPE, psz_name, false, podcastsParent ); item->addAction( RM_ACTION, qtr( "Remove this podcast subscription" ) ); item->treeItem()->setData( 0, PL_ITEM_ROLE, QVariant::fromValue( p_item ) ); item->treeItem()->setData( 0, PL_ITEM_ID_ROLE, QVariant(p_item->i_id) ); item->treeItem()->setData( 0, IN_ITEM_ROLE, QVariant::fromValue( p_item->p_input ) ); CONNECT( item, action( PLSelItem* ), this, podcastRemove( PLSelItem* ) ); free( psz_name ); return item; }
/** * Recursiveyy follow the playlist * @param p_playlist: the playlist * @param p_export: the export structure * @param p_root: the current node */ static void DoChildren( playlist_t *p_playlist, playlist_export_t *p_export, playlist_item_t *p_root ) { /* Go through the playlist and add items */ for( int i = 0; i < p_root->i_children ; i++) { playlist_item_t *p_current = p_root->pp_children[i]; assert( p_current ); if( p_current->i_flags & PLAYLIST_SAVE_FLAG ) continue; if( p_current->i_children >= 0 ) { DoChildren( p_playlist, p_export, p_current ); continue; } char* psz_name = NULL; char *psz_tmp = input_item_GetName( p_current->p_input ); if( psz_tmp ) psz_name = convert_xml_special_chars( psz_tmp ); free( psz_tmp ); if( psz_name ) { char* psz_artist = NULL; psz_tmp = input_item_GetArtist( p_current->p_input ); if( psz_tmp ) psz_artist = convert_xml_special_chars( psz_tmp ); free( psz_tmp ); mtime_t i_duration = input_item_GetDuration( p_current->p_input ); int min = ( i_duration / 1000000 ) / 60; int sec = ( i_duration / 1000000 ) - min * 60; // Print the artist if we have one if( psz_artist && *psz_artist ) fprintf( p_export->p_file, " <li>%s - %s (%02d:%02d)</li>\n", psz_artist, psz_name, min, sec ); else fprintf( p_export->p_file, " <li>%s (%2d:%2d)</li>\n", psz_name, min, sec ); free( psz_artist ); } free( psz_name ); } }
/** * Recursively follow the playlist * @param p_export: the export structure * @param p_root: the current node */ static void DoChildren( playlist_export_t *p_export, playlist_item_t *p_root ) { /* Go through the playlist and add items */ for( int i = 0; i < p_root->i_children ; i++) { playlist_item_t *p_current = p_root->pp_children[i]; assert( p_current ); if( p_current->i_children >= 0 ) { DoChildren( p_export, p_current ); continue; } char* psz_name = NULL; char *psz_tmp = input_item_GetName( p_current->p_input ); if( psz_tmp ) psz_name = vlc_xml_encode( psz_tmp ); free( psz_tmp ); if( psz_name ) { char* psz_artist = NULL; psz_tmp = input_item_GetArtist( p_current->p_input ); if( psz_tmp ) psz_artist = vlc_xml_encode( psz_tmp ); free( psz_tmp ); vlc_tick_t i_duration = input_item_GetDuration( p_current->p_input ); int min = SEC_FROM_VLC_TICK( i_duration ) / 60; int sec = SEC_FROM_VLC_TICK( i_duration ) - min * 60; // Print the artist if we have one if( psz_artist && *psz_artist ) fprintf( p_export->p_file, " <li>%s - %s (%02d:%02d)</li>\n", psz_artist, psz_name, min, sec ); else fprintf( p_export->p_file, " <li>%s (%2d:%2d)</li>\n", psz_name, min, sec ); free( psz_artist ); } free( psz_name ); } }
static void DisplayVoutTitle( input_resource_t *p_resource, vout_thread_t *p_vout ) { if( p_resource->p_input == NULL ) return; /* TODO display the title only one time for the same input ? */ input_item_t *p_item = input_GetItem( p_resource->p_input ); char *psz_nowplaying = input_item_GetNowPlaying( p_item ); if( psz_nowplaying && *psz_nowplaying ) { vout_DisplayTitle( p_vout, psz_nowplaying ); } else { char *psz_artist = input_item_GetArtist( p_item ); char *psz_name = input_item_GetTitle( p_item ); if( !psz_name || *psz_name == '\0' ) { free( psz_name ); psz_name = input_item_GetName( p_item ); } if( psz_artist && *psz_artist ) { char *psz_string; if( asprintf( &psz_string, "%s - %s", psz_name, psz_artist ) != -1 ) { vout_DisplayTitle( p_vout, psz_string ); free( psz_string ); } } else if( psz_name ) { vout_DisplayTitle( p_vout, psz_name ); } free( psz_name ); free( psz_artist ); } free( psz_nowplaying ); }
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 ); }
/** * Start the input for an item * * \param p_playlist the playlist object * \param p_item the item to play * \return nothing */ static int PlayItem( playlist_t *p_playlist, playlist_item_t *p_item ) { playlist_private_t *p_sys = pl_priv(p_playlist); input_item_t *p_input = p_item->p_input; PL_ASSERT_LOCKED; msg_Dbg( p_playlist, "creating new input thread" ); p_input->i_nb_played++; set_current_status_item( p_playlist, p_item ); p_sys->status.i_status = PLAYLIST_RUNNING; UpdateActivity( p_playlist, DEFAULT_INPUT_ACTIVITY ); assert( p_sys->p_input == NULL ); if( !p_sys->p_input_resource ) p_sys->p_input_resource = input_resource_New( VLC_OBJECT( p_playlist ) ); input_thread_t *p_input_thread = input_Create( p_playlist, p_input, NULL, p_sys->p_input_resource ); if( p_input_thread ) { p_sys->p_input = p_input_thread; var_AddCallback( p_input_thread, "intf-event", InputEvent, p_playlist ); var_SetAddress( p_playlist, "input-current", p_input_thread ); if( input_Start( p_sys->p_input ) ) { vlc_object_release( p_input_thread ); p_sys->p_input = p_input_thread = NULL; } } char *psz_uri = input_item_GetURI( p_item->p_input ); if( psz_uri && ( !strncmp( psz_uri, "directory:", 10 ) || !strncmp( psz_uri, "vlc:", 4 ) ) ) { free( psz_uri ); return VLC_SUCCESS; } free( psz_uri ); /* TODO store art policy in playlist private data */ if( var_GetInteger( p_playlist, "album-art" ) == ALBUM_ART_WHEN_PLAYED ) { bool b_has_art; char *psz_arturl, *psz_name; psz_arturl = input_item_GetArtURL( p_input ); psz_name = input_item_GetName( p_input ); /* p_input->p_meta should not be null after a successfull CreateThread */ b_has_art = !EMPTY_STR( psz_arturl ); if( !b_has_art || strncmp( psz_arturl, "attachment://", 13 ) ) { PL_DEBUG( "requesting art for %s", psz_name ); playlist_AskForArtEnqueue( p_playlist, p_input ); } free( psz_arturl ); free( psz_name ); } /* FIXME: this is not safe !!*/ PL_UNLOCK; var_SetAddress( p_playlist, "item-current", p_input ); PL_LOCK; return VLC_SUCCESS; }
/***************************************************************************** * Export_M3U: main export function *****************************************************************************/ static void DoChildren( playlist_export_t *p_export, playlist_item_t *p_root, int (*pf_fprintf) (FILE *, const char *, ...) ) { /* Write header */ fputs( "#EXTM3U\n", p_export->p_file ); /* Go through the playlist and add items */ for( int i = 0; i< p_root->i_children ; i++) { playlist_item_t *p_current = p_root->pp_children[i]; assert( p_current ); if( p_current->i_flags & PLAYLIST_SAVE_FLAG ) continue; if( p_current->i_children >= 0 ) { DoChildren( p_export, p_current, pf_fprintf ); continue; } /* General info */ char *psz_uri = input_item_GetURI( p_current->p_input ); assert( psz_uri ); char *psz_name = input_item_GetName( p_current->p_input ); if( psz_name && strcmp( psz_uri, psz_name ) ) { char *psz_artist = input_item_GetArtist( p_current->p_input ); if( psz_artist == NULL ) psz_artist = strdup( "" ); mtime_t i_duration = input_item_GetDuration( p_current->p_input ); if( psz_artist && *psz_artist ) { /* write EXTINF with artist */ pf_fprintf( p_export->p_file, "#EXTINF:%"PRIu64",%s - %s\n", i_duration / CLOCK_FREQ, psz_artist, psz_name); } else { /* write EXTINF without artist */ pf_fprintf( p_export->p_file, "#EXTINF:%"PRIu64",%s\n", i_duration / CLOCK_FREQ, psz_name); } free( psz_artist ); } free( psz_name ); /* VLC specific options */ vlc_mutex_lock( &p_current->p_input->lock ); for( int j = 0; j < p_current->p_input->i_options; j++ ) { pf_fprintf( p_export->p_file, "#EXTVLCOPT:%s\n", p_current->p_input->ppsz_options[j][0] == ':' ? p_current->p_input->ppsz_options[j] + 1 : p_current->p_input->ppsz_options[j] ); } vlc_mutex_unlock( &p_current->p_input->lock ); /* Stupid third party players don't understand file: URIs. */ char *psz_path = make_path( psz_uri ); if( psz_path != NULL ) { free( psz_uri ); psz_uri = psz_path; } fprintf( p_export->p_file, "%s\n", psz_uri ); free( psz_uri ); } }
static int vlclua_input_item_name( lua_State *L ) { lua_pushstring( L, input_item_GetName( vlclua_input_item_get_internal( L ) ) ); return 1; }
/************************************************************************* * Playlist stuff *************************************************************************/ void PlaylistListNode( intf_thread_t *p_intf, playlist_t *p_pl, playlist_item_t *p_node, char *name, mvar_t *s, int i_depth ) { if( !p_node || !p_node->p_input ) return; if( p_node->i_children == -1 ) { char value[512]; char *psz; playlist_item_t * p_item = playlist_CurrentPlayingItem( p_pl ); if( !p_item || !p_item->p_input ) return; mvar_t *itm = mvar_New( name, "set" ); if( p_item->p_input == p_node->p_input ) mvar_AppendNewVar( itm, "current", "1" ); else mvar_AppendNewVar( itm, "current", "0" ); sprintf( value, "%d", p_node->i_id ); mvar_AppendNewVar( itm, "index", value ); psz = input_item_GetName( p_node->p_input ); mvar_AppendNewVar( itm, "name", psz ); free( psz ); psz = input_item_GetURI( p_node->p_input ); mvar_AppendNewVar( itm, "uri", psz ); free( psz ); mvar_AppendNewVar( itm, "type", "Item" ); sprintf( value, "%d", i_depth ); mvar_AppendNewVar( itm, "depth", value ); if( p_node->i_flags & PLAYLIST_RO_FLAG ) mvar_AppendNewVar( itm, "ro", "ro" ); else mvar_AppendNewVar( itm, "ro", "rw" ); sprintf( value, "%"PRId64, input_item_GetDuration( p_node->p_input ) ); mvar_AppendNewVar( itm, "duration", value ); //Adding extra meta-information to each playlist item psz = input_item_GetTitle( p_node->p_input ); mvar_AppendNewVar( itm, "title", psz ); free( psz ); psz = input_item_GetArtist( p_node->p_input ); mvar_AppendNewVar( itm, "artist", psz ); free( psz ); psz = input_item_GetGenre( p_node->p_input ); mvar_AppendNewVar( itm, "genre", psz ); free( psz ); psz = input_item_GetCopyright( p_node->p_input ); mvar_AppendNewVar( itm, "copyright", psz ); free( psz ); psz = input_item_GetAlbum( p_node->p_input ); mvar_AppendNewVar( itm, "album", psz ); free( psz ); psz = input_item_GetTrackNum( p_node->p_input ); mvar_AppendNewVar( itm, "track", psz ); free( psz ); psz = input_item_GetDescription( p_node->p_input ); mvar_AppendNewVar( itm, "description", psz ); free( psz ); psz = input_item_GetRating( p_node->p_input ); mvar_AppendNewVar( itm, "rating", psz ); free( psz ); psz = input_item_GetDate( p_node->p_input ); mvar_AppendNewVar( itm, "date", psz ); free( psz ); psz = input_item_GetURL( p_node->p_input ); mvar_AppendNewVar( itm, "url", psz ); free( psz ); psz = input_item_GetLanguage( p_node->p_input ); mvar_AppendNewVar( itm, "language", psz ); free( psz ); psz = input_item_GetNowPlaying( p_node->p_input ); mvar_AppendNewVar( itm, "now_playing", psz ); free( psz ); psz = input_item_GetPublisher( p_node->p_input ); mvar_AppendNewVar( itm, "publisher", psz ); free( psz ); psz = input_item_GetEncodedBy( p_node->p_input ); mvar_AppendNewVar( itm, "encoded_by", psz ); free( psz ); psz = input_item_GetArtURL( p_node->p_input ); mvar_AppendNewVar( itm, "art_url", psz ); free( psz ); psz = input_item_GetTrackID( p_node->p_input ); mvar_AppendNewVar( itm, "track_id", psz ); free( psz ); mvar_AppendVar( s, itm ); } else { char value[512]; int i_child; mvar_t *itm = mvar_New( name, "set" ); mvar_AppendNewVar( itm, "name", p_node->p_input->psz_name ); mvar_AppendNewVar( itm, "uri", p_node->p_input->psz_name ); mvar_AppendNewVar( itm, "type", "Node" ); sprintf( value, "%d", p_node->i_id ); mvar_AppendNewVar( itm, "index", value ); sprintf( value, "%d", p_node->i_children); mvar_AppendNewVar( itm, "i_children", value ); sprintf( value, "%d", i_depth ); mvar_AppendNewVar( itm, "depth", value ); if( p_node->i_flags & PLAYLIST_RO_FLAG ) mvar_AppendNewVar( itm, "ro", "ro" ); else mvar_AppendNewVar( itm, "ro", "rw" ); mvar_AppendVar( s, itm ); for( i_child = 0 ; i_child < p_node->i_children ; i_child++ ) PlaylistListNode( p_intf, p_pl, p_node->pp_children[i_child], name, s, i_depth + 1); } }
void EvaluateRPN( intf_thread_t *p_intf, mvar_t *vars, rpn_stack_t *st, char *exp ) { intf_sys_t *p_sys = p_intf->p_sys; while( exp != NULL && *exp != '\0' ) { char *p, *s; /* skip space */ while( *exp == ' ' ) { exp++; } if( *exp == '\'' ) { /* extract string */ p = FirstWord( exp, exp ); SSPush( st, exp ); exp = p; continue; } /* extract token */ p = FirstWord( exp, exp ); s = exp; if( p == NULL ) { exp += strlen( exp ); } else { exp = p; } if( *s == '\0' ) { break; } /* 1. Integer function */ if( !strcmp( s, "!" ) ) { SSPushN( st, ~SSPopN( st, vars ) ); } else if( !strcmp( s, "^" ) ) { SSPushN( st, SSPopN( st, vars ) ^ SSPopN( st, vars ) ); } else if( !strcmp( s, "&" ) ) { SSPushN( st, SSPopN( st, vars ) & SSPopN( st, vars ) ); } else if( !strcmp( s, "|" ) ) { SSPushN( st, SSPopN( st, vars ) | SSPopN( st, vars ) ); } else if( !strcmp( s, "+" ) ) { SSPushN( st, SSPopN( st, vars ) + SSPopN( st, vars ) ); } else if( !strcmp( s, "-" ) ) { int j = SSPopN( st, vars ); int i = SSPopN( st, vars ); SSPushN( st, i - j ); } else if( !strcmp( s, "*" ) ) { SSPushN( st, SSPopN( st, vars ) * SSPopN( st, vars ) ); } else if( !strcmp( s, "/" ) ) { int i, j; j = SSPopN( st, vars ); i = SSPopN( st, vars ); SSPushN( st, j != 0 ? i / j : 0 ); } else if( !strcmp( s, "%" ) ) { int i, j; j = SSPopN( st, vars ); i = SSPopN( st, vars ); SSPushN( st, j != 0 ? i % j : 0 ); } /* 2. integer tests */ else if( !strcmp( s, "=" ) ) { SSPushN( st, SSPopN( st, vars ) == SSPopN( st, vars ) ? -1 : 0 ); } else if( !strcmp( s, "!=" ) ) { SSPushN( st, SSPopN( st, vars ) != SSPopN( st, vars ) ? -1 : 0 ); } else if( !strcmp( s, "<" ) ) { int j = SSPopN( st, vars ); int i = SSPopN( st, vars ); SSPushN( st, i < j ? -1 : 0 ); } else if( !strcmp( s, ">" ) ) { int j = SSPopN( st, vars ); int i = SSPopN( st, vars ); SSPushN( st, i > j ? -1 : 0 ); } else if( !strcmp( s, "<=" ) ) { int j = SSPopN( st, vars ); int i = SSPopN( st, vars ); SSPushN( st, i <= j ? -1 : 0 ); } else if( !strcmp( s, ">=" ) ) { int j = SSPopN( st, vars ); int i = SSPopN( st, vars ); SSPushN( st, i >= j ? -1 : 0 ); } /* 3. string functions */ else if( !strcmp( s, "strcat" ) ) { char *s2 = SSPop( st ); char *s1 = SSPop( st ); char *str = malloc( strlen( s1 ) + strlen( s2 ) + 1 ); strcpy( str, s1 ); strcat( str, s2 ); SSPush( st, str ); free( s1 ); free( s2 ); free( str ); } else if( !strcmp( s, "strcmp" ) ) { char *s2 = SSPop( st ); char *s1 = SSPop( st ); SSPushN( st, strcmp( s1, s2 ) ); free( s1 ); free( s2 ); } else if( !strcmp( s, "strncmp" ) ) { int n = SSPopN( st, vars ); char *s2 = SSPop( st ); char *s1 = SSPop( st ); SSPushN( st, strncmp( s1, s2 , n ) ); free( s1 ); free( s2 ); } else if( !strcmp( s, "strsub" ) ) { int n = SSPopN( st, vars ); int m = SSPopN( st, vars ); int i_len; char *s = SSPop( st ); char *str; if( n >= m ) { i_len = n - m + 1; } else { i_len = 0; } str = malloc( i_len + 1 ); memcpy( str, s + m - 1, i_len ); str[ i_len ] = '\0'; SSPush( st, str ); free( s ); free( str ); } else if( !strcmp( s, "strlen" ) ) { char *str = SSPop( st ); SSPushN( st, strlen( str ) ); free( str ); } else if( !strcmp( s, "str_replace" ) ) { char *psz_to = SSPop( st ); char *psz_from = SSPop( st ); char *psz_in = SSPop( st ); char *psz_in_current = psz_in; char *psz_out = malloc( strlen(psz_in) * strlen(psz_to) + 1 ); char *psz_out_current = psz_out; while( (p = strstr( psz_in_current, psz_from )) != NULL ) { memcpy( psz_out_current, psz_in_current, p - psz_in_current ); psz_out_current += p - psz_in_current; strcpy( psz_out_current, psz_to ); psz_out_current += strlen(psz_to); psz_in_current = p + strlen(psz_from); } strcpy( psz_out_current, psz_in_current ); psz_out_current += strlen(psz_in_current); *psz_out_current = '\0'; SSPush( st, psz_out ); free( psz_to ); free( psz_from ); free( psz_in ); free( psz_out ); } else if( !strcmp( s, "url_extract" ) ) { const char *url = mvar_GetValue( vars, "url_value" ); char *name = SSPop( st ); char *value = ExtractURIString( url, name ); if( value != NULL ) { decode_URI( value ); SSPush( st, value ); free( value ); } else SSPush( st, "" ); free( name ); } else if( !strcmp( s, "url_encode" ) ) { char *url = SSPop( st ); char *value = vlc_UrlEncode( url ); free( url ); SSPush( st, value ); free( value ); } else if( !strcmp( s, "xml_encode" ) || !strcmp( s, "htmlspecialchars" ) ) { char *url = SSPop( st ); char *value = convert_xml_special_chars( url ); free( url ); SSPush( st, value ); free( value ); } else if( !strcmp( s, "addslashes" ) ) { char *psz_src = SSPop( st ); char *psz_dest; char *str = psz_src; p = psz_dest = malloc( strlen( str ) * 2 + 1 ); while( *str != '\0' ) { if( *str == '"' || *str == '\'' || *str == '\\' ) { *p++ = '\\'; } *p++ = *str; str++; } *p = '\0'; SSPush( st, psz_dest ); free( psz_src ); free( psz_dest ); } else if( !strcmp( s, "stripslashes" ) ) { char *psz_src = SSPop( st ); char *psz_dest; char *str = psz_src; p = psz_dest = strdup( psz_src ); while( *str ) { if( *str == '\\' && *(str + 1) ) { str++; } *p++ = *str++; } *p = '\0'; SSPush( st, psz_dest ); free( psz_src ); free( psz_dest ); } else if( !strcmp( s, "realpath" ) ) { char *psz_src = SSPop( st ); char *psz_dir = RealPath( psz_src ); SSPush( st, psz_dir ); free( psz_src ); free( psz_dir ); } /* 4. stack functions */ else if( !strcmp( s, "dup" ) ) { char *str = SSPop( st ); SSPush( st, str ); SSPush( st, str ); free( str ); } else if( !strcmp( s, "drop" ) ) { char *str = SSPop( st ); free( str ); } else if( !strcmp( s, "swap" ) ) { char *s1 = SSPop( st ); char *s2 = SSPop( st ); SSPush( st, s1 ); SSPush( st, s2 ); free( s1 ); free( s2 ); } else if( !strcmp( s, "flush" ) ) { SSClean( st ); SSInit( st ); } else if( !strcmp( s, "store" ) ) { char *value = SSPop( st ); char *name = SSPop( st ); mvar_PushNewVar( vars, name, value ); free( name ); free( value ); } else if( !strcmp( s, "value" ) ) { char *name = SSPop( st ); const char *value = mvar_GetValue( vars, name ); SSPush( st, value ); free( name ); } /* 5. player control */ else if( !strcmp( s, "vlc_play" ) ) { int i_id = SSPopN( st, vars ); int i_ret; playlist_Lock( p_sys->p_playlist ); i_ret = playlist_Control( p_sys->p_playlist, PLAYLIST_VIEWPLAY, pl_Locked, NULL, playlist_ItemGetById( p_sys->p_playlist, i_id ) ); playlist_Unlock( p_sys->p_playlist ); msg_Dbg( p_intf, "requested playlist item: %i", i_id ); SSPushN( st, i_ret ); } else if( !strcmp( s, "vlc_stop" ) ) { playlist_Control( p_sys->p_playlist, PLAYLIST_STOP, pl_Unlocked ); msg_Dbg( p_intf, "requested playlist stop" ); } else if( !strcmp( s, "vlc_pause" ) ) { playlist_Control( p_sys->p_playlist, PLAYLIST_PAUSE, pl_Unlocked ); msg_Dbg( p_intf, "requested playlist pause" ); } else if( !strcmp( s, "vlc_next" ) ) { playlist_Control( p_sys->p_playlist, PLAYLIST_SKIP, pl_Unlocked, 1 ); msg_Dbg( p_intf, "requested playlist next" ); } else if( !strcmp( s, "vlc_previous" ) ) { playlist_Control( p_sys->p_playlist, PLAYLIST_SKIP, pl_Unlocked, -1 ); msg_Dbg( p_intf, "requested playlist previous" ); } else if( !strcmp( s, "vlc_seek" ) ) { char *psz_value = SSPop( st ); HandleSeek( p_intf, psz_value ); msg_Dbg( p_intf, "requested playlist seek: %s", psz_value ); free( psz_value ); } else if( !strcmp( s, "vlc_var_type" ) || !strcmp( s, "vlc_config_type" ) ) { vlc_object_t *p_object; const char *psz_type = NULL; int i_type = 0; if( !strcmp( s, "vlc_var_type" ) ) { char *psz_object = SSPop( st ); char *psz_variable = SSPop( st ); bool b_need_release; p_object = GetVLCObject( p_intf, psz_object, &b_need_release ); if( p_object != NULL ) i_type = var_Type( p_object, psz_variable ); free( psz_variable ); free( psz_object ); if( b_need_release && p_object != NULL ) vlc_object_release( p_object ); } else { char *psz_variable = SSPop( st ); p_object = VLC_OBJECT(p_intf); i_type = config_GetType( p_object, psz_variable ); free( psz_variable ); } if( p_object != NULL ) { switch( i_type & VLC_VAR_TYPE ) { case VLC_VAR_BOOL: psz_type = "VLC_VAR_BOOL"; break; case VLC_VAR_INTEGER: psz_type = "VLC_VAR_INTEGER"; break; case VLC_VAR_HOTKEY: psz_type = "VLC_VAR_HOTKEY"; break; case VLC_VAR_STRING: psz_type = "VLC_VAR_STRING"; break; case VLC_VAR_MODULE: psz_type = "VLC_VAR_MODULE"; break; case VLC_VAR_FILE: psz_type = "VLC_VAR_FILE"; break; case VLC_VAR_DIRECTORY: psz_type = "VLC_VAR_DIRECTORY"; break; case VLC_VAR_VARIABLE: psz_type = "VLC_VAR_VARIABLE"; break; case VLC_VAR_FLOAT: psz_type = "VLC_VAR_FLOAT"; break; default: psz_type = "UNDEFINED"; } } else psz_type = "INVALID"; SSPush( st, psz_type ); } else if( !strcmp( s, "vlc_var_set" ) ) { char *psz_object = SSPop( st ); char *psz_variable = SSPop( st ); bool b_need_release; vlc_object_t *p_object = GetVLCObject( p_intf, psz_object, &b_need_release ); if( p_object != NULL ) { bool b_error = false; char *psz_value = NULL; vlc_value_t val; int i_type; i_type = var_Type( p_object, psz_variable ); switch( i_type & VLC_VAR_TYPE ) { case VLC_VAR_BOOL: val.b_bool = SSPopN( st, vars ); msg_Dbg( p_intf, "requested %s var change: %s->%d", psz_object, psz_variable, val.b_bool ); break; case VLC_VAR_INTEGER: case VLC_VAR_HOTKEY: val.i_int = SSPopN( st, vars ); msg_Dbg( p_intf, "requested %s var change: %s->%d", psz_object, psz_variable, val.i_int ); break; case VLC_VAR_STRING: case VLC_VAR_MODULE: case VLC_VAR_FILE: case VLC_VAR_DIRECTORY: case VLC_VAR_VARIABLE: val.psz_string = psz_value = SSPop( st ); msg_Dbg( p_intf, "requested %s var change: %s->%s", psz_object, psz_variable, psz_value ); break; case VLC_VAR_FLOAT: psz_value = SSPop( st ); val.f_float = atof( psz_value ); msg_Dbg( p_intf, "requested %s var change: %s->%f", psz_object, psz_variable, val.f_float ); break; default: SSPopN( st, vars ); msg_Warn( p_intf, "invalid %s variable type %d (%s)", psz_object, i_type & VLC_VAR_TYPE, psz_variable ); b_error = true; } if( !b_error ) var_Set( p_object, psz_variable, val ); if( psz_value != NULL ) free( psz_value ); } else msg_Warn( p_intf, "vlc_var_set called without an object" ); free( psz_variable ); free( psz_object ); if( b_need_release && p_object != NULL ) vlc_object_release( p_object ); } else if( !strcmp( s, "vlc_var_get" ) ) { char *psz_object = SSPop( st ); char *psz_variable = SSPop( st ); bool b_need_release; vlc_object_t *p_object = GetVLCObject( p_intf, psz_object, &b_need_release ); if( p_object != NULL ) { vlc_value_t val; int i_type; i_type = var_Type( p_object, psz_variable ); var_Get( p_object, psz_variable, &val ); switch( i_type & VLC_VAR_TYPE ) { case VLC_VAR_BOOL: SSPushN( st, val.b_bool ); break; case VLC_VAR_INTEGER: case VLC_VAR_HOTKEY: SSPushN( st, val.i_int ); break; case VLC_VAR_STRING: case VLC_VAR_MODULE: case VLC_VAR_FILE: case VLC_VAR_DIRECTORY: case VLC_VAR_VARIABLE: SSPush( st, val.psz_string ); free( val.psz_string ); break; case VLC_VAR_FLOAT: { char psz_value[20]; lldiv_t value = lldiv( val.f_float * 1000000, 1000000 ); snprintf( psz_value, sizeof(psz_value), "%lld.%06u", value.quot, (unsigned int)value.rem ); SSPush( st, psz_value ); break; } default: msg_Warn( p_intf, "invalid %s variable type %d (%s)", psz_object, i_type & VLC_VAR_TYPE, psz_variable ); SSPush( st, "" ); } } else { msg_Warn( p_intf, "vlc_var_get called without an object" ); SSPush( st, "" ); } free( psz_variable ); free( psz_object ); if( b_need_release && p_object != NULL ) vlc_object_release( p_object ); } else if( !strcmp( s, "vlc_object_exists" ) ) { char *psz_object = SSPop( st ); bool b_need_release; vlc_object_t *p_object = GetVLCObject( p_intf, psz_object, &b_need_release ); if( b_need_release && p_object != NULL ) vlc_object_release( p_object ); if( p_object != NULL ) SSPush( st, "1" ); else SSPush( st, "0" ); } else if( !strcmp( s, "vlc_config_set" ) ) { char *psz_variable = SSPop( st ); int i_type = config_GetType( p_intf, psz_variable ); switch( i_type & VLC_VAR_TYPE ) { case VLC_VAR_BOOL: case VLC_VAR_INTEGER: config_PutInt( p_intf, psz_variable, SSPopN( st, vars ) ); break; case VLC_VAR_STRING: case VLC_VAR_MODULE: case VLC_VAR_FILE: case VLC_VAR_DIRECTORY: { char *psz_string = SSPop( st ); config_PutPsz( p_intf, psz_variable, psz_string ); free( psz_string ); break; } case VLC_VAR_FLOAT: { char *psz_string = SSPop( st ); config_PutFloat( p_intf, psz_variable, atof(psz_string) ); free( psz_string ); break; } default: msg_Warn( p_intf, "vlc_config_set called on unknown var (%s)", psz_variable ); } free( psz_variable ); } else if( !strcmp( s, "vlc_config_get" ) ) { char *psz_variable = SSPop( st ); int i_type = config_GetType( p_intf, psz_variable ); switch( i_type & VLC_VAR_TYPE ) { case VLC_VAR_BOOL: case VLC_VAR_INTEGER: SSPushN( st, config_GetInt( p_intf, psz_variable ) ); break; case VLC_VAR_STRING: case VLC_VAR_MODULE: case VLC_VAR_FILE: case VLC_VAR_DIRECTORY: { char *psz_string = config_GetPsz( p_intf, psz_variable ); SSPush( st, psz_string ); free( psz_string ); break; } case VLC_VAR_FLOAT: { char psz_string[20]; lldiv_t value = lldiv( config_GetFloat( p_intf, psz_variable ) * 1000000, 1000000 ); snprintf( psz_string, sizeof(psz_string), "%lld.%06u", value.quot, (unsigned int)value.rem ); SSPush( st, psz_string ); break; } default: msg_Warn( p_intf, "vlc_config_get called on unknown var (%s)", psz_variable ); SSPush( st, "" ); } free( psz_variable ); } else if( !strcmp( s, "vlc_config_save" ) ) { char *psz_module = SSPop( st ); int i_result; if( !*psz_module ) { free( psz_module ); psz_module = NULL; } i_result = config_SaveConfigFile( p_intf, psz_module ); if( psz_module != NULL ) free( psz_module ); SSPushN( st, i_result ); } else if( !strcmp( s, "vlc_config_reset" ) ) { config_ResetAll( p_intf ); } /* 6. playlist functions */ else if( !strcmp( s, "playlist_add" ) ) { char *psz_name = SSPop( st ); char *mrl = SSPop( st ); input_item_t *p_input; int i_ret; p_input = MRLParse( p_intf, mrl, psz_name ); char *psz_uri = input_item_GetURI( p_input ); if( !p_input || !psz_uri || !*psz_uri ) { i_ret = VLC_EGENERIC; msg_Dbg( p_intf, "invalid requested mrl: %s", mrl ); } else { i_ret = playlist_AddInput( p_sys->p_playlist, p_input, PLAYLIST_APPEND, PLAYLIST_END, true, pl_Unlocked ); if( i_ret == VLC_SUCCESS ) { playlist_item_t *p_item; msg_Dbg( p_intf, "requested mrl add: %s", mrl ); playlist_Lock( p_sys->p_playlist ); p_item = playlist_ItemGetByInput( p_sys->p_playlist, p_input ); if( p_item ) i_ret = p_item->i_id; playlist_Unlock( p_sys->p_playlist ); } else msg_Warn( p_intf, "adding mrl %s failed", mrl ); vlc_gc_decref( p_input ); } free( psz_uri ); SSPushN( st, i_ret ); free( mrl ); free( psz_name ); } else if( !strcmp( s, "playlist_empty" ) ) { playlist_Clear( p_sys->p_playlist, pl_Unlocked ); msg_Dbg( p_intf, "requested playlist empty" ); } else if( !strcmp( s, "playlist_delete" ) ) { int i_id = SSPopN( st, vars ); playlist_Lock( p_sys->p_playlist ); playlist_item_t *p_item = playlist_ItemGetById( p_sys->p_playlist, i_id ); if( p_item ) { playlist_DeleteFromInput( p_sys->p_playlist, p_item->p_input, pl_Locked ); msg_Dbg( p_intf, "requested playlist delete: %d", i_id ); } else { msg_Dbg( p_intf, "couldn't find playlist item to delete (%d)", i_id ); } playlist_Unlock( p_sys->p_playlist ); } else if( !strcmp( s, "playlist_move" ) ) { /*int i_newpos =*/ SSPopN( st, vars ); /*int i_pos =*/ SSPopN( st, vars ); /* FIXME FIXME TODO TODO XXX XXX do not release before fixing this if ( i_pos < i_newpos ) { playlist_Move( p_sys->p_playlist, i_pos, i_newpos + 1 ); } else { playlist_Move( p_sys->p_playlist, i_pos, i_newpos ); } msg_Dbg( p_intf, "requested to move playlist item %d to %d", i_pos, i_newpos); FIXME FIXME TODO TODO XXX XXX */ msg_Err( p_intf, "moving using indexes is obsolete. We need to update this function" ); } else if( !strcmp( s, "playlist_sort" ) ) { int i_order = SSPopN( st, vars ); int i_sort = SSPopN( st, vars ); i_order = i_order % 2; i_sort = i_sort % 9; /* FIXME FIXME TODO TODO XXX XXX do not release before fixing this playlist_RecursiveNodeSort( p_sys->p_playlist, p_sys->p_playlist->p_general, i_sort, i_order ); msg_Dbg( p_intf, "requested sort playlist by : %d in order : %d", i_sort, i_order ); FIXME FIXME TODO TODO XXX XXX */ msg_Err( p_intf, "this needs to be fixed to use the new playlist framework" ); } else if( !strcmp( s, "services_discovery_add" ) ) { char *psz_sd = SSPop( st ); playlist_ServicesDiscoveryAdd( p_sys->p_playlist, psz_sd ); free( psz_sd ); } else if( !strcmp( s, "services_discovery_remove" ) ) { char *psz_sd = SSPop( st ); playlist_ServicesDiscoveryRemove( p_sys->p_playlist, psz_sd ); free( psz_sd ); } else if( !strcmp( s, "services_discovery_is_loaded" ) ) { char *psz_sd = SSPop( st ); SSPushN( st, playlist_IsServicesDiscoveryLoaded( p_sys->p_playlist, psz_sd ) ); free( psz_sd ); } else if( !strcmp( s, "vlc_volume_set" ) ) { char *psz_vol = SSPop( st ); int i_value; audio_volume_t i_volume; aout_VolumeGet( p_intf, &i_volume ); if( psz_vol[0] == '+' ) { i_value = atoi( psz_vol ); if( (i_volume + i_value) > AOUT_VOLUME_MAX ) aout_VolumeSet( p_intf, AOUT_VOLUME_MAX ); else aout_VolumeSet( p_intf, i_volume + i_value ); } else if( psz_vol[0] == '-' ) { i_value = atoi( psz_vol ); if( (i_volume + i_value) < AOUT_VOLUME_MIN ) aout_VolumeSet( p_intf, AOUT_VOLUME_MIN ); else aout_VolumeSet( p_intf, i_volume + i_value ); } else if( strstr( psz_vol, "%") != NULL ) { i_value = atoi( psz_vol ); if( i_value < 0 ) i_value = 0; if( i_value > 400 ) i_value = 400; aout_VolumeSet( p_intf, (i_value * (AOUT_VOLUME_MAX - AOUT_VOLUME_MIN))/400+AOUT_VOLUME_MIN); } else { i_value = atoi( psz_vol ); if( i_value > AOUT_VOLUME_MAX ) i_value = AOUT_VOLUME_MAX; if( i_value < AOUT_VOLUME_MIN ) i_value = AOUT_VOLUME_MIN; aout_VolumeSet( p_intf, i_value ); } aout_VolumeGet( p_intf, &i_volume ); free( psz_vol ); } else if( !strcmp( s, "vlc_get_meta" ) ) { char *psz_meta = SSPop( st ); char *psz_val = NULL; if( p_sys->p_input && input_GetItem(p_sys->p_input) ) { #define p_item input_GetItem( p_sys->p_input ) if( !strcmp( psz_meta, "ARTIST" ) ) { psz_val = input_item_GetArtist( p_item ); } else if( !strcmp( psz_meta, "TITLE" ) ) { psz_val = input_item_GetTitle( p_item ); if( !psz_val ) psz_val = input_item_GetName( p_item ); } else if( !strcmp( psz_meta, "ALBUM" ) ) { psz_val = input_item_GetAlbum( p_item ); } else if( !strcmp( psz_meta, "GENRE" ) ) { psz_val = input_item_GetGenre( p_item ); } else if( !strcmp( psz_meta, "COPYRIGHT" ) ) { psz_val = input_item_GetCopyright( p_item ); } else if( !strcmp( psz_meta, "TRACK_NUMBER" ) ) { psz_val = input_item_GetTrackNum( p_item ); } else if( !strcmp( psz_meta, "DESCRIPTION" ) ) { psz_val = input_item_GetDescription( p_item ); } else if( !strcmp( psz_meta, "RATING" ) ) { psz_val = input_item_GetRating( p_item ); } else if( !strcmp( psz_meta, "DATE" ) ) { psz_val = input_item_GetDate( p_item ); } else if( !strcmp( psz_meta, "URL" ) ) { psz_val = input_item_GetURL( p_item ); } else if( !strcmp( psz_meta, "LANGUAGE" ) ) { psz_val = input_item_GetLanguage( p_item ); } else if( !strcmp( psz_meta, "NOW_PLAYING" ) ) { psz_val = input_item_GetNowPlaying( p_item ); } else if( !strcmp( psz_meta, "PUBLISHER" ) ) { psz_val = input_item_GetPublisher( p_item ); } else if( !strcmp( psz_meta, "ENCODED_BY" ) ) { psz_val = input_item_GetEncodedBy( p_item ); } else if( !strcmp( psz_meta, "ART_URL" ) ) { psz_val = input_item_GetEncodedBy( p_item ); } else if( !strcmp( psz_meta, "TRACK_ID" ) ) { psz_val = input_item_GetTrackID( p_item ); } #undef p_item } if( psz_val == NULL ) psz_val = strdup( "" ); SSPush( st, psz_val ); free( psz_meta ); free( psz_val ); } #ifdef ENABLE_VLM else if( !strcmp( s, "vlm_command" ) || !strcmp( s, "vlm_cmd" ) ) { char *psz_elt; char *psz_cmd = strdup( "" ); char *psz_error; vlm_message_t *vlm_answer; /* make sure that we have a vlm object */ if( p_intf->p_sys->p_vlm == NULL ) p_intf->p_sys->p_vlm = vlm_New( p_intf ); /* vlm command uses the ';' delimiter * (else we can't know when to stop) */ while( strcmp( psz_elt = SSPop( st ), "" ) && strcmp( psz_elt, ";" ) ) { char* psz_buf; if( asprintf( &psz_buf, "%s %s", psz_cmd, psz_elt ) == -1 ) psz_buf = NULL; free( psz_cmd ); free( psz_elt ); psz_cmd = psz_buf; } msg_Dbg( p_intf, "executing vlm command: %s", psz_cmd ); vlm_ExecuteCommand( p_intf->p_sys->p_vlm, psz_cmd, &vlm_answer ); if( vlm_answer->psz_value == NULL ) { psz_error = strdup( "" ); } else { if( asprintf( &psz_error , "%s : %s" , vlm_answer->psz_name, vlm_answer->psz_value ) == -1 ) psz_error = NULL; } mvar_AppendNewVar( vars, "vlm_error", psz_error ); /* this is kind of a duplicate but we need to have the message * without the command name for the "export" command */ mvar_AppendNewVar( vars, "vlm_value", vlm_answer->psz_value ); vlm_MessageDelete( vlm_answer ); free( psz_cmd ); free( psz_error ); } #endif /* ENABLE_VLM */ else if( !strcmp( s, "snapshot" ) ) { if( p_sys->p_input ) { vout_thread_t *p_vout = input_GetVout( p_sys->p_input ); if( p_vout ) { var_TriggerCallback( p_vout, "video-snapshot" ); vlc_object_release( p_vout ); msg_Dbg( p_intf, "requested snapshot" ); } } break; } else { SSPush( st, s ); } } }