static int onNewFileAdded( vlc_object_t *p_this, char const *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
(void)p_this;
services_discovery_t *p_sd = p_data;
services_discovery_sys_t *p_sys = p_sd->p_sys;
(void)psz_var; (void)oldval;
char* psz_file = newval.psz_string;
if( !psz_file || !*psz_file )
return VLC_EGENERIC;
char* psz_uri = make_URI( psz_file, "file" );
input_item_t* p_item = input_item_New( psz_uri, NULL );
if( p_sys->i_type == Picture )
{
if( fileType( p_sd, psz_file ) == Picture )
{
formatSnapshotItem( p_item );
services_discovery_AddItem( p_sd, p_item, NULL );
msg_Dbg( p_sd, "New snapshot added : %s", psz_file );
}
}
else if( p_sys->i_type == Audio )
{
if( fileType( p_sd, psz_file ) == Audio )
{
services_discovery_AddItem( p_sd, p_item, NULL );
msg_Dbg( p_sd, "New recorded audio added : %s", psz_file );
}
}
else if( p_sys->i_type == Video )
{
if( fileType( p_sd, psz_file ) == Video ||
fileType( p_sd, psz_file ) == Unknown )
{
services_discovery_AddItem( p_sd, p_item, NULL );
msg_Dbg( p_sd, "New recorded video added : %s", psz_file );
}
}
vlc_gc_decref( p_item );
free( psz_uri );
return VLC_SUCCESS;
}
static int vlclua_sd_add_node( lua_State *L )
{
services_discovery_t *p_sd = (services_discovery_t *)vlclua_get_this( L );
if( lua_istable( L, -1 ) )
{
lua_getfield( L, -1, "title" );
if( lua_isstring( L, -1 ) )
{
const char *psz_name = lua_tostring( L, -1 );
input_item_t *p_input = input_item_NewWithType( "vlc://nop",
psz_name, 0, NULL, 0,
-1, ITEM_TYPE_NODE );
lua_pop( L, 1 );
if( p_input )
{
lua_getfield( L, -1, "arturl" );
if( lua_isstring( L, -1 ) && strcmp( lua_tostring( L, -1 ), "" ) )
{
char *psz_value = strdup( lua_tostring( L, -1 ) );
EnsureUTF8( psz_value );
msg_Dbg( p_sd, "ArtURL: %s", psz_value );
/** @todo Ask for art download if not local file */
input_item_SetArtURL( p_input, psz_value );
free( psz_value );
}
lua_pop( L, 1 );
lua_getfield( L, -1, "category" );
if( lua_isstring( L, -1 ) )
services_discovery_AddItem( p_sd, p_input, luaL_checkstring( L, -1 ) );
else
services_discovery_AddItem( p_sd, p_input, NULL );
input_item_t **udata = (input_item_t **)
lua_newuserdata( L, sizeof( input_item_t * ) );
*udata = p_input;
if( luaL_newmetatable( L, "node" ) )
{
lua_newtable( L );
luaL_register( L, NULL, vlclua_node_reg );
lua_setfield( L, -2, "__index" );
}
lua_setmetatable( L, -2 );
}
}
else
msg_Err( p_sd, "vlc.sd.add_node: the \"title\" parameter can't be empty" );
}
else
msg_Err( p_sd, "Error parsing add_node arguments" );
return 1;
}
/*****************************************************************************
* ItemAdded:
*****************************************************************************/
static void ItemAdded( const vlc_event_t * p_event, void * user_data )
{
struct shout_category_t * params = user_data;
services_discovery_AddItem( params->p_sd,
p_event->u.input_item_subitem_added.p_new_child,
params->psz_category );
}
/*****************************************************************************
* Run:
*****************************************************************************/
static void *Run( void *data )
{
services_discovery_t *p_sd = data;
services_discovery_sys_t *p_sys = p_sd->p_sys;
enum type_e i_type = p_sys->i_type;
int i, j;
int canc = vlc_savecancel();
if( !p_items[i_type].p_children )
{
AddSubitemsOfShoutItemURL( p_sd, &p_items[i_type], NULL );
vlc_restorecancel(canc);
return NULL;
}
for( i = 0; p_items[i_type].p_children[i].psz_name; i++ )
{
const struct shout_item_t * p_subitem = &p_items[i_type].p_children[i];
if( !p_subitem->p_children )
{
AddSubitemsOfShoutItemURL( p_sd, p_subitem, p_subitem->psz_name );
continue;
}
for( j = 0; p_subitem->p_children[j].psz_name; j++ )
{
input_item_t *p_input = CreateInputItemFromShoutItem( p_sd, &p_subitem->p_children[j] );
services_discovery_AddItem( p_sd,
p_input,
p_subitem->psz_name );
vlc_gc_decref( p_input );
}
}
vlc_restorecancel(canc);
return NULL;
}
/**
* Probes and initializes.
*/
static int Open (vlc_object_t *obj)
{
services_discovery_t *sd = (services_discovery_t *)obj;
LONG drives = GetLogicalDrives ();
char mrl[12] = "file:///A:/", name[3] = "A:";
TCHAR path[4] = "A:\\";
for (char d = 0; d < 26; d++)
{
input_item_t *item;
char letter = 'A' + d;
/* Does this drive actually exist? */
if (!(drives & (1 << d)))
continue;
/* Is it a disc drive? */
path[0] = letter;
if (GetDriveType (path) != DRIVE_CDROM)
continue;
mrl[8] = name[0] = letter;
item = input_item_NewWithType (VLC_OBJECT (sd), mrl, name,
0, NULL, 0, -1, ITEM_TYPE_DISC);
msg_Dbg (sd, "adding %s (%s)", mrl, name);
if (item == NULL)
break;
services_discovery_AddItem (sd, item, _("Local drives"));
}
return VLC_SUCCESS;
}
/*****************************************************************************
* ItemAdded:
*****************************************************************************/
static void ItemAdded( const vlc_event_t * p_event, void * user_data )
{
struct shout_category_t * params = user_data;
const struct shout_item_t * p_parent = params->p_parent;
input_item_t * p_input = p_event->u.input_item_subitem_added.p_new_child;
for(int i = 0; p_parent->ppsz_options[i] != NULL; i++)
input_item_AddOption( p_input, p_parent->ppsz_options[i], VLC_INPUT_OPTION_TRUSTED);
services_discovery_AddItem( params->p_sd, p_input, params->psz_category );
}
/*** Whole desktop ***/
static void AddDesktop(services_discovery_t *sd)
{
input_item_t *item;
item = input_item_NewCard ("screen://", _("Desktop"));
if (item == NULL)
return;
services_discovery_AddItem(sd, item);
input_item_Release (item);
}
static int vlclua_sd_add_item( lua_State *L )
{
services_discovery_t *p_sd = (services_discovery_t *)vlclua_get_this( L );
if( lua_istable( L, -1 ) )
{
lua_getfield( L, -1, "path" );
if( lua_isstring( L, -1 ) )
{
char **ppsz_options = NULL;
int i_options = 0;
const char *psz_path = lua_tostring( L, -1 );
vlclua_read_options( p_sd, L, &i_options, &ppsz_options );
input_item_t *p_input = input_item_NewExt( p_sd, psz_path, psz_path,
i_options,
(const char **)ppsz_options,
VLC_INPUT_OPTION_TRUSTED, -1 );
lua_pop( L, 1 );
if( p_input )
{
vlclua_read_meta_data( p_sd, L, p_input );
/* This one is to be tested... */
vlclua_read_custom_meta_data( p_sd, L, p_input );
/* The duration is given in seconds, convert to microseconds */
lua_getfield( L, -1, "duration" );
if( lua_isnumber( L, -1 ) )
input_item_SetDuration( p_input, (lua_tonumber( L, -1 )*1e6) );
else if( !lua_isnil( L, -1 ) )
msg_Warn( p_sd, "Item duration should be a number (in seconds)." );
lua_pop( L, 1 );
services_discovery_AddItem( p_sd, p_input, NULL );
input_item_t **udata = (input_item_t **)
lua_newuserdata( L, sizeof( input_item_t * ) );
*udata = p_input;
if( luaL_newmetatable( L, "input_item_t" ) )
{
lua_pushliteral( L, "none of your business" );
lua_setfield( L, -2, "__metatable" );
}
lua_setmetatable( L, -2 );
vlc_gc_decref( p_input );
}
while( i_options > 0 )
free( ppsz_options[--i_options] );
free( ppsz_options );
}
else
msg_Err( p_sd, "vlc.sd.add_item: the \"path\" parameter can't be empty" );
}
else
msg_Err( p_sd, "Error parsing add_item arguments" );
return 1;
}
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;
}
/*****************************************************************************
* Callbacks and helper functions
*****************************************************************************/
static void input_item_subitem_added( const vlc_event_t * p_event,
void * user_data )
{
services_discovery_t *p_sd = user_data;
services_discovery_sys_t *p_sys = p_sd->p_sys;
/* retrieve new item */
input_item_t *p_item = p_event->u.input_item_subitem_added.p_new_child;
if( p_sys->i_type == Picture )
formatSnapshotItem( p_item );
services_discovery_AddItem( p_sd, p_item, NULL );
}
int SdOpen (vlc_object_t *p_this)
{
services_discovery_t *p_sd = (services_discovery_t *)p_this;
services_discovery_sys_t *p_sys = malloc (sizeof (*p_sys));
if( p_sys == NULL )
return VLC_ENOMEM;
p_sd->p_sys = p_sys;
/* Let's create a NETBIOS name service object */
p_sys->ns = netbios_ns_new();
if( p_sys->ns == NULL )
goto error;
if( !netbios_ns_discover( p_sys->ns ) )
goto error;
for( ssize_t i = 0; i < netbios_ns_entry_count( p_sys->ns ); i++ )
{
netbios_ns_entry *p_entry = netbios_ns_entry_at( p_sys->ns, i );
if( p_entry->type == 0x20 )
{
input_item_t *p_item;
char *psz_mrl;
if( asprintf(&psz_mrl, "smb://%s", p_entry->name) < 0 )
goto error;
p_item = input_item_NewWithType( psz_mrl, p_entry->name, 0, NULL,
0, -1, ITEM_TYPE_NODE );
msg_Dbg( p_sd, "Adding item %s", psz_mrl );
services_discovery_AddItem( p_sd, p_item, NULL );
free( psz_mrl );
}
}
return VLC_SUCCESS;
error:
if( p_sys->ns != NULL )
netbios_ns_destroy( p_sys->ns );
free( p_sys );
p_sd->p_sys = NULL;
return VLC_EGENERIC;
}
bool MediaServerList::addServer( MediaServerDesc* desc )
{
input_item_t* p_input_item = NULL;
if ( getServer( desc->UDN ) )
return false;
msg_Dbg( m_sd, "Adding server '%s' with uuid '%s'", desc->friendlyName.c_str(), desc->UDN.c_str() );
if ( desc->isSatIp )
{
p_input_item = input_item_NewDirectory( desc->location.c_str(),
desc->friendlyName.c_str(),
ITEM_NET );
input_item_SetSetting( p_input_item, SATIP_SERVER_DEVICE_TYPE );
char *psz_playlist_option;
if (asprintf( &psz_playlist_option, "satip-host=%s",
desc->satIpHost.c_str() ) >= 0 ) {
input_item_AddOption( p_input_item, psz_playlist_option, 0 );
free( psz_playlist_option );
}
} else {
char* psz_mrl;
// We might already have some options specified in the location.
char opt_delim = desc->location.find( '?' ) == 0 ? '?' : '&';
if( asprintf( &psz_mrl, "upnp://%s%cObjectID=0", desc->location.c_str(), opt_delim ) < 0 )
return false;
p_input_item = input_item_NewDirectory( psz_mrl,
desc->friendlyName.c_str(),
ITEM_NET );
input_item_SetSetting( p_input_item, MEDIA_SERVER_DEVICE_TYPE );
free( psz_mrl );
}
if ( !p_input_item )
return false;
if ( desc->iconUrl.empty() == false )
input_item_SetArtworkURL( p_input_item, desc->iconUrl.c_str() );
desc->inputItem = p_input_item;
input_item_SetDescription( p_input_item, desc->UDN.c_str() );
services_discovery_AddItem( m_sd, p_input_item, NULL );
m_list.push_back( desc );
return true;
}
static void entry_item_append( services_discovery_t *p_sd,
netbios_ns_entry *p_entry,
input_item_t *p_item )
{
services_discovery_sys_t *p_sys = p_sd->p_sys;
struct entry_item *p_entry_item = calloc(1, sizeof(struct entry_item));
if( !p_entry_item )
return;
p_entry_item->p_entry = p_entry;
p_entry_item->p_item = p_item;
vlc_gc_incref( p_item );
vlc_array_append( p_sys->p_entry_item_list, p_entry_item );
services_discovery_AddItem( p_sd, p_item, NULL );
}
/**
* Probes and initializes.
*/
static int Open (vlc_object_t *obj)
{
services_discovery_t *sd = (services_discovery_t *)obj;
HFILE hcd2;
ULONG ulAction;
ULONG ulParamLen;
ULONG ulData;
ULONG ulDataLen;
ULONG rc;
sd->description = _("Discs");
if (DosOpen ((PSZ)"CD-ROM2$", (PHFILE)&hcd2, &ulAction, 0, FILE_NORMAL,
OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW,
OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE, NULL))
return VLC_EGENERIC;
rc = DosDevIOCtl (hcd2, IOCTL_CDROMDISK2, CDROMDISK2_DRIVELETTERS,
NULL, 0, &ulParamLen, &ulData, sizeof(ulData), &ulDataLen);
if (!rc)
{
char mrl[] = "file:///A:/", name[] = "A:";
int count = LOUSHORT(ulData);
int drive = HIUSHORT(ulData);
input_item_t *item;
char letter;
for (; count; --count, ++drive)
{
letter = 'A' + drive;
mrl[8] = name[0] = letter;
item = input_item_NewDisc (mrl, name, -1);
msg_Dbg (sd, "adding %s (%s)", mrl, name);
if (item == NULL)
break;
services_discovery_AddItem (sd, item);
}
}
DosClose (hcd2);
return rc ? VLC_EGENERIC : VLC_SUCCESS;
}
/**
* Adds a source.
*/
static int AddSource (services_discovery_t *sd, const pa_source_info *info)
{
services_discovery_sys_t *sys = sd->p_sys;
msg_Dbg (sd, "adding %s (%s)", info->name, info->description);
char *mrl;
if (unlikely(asprintf (&mrl, "pulse://%s", info->name) == -1))
return -1;
input_item_t *item = input_item_NewCard (mrl, info->description);
free (mrl);
if (unlikely(item == NULL))
return -1;
struct device *d = malloc (sizeof (*d));
if (unlikely(d == NULL))
{
vlc_gc_decref (item);
return -1;
}
d->index = info->index;
d->item = item;
struct device **dp = tsearch (d, &sys->root, cmpsrc);
if (dp == NULL) /* Out-of-memory */
{
free (d);
vlc_gc_decref (item);
return -1;
}
if (*dp != d) /* Update existing source */
{
free (d);
d = *dp;
input_item_SetURI (d->item, item->psz_uri);
input_item_SetName (d->item, item->psz_name);
vlc_gc_decref (item);
return 0;
}
const char *card = pa_proplist_gets(info->proplist, "device.product.name");
services_discovery_AddItem (sd, item,
(card != NULL) ? card : N_("Generic"));
d->sd = sd;
return 0;
}
/*****************************************************************************
* Callbacks and helper functions
*****************************************************************************/
static void input_subnode_added( const vlc_event_t *p_event, void *user_data )
{
services_discovery_t *p_sd = user_data;
services_discovery_sys_t *p_sys = p_sd->p_sys;
input_item_node_t *root = p_event->u.input_item_subitem_tree_added.p_root;
for( int i = 0; i < root->i_children; i++ )
{
input_item_node_t *child = root->pp_children[i];
input_item_t *item = child->p_item;
if( p_sys->i_type == Picture )
formatSnapshotItem( item );
services_discovery_AddItem( p_sd, item );
}
}
/**
* Adds a udev device.
*/
static int AddDevice (services_discovery_t *sd, struct udev_device *dev)
{
services_discovery_sys_t *p_sys = sd->p_sys;
char *mrl = p_sys->subsys->get_mrl (dev);
if (mrl == NULL)
return 0; /* don't know if it was an error... */
char *name = p_sys->subsys->get_name (dev);
input_item_t *item = input_item_NewWithType (VLC_OBJECT (sd), mrl,
name ? name : mrl,
0, NULL, 0, -1,
p_sys->subsys->item_type);
msg_Dbg (sd, "adding %s (%s)", mrl, name);
free (name);
free (mrl);
if (item == NULL)
return -1;
struct device *d = malloc (sizeof (*d));
if (d == NULL)
{
vlc_gc_decref (item);
return -1;
}
d->devnum = udev_device_get_devnum (dev);
d->item = item;
d->sd = NULL;
struct device **dp = tsearch (d, &p_sys->root, cmpdev);
if (dp == NULL) /* Out-of-memory */
{
DestroyDevice (d);
return -1;
}
if (*dp != d) /* Overwrite existing device */
{
DestroyDevice (*dp);
*dp = d;
}
name = p_sys->subsys->get_cat (dev);
services_discovery_AddItem (sd, item, name ? name : "Generic");
d->sd = sd;
free (name);
return 0;
}
bool MediaServerList::addServer( MediaServer* s )
{
input_item_t* p_input_item = NULL;
if ( getServer( s->getUDN() ) != 0 ) return false;
msg_Dbg( _p_sd, "Adding server '%s'",
s->getFriendlyName() );
services_discovery_t* p_sd = _p_sd;
p_input_item = input_item_New( p_sd, "vlc://nop", s->getFriendlyName() );
s->setInputItem( p_input_item );
services_discovery_AddItem( p_sd, p_input_item, NULL );
_list.push_back( s );
return true;
}
bool MediaServerList::addServer( MediaServer* p_server )
{
input_item_t* p_input_item = NULL;
if ( getServer( p_server->getUDN() ) != 0 ) return false;
msg_Dbg( _p_sd, "Adding server '%s' with uuid '%s'", p_server->getFriendlyName(), p_server->getUDN() );
p_input_item = input_item_New( "vlc://nop", p_server->getFriendlyName() );
input_item_SetDescription( p_input_item, p_server->getUDN() );
p_server->setInputItem( p_input_item );
services_discovery_AddItem( _p_sd, p_input_item, NULL );
_list.push_back( p_server );
return true;
}
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 );
}
static void AddTrack( services_discovery_t *p_sd, LIBMTP_track_t *p_track )
{
input_item_t *p_input;
char *psz_string;
char *extension;
extension = rindex( p_track->filename, '.' );
if( asprintf( &psz_string, "mtp://%"PRIu32":%"PRIu8":%"PRIu16":%d%s",
p_sd->p_sys->i_bus, p_sd->p_sys->i_dev,
p_sd->p_sys->i_product_id, p_track->item_id,
extension ) == -1 )
{
msg_Err( p_sd, "Error adding %s, skipping it", p_track->filename );
return;
}
if( ( p_input = input_item_New( psz_string, p_track->title ) ) == NULL )
{
msg_Err( p_sd, "Error adding %s, skipping it", p_track->filename );
free( psz_string );
return;
}
free( psz_string );
input_item_SetArtist( p_input, p_track->artist );
input_item_SetGenre( p_input, p_track->genre );
input_item_SetAlbum( p_input, p_track->album );
if( asprintf( &psz_string, "%d", p_track->tracknumber ) != -1 )
{
input_item_SetTrackNum( p_input, psz_string );
free( psz_string );
}
if( asprintf( &psz_string, "%d", p_track->rating ) != -1 )
{
input_item_SetRating( p_input, psz_string );
free( psz_string );
}
input_item_SetDate( p_input, p_track->date );
input_item_SetDuration( p_input, p_track->duration * 1000 );
services_discovery_AddItem( p_sd, p_input, NULL );
p_sd->p_sys->pp_items[p_sd->p_sys->i_count++] = p_input;
}
bool MediaServerList::addServer( MediaServerDesc* desc )
{
vlc_mutex_locker lock( &lock_ );
input_item_t* p_input_item = NULL;
if ( getServer( desc->UDN ) )
return false;
msg_Dbg( p_sd_, "Adding server '%s' with uuid '%s'", desc->friendlyName.c_str(), desc->UDN.c_str() );
char* psz_mrl;
if( asprintf(&psz_mrl, "upnp://%s?ObjectID=0", desc->location.c_str() ) < 0 )
return false;
p_input_item = input_item_NewWithTypeExt( psz_mrl, desc->friendlyName.c_str(), 0,
NULL, 0, -1, ITEM_TYPE_NODE, 1);
free( psz_mrl );
if ( !p_input_item )
return false;
desc->inputItem = p_input_item;
input_item_SetDescription( p_input_item, desc->UDN.c_str() );
services_discovery_AddItem( p_sd_, p_input_item, NULL );
list_.push_back( desc );
return true;
}
/*****************************************************************************
* resolve_callback
*****************************************************************************/
static void resolve_callback(
AvahiServiceResolver *r,
AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiResolverEvent event,
const char *name,
const char *type,
const char *domain,
const char *host_name,
const AvahiAddress *address,
uint16_t port,
AvahiStringList *txt,
AvahiLookupResultFlags flags,
void* userdata )
{
services_discovery_t *p_sd = ( services_discovery_t* )userdata;
services_discovery_sys_t *p_sys = p_sd->p_sys;
VLC_UNUSED(interface); VLC_UNUSED(host_name);
VLC_UNUSED(flags);
if( event == AVAHI_RESOLVER_FAILURE )
{
msg_Err( p_sd,
"failed to resolve service '%s' of type '%s' in domain '%s'",
name, type, domain );
}
else if( event == AVAHI_RESOLVER_FOUND )
{
char a[128];
char *psz_uri = NULL;
char *psz_addr = NULL;
AvahiStringList *asl = NULL;
input_item_t *p_input = NULL;
msg_Dbg( p_sd, "service '%s' of type '%s' in domain '%s'",
name, type, domain );
avahi_address_snprint(a, (sizeof(a)/sizeof(a[0]))-1, address);
if( protocol == AVAHI_PROTO_INET6 )
if( asprintf( &psz_addr, "[%s]", a ) == -1 )
return;
if( txt != NULL )
asl = avahi_string_list_find( txt, "path" );
if( asl != NULL )
{
size_t size;
char *key = NULL;
char *value = NULL;
if( avahi_string_list_get_pair( asl, &key, &value, &size ) == 0 &&
value != NULL )
{
if( asprintf( &psz_uri, "http://%s:%d%s",
psz_addr != NULL ? psz_addr : a, port, value ) == -1 )
{
free( psz_addr );
return;
}
}
if( key != NULL )
avahi_free( (void *)key );
if( value != NULL )
avahi_free( (void *)value );
}
else
{
if( asprintf( &psz_uri, "http://%s:%d",
psz_addr != NULL ? psz_addr : a, port ) == -1 )
{
free( psz_addr );
return;
}
}
free( psz_addr );
if( psz_uri != NULL )
{
p_input = input_item_New( p_sd, psz_uri, name );
free( psz_uri );
}
if( p_input != NULL )
{
vlc_dictionary_insert( &p_sys->services_name_to_input_item,
name, p_input );
services_discovery_AddItem( p_sd, p_input, NULL /* no category */ );
vlc_gc_decref( p_input );
}
}
avahi_service_resolver_free( r );
}
static int vlclua_sd_add_item( lua_State *L )
{
services_discovery_t *p_sd = (services_discovery_t *)vlclua_get_this( L );
if( lua_istable( L, -1 ) )
{
lua_getfield( L, -1, "path" );
if( lua_isstring( L, -1 ) )
{
const char *psz_path = lua_tostring( L, -1 );
lua_getfield( L, -2, "title" );
const char *psz_title = luaL_checkstring( L, -1 ) ? luaL_checkstring( L, -1 ) : psz_path;
/* The table must be at the top of the stack when calling
* vlclua_read_options() */
char **ppsz_options = NULL;
int i_options = 0;
lua_pushvalue( L, -3 );
vlclua_read_options( p_sd, L, &i_options, &ppsz_options );
input_item_t *p_input = input_item_NewExt( psz_path, psz_title,
i_options,
(const char **)ppsz_options,
VLC_INPUT_OPTION_TRUSTED, -1 );
lua_pop( L, 3 );
if( p_input )
{
vlclua_read_meta_data( p_sd, L, p_input );
/* This one is to be tested... */
vlclua_read_custom_meta_data( p_sd, L, p_input );
/* The duration is given in seconds, convert to microseconds */
lua_getfield( L, -1, "duration" );
if( lua_isnumber( L, -1 ) )
input_item_SetDuration( p_input, (lua_tonumber( L, -1 )*1e6) );
else if( !lua_isnil( L, -1 ) )
msg_Warn( p_sd, "Item duration should be a number (in seconds)." );
lua_pop( L, 1 );
lua_getfield( L, -1, "category" );
if( lua_isstring( L, -1 ) )
services_discovery_AddItem( p_sd, p_input, luaL_checkstring( L, -1 ) );
else
services_discovery_AddItem( p_sd, p_input, NULL );
lua_pop( L, 1 );
/* string to build the input item uid */
lua_getfield( L, -1, "uiddata" );
if( lua_isstring( L, -1 ) )
{
char *s = strdup( luaL_checkstring( L, -1 ) );
if ( s )
{
struct md5_s md5;
InitMD5( &md5 );
AddMD5( &md5, s, strlen( s ) );
EndMD5( &md5 );
free( s );
s = psz_md5_hash( &md5 );
if ( s )
input_item_AddInfo( p_input, "uid", "md5", "%s", s );
free( s );
}
}
lua_pop( L, 1 );
input_item_t **udata = (input_item_t **)
lua_newuserdata( L, sizeof( input_item_t * ) );
*udata = p_input;
if( luaL_newmetatable( L, "input_item_t" ) )
{
lua_newtable( L );
luaL_register( L, NULL, vlclua_item_reg );
lua_setfield( L, -2, "__index" );
lua_pushliteral( L, "none of your business" );
lua_setfield( L, -2, "__metatable" );
}
lua_setmetatable( L, -2 );
vlc_gc_decref( p_input );
}
while( i_options > 0 )
free( ppsz_options[--i_options] );
free( ppsz_options );
}
else
msg_Err( p_sd, "vlc.sd.add_item: the \"path\" parameter can't be empty" );
}
else
msg_Err( p_sd, "Error parsing add_item arguments" );
return 1;
}
/**
* Probes and initializes.
*/
static int Open (vlc_object_t *obj)
{
services_discovery_t *sd = (services_discovery_t *)obj;
services_discovery_sys_t *p_sys = malloc (sizeof (*p_sys));
if (p_sys == NULL)
return VLC_ENOMEM;
sd->p_sys = p_sys;
sd->description = _("Screen capture");
/* Connect to X server */
char *display = var_InheritString (obj, "x11-display");
int snum;
xcb_connection_t *conn = xcb_connect (display, &snum);
free (display);
if (xcb_connection_has_error (conn))
{
free (p_sys);
return VLC_EGENERIC;
}
p_sys->conn = conn;
/* Find configured screen */
const xcb_setup_t *setup = xcb_get_setup (conn);
const xcb_screen_t *scr = NULL;
for (xcb_screen_iterator_t i = xcb_setup_roots_iterator (setup);
i.rem > 0; xcb_screen_next (&i))
{
if (snum == 0)
{
scr = i.data;
break;
}
snum--;
}
if (scr == NULL)
{
msg_Err (obj, "bad X11 screen number");
goto error;
}
/* Add a permanent item for the entire desktop */
AddDesktop (sd);
p_sys->root_window = scr->root;
xcb_change_window_attributes (conn, scr->root, XCB_CW_EVENT_MASK,
&(uint32_t) { XCB_EVENT_MASK_PROPERTY_CHANGE });
/* TODO: check that _NET_CLIENT_LIST is in _NET_SUPPORTED
* (and _NET_SUPPORTING_WM_CHECK) */
xcb_intern_atom_reply_t *r;
xcb_intern_atom_cookie_t ncl, nwn;
ncl = xcb_intern_atom (conn, 1, strlen ("_NET_CLIENT_LIST"),
"_NET_CLIENT_LIST");
nwn = xcb_intern_atom (conn, 0, strlen ("_NET_WM_NAME"), "_NET_WM_NAME");
r = xcb_intern_atom_reply (conn, ncl, NULL);
if (r == NULL || r->atom == 0)
{
vlc_dialog_display_error (sd, _("Screen capture"),
_("Your window manager does not provide a list of applications."));
msg_Err (sd, "client list not supported (_NET_CLIENT_LIST absent)");
}
p_sys->net_client_list = r ? r->atom : 0;
free (r);
r = xcb_intern_atom_reply (conn, nwn, NULL);
if (r != NULL)
{
p_sys->net_wm_name = r->atom;
free (r);
}
p_sys->apps = NULL;
p_sys->apps_root = input_item_NewExt("vlc://nop", _("Applications"), -1,
ITEM_TYPE_NODE, ITEM_LOCAL);
if (likely(p_sys->apps_root != NULL))
services_discovery_AddItem(sd, p_sys->apps_root);
UpdateApps (sd);
if (vlc_clone (&p_sys->thread, Run, sd, VLC_THREAD_PRIORITY_LOW))
goto error;
return VLC_SUCCESS;
error:
xcb_disconnect (p_sys->conn);
tdestroy (p_sys->apps, DelApp);
if (p_sys->apps_root != NULL)
input_item_Release(p_sys->apps_root);
free (p_sys);
return VLC_EGENERIC;
}
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;
}
