/***********************************************************************
* RunSD (Private)
***********************************************************************/
static void* RunSD( vlc_object_t *p_this )
{
services_discovery_t *p_sd = (services_discovery_t *)p_this;
vlc_event_t event;
event.type = vlc_ServicesDiscoveryStarted;
vlc_event_send( &p_sd->event_manager, &event );
p_sd->pf_run( p_sd );
event.type = vlc_ServicesDiscoveryEnded;
vlc_event_send( &p_sd->event_manager, &event );
return NULL;
}
int input_item_AddInfo( input_item_t *p_i,
const char *psz_cat,
const char *psz_name,
const char *psz_format, ... )
{
va_list args;
vlc_mutex_lock( &p_i->lock );
va_start( args, psz_format );
const int i_ret = InputItemVaAddInfo( p_i, psz_cat, psz_name, psz_format, args );
va_end( args );
vlc_mutex_unlock( &p_i->lock );
if( !i_ret )
{
vlc_event_t event;
event.type = vlc_InputItemInfoChanged;
vlc_event_send( &p_i->event_manager, &event );
}
return i_ret;
}
void input_item_SetPreparsed( input_item_t *p_i, bool b_preparsed )
{
bool b_send_event = false;
vlc_mutex_lock( &p_i->lock );
if( !p_i->p_meta )
p_i->p_meta = vlc_meta_New();
int status = vlc_meta_GetStatus(p_i->p_meta);
int new_status;
if( b_preparsed )
new_status = status | ITEM_PREPARSED;
else
new_status = status & ~ITEM_PREPARSED;
if( status != new_status )
{
vlc_meta_SetStatus(p_i->p_meta, new_status);
b_send_event = true;
}
vlc_mutex_unlock( &p_i->lock );
if( b_send_event )
{
vlc_event_t event;
event.type = vlc_InputItemPreparsedChanged;
event.u.input_item_preparsed_changed.new_status = new_status;
vlc_event_send( &p_i->event_manager, &event );
}
}
void input_item_SetEpgEvent( input_item_t *p_item, const vlc_epg_event_t *p_epg_evt )
{
bool b_changed = false;
vlc_mutex_lock( &p_item->lock );
for( int i = 0; i < p_item->i_epg; i++ )
{
vlc_epg_t *p_epg = p_item->pp_epg[i];
for( size_t j = 0; j < p_epg->i_event; j++ )
{
/* Same event can exist in more than one table */
if( p_epg->pp_event[j]->i_id == p_epg_evt->i_id )
{
vlc_epg_event_t *p_dup = vlc_epg_event_Duplicate( p_epg_evt );
if( p_dup )
{
if( p_epg->p_current == p_epg->pp_event[j] )
p_epg->p_current = p_dup;
vlc_epg_event_Delete( p_epg->pp_event[j] );
p_epg->pp_event[j] = p_dup;
b_changed = true;
}
break;
}
}
}
vlc_mutex_unlock( &p_item->lock );
if ( b_changed )
{
vlc_event_t event = { .type = vlc_InputItemInfoChanged, };
vlc_event_send( &p_item->event_manager, &event );
}
}
void input_item_SignalPreparseEnded( input_item_t *p_i, int status )
{
vlc_event_t event;
event.type = vlc_InputItemPreparseEnded;
event.u.input_item_preparse_ended.new_status = status;
vlc_event_send( &p_i->event_manager, &event );
}
/***********************************************************************
* RemoveItem
***********************************************************************/
void
services_discovery_RemoveItem ( services_discovery_t * p_sd, input_item_t * p_item )
{
vlc_event_t event;
event.type = vlc_ServicesDiscoveryItemRemoved;
event.u.services_discovery_item_removed.p_item = p_item;
vlc_event_send( &p_sd->event_manager, &event );
}
void input_SendEventMetaInfo( input_thread_t *p_input )
{
Trigger( p_input, INPUT_EVENT_ITEM_INFO );
/* FIXME remove this ugliness */
vlc_event_t event;
event.type = vlc_InputItemInfoChanged;
vlc_event_send( &p_input->p->p_item->event_manager, &event );
}
void input_SendEventMetaName( input_thread_t *p_input, const char *psz_name )
{
Trigger( p_input, INPUT_EVENT_ITEM_NAME );
/* FIXME remove this ugliness */
vlc_event_t event;
event.type = vlc_InputItemNameChanged;
event.u.input_item_name_changed.new_name = psz_name;
vlc_event_send( &p_input->p->p_item->event_manager, &event );
}
/***********************************************************************
* AddItem
***********************************************************************/
void
services_discovery_AddItem ( services_discovery_t * p_sd, input_item_t * p_item,
const char * psz_category )
{
vlc_event_t event;
event.type = vlc_ServicesDiscoveryItemAdded;
event.u.services_discovery_item_added.p_new_item = p_item;
event.u.services_discovery_item_added.psz_category = psz_category;
vlc_event_send( &p_sd->event_manager, &event );
}
/* FIXME: review them because vlc_event_send might be
* moved inside input_item* functions.
*/
void input_SendEventMeta( input_thread_t *p_input )
{
Trigger( p_input, INPUT_EVENT_ITEM_META );
/* FIXME remove this ugliness ? */
vlc_event_t event;
event.type = vlc_InputItemMetaChanged;
event.u.input_item_meta_changed.meta_type = vlc_meta_ArtworkURL;
vlc_event_send( &p_input->p->p_item->event_manager, &event );
}
static void post_subitems( input_item_node_t *p_node )
{
for( int i = 0; i < p_node->i_children; i++ )
{
vlc_event_t event;
event.type = vlc_InputItemSubItemAdded;
event.u.input_item_subitem_added.p_new_child = p_node->pp_children[i]->p_item;
vlc_event_send( &p_node->p_item->event_manager, &event );
post_subitems( p_node->pp_children[i] );
}
}
void input_item_SetMeta( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz_val )
{
vlc_event_t event;
vlc_mutex_lock( &p_i->lock );
if( !p_i->p_meta )
p_i->p_meta = vlc_meta_New();
vlc_meta_Set( p_i->p_meta, meta_type, psz_val );
vlc_mutex_unlock( &p_i->lock );
/* Notify interested third parties */
event.type = vlc_InputItemMetaChanged;
event.u.input_item_meta_changed.meta_type = meta_type;
vlc_event_send( &p_i->event_manager, &event );
}
/* This won't hold the item, but can tell to interested third parties
* Like the playlist, that there is a new sub item. With this design
* It is not the input item's responsability to keep all the ref of
* the input item children. */
void input_item_AddSubItem( input_item_t *p_parent, input_item_t *p_child )
{
vlc_mutex_lock( &p_parent->lock );
p_parent->i_type = ITEM_TYPE_PLAYLIST;
vlc_mutex_unlock( &p_parent->lock );
/* Notify interested third parties */
vlc_event_t event;
event.type = vlc_InputItemSubItemAdded;
event.u.input_item_subitem_added.p_new_child = p_child;
vlc_event_send( &p_parent->event_manager, &event );
}
/*******************************************************************//**
* Start a Service Discovery
***********************************************************************/
bool vlc_sd_Start ( services_discovery_t * p_sd )
{
assert(!p_sd->p_module);
p_sd->p_module = module_need( p_sd, "services_discovery",
p_sd->psz_name, true );
if( p_sd->p_module == NULL )
{
msg_Err( p_sd, "no suitable services discovery module" );
return false;
}
vlc_event_t event = {
.type = vlc_ServicesDiscoveryStarted
};
vlc_event_send( &p_sd->event_manager, &event );
return true;
}
void input_item_SetErrorWhenReading( input_item_t *p_i, bool b_error )
{
bool b_changed;
vlc_mutex_lock( &p_i->lock );
b_changed = p_i->b_error_when_reading != b_error;
p_i->b_error_when_reading = b_error;
vlc_mutex_unlock( &p_i->lock );
if( b_changed )
{
vlc_event_t event;
event.type = vlc_InputItemErrorWhenReadingChanged;
event.u.input_item_error_when_reading_changed.new_value = b_error;
vlc_event_send( &p_i->event_manager, &event );
}
}
void input_item_SetDuration( input_item_t *p_i, mtime_t i_duration )
{
bool b_send_event = false;
vlc_mutex_lock( &p_i->lock );
if( p_i->i_duration != i_duration )
{
p_i->i_duration = i_duration;
b_send_event = true;
}
vlc_mutex_unlock( &p_i->lock );
if( b_send_event )
{
vlc_event_t event;
event.type = vlc_InputItemDurationChanged;
event.u.input_item_duration_changed.new_duration = i_duration;
vlc_event_send( &p_i->event_manager, &event );
}
}
void input_item_SetEpg( input_item_t *p_item,
const char *psz_epg, const vlc_epg_t *p_epg )
{
input_item_DelInfo( p_item, psz_epg, NULL );
#ifdef HAVE_LOCALTIME_R
vlc_mutex_lock( &p_item->lock );
for( int i = 0; i < p_epg->i_event; i++ )
{
const vlc_epg_event_t *p_evt = p_epg->pp_event[i];
time_t t_start = (time_t)p_evt->i_start;
struct tm tm_start;
char psz_start[128];
localtime_r( &t_start, &tm_start );
snprintf( psz_start, sizeof(psz_start), "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
1900 + tm_start.tm_year, 1 + tm_start.tm_mon, tm_start.tm_mday,
tm_start.tm_hour, tm_start.tm_min, tm_start.tm_sec );
if( p_evt->psz_short_description || p_evt->psz_description )
InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d) - %s",
p_evt->psz_name,
p_evt->i_duration/60/60, (p_evt->i_duration/60)%60,
p_evt->psz_short_description ? p_evt->psz_short_description : p_evt->psz_description );
else
InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d)",
p_evt->psz_name,
p_evt->i_duration/60/60, (p_evt->i_duration/60)%60 );
}
vlc_mutex_unlock( &p_item->lock );
if( p_epg->i_event > 0 )
{
vlc_event_t event;
event.type = vlc_InputItemInfoChanged;
vlc_event_send( &p_item->event_manager, &event );
}
#endif
}
void input_item_ReplaceInfos( input_item_t *p_item, info_category_t *p_cat )
{
vlc_mutex_lock( &p_item->lock );
int i_cat;
info_category_t *p_old = InputItemFindCat( p_item, &i_cat, p_cat->psz_name );
if( p_old )
{
info_category_Delete( p_old );
p_item->pp_categories[i_cat] = p_cat;
}
else
{
INSERT_ELEM( p_item->pp_categories, p_item->i_categories, p_item->i_categories,
p_cat );
}
vlc_mutex_unlock( &p_item->lock );
vlc_event_t event;
event.type = vlc_InputItemInfoChanged;
vlc_event_send( &p_item->event_manager, &event );
}
int input_item_DelInfo( input_item_t *p_i,
const char *psz_cat,
const char *psz_name )
{
vlc_mutex_lock( &p_i->lock );
int i_cat;
info_category_t *p_cat = InputItemFindCat( p_i, &i_cat, psz_cat );
if( !p_cat )
{
vlc_mutex_unlock( &p_i->lock );
return VLC_EGENERIC;
}
if( psz_name )
{
/* Remove a specific info */
int i_ret = info_category_DeleteInfo( p_cat, psz_name );
if( i_ret )
{
vlc_mutex_unlock( &p_i->lock );
return VLC_EGENERIC;
}
}
else
{
/* Remove the complete categorie */
info_category_Delete( p_cat );
REMOVE_ELEM( p_i->pp_categories, p_i->i_categories, i_cat );
}
vlc_mutex_unlock( &p_i->lock );
vlc_event_t event;
event.type = vlc_InputItemInfoChanged;
vlc_event_send( &p_i->event_manager, &event );
return VLC_SUCCESS;
}
void input_item_MergeInfos( input_item_t *p_item, info_category_t *p_cat )
{
vlc_mutex_lock( &p_item->lock );
info_category_t *p_old = InputItemFindCat( p_item, NULL, p_cat->psz_name );
if( p_old )
{
for( int i = 0; i < p_cat->i_infos; i++ )
info_category_ReplaceInfo( p_old, p_cat->pp_infos[i] );
TAB_CLEAN( p_cat->i_infos, p_cat->pp_infos );
info_category_Delete( p_cat );
}
else
{
INSERT_ELEM( p_item->pp_categories, p_item->i_categories, p_item->i_categories,
p_cat );
}
vlc_mutex_unlock( &p_item->lock );
vlc_event_t event;
event.type = vlc_InputItemInfoChanged;
vlc_event_send( &p_item->event_manager, &event );
}
void input_item_SetEpg( input_item_t *p_item, const vlc_epg_t *p_update )
{
vlc_mutex_lock( &p_item->lock );
/* */
vlc_epg_t *p_epg = NULL;
for( int i = 0; i < p_item->i_epg; i++ )
{
vlc_epg_t *p_tmp = p_item->pp_epg[i];
if( (p_tmp->psz_name == NULL) != (p_update->psz_name == NULL) )
continue;
if( p_tmp->psz_name && p_update->psz_name && strcmp(p_tmp->psz_name, p_update->psz_name) )
continue;
p_epg = p_tmp;
break;
}
/* */
if( !p_epg )
{
p_epg = vlc_epg_New( p_update->psz_name );
if( p_epg )
TAB_APPEND( p_item->i_epg, p_item->pp_epg, p_epg );
}
if( p_epg )
vlc_epg_Merge( p_epg, p_update );
vlc_mutex_unlock( &p_item->lock );
if( !p_epg )
return;
#ifdef EPG_DEBUG
char *psz_epg;
if( asprintf( &psz_epg, "EPG %s", p_epg->psz_name ? p_epg->psz_name : "unknown" ) < 0 )
goto signal;
input_item_DelInfo( p_item, psz_epg, NULL );
vlc_mutex_lock( &p_item->lock );
for( int i = 0; i < p_epg->i_event; i++ )
{
const vlc_epg_event_t *p_evt = p_epg->pp_event[i];
time_t t_start = (time_t)p_evt->i_start;
struct tm tm_start;
char psz_start[128];
localtime_r( &t_start, &tm_start );
snprintf( psz_start, sizeof(psz_start), "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
1900 + tm_start.tm_year, 1 + tm_start.tm_mon, tm_start.tm_mday,
tm_start.tm_hour, tm_start.tm_min, tm_start.tm_sec );
if( p_evt->psz_short_description || p_evt->psz_description )
InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d) - %s %s",
p_evt->psz_name,
p_evt->i_duration/60/60, (p_evt->i_duration/60)%60,
p_evt->psz_short_description ? p_evt->psz_short_description : "" ,
p_evt->psz_description ? p_evt->psz_description : "" );
else
InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d)",
p_evt->psz_name,
p_evt->i_duration/60/60, (p_evt->i_duration/60)%60 );
}
vlc_mutex_unlock( &p_item->lock );
free( psz_epg );
signal:
#endif
if( p_epg->i_event > 0 )
{
vlc_event_t event = { .type = vlc_InputItemInfoChanged, };
vlc_event_send( &p_item->event_manager, &event );
}
int input_item_DelInfo( input_item_t *p_i,
const char *psz_cat,
const char *psz_name )
{
info_category_t *p_cat = NULL;
int i_cat;
int i;
vlc_mutex_lock( &p_i->lock );
for( i_cat = 0; i_cat < p_i->i_categories; i_cat++ )
{
if( !strcmp( p_i->pp_categories[i_cat]->psz_name,
psz_cat ) )
{
p_cat = p_i->pp_categories[i_cat];
break;
}
}
if( p_cat == NULL )
{
vlc_mutex_unlock( &p_i->lock );
return VLC_EGENERIC;
}
if( psz_name )
{
/* Remove a specific info */
for( i = 0; i < p_cat->i_infos; i++ )
{
if( !strcmp( p_cat->pp_infos[i]->psz_name, psz_name ) )
{
free( p_cat->pp_infos[i]->psz_name );
free( p_cat->pp_infos[i]->psz_value );
free( p_cat->pp_infos[i] );
REMOVE_ELEM( p_cat->pp_infos, p_cat->i_infos, i );
break;
}
}
if( i >= p_cat->i_infos )
{
vlc_mutex_unlock( &p_i->lock );
return VLC_EGENERIC;
}
}
else
{
/* Remove the complete categorie */
for( i = 0; i < p_cat->i_infos; i++ )
{
free( p_cat->pp_infos[i]->psz_name );
free( p_cat->pp_infos[i]->psz_value );
free( p_cat->pp_infos[i] );
}
free( p_cat->pp_infos );
REMOVE_ELEM( p_i->pp_categories, p_i->i_categories, i_cat );
}
// Free the category
free( p_cat->psz_name );
free( p_cat );
vlc_mutex_unlock( &p_i->lock );
vlc_event_t event;
event.type = vlc_InputItemInfoChanged;
vlc_event_send( &p_i->event_manager, &event );
return VLC_SUCCESS;
}
void input_item_SignalPreparseEnded( input_item_t *p_i )
{
vlc_event_t event;
event.type = vlc_InputItemPreparseEnded;
vlc_event_send( &p_i->event_manager, &event );
}
