vlc_family_t *Win32_GetFallbacks( filter_t *p_filter, const char *psz_family,
uni_char_t codepoint )
{
vlc_family_t *p_family = NULL;
vlc_family_t *p_fallbacks = NULL;
filter_sys_t *p_sys = p_filter->p_sys;
char *psz_uniscribe = NULL;
char *psz_lc = ToLower( psz_family );
if( unlikely( !psz_lc ) )
return NULL;
p_fallbacks = vlc_dictionary_value_for_key( &p_sys->fallback_map, psz_lc );
if( p_fallbacks )
p_family = SearchFallbacks( p_filter, p_fallbacks, codepoint );
/*
* If the fallback list of psz_family has no family which contains the requested
* codepoint, try UniscribeFallback(). If it returns a valid family which does
* contain that codepoint, add the new family to the fallback list to speed up
* later searches.
*/
if( !p_family )
{
psz_uniscribe = UniscribeFallback( psz_lc, codepoint );
if( !psz_uniscribe )
goto done;
const vlc_family_t *p_uniscribe = Win32_GetFamily( p_filter, psz_uniscribe );
if( !p_uniscribe || !p_uniscribe->p_fonts )
goto done;
FT_Face p_face = GetFace( p_filter, p_uniscribe->p_fonts );
if( !p_face || !FT_Get_Char_Index( p_face, codepoint ) )
goto done;
p_family = NewFamily( p_filter, psz_uniscribe, NULL, NULL, NULL );
if( unlikely( !p_family ) )
goto done;
p_family->p_fonts = p_uniscribe->p_fonts;
if( p_fallbacks )
AppendFamily( &p_fallbacks, p_family );
else
vlc_dictionary_insert( &p_sys->fallback_map,
psz_lc, p_family );
}
done:
free( psz_lc );
free( psz_uniscribe );
return p_family;
}
vlc_family_t *InitDefaultList( filter_t *p_filter, const char *const *ppsz_default,
int i_size )
{
vlc_family_t *p_default = NULL;
filter_sys_t *p_sys = p_filter->p_sys;
for( int i = 0; i < i_size; ++i )
{
const vlc_family_t *p_family =
p_sys->pf_get_family( p_filter, ppsz_default[ i ] );
if( p_family )
{
vlc_family_t *p_temp =
NewFamily( p_filter, ppsz_default[ i ], &p_default, NULL, NULL );
if( unlikely( !p_temp ) )
goto error;
p_temp->p_fonts = p_family->p_fonts;
}
}
if( p_default )
vlc_dictionary_insert( &p_sys->fallback_map, FB_LIST_DEFAULT, p_default );
return p_default;
error:
if( p_default ) FreeFamilies( p_default, NULL );
return NULL;
}
void vlc_meta_AddExtra( vlc_meta_t *m, const char *psz_name, const char *psz_value )
{
char *psz_oldvalue = (char *)vlc_dictionary_value_for_key( &m->extra_tags, psz_name );
if( psz_oldvalue != kVLCDictionaryNotFound )
vlc_dictionary_remove_value_for_key( &m->extra_tags, psz_name,
vlc_meta_FreeExtraKey, NULL );
vlc_dictionary_insert( &m->extra_tags, psz_name, strdup(psz_value) );
}
void __msg_DisableObjectPrinting (vlc_object_t *p_this, char * psz_object)
{
libvlc_priv_t *priv = libvlc_priv (p_this->p_libvlc);
vlc_mutex_lock( &QUEUE.lock );
if( !strcmp(psz_object, "all") )
priv->msg_all_objects_enabled = false;
else
vlc_dictionary_insert( &priv->msg_enabled_objects, psz_object, (void *)kObjectPrintingDisabled );
vlc_mutex_unlock( &QUEUE.lock );
}
void msg_DisableObjectPrinting (vlc_object_t *obj, const char * psz_object)
{
msg_bank_t *bank = libvlc_bank (obj->p_libvlc);
vlc_rwlock_wrlock (&bank->lock);
if( !strcmp(psz_object, "all") )
bank->all_objects_enabled = false;
else
vlc_dictionary_insert (&bank->enabled_objects, psz_object,
(void *)kObjectPrintingDisabled);
vlc_rwlock_unlock (&bank->lock);
}
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;
}
vlc_family_t *NewFamily( filter_t *p_filter, const char *psz_family,
vlc_family_t **pp_list, vlc_dictionary_t *p_dict,
const char *psz_key )
{
filter_sys_t *p_sys = p_filter->p_sys;
vlc_family_t *p_family = NULL;
p_family = calloc( 1, sizeof( *p_family ) );
char *psz_name;
if( psz_family && *psz_family )
psz_name = ToLower( psz_family );
else
if( asprintf( &psz_name, FB_NAME"-%02d",
p_sys->i_fallback_counter++ ) < 0 )
psz_name = NULL;
char *psz_lc = NULL;
if( likely( psz_name ) )
{
if( !psz_key )
psz_lc = strdup( psz_name );
else
psz_lc = ToLower( psz_key );
}
if( unlikely( !p_family || !psz_name || !psz_lc ) )
{
free( p_family );
free( psz_name );
free( psz_lc );
return NULL;
}
p_family->psz_name = psz_name;
if( pp_list )
AppendFamily( pp_list, p_family );
if( p_dict )
{
vlc_family_t *p_root = vlc_dictionary_value_for_key( p_dict, psz_lc );
if( p_root )
AppendFamily( &p_root, p_family );
else
vlc_dictionary_insert( p_dict, psz_lc, p_family );
}
free( psz_lc );
return p_family;
}
static void services_discovery_item_added( services_discovery_t *sd,
input_item_t *parent,
input_item_t *p_item,
const char *psz_cat )
{
libvlc_media_t * p_md;
libvlc_media_discoverer_t *p_mdis = sd->owner.sys;
libvlc_media_list_t * p_mlist = p_mdis->p_mlist;
p_md = libvlc_media_new_from_input_item( p_mdis->p_libvlc_instance,
p_item );
if( parent != NULL )
{
/* Flatten items list for now. TODO: tree support. */
}
else
/* If we have a category, that mean we have to group the items having
* that category in a media_list. */
if( psz_cat )
{
p_mlist = vlc_dictionary_value_for_key( &p_mdis->catname_to_submedialist, psz_cat );
if( p_mlist == kVLCDictionaryNotFound )
{
libvlc_media_t * p_catmd;
p_catmd = libvlc_media_new_as_node( p_mdis->p_libvlc_instance, psz_cat );
p_mlist = libvlc_media_subitems( p_catmd );
p_mlist->b_read_only = true;
/* Insert the newly created mlist in our dictionary */
vlc_dictionary_insert( &p_mdis->catname_to_submedialist, psz_cat, p_mlist );
/* Insert the md into the root list */
libvlc_media_list_lock( p_mdis->p_mlist );
libvlc_media_list_internal_add_media( p_mdis->p_mlist, p_catmd );
libvlc_media_list_unlock( p_mdis->p_mlist );
/* We don't release the mlist cause the dictionary
* doesn't retain the object. But we release the md. */
libvlc_media_release( p_catmd );
}
}
libvlc_media_list_lock( p_mlist );
libvlc_media_list_internal_add_media( p_mlist, p_md );
libvlc_media_list_unlock( p_mlist );
libvlc_media_release( p_md );
}
static void services_discovery_item_added( const vlc_event_t * p_event,
void * user_data )
{
input_item_t * p_item = p_event->u.services_discovery_item_added.p_new_item;
const char * psz_cat = p_event->u.services_discovery_item_added.psz_category;
libvlc_media_t * p_md;
libvlc_media_discoverer_t * p_mdis = user_data;
libvlc_media_list_t * p_mlist = p_mdis->p_mlist;
p_md = libvlc_media_new_from_input_item(
p_mdis->p_libvlc_instance,
p_item, NULL );
/* If we have a category, that mean we have to group the items having
* that category in a media_list. */
if( psz_cat )
{
p_mlist = vlc_dictionary_value_for_key( &p_mdis->catname_to_submedialist, psz_cat );
if( p_mlist == kVLCDictionaryNotFound )
{
libvlc_media_t * p_catmd;
p_catmd = libvlc_media_new_as_node( p_mdis->p_libvlc_instance, psz_cat, NULL );
p_mlist = libvlc_media_subitems( p_catmd, NULL );
p_mlist->b_read_only = true;
/* Insert the newly created mlist in our dictionary */
vlc_dictionary_insert( &p_mdis->catname_to_submedialist, psz_cat, p_mlist );
/* Insert the md into the root list */
libvlc_media_list_lock( p_mdis->p_mlist );
_libvlc_media_list_add_media( p_mdis->p_mlist, p_catmd, NULL );
libvlc_media_list_unlock( p_mdis->p_mlist );
/* We don't release the mlist cause the dictionary
* doesn't retain the object. But we release the md. */
libvlc_media_release( p_catmd );
}
}
else
{
libvlc_media_list_lock( p_mlist );
_libvlc_media_list_add_media( p_mlist, p_md, NULL );
libvlc_media_list_unlock( p_mlist );
}
}
tt_node_t * tt_node_New( xml_reader_t* reader, tt_node_t* p_parent, const char* psz_node_name )
{
tt_node_t *p_node = calloc( 1, sizeof( *p_node ) );
if( !p_node )
return NULL;
p_node->i_type = TT_NODE_TYPE_ELEMENT;
p_node->psz_node_name = strdup( psz_node_name );
if( unlikely( p_node->psz_node_name == NULL ) )
{
free( p_node );
return NULL;
}
vlc_dictionary_init( &p_node->attr_dict, 0 );
tt_time_Init( &p_node->timings.begin );
tt_time_Init( &p_node->timings.end );
tt_time_Init( &p_node->timings.dur );
p_node->p_parent = p_parent;
if( p_parent )
tt_node_ParentAddChild( p_parent, (tt_basenode_t *) p_node );
const char* psz_value = NULL;
for( const char* psz_key = xml_ReaderNextAttr( reader, &psz_value );
psz_key != NULL;
psz_key = xml_ReaderNextAttr( reader, &psz_value ) )
{
char *psz_val = strdup( psz_value );
if( psz_val )
{
vlc_dictionary_insert( &p_node->attr_dict, psz_key, psz_val );
if( !strcasecmp( psz_key, "begin" ) )
p_node->timings.begin = tt_ParseTime( psz_val );
else if( ! strcasecmp( psz_key, "end" ) )
p_node->timings.end = tt_ParseTime( psz_val );
else if( ! strcasecmp( psz_key, "dur" ) )
p_node->timings.dur = tt_ParseTime( psz_val );
else if( ! strcasecmp( psz_key, "timeContainer" ) )
p_node->timings.i_type = strcmp( psz_val, "seq" ) ? TT_TIMINGS_PARALLEL
: TT_TIMINGS_SEQUENTIAL;
}
}
return p_node;
}
static FT_Face LoadFace( filter_t *p_filter, const char *psz_fontfile, int i_idx,
const text_style_t *p_style )
{
filter_sys_t *p_sys = p_filter->p_sys;
char *psz_key = NULL;
int i_font_size = ConvertToLiveSize( p_filter, p_style );
int i_font_width = p_style->i_style_flags & STYLE_HALFWIDTH ?
i_font_size / 2 : i_font_size;
if( asprintf( &psz_key, "%s - %d - %d - %d",
psz_fontfile, i_idx,
i_font_size, i_font_width ) < 0 )
return NULL;
FT_Face p_face = vlc_dictionary_value_for_key( &p_sys->face_map, psz_key );
if( p_face != kVLCDictionaryNotFound )
goto done;
if( psz_fontfile[0] == ':' && psz_fontfile[1] == '/' )
{
int i_attach = atoi( psz_fontfile + 2 );
if( i_attach < 0 || i_attach >= p_sys->i_font_attachments )
{
msg_Err( p_filter, "LoadFace: Invalid font attachment index" );
p_face = NULL;
}
else
{
input_attachment_t *p_attach = p_sys->pp_font_attachments[ i_attach ];
if( FT_New_Memory_Face( p_sys->p_library, p_attach->p_data,
p_attach->i_data, i_idx, &p_face ) )
p_face = NULL;
}
}
else
if( FT_New_Face( p_sys->p_library, psz_fontfile, i_idx, &p_face ) )
{
msg_Err( p_filter, "LoadFace: Error creating face for %s", psz_key );
p_face = NULL;
}
if( !p_face )
goto done;
if( FT_Select_Charmap( p_face, ft_encoding_unicode ) )
{
/* We've loaded a font face which is unhelpful for actually
* rendering text - fallback to the default one.
*/
msg_Err( p_filter, "LoadFace: Error selecting charmap for %s", psz_key );
FT_Done_Face( p_face );
p_face = NULL;
goto done;
}
if( FT_Set_Pixel_Sizes( p_face, i_font_width, i_font_size ) )
{
msg_Err( p_filter,
"LoadFace: Failed to set font size for %s", psz_key );
FT_Done_Face( p_face );
p_face = NULL;
goto done;
}
vlc_dictionary_insert( &p_sys->face_map, psz_key, p_face );
done:
free( psz_key );
return p_face;
}
/*****************************************************************************
* 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 Android_ParseFamily( filter_t *p_filter, xml_reader_t *p_xml )
{
filter_sys_t *p_sys = p_filter->p_sys;
vlc_dictionary_t *p_dict = &p_sys->family_map;
vlc_family_t *p_family = NULL;
char *psz_lc = NULL;
int i_counter = 0;
bool b_bold = false;
bool b_italic = false;
const char *p_node = NULL;
int i_type = 0;
while( ( i_type = xml_ReaderNextNode( p_xml, &p_node ) ) > 0 )
{
switch( i_type )
{
case XML_READER_STARTELEM:
/*
* Multiple names can reference the same family in Android. When
* the first name is encountered we set p_family to the vlc_family_t
* in the master list matching this name, and if no such family
* exists we create a new one and add it to the master list.
* If the master list does contain a family with that name it's one
* of the font attachments, and the family will end up having embedded
* fonts and system fonts.
*/
if( !strcasecmp( "name", p_node ) )
{
i_type = xml_ReaderNextNode( p_xml, &p_node );
if( i_type != XML_READER_TEXT || !p_node || !*p_node )
{
msg_Warn( p_filter, "Android_ParseFamily: empty name" );
continue;
}
psz_lc = ToLower( p_node );
if( unlikely( !psz_lc ) )
return VLC_ENOMEM;
if( !p_family )
{
p_family = vlc_dictionary_value_for_key( p_dict, psz_lc );
if( p_family == kVLCDictionaryNotFound )
{
p_family =
NewFamily( p_filter, psz_lc, &p_sys->p_families, NULL, NULL );
if( unlikely( !p_family ) )
{
free( psz_lc );
return VLC_ENOMEM;
}
}
}
if( vlc_dictionary_value_for_key( p_dict, psz_lc ) == kVLCDictionaryNotFound )
vlc_dictionary_insert( p_dict, psz_lc, p_family );
free( psz_lc );
}
/*
* If p_family has not been set by the time we encounter the first file,
* it means this family has no name, and should be used only as a fallback.
* We create a new family for it in the master list with the name "fallback-xx"
* and later add it to the "default" fallback list.
*/
else if( !strcasecmp( "file", p_node ) )
{
i_type = xml_ReaderNextNode( p_xml, &p_node );
if( i_type != XML_READER_TEXT || !p_node || !*p_node )
{
++i_counter;
continue;
}
if( !p_family )
p_family = NewFamily( p_filter, NULL, &p_sys->p_families,
&p_sys->family_map, NULL );
if( unlikely( !p_family ) )
return VLC_ENOMEM;
switch( i_counter )
{
case 0:
b_bold = false;
b_italic = false;
break;
case 1:
b_bold = true;
b_italic = false;
break;
case 2:
b_bold = false;
b_italic = true;
break;
case 3:
b_bold = true;
b_italic = true;
break;
default:
msg_Warn( p_filter, "Android_ParseFamily: too many files" );
return VLC_EGENERIC;
}
char *psz_fontfile = NULL;
if( asprintf( &psz_fontfile, "%s/%s", ANDROID_FONT_PATH, p_node ) < 0
|| !NewFont( psz_fontfile, 0, b_bold, b_italic, p_family ) )
return VLC_ENOMEM;
++i_counter;
}
break;
case XML_READER_ENDELEM:
if( !strcasecmp( "family", p_node ) )
{
if( !p_family )
{
msg_Warn( p_filter, "Android_ParseFamily: empty family" );
return VLC_EGENERIC;
}
/*
* If the family name has "fallback" in it, add it to the
* "default" fallback list.
*/
if( strcasestr( p_family->psz_name, FB_NAME ) )
{
vlc_family_t *p_fallback =
NewFamily( p_filter, p_family->psz_name,
NULL, &p_sys->fallback_map, FB_LIST_DEFAULT );
if( unlikely( !p_fallback ) )
return VLC_ENOMEM;
p_fallback->p_fonts = p_family->p_fonts;
}
return VLC_SUCCESS;
}
break;
}
}
msg_Warn( p_filter, "Android_ParseFamily: Corrupt font configuration file" );
return VLC_EGENERIC;
}
static FT_Face LoadFace( filter_t *p_filter, const char *psz_fontfile, int i_idx,
const text_style_t *p_style )
{
filter_sys_t *p_sys = p_filter->p_sys;
char *psz_key = NULL;
int i_font_size = ConvertToLiveSize( p_filter, p_style );
int i_font_width = p_style->i_style_flags & STYLE_HALFWIDTH ?
i_font_size / 2 : i_font_size;
if( asprintf( &psz_key, "%s - %d - %d - %d",
psz_fontfile, i_idx,
i_font_size, i_font_width ) < 0 )
return NULL;
FT_Face p_face = vlc_dictionary_value_for_key( &p_sys->face_map, psz_key );
if( p_face != NULL )
goto done;
if( psz_fontfile[0] == ':' && psz_fontfile[1] == '/' )
{
int i_attach = atoi( psz_fontfile + 2 );
if( i_attach < 0 || i_attach >= p_sys->i_font_attachments )
msg_Err( p_filter, "LoadFace: Invalid font attachment index" );
else
{
input_attachment_t *p_attach = p_sys->pp_font_attachments[ i_attach ];
if( FT_New_Memory_Face( p_sys->p_library, p_attach->p_data,
p_attach->i_data, i_idx, &p_face ) )
msg_Err( p_filter, "LoadFace: Error creating face for %s", psz_key );
}
}
#if defined( _WIN32 )
else if( !memcmp( psz_fontfile, ":dw/", 4 ) )
{
int i_index = atoi( psz_fontfile + 4 );
FT_Stream p_stream;
if( DWrite_GetFontStream( p_filter, i_index, &p_stream ) != VLC_SUCCESS )
msg_Err( p_filter, "LoadFace: Invalid font stream index" );
else
{
FT_Open_Args args = {0};
args.flags = FT_OPEN_STREAM;
args.stream = p_stream;
if( FT_Open_Face( p_sys->p_library, &args, i_idx, &p_face ) )
msg_Err( p_filter, "LoadFace: Error creating face for %s", psz_key );
}
}
#endif
else
if( FT_New_Face( p_sys->p_library, psz_fontfile, i_idx, &p_face ) )
msg_Err( p_filter, "LoadFace: Error creating face for %s", psz_key );
if( !p_face )
goto done;
if( FT_Select_Charmap( p_face, ft_encoding_unicode ) )
{
/* We've loaded a font face which is unhelpful for actually
* rendering text - fallback to the default one.
*/
msg_Err( p_filter, "LoadFace: Error selecting charmap for %s", psz_key );
FT_Done_Face( p_face );
p_face = NULL;
goto done;
}
if( FT_Set_Pixel_Sizes( p_face, i_font_width, i_font_size ) )
{
msg_Err( p_filter,
"LoadFace: Failed to set font size for %s", psz_key );
FT_Done_Face( p_face );
p_face = NULL;
goto done;
}
vlc_dictionary_insert( &p_sys->face_map, psz_key, p_face );
done:
free( psz_key );
return p_face;
}
/**
* ProcessEvents() reacts to a list of events originating from other VLC threads
*
* This function must be called with p_sys->lock unlocked
*
* @param intf_thread_t *p_intf This interface thread state
* @param callback_info_t *p_events the list of events to process
*/
static void ProcessEvents( intf_thread_t *p_intf,
callback_info_t **p_events, int i_events )
{
playlist_t *p_playlist = p_intf->p_sys->p_playlist;
bool b_can_play = p_intf->p_sys->b_can_play;
vlc_dictionary_t player_properties, tracklist_properties;
vlc_dictionary_init( &player_properties, 0 );
vlc_dictionary_init( &tracklist_properties, 0 );
for( int i = 0; i < i_events; i++ )
{
switch( p_events[i]->signal )
{
case SIGNAL_ITEM_CURRENT:
TrackChange( p_intf );
vlc_dictionary_insert( &player_properties, "Metadata", NULL );
break;
case SIGNAL_INTF_CHANGE:
case SIGNAL_PLAYLIST_ITEM_APPEND:
case SIGNAL_PLAYLIST_ITEM_DELETED:
PL_LOCK;
b_can_play = playlist_CurrentSize( p_playlist ) > 0;
PL_UNLOCK;
if( b_can_play != p_intf->p_sys->b_can_play )
{
p_intf->p_sys->b_can_play = b_can_play;
vlc_dictionary_insert( &player_properties, "CanPlay", NULL );
}
if( !vlc_dictionary_has_key( &tracklist_properties, "Tracks" ) )
vlc_dictionary_insert( &tracklist_properties, "Tracks", NULL );
break;
case SIGNAL_VOLUME_MUTED:
case SIGNAL_VOLUME_CHANGE:
vlc_dictionary_insert( &player_properties, "Volume", NULL );
break;
case SIGNAL_RANDOM:
vlc_dictionary_insert( &player_properties, "Shuffle", NULL );
break;
case SIGNAL_REPEAT:
case SIGNAL_LOOP:
vlc_dictionary_insert( &player_properties, "LoopStatus", NULL );
break;
case SIGNAL_STATE:
vlc_dictionary_insert( &player_properties, "PlaybackStatus", NULL );
break;
case SIGNAL_RATE:
vlc_dictionary_insert( &player_properties, "Rate", NULL );
break;
case SIGNAL_INPUT_METADATA:
{
input_thread_t *p_input = playlist_CurrentInput( p_playlist );
input_item_t *p_item;
if( p_input )
{
p_item = input_GetItem( p_input );
vlc_object_release( p_input );
if( p_item )
vlc_dictionary_insert( &player_properties,
"Metadata", NULL );
}
break;
}
case SIGNAL_CAN_SEEK:
vlc_dictionary_insert( &player_properties, "CanSeek", NULL );
break;
case SIGNAL_CAN_PAUSE:
vlc_dictionary_insert( &player_properties, "CanPause", NULL );
break;
case SIGNAL_SEEK:
{
input_thread_t *p_input;
input_item_t *p_item;
p_input = playlist_CurrentInput( p_intf->p_sys->p_playlist );
if( p_input )
{
p_item = input_GetItem( p_input );
vlc_object_release( p_input );
if( p_item && ( p_item->i_id == p_events[i]->i_item ) )
SeekedEmit( p_intf );
}
break;
}
default:
assert(0);
}
free( p_events[i] );
}
if( vlc_dictionary_keys_count( &player_properties ) )
PlayerPropertiesChangedEmit( p_intf, &player_properties );
if( vlc_dictionary_keys_count( &tracklist_properties ) )
TrackListPropertiesChangedEmit( p_intf, &tracklist_properties );
vlc_dictionary_clear( &player_properties, NULL, NULL );
vlc_dictionary_clear( &tracklist_properties, NULL, NULL );
}
vlc_family_t *FontConfig_GetFallbacks( filter_t *p_filter, const char *psz_family,
uni_char_t codepoint )
{
VLC_UNUSED( codepoint );
vlc_family_t *p_family = NULL;
filter_sys_t *p_sys = p_filter->p_sys;
char *psz_lc = ToLower( psz_family );
if( unlikely( !psz_lc ) )
return NULL;
p_family = vlc_dictionary_value_for_key( &p_sys->fallback_map, psz_lc );
if( p_family != kVLCDictionaryNotFound )
{
free( psz_lc );
return p_family;
}
else
p_family = NULL;
const char *psz_last_name = "";
FcPattern *p_pattern = FcPatternCreate();
FcValue family;
family.type = FcTypeString;
family.u.s = ( const FcChar8* ) psz_family;
FcPatternAdd( p_pattern, FC_FAMILY, family, FcFalse );
if( FcConfigSubstitute( NULL, p_pattern, FcMatchPattern ) == FcTrue )
{
FcDefaultSubstitute( p_pattern );
FcResult result;
FcFontSet* p_font_set = FcFontSort( NULL, p_pattern, FcTrue, NULL, &result );
if( p_font_set )
{
for( int i = 0; i < p_font_set->nfont; ++i )
{
char* psz_name = NULL;
FcPatternGetString( p_font_set->fonts[i],
FC_FAMILY, 0, ( FcChar8** )( &psz_name ) );
/* Avoid duplicate family names */
if( strcasecmp( psz_last_name, psz_name ) )
{
vlc_family_t *p_temp = NewFamily( p_filter, psz_name,
&p_family, NULL, NULL );
if( unlikely( !p_temp ) )
{
FcFontSetDestroy( p_font_set );
FcPatternDestroy( p_pattern );
if( p_family )
FreeFamilies( p_family, NULL );
free( psz_lc );
return NULL;
}
psz_last_name = p_temp->psz_name;
}
}
FcFontSetDestroy( p_font_set );
}
}
FcPatternDestroy( p_pattern );
if( p_family )
vlc_dictionary_insert( &p_sys->fallback_map, psz_lc, p_family );
free( psz_lc );
return p_family;
}
