int main (void)
{
static const char * our_keys[] = {
"Hello", "Hella", "flowmeter", "Frostnipped", "frostnipped", "remiform", "quadrifoliolate", "singularity", "unafflicted"
};
const int size = sizeof(our_keys)/sizeof(our_keys[0]);
char ** keys;
int i = 0;
vlc_dictionary_t dict;
vlc_dictionary_init( &dict, 0 );
assert( vlc_dictionary_keys_count( &dict ) == 0 );
keys = vlc_dictionary_all_keys( &dict );
assert( keys && !keys[0] );
free(keys);
/* Insert some values */
for( i = 0; i < size; i++ )
vlc_dictionary_insert( &dict, our_keys[i], (void*)i );
test_dictionary_validity( &dict, our_keys, size );
vlc_dictionary_remove_value_for_key( &dict, our_keys[size-1], NULL, NULL );
test_dictionary_validity( &dict, our_keys, size-1 );
vlc_dictionary_clear( &dict, NULL, NULL );
assert( vlc_dictionary_keys_count( &dict ) == 0 );
return 0;
}
/**
* Merging meta
*/
void vlc_meta_Merge( vlc_meta_t *dst, const vlc_meta_t *src )
{
char **ppsz_all_keys;
int i;
if( !dst || !src )
return;
for( i = 0; i < VLC_META_TYPE_COUNT; i++ )
{
if( src->ppsz_meta[i] )
{
free( dst->ppsz_meta[i] );
dst->ppsz_meta[i] = strdup( src->ppsz_meta[i] );
}
}
/* XXX: If speed up are needed, it is possible */
ppsz_all_keys = vlc_dictionary_all_keys( &src->extra_tags );
for( i = 0; ppsz_all_keys && ppsz_all_keys[i]; i++ )
{
/* Always try to remove the previous value */
vlc_dictionary_remove_value_for_key( &dst->extra_tags, ppsz_all_keys[i], vlc_meta_FreeExtraKey, NULL );
void *p_value = vlc_dictionary_value_for_key( &src->extra_tags, ppsz_all_keys[i] );
vlc_dictionary_insert( &dst->extra_tags, ppsz_all_keys[i], strdup( (const char*)p_value ) );
free( ppsz_all_keys[i] );
}
free( ppsz_all_keys );
}
static void test_dictionary_validity (vlc_dictionary_t * p_dict, const char ** our_keys, int size )
{
/* Test values and keys now */
char ** keys = vlc_dictionary_all_keys( p_dict );
int i, j;
assert( keys );
for( j = 0; keys[j]; j++ )
{
bool found = false;
for( i = 0; i < size; i++ )
{
if(!strcmp( keys[j], our_keys[i] ))
{
found = true;
break;
}
}
free( keys[j] );
assert( found );
}
free( keys );
for( i = 0; i < size; i++ )
assert( vlc_dictionary_value_for_key( p_dict, our_keys[i] ) == (void*)i );
}
/**
* 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;
const char *psz_interface_name = DBUS_MPRIS_PLAYER_INTERFACE;
char **ppsz_properties = NULL;
SIGNAL_INIT( DBUS_INTERFACE_PROPERTIES,
DBUS_MPRIS_OBJECT_PATH,
"PropertiesChanged" );
OUT_ARGUMENTS;
ADD_STRING( &psz_interface_name );
if( !dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "{sv}",
&changed_properties ) )
return DBUS_HANDLER_RESULT_NEED_MEMORY;
ppsz_properties = vlc_dictionary_all_keys( p_changed_properties );
if( unlikely(!ppsz_properties) )
{
dbus_message_iter_abandon_container( &args, &changed_properties );
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
for( int i = 0; ppsz_properties[i]; i++ )
{
PROPERTY_MAPPING_BEGIN
PROPERTY_ENTRY( Metadata, "a{sv}" )
PROPERTY_ENTRY( PlaybackStatus, "s" )
PROPERTY_ENTRY( LoopStatus, "s" )
PROPERTY_ENTRY( Rate, "d" )
PROPERTY_ENTRY( Shuffle, "b" )
PROPERTY_ENTRY( Volume, "d" )
PROPERTY_ENTRY( CanSeek, "b" )
PROPERTY_ENTRY( CanPlay, "b" )
PROPERTY_ENTRY( CanPause, "b" )
PROPERTY_MAPPING_END
free( ppsz_properties[i] );
}
free( ppsz_properties );
if( !dbus_message_iter_close_container( &args, &changed_properties ) )
return DBUS_HANDLER_RESULT_NEED_MEMORY;
if( !dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "s",
&invalidated_properties ) )
return DBUS_HANDLER_RESULT_NEED_MEMORY;
if( !dbus_message_iter_close_container( &args, &invalidated_properties ) )
return DBUS_HANDLER_RESULT_NEED_MEMORY;
SIGNAL_SEND;
}
/**
* 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;
const char *psz_interface_name = DBUS_MPRIS_TRACKLIST_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 );
if( unlikely(!dbus_message_iter_open_container( &args,
DBUS_TYPE_ARRAY, "{sv}",
&changed_properties )) )
return DBUS_HANDLER_RESULT_NEED_MEMORY;
if( unlikely(!dbus_message_iter_close_container( &args,
&changed_properties )) )
return DBUS_HANDLER_RESULT_NEED_MEMORY;
if( unlikely(!dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "s",
&invalidated_properties )) )
return DBUS_HANDLER_RESULT_NEED_MEMORY;
i_properties = vlc_dictionary_keys_count( p_changed_properties );
ppsz_properties = vlc_dictionary_all_keys( p_changed_properties );
if( unlikely(!ppsz_properties) )
{
dbus_message_iter_abandon_container( &args, &invalidated_properties );
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
for( int i = 0; i < i_properties; i++ )
{
if( !strcmp( ppsz_properties[i], "Tracks" ) )
dbus_message_iter_append_basic( &invalidated_properties,
DBUS_TYPE_STRING,
&ppsz_properties[i] );
free( ppsz_properties[i] );
}
free( ppsz_properties );
if( unlikely(!dbus_message_iter_close_container( &args,
&invalidated_properties )) )
return DBUS_HANDLER_RESULT_NEED_MEMORY;
SIGNAL_SEND;
}
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_ROOT_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], "Fullscreen" ) )
{
dbus_message_iter_open_container( &entry,
DBUS_TYPE_VARIANT, "b",
&variant );
MarshalFullscreen( 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 int vlc_sd_probe_Open( vlc_object_t *obj )
{
vlc_dictionary_t name_d;
char **ppsz_dir_list;
if( vlclua_dir_list( "sd", &ppsz_dir_list ) )
return VLC_ENOMEM;
vlc_dictionary_init( &name_d, 32 );
for( char **ppsz_dir = ppsz_dir_list; *ppsz_dir; ppsz_dir++ )
{
char **ppsz_filelist;
int i_files = vlc_scandir( *ppsz_dir, &ppsz_filelist, file_select,
file_compare );
if( i_files < 1 ) continue;
for( char **ppsz_file = ppsz_filelist;
ppsz_file < ppsz_filelist + i_files; ppsz_file++ )
{
char *temp = strchr( *ppsz_file, '.' );
if( temp )
*temp = '\0';
if( vlc_dictionary_value_for_key( &name_d, *ppsz_file ) ==
kVLCDictionaryNotFound )
vlc_dictionary_insert( &name_d, *ppsz_file, &name_d );
free( *ppsz_file );
}
free( ppsz_filelist );
}
vlclua_dir_list_free( ppsz_dir_list );
int r = VLC_PROBE_CONTINUE;
char **names = vlc_dictionary_all_keys( &name_d );
if( names != NULL )
{
for( char **name = names; *name; ++name )
{
r = vlclua_probe_sd( obj, *name );
if( r != VLC_PROBE_CONTINUE )
break;
}
for( char **name = names; *name; ++name )
free( *name );
free( names );
}
vlc_dictionary_clear( &name_d, NULL, NULL );
return r;
}
void DumpDictionary( filter_t *p_filter, const vlc_dictionary_t *p_dict,
bool b_dump_fonts, int i_max_families )
{
char **ppsz_keys = vlc_dictionary_all_keys( p_dict );
for( int i = 0; ppsz_keys[ i ]; ++i )
{
vlc_family_t *p_family = vlc_dictionary_value_for_key( p_dict, ppsz_keys[ i ] );
msg_Dbg( p_filter, "Key: %s", ppsz_keys[ i ] );
if( p_family )
DumpFamily( p_filter, p_family, b_dump_fonts, i_max_families );
free( ppsz_keys[ i ] );
}
free( ppsz_keys );
}
/**************************************************************************
* release (Public)
**************************************************************************/
void
libvlc_media_discoverer_release( libvlc_media_discoverer_t * p_mdis )
{
int i;
vlc_event_detach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemAdded,
services_discovery_item_added,
p_mdis );
vlc_event_detach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemRemoved,
services_discovery_item_removed,
p_mdis );
vlc_event_detach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryStarted,
services_discovery_started,
p_mdis );
vlc_event_detach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryEnded,
services_discovery_ended,
p_mdis );
vlc_event_detach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemRemoveAll,
services_discovery_removeall,
p_mdis );
libvlc_media_list_release( p_mdis->p_mlist );
if( p_mdis->running )
vlc_sd_Stop( p_mdis->p_sd );
vlc_sd_Destroy( p_mdis->p_sd );
/* Free catname_to_submedialist and all the mlist */
char ** all_keys = vlc_dictionary_all_keys( &p_mdis->catname_to_submedialist );
for( i = 0; all_keys[i]; i++ )
{
libvlc_media_list_t * p_catmlist = vlc_dictionary_value_for_key( &p_mdis->catname_to_submedialist, all_keys[i] );
libvlc_media_list_release( p_catmlist );
free( all_keys[i] );
}
free( all_keys );
vlc_dictionary_clear( &p_mdis->catname_to_submedialist, NULL, NULL );
libvlc_event_manager_release( p_mdis->p_event_manager );
libvlc_release( p_mdis->p_libvlc_instance );
free( p_mdis );
}
/**************************************************************************
* release (Public)
**************************************************************************/
void
libvlc_media_discoverer_release( libvlc_media_discoverer_t * p_mdis )
{
int i;
libvlc_media_list_release( p_mdis->p_mlist );
services_discovery_Destroy( p_mdis->p_sd );
/* Free catname_to_submedialist and all the mlist */
char ** all_keys = vlc_dictionary_all_keys( &p_mdis->catname_to_submedialist );
for( i = 0; all_keys[i]; i++ )
{
libvlc_media_list_t * p_catmlist = vlc_dictionary_value_for_key( &p_mdis->catname_to_submedialist, all_keys[i] );
libvlc_media_list_release( p_catmlist );
free( all_keys[i] );
}
free( all_keys );
vlc_dictionary_clear( &p_mdis->catname_to_submedialist );
free( p_mdis );
}
/**
* 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;
}
