static void DestroySource (void *data)
{
struct device *d = data;
services_discovery_RemoveItem (d->sd, d->item);
input_item_Release (d->item);
free (d);
}
static void DestroySource (void *data)
{
struct device *d = data;
services_discovery_RemoveItem (d->sd, d->item);
vlc_gc_decref (d->item);
free (d);
}
static void DelApp (void *data)
{
struct app *app = data;
services_discovery_RemoveItem (app->owner, app->item);
input_item_Release (app->item);
free (app);
}
static void ParseRequest( services_discovery_t *p_sd )
{
services_discovery_sys_t *p_sys = p_sd->p_sys;
char *psz_request = p_sys->psz_request;
int i;
char *psz_tok = strchr( psz_request, ':' );
if( !psz_tok ) return;
*psz_tok = '\0';
if( !strcmp( psz_request, "ADD" ) )
{
psz_request = psz_tok + 1;
for( i = 0; i<p_sys->i_urls; i++ )
if( !strcmp(p_sys->ppsz_urls[i],psz_request) )
break;
if( i == p_sys->i_urls )
{
INSERT_ELEM( p_sys->ppsz_urls, p_sys->i_urls, p_sys->i_urls,
strdup( psz_request ) );
input_item_t *p_input;
p_input = input_item_New( p_sd, psz_request, psz_request );
input_item_AddOption( p_input, "demux=podcast", VLC_INPUT_OPTION_TRUSTED );
INSERT_ELEM( p_sys->pp_items, p_sys->i_items, p_sys->i_items, p_input );
services_discovery_AddItem( p_sd, p_input, NULL /* no cat */ );
INSERT_ELEM( p_sys->pp_input, p_sys->i_input, p_sys->i_input,
input_CreateAndStart( p_sd, p_input, NULL ) );
SaveUrls( p_sd );
}
}
else if ( !strcmp( psz_request, "RM" ) )
{
psz_request = psz_tok + 1;
for( i = 0; i<p_sys->i_urls; i++ )
if( !strcmp(p_sys->ppsz_urls[i],psz_request) )
break;
if( i != p_sys->i_urls )
{
services_discovery_RemoveItem( p_sd, p_sys->pp_items[i] );
vlc_gc_decref( p_sys->pp_items[i] );
REMOVE_ELEM( p_sys->ppsz_urls, p_sys->i_urls, i );
REMOVE_ELEM( p_sys->pp_items, p_sys->i_items, i );
}
SaveUrls( p_sd );
}
free( p_sys->psz_request );
p_sys->psz_request = NULL;
}
static int vlclua_sd_remove_item( lua_State *L )
{
services_discovery_t *p_sd = (services_discovery_t *)vlclua_get_this( L );
if( !lua_isnil( L, 1 ) )
{
input_item_t **pp_input = luaL_checkudata( L, 1, "input_item_t" );
if( *pp_input )
services_discovery_RemoveItem( p_sd, *pp_input );
/* Make sure we won't try to remove it again */
*pp_input = NULL;
}
return 1;
}
static void CloseDevice( services_discovery_t *p_sd )
{
input_item_t **pp_items = p_sd->p_sys->pp_items;
if( pp_items != NULL )
{
for( int i_i = 0; i_i < p_sd->p_sys->i_count; i_i++ )
{
if( pp_items[i_i] != NULL )
{
services_discovery_RemoveItem( p_sd, pp_items[i_i] );
vlc_gc_decref( pp_items[i_i] );
}
}
free( pp_items );
}
}
void MediaServerList::removeServer( const std::string& udn )
{
MediaServerDesc* p_server = getServer( udn );
if ( !p_server )
return;
msg_Dbg( m_sd, "Removing server '%s'", p_server->friendlyName.c_str() );
assert(p_server->inputItem);
services_discovery_RemoveItem( m_sd, p_server->inputItem );
std::vector<MediaServerDesc*>::iterator it = std::find(m_list.begin(), m_list.end(), p_server);
if (it != m_list.end())
{
m_list.erase( it );
}
delete p_server;
}
/*****************************************************************************
* browser_callback
*****************************************************************************/
static void browse_callback(
AvahiServiceBrowser *b,
AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiBrowserEvent event,
const char *name,
const char *type,
const char *domain,
AvahiLookupResultFlags flags,
void* userdata )
{
VLC_UNUSED(b);
VLC_UNUSED(flags);
services_discovery_t *p_sd = ( services_discovery_t* )userdata;
services_discovery_sys_t *p_sys = p_sd->p_sys;
if( event == AVAHI_BROWSER_NEW )
{
if( avahi_service_resolver_new( p_sys->client, interface, protocol,
name, type, domain, AVAHI_PROTO_UNSPEC,
0,
resolve_callback, userdata ) == NULL )
{
msg_Err( p_sd, "failed to resolve service '%s': %s", name,
avahi_strerror( avahi_client_errno( p_sys->client ) ) );
}
}
else if( name )
{
/** \todo Store the input id and search it, rather than searching the items */
input_item_t *p_item;
p_item = vlc_dictionary_value_for_key(
&p_sys->services_name_to_input_item,
name );
if( !p_item )
msg_Err( p_sd, "failed to find service '%s' in playlist", name );
else
{
services_discovery_RemoveItem( p_sd, p_item );
vlc_dictionary_remove_value_for_key(
&p_sys->services_name_to_input_item,
name, NULL, NULL );
}
}
}
void MediaServer::fetchContents()
{
/* Delete previous contents to prevent duplicate entries */
if ( _p_contents )
{
delete _p_contents;
services_discovery_RemoveItem( _p_sd, _p_input_item );
services_discovery_AddItem( _p_sd, _p_input_item, NULL );
}
Container* root = new Container( 0, "0", getFriendlyName() );
_fetchContents( root );
_p_contents = root;
_p_contents->setInputItem( _p_input_item );
_buildPlaylist( _p_contents, NULL );
}
void MediaServerList::removeServer( const char* psz_udn )
{
MediaServer* p_server = getServer( psz_udn );
if ( !p_server ) return;
msg_Dbg( _p_sd, "Removing server '%s'", p_server->getFriendlyName() );
services_discovery_RemoveItem( _p_sd, p_server->getInputItem() );
std::vector<MediaServer*>::iterator it;
for ( it = _list.begin(); it != _list.end(); ++it )
{
if ( *it == p_server )
{
_list.erase( it );
delete p_server;
break;
}
}
}
void MediaServerList::removeServer( const std::string& udn )
{
vlc_mutex_locker lock( &lock_ );
MediaServerDesc* p_server = getServer( udn );
if ( !p_server )
return;
msg_Dbg( p_sd_, "Removing server '%s'", p_server->friendlyName.c_str() );
assert(p_server->inputItem);
services_discovery_RemoveItem( p_sd_, p_server->inputItem );
std::vector<MediaServerDesc*>::iterator it = std::find(list_.begin(), list_.end(), p_server);
if (it != list_.end())
{
list_.erase( it );
}
delete p_server;
}
static void entry_item_remove( services_discovery_t *p_sd,
netbios_ns_entry *p_entry )
{
services_discovery_sys_t *p_sys = p_sd->p_sys;
for ( int i = 0; i < vlc_array_count( p_sys->p_entry_item_list ); i++ )
{
struct entry_item *p_entry_item;
p_entry_item = vlc_array_item_at_index( p_sys->p_entry_item_list, i );
if( p_entry_item->p_entry == p_entry )
{
services_discovery_RemoveItem( p_sd, p_entry_item->p_item );
vlc_gc_decref( p_entry_item->p_item );
vlc_array_remove( p_sys->p_entry_item_list, i );
free( p_entry_item );
break;
}
}
}
static void ParseUrls( services_discovery_t *p_sd, char *psz_urls )
{
services_discovery_sys_t *p_sys = p_sd->p_sys;
int i_new_items = 0;
input_item_t **pp_new_items = NULL;
int i_new_urls = 0;
char **ppsz_new_urls = NULL;
int i, j;
for( ;; )
{
if( !psz_urls ) break;
char *psz_tok = strchr( psz_urls, '|' );
if( psz_tok ) *psz_tok = '\0';
for( i = 0; i < p_sys->i_urls; i++ )
if( !strcmp( psz_urls, p_sys->ppsz_urls[i] ) )
break;
if( i == p_sys->i_urls )
{
INSERT_ELEM( ppsz_new_urls, i_new_urls, i_new_urls,
strdup( psz_urls ) );
input_item_t *p_input;
p_input = input_item_New( p_sd, psz_urls, psz_urls );
input_item_AddOption( p_input, "demux=podcast", VLC_INPUT_OPTION_TRUSTED );
INSERT_ELEM( pp_new_items, i_new_items, i_new_items, p_input );
services_discovery_AddItem( p_sd, p_input, NULL /* no cat */ );
INSERT_ELEM( p_sys->pp_input, p_sys->i_input, p_sys->i_input,
input_CreateAndStart( p_sd, p_input, NULL ) );
}
else
{
INSERT_ELEM( ppsz_new_urls, i_new_urls, i_new_urls,
strdup( p_sys->ppsz_urls[i]) );
INSERT_ELEM( pp_new_items, i_new_items, i_new_items, p_sys->pp_items[i] );
}
if( psz_tok ) psz_urls = psz_tok+1;
else break;
}
/* delete removed items and signal the removal */
for( i = 0; i<p_sys->i_items; ++i )
{
for( j = 0; j < i_new_items; ++j )
if( pp_new_items[j] == p_sys->pp_items[i] ) break;
if( j == i_new_items )
{
services_discovery_RemoveItem( p_sd, p_sys->pp_items[i] );
vlc_gc_decref( p_sys->pp_items[i] );
}
}
free( p_sys->pp_items );
for( int i = 0; i < p_sys->i_urls; i++ ) free( p_sys->ppsz_urls[i] );
free( p_sys->ppsz_urls );
p_sys->ppsz_urls = ppsz_new_urls;
p_sys->i_urls = i_new_urls;
p_sys->pp_items = pp_new_items;
p_sys->i_items = i_new_items;
}