自学教程：C++ vlc_event_send函数代码示例

/*********************************************************************** * 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 ***********************************************************************/voidservices_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 ***********************************************************************/voidservices_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 );}