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

static void test_strings( libvlc_int_t *p_libvlc ){    int i;    char *psz_tmp;    for( i = 0; i < i_var_count; i++ )         var_Create( p_libvlc, psz_var_name[i], VLC_VAR_STRING );    for( i = 0; i < i_var_count; i++ )        var_SetString( p_libvlc, psz_var_name[i], psz_var_name[i] );    for( i = 0; i < i_var_count; i++ )    {        psz_tmp = var_GetString( p_libvlc, psz_var_name[i] );        assert( !strcmp( psz_tmp, psz_var_name[i] ) );        free( psz_tmp );    }    for( i = 0; i < i_var_count; i++ )        var_Destroy( p_libvlc, psz_var_name[i] );    /* Some more test for strings */    var_Create( p_libvlc, "bla", VLC_VAR_STRING );    assert( var_GetNonEmptyString( p_libvlc, "bla" ) == NULL );    var_SetString( p_libvlc, "bla", "" );    assert( var_GetNonEmptyString( p_libvlc, "bla" ) == NULL );    var_SetString( p_libvlc, "bla", "test" );    psz_tmp = var_GetNonEmptyString( p_libvlc, "bla" );    assert( !strcmp( psz_tmp, "test" ) );    free( psz_tmp );    var_Destroy( p_libvlc, "bla" );}

static void create_SDP(sout_stream_t *p_stream, sout_access_out_t *p_access){    sout_stream_sys_t   *p_sys = p_stream->p_sys;    static const struct addrinfo hints = {		// sunqueen modify start        /*.ai_family =*/ AF_UNSPEC,        /*.ai_socktype =*/ SOCK_DGRAM,        /*.ai_protocol =*/ 0,        /*.ai_flags =*/ AI_NUMERICHOST | AI_NUMERICSERV | AI_IDN,		// sunqueen modify end    };    char *shost = var_GetNonEmptyString (p_access, "src-addr");    char *dhost = var_GetNonEmptyString (p_access, "dst-addr");    int sport = var_GetInteger (p_access, "src-port");    int dport = var_GetInteger (p_access, "dst-port");    struct sockaddr_storage src, dst;    socklen_t srclen = 0, dstlen = 0;    struct addrinfo *res;    if (!vlc_getaddrinfo (dhost, dport, &hints, &res))    {        memcpy (&dst, res->ai_addr, dstlen = res->ai_addrlen);        freeaddrinfo (res);    }    if (!vlc_getaddrinfo (shost, sport, &hints, &res))    {        memcpy (&src, res->ai_addr, srclen = res->ai_addrlen);        freeaddrinfo (res);    }    char *head = vlc_sdp_Start (VLC_OBJECT (p_stream), SOUT_CFG_PREFIX,            (struct sockaddr *)&src, srclen,            (struct sockaddr *)&dst, dstlen);    free (shost);    if (head != NULL)    {        char *psz_sdp = NULL;        if (asprintf (&psz_sdp, "%s"                    "m=video %d udp mpeg/r/n", head, dport) == -1)            psz_sdp = NULL;        free (head);        /* Register the SDP with the SAP thread */        if (psz_sdp)        {            msg_Dbg (p_stream, "Generated SDP:/n%s", psz_sdp);            p_sys->p_session =                sout_AnnounceRegisterSDP (p_stream, psz_sdp, dhost);            free( psz_sdp );        }    }    free (dhost);}

/****************************************************************************** Return EQ level for all bands as a Table*****************************************************************************/static int vlclua_equalizer_get( lua_State *L ){    int bands = 9;    input_thread_t *p_input = vlclua_get_input_internal( L );    if( !p_input )        return 0;    audio_output_t *p_aout = input_GetAout( p_input );    vlc_object_release( p_input );    if( !p_aout )        return 0;    float level = 0 ;    char *psz_af = var_GetNonEmptyString( p_aout, "audio-filter" );    if( !psz_af || strstr ( psz_af, "equalizer" ) == NULL )    {        free( psz_af );        vlc_object_release( p_aout );        return 0;    }    free( psz_af );    char *psz_bands_origin, *psz_bands;    psz_bands_origin = psz_bands = var_GetNonEmptyString( p_aout, "equalizer-bands" );    if( !psz_bands )    {        vlc_object_release( p_aout );        return 0;    }    locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL);    locale_t oldloc = uselocale (loc);    int i = 0;    char *str;    lua_newtable( L );    while( bands >= 0 )    {        level = strtof( psz_bands, &psz_bands);        bands--;        if( asprintf( &str , "%f" , level ) == -1 )            return 0;        lua_pushstring( L, str );        free(str);        if( asprintf( &str , "band id=/"%d/"", i++ ) == -1 )            return 0;        lua_setfield( L , -2 , str );        free( str );    }    free( psz_bands_origin );    if( loc != (locale_t)0 )    {        uselocale (oldloc);        freelocale (loc);    }    vlc_object_release( p_aout );    return 1;}

/***************************************************************************** * Open: open the file *****************************************************************************/static int Open( vlc_object_t *p_this ){    sout_access_out_t   *p_access = (sout_access_out_t*)p_this;    sout_access_out_sys_t *p_sys;    char *psz_idx;    config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );    if( !p_access->psz_path )    {        msg_Err( p_access, "no file name specified" );        return VLC_EGENERIC;    }    if( !( p_sys = malloc ( sizeof( *p_sys ) ) ) )        return VLC_ENOMEM;    p_sys->i_seglen = var_GetInteger( p_access, SOUT_CFG_PREFIX "seglen" );    p_sys->i_seglenm = CLOCK_FREQ * p_sys->i_seglen;    p_sys->i_numsegs = var_GetInteger( p_access, SOUT_CFG_PREFIX "numsegs" );    p_sys->b_splitanywhere = var_GetBool( p_access, SOUT_CFG_PREFIX "splitanywhere" );    p_sys->b_delsegs = var_GetBool( p_access, SOUT_CFG_PREFIX "delsegs" );    p_sys->b_ratecontrol = var_GetBool( p_access, SOUT_CFG_PREFIX "ratecontrol") ;    p_sys->psz_indexPath = NULL;    psz_idx = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "index" );    if ( psz_idx )    {        char *psz_tmp;        psz_tmp = str_format( p_access, psz_idx );        free( psz_idx );        if ( !psz_tmp )        {            free( p_sys );            return VLC_ENOMEM;        }        path_sanitize( psz_tmp );        p_sys->psz_indexPath = psz_tmp;        vlc_unlink( p_sys->psz_indexPath );    }    p_sys->psz_indexUrl = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "index-url" );    p_access->p_sys = p_sys;    p_sys->i_handle = -1;    p_sys->i_segment = 0;    p_sys->psz_cursegPath = NULL;    p_access->pf_write = Write;    p_access->pf_seek  = Seek;    p_access->pf_control = Control;    return VLC_SUCCESS;}

/** * This function will handle a snapshot request */static void VoutSaveSnapshot( vout_thread_t *p_vout ){    char *psz_path = var_GetNonEmptyString( p_vout, "snapshot-path" );    char *psz_format = var_GetNonEmptyString( p_vout, "snapshot-format" );    char *psz_prefix = var_GetNonEmptyString( p_vout, "snapshot-prefix" );    /* */    picture_t *p_picture;    block_t *p_image;    video_format_t fmt;    /* 500ms timeout     * XXX it will cause trouble with low fps video (< 2fps) */    if( vout_GetSnapshot( p_vout, &p_image, &p_picture, &fmt, psz_format, 500*1000 ) )    {        p_picture = NULL;        p_image = NULL;        goto exit;    }    if( !psz_path )    {        psz_path = VoutSnapshotGetDefaultDirectory();        if( !psz_path )        {            msg_Err( p_vout, "no path specified for snapshots" );            goto exit;        }    }    char *psz_filename;    if( VoutWriteSnapshot( p_vout, &psz_filename,                           p_image,                           psz_path, psz_format, psz_prefix ) )        goto exit;    VoutOsdSnapshot( p_vout, p_picture, psz_filename );    /* Generate a media player event  - Right now just trigger a global libvlc var        CHECK: Could not find a more local object. The goal is to communicate        vout_thread with libvlc_media_player or its input_thread */    var_SetString( p_vout->p_libvlc, "vout-snapshottaken", psz_filename );    free( psz_filename );exit:    if( p_image )        block_Release( p_image );    if( p_picture )        picture_Release( p_picture );    free( psz_prefix );    free( psz_format );    free( psz_path );}

static void DeinterlaceAdd(vout_thread_t *vout){    char *filter = var_GetNonEmptyString(vout, "video-filter");    if (FilterFind(filter, "deinterlace")) {        free(filter);        return;    }    /* */    if (filter) {        char *tmp = filter;        if (asprintf(&filter, "%s:%s", tmp, "deinterlace") < 0)            filter = tmp;        else            free(tmp);    } else {        filter = strdup("deinterlace");    }    if (filter) {        var_SetString(vout, "video-filter", filter);        free(filter);    }}

/****************************************************************************** Get the preamp level*****************************************************************************/static int vlclua_preamp_get( lua_State *L ){    input_thread_t *p_input = vlclua_get_input_internal( L );    if( !p_input )        return 0;    audio_output_t *p_aout = input_GetAout( p_input );    vlc_object_release( p_input );    if( !p_aout)        return 0;    char *psz_af = var_GetNonEmptyString( p_aout, "audio-filter" );    if( !psz_af || strstr ( psz_af, "equalizer" ) == NULL )    {        free( psz_af );        vlc_object_release( p_aout );        return 0;    }    free( psz_af );    lua_pushnumber( L, var_GetFloat( p_aout, "equalizer-preamp") );    vlc_object_release( p_aout );    return 1;}

/****************************************************************************** Set the equalizer level for the specified band*****************************************************************************/static int vlclua_equalizer_set( lua_State *L ){    int bandid = luaL_checknumber( L, 1 );    if( bandid < 0 || bandid > 9)        return 0;    input_thread_t *p_input = vlclua_get_input_internal( L );    if( !p_input )        return 0;    audio_output_t *p_aout = input_GetAout( p_input );    vlc_object_release( p_input );    if( !p_aout )        return 0;    char *psz_af = var_GetNonEmptyString( p_aout, "audio-filter" );    if( !psz_af || strstr ( psz_af, "equalizer" ) == NULL )    {        free( psz_af );        vlc_object_release( p_aout );        return 0;    }    free( psz_af );    float level = luaL_checknumber( L, 2 );    char *bands = var_GetString( p_aout, "equalizer-bands" );    locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL);    locale_t oldloc = uselocale (loc);    char *b = bands;    while( bandid > 0 )    {        float dummy = strtof( b, &b );        (void)dummy;        bandid--;    }    if( *b != '/0' )        *b++ = '/0';    float dummy = strtof( b, &b );    (void)dummy;    char *newstr;    if( asprintf( &newstr, "%s %.1f%s", bands, level, b ) != -1 )    {        var_SetString( p_aout, "equalizer-bands", newstr );        free( newstr );    }    if( loc != (locale_t)0 )    {        uselocale (oldloc);        freelocale (loc);    }    free( bands );    vlc_object_release( p_aout );    return 0;}

static bool DeinterlaceIsPresent(vout_thread_t *vout){    char *filter = var_GetNonEmptyString(vout, "video-filter");    bool is_found = FilterFind(filter, "deinterlace") != NULL;    free(filter);    return is_found;}

static int PPQCallback( vlc_object_t *p_this, const char *psz_var,                        vlc_value_t oldval, vlc_value_t newval, void *p_data ){    VLC_UNUSED(psz_var); VLC_UNUSED(oldval); VLC_UNUSED(p_data);    filter_t *p_filter = (filter_t *)p_this;    char *psz_name = var_GetNonEmptyString( p_filter, FILTER_PREFIX "name" );    PPChangeMode( p_filter, psz_name, newval.i_int );    free( psz_name );    return VLC_SUCCESS;}

char *libvlc_video_get_aspect_ratio( libvlc_media_player_t *p_mi,                                     libvlc_exception_t *p_e ){    char *psz_aspect = 0;    vout_thread_t *p_vout = GetVout( p_mi, p_e );    if( !p_vout ) return 0;    psz_aspect = var_GetNonEmptyString( p_vout, "aspect-ratio" );    vlc_object_release( p_vout );    return psz_aspect ? psz_aspect : strdup("");}

/***************************************************************************** * Create: initialize and set pf_video_filter() *****************************************************************************/static int Create( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys;    const vlc_chroma_description_t *p_chroma =        vlc_fourcc_GetChromaDescription( p_filter->fmt_in.video.i_chroma );    if( p_chroma == NULL || p_chroma->plane_count == 0 )        return VLC_EGENERIC;    config_ChainParse( p_filter, CFG_PREFIX, ppsz_vfilter_options,                       p_filter->p_cfg );    p_filter->p_sys = p_sys = calloc( 1, sizeof( filter_sys_t ) );    if( p_filter->p_sys == NULL )        return VLC_ENOMEM;    p_sys->p_image = image_HandlerCreate( p_this );    if( !p_sys->p_image )    {        msg_Err( p_this, "Couldn't get handle to image conversion routines." );        free( p_sys );        return VLC_EGENERIC;    }    p_sys->psz_format = var_CreateGetString( p_this, CFG_PREFIX "format" );    p_sys->i_format = image_Type2Fourcc( p_sys->psz_format );    if( !p_sys->i_format )    {        msg_Err( p_filter, "Could not find FOURCC for image type '%s'",                 p_sys->psz_format );        image_HandlerDelete( p_sys->p_image );        free( p_sys->psz_format );        free( p_sys );        return VLC_EGENERIC;    }    p_sys->i_width = var_CreateGetInteger( p_this, CFG_PREFIX "width" );    p_sys->i_height = var_CreateGetInteger( p_this, CFG_PREFIX "height" );    p_sys->i_ratio = var_CreateGetInteger( p_this, CFG_PREFIX "ratio" );    if( p_sys->i_ratio <= 0)        p_sys->i_ratio = 1;    p_sys->b_replace = var_CreateGetBool( p_this, CFG_PREFIX "replace" );    p_sys->psz_prefix = var_CreateGetString( p_this, CFG_PREFIX "prefix" );    p_sys->psz_path = var_GetNonEmptyString( p_this, CFG_PREFIX "path" );    if( p_sys->psz_path == NULL )        p_sys->psz_path = config_GetUserDir( VLC_PICTURES_DIR );    p_filter->pf_video_filter = Filter;    return VLC_SUCCESS;}

/***************************************************************************** * Mux: multiplex available data in input fifos *****************************************************************************/static int Mux( sout_mux_t *p_mux ){    sout_mux_sys_t *p_sys = p_mux->p_sys;    if( p_sys->b_error ) return VLC_EGENERIC;    if( p_sys->b_write_header )    {        int error;        msg_Dbg( p_mux, "writing header" );        char *psz_opts = var_GetNonEmptyString( p_mux, "sout-avformat-options" );        AVDictionary *options = NULL;        if (psz_opts) {            vlc_av_get_options(psz_opts, &options);            free(psz_opts);        }        av_dict_set( &p_sys->oc->metadata, "encoding_tool", "VLC "VERSION, 0 );        error = avformat_write_header( p_sys->oc, options ? &options : NULL);        AVDictionaryEntry *t = NULL;        while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX))) {            msg_Err( p_mux, "Unknown option /"%s/"", t->key );        }        av_dict_free(&options);        if( error < 0 )        {            msg_Err( p_mux, "could not write header: %s",                     vlc_strerror_c(AVUNERROR(error)) );            p_sys->b_write_header = false;            p_sys->b_error = true;            return VLC_EGENERIC;        }        avio_flush( p_sys->oc->pb );        p_sys->b_write_header = false;    }    for( ;; )    {        mtime_t i_dts;        int i_stream = sout_MuxGetStream( p_mux, 1, &i_dts );        if( i_stream < 0 )            return VLC_SUCCESS;        MuxBlock( p_mux, p_mux->pp_inputs[i_stream] );    }    return VLC_SUCCESS;}

void VlcProc::init_equalizer(){    playlist_t* pPlaylist = getIntf()->p_sys->p_playlist;    audio_output_t* pAout = playlist_GetAout( pPlaylist );    if( pAout )    {        if( !var_Type( pAout, "equalizer-bands" ) )            var_Create( pAout, "equalizer-bands",                        VLC_VAR_STRING | VLC_VAR_DOINHERIT);        if( !var_Type( pAout, "equalizer-preamp" ) )            var_Create( pAout, "equalizer-preamp",                        VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);        // New Aout (addCallbacks)        var_AddCallback( pAout, "audio-filter",                         onGenericCallback, this );        var_AddCallback( pAout, "equalizer-bands",                         onEqBandsChange, this );        var_AddCallback( pAout, "equalizer-preamp",                         onEqPreampChange, this );    }    // is equalizer enabled ?    char *pFilters = pAout ?                   var_GetNonEmptyString( pAout, "audio-filter" ) :                   var_InheritString( getIntf(), "audio-filter" );    bool b_equalizer = pFilters && strstr( pFilters, "equalizer" );    free( pFilters );    SET_BOOL( m_cVarEqualizer, b_equalizer );    // retrieve initial bands    char* bands = pAout ?                  var_GetString( pAout, "equalizer-bands" ) :                  var_InheritString( getIntf(), "equalizer-bands" );    if( bands )    {        m_varEqBands.set( bands );        free( bands );    }    // retrieve initial preamp    float preamp = pAout ?                   var_GetFloat( pAout, "equalizer-preamp" ) :                   var_InheritFloat( getIntf(), "equalizer-preamp" );    EqualizerPreamp *pVarPreamp = (EqualizerPreamp*)m_cVarEqPreamp.get();    pVarPreamp->set( (preamp + 20.0) / 40.0 );    if( pAout )        vlc_object_release( pAout);}

void VlcProc::update_equalizer(){    char *pFilters;    if( m_pAout )        pFilters = var_GetNonEmptyString( m_pAout, "audio-filter" );    else        pFilters = var_InheritString( getIntf(), "audio-filter" );    bool b_equalizer = pFilters && strstr( pFilters, "equalizer" );    free( pFilters );    SET_BOOL( m_cVarEqualizer, b_equalizer );}

void EventThreadUpdateTitle( event_thread_t *p_event, const char *psz_fallback ){    char *psz_title = var_GetNonEmptyString( p_event->vd, "video-title" );    if( !psz_title )        psz_title = strdup( psz_fallback );    if( !psz_title )        return;    vlc_mutex_lock( &p_event->lock );    free( p_event->psz_title );    p_event->psz_title = psz_title;    vlc_mutex_unlock( &p_event->lock );    PostMessage( p_event->hwnd, WM_VLC_CHANGE_TEXT, 0, 0 );}

/***************************************************************************** * Run: main thread *****************************************************************************/VLC_NORETURNstatic void *Run( void *data ){    services_discovery_t *p_sd = data;    services_discovery_sys_t *p_sys  = p_sd->p_sys;    vlc_mutex_lock( &p_sys->lock );    mutex_cleanup_push( &p_sys->lock );    for( ;; )    {        while( !p_sys->b_update )            vlc_cond_wait( &p_sys->wait, &p_sys->lock );        int canc = vlc_savecancel ();        msg_Dbg( p_sd, "Update required" );        if( p_sys->update_type == UPDATE_URLS )        {            char *psz_urls = var_GetNonEmptyString( p_sd->p_parent,                                                    "podcast-urls" );            ParseUrls( p_sd, psz_urls );            free( psz_urls );        }        else if( p_sys->update_type == UPDATE_REQUEST )            ParseRequest( p_sd );        p_sys->b_update = false;        for( int i = 0; i < p_sd->p_sys->i_input; i++ )        {            input_thread_t *p_input = p_sd->p_sys->pp_input[i];            int state = var_GetInteger( p_input, "state" );            if( state == END_S || state == ERROR_S )            {                input_Stop( p_input );                input_Close( p_input );                p_sd->p_sys->pp_input[i] = NULL;                REMOVE_ELEM( p_sys->pp_input, p_sys->i_input, i );                i--;            }        }        vlc_restorecancel (canc);    }    vlc_cleanup_pop();    vlc_assert_unreachable(); /* dead code */}

/***************************************************************************** * Run: main thread *****************************************************************************/static void *Run( void *data ){    services_discovery_t *p_sd = data;    services_discovery_sys_t *p_sys  = p_sd->p_sys;    vlc_mutex_lock( &p_sys->lock );    mutex_cleanup_push( &p_sys->lock );    for( ;; )    {        while( !p_sys->b_update )            vlc_cond_wait( &p_sys->wait, &p_sys->lock );        int canc = vlc_savecancel ();        msg_Dbg( p_sd, "Update required" );        if( p_sys->update_type == UPDATE_URLS )        {          char* psz_urls = var_GetNonEmptyString( p_sd, "podcast-urls" );          ParseUrls( p_sd, psz_urls );          free( psz_urls );        }        else if( p_sys->update_type == UPDATE_REQUEST )        {          ParseRequest( p_sd );        }        p_sys->b_update = false;        for( int i = 0; i < p_sd->p_sys->i_input; i++ )        {            input_thread_t *p_input = p_sd->p_sys->pp_input[i];            if( p_input->b_eof || p_input->b_error )            {                input_Stop( p_input, false );                vlc_thread_join( p_input );                vlc_object_release( p_input );                p_sd->p_sys->pp_input[i] = NULL;                REMOVE_ELEM( p_sys->pp_input, p_sys->i_input, i );                i--;            }        }        vlc_restorecancel (canc);    }    vlc_cleanup_pop();    assert(0); /* dead code */}

/****************************************************************************** Set the equalizer level for the specified band*****************************************************************************/static int vlclua_equalizer_set( lua_State *L ){    int bandid = luaL_checknumber( L, 1 );    if( bandid < 0 || bandid > 9)        return 0;    input_thread_t *p_input = vlclua_get_input_internal( L );    if( !p_input )        return 0;    int i_pos = 0 , j = 0;    audio_output_t *p_aout = input_GetAout( p_input );    vlc_object_release( p_input );    if( !p_aout )        return 0;    char *psz_af = var_GetNonEmptyString( p_aout, "audio-filter" );    if( !psz_af || strstr ( psz_af, "equalizer" ) == NULL )    {        free( psz_af );        vlc_object_release( p_aout );        return 0;    }    free( psz_af );    float level = luaL_checknumber( L, 2 );    char *bands = var_GetString( p_aout, "equalizer-bands" );    char newstr[7];    while( j != bandid )    {        i_pos++;        if( bands[i_pos] == '.' )        {            i_pos++;            j++;        }    }    if( bandid != 0 )        i_pos++;    snprintf( newstr, sizeof ( newstr ) , "%6.1f", level);    for( int i = 0 ; i < 6 ; i++ )        bands[i_pos+i] = newstr[i];    var_SetString( p_aout, "equalizer-bands", bands );    vlc_object_release( p_aout );    return 1;}

static void DeinterlaceRemove(vout_thread_t *vout){    char *filter = var_GetNonEmptyString(vout, "video-filter");    char *start = FilterFind(filter, "deinterlace");    if (!start) {        free(filter);        return;    }    /* */    strcpy(&start[0], &start[strlen("deinterlace")]);    if (*start == ':')        strcpy(&start[0], &start[1]);    var_SetString(vout, "video-filter", filter);    free(filter);}

void intf_sys_t::msgPlayerLoad(){    char *psz_mime = var_GetNonEmptyString(p_stream, SOUT_CFG_PREFIX "mime");    if (psz_mime == NULL)        return;    std::stringstream ss;    ss << "{/"type/":/"LOAD/","       <<  "/"media/":{/"contentId/":/"http://" << serverIP << ":"           << var_InheritInteger(p_stream, SOUT_CFG_PREFIX"http-port")           << "/stream/","       <<             "/"streamType/":/"LIVE/","       <<             "/"contentType/":/"" << std::string(psz_mime) << "/"},"       <<  "/"requestId/":" << i_requestId++ << "}";    free(psz_mime);    buildMessage(NAMESPACE_MEDIA, ss.str(), appTransportId);}

/***************************************************************************** * Open: *****************************************************************************/static int Open( vlc_object_t *p_this ){    sout_stream_t *p_stream = (sout_stream_t*)p_this;    sout_stream_sys_t *p_sys;    p_stream->pf_add    = Add;    p_stream->pf_del    = Del;    p_stream->pf_send   = Send;    p_stream->p_sys = p_sys = malloc( sizeof(*p_sys) );    if( !p_sys )        return VLC_ENOMEM;    config_ChainParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options, p_stream->p_cfg );    p_sys->p_out = NULL;    p_sys->psz_prefix = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "dst-prefix" );    if( !p_sys->psz_prefix  )    {        p_sys->psz_prefix = strdup( "sout-record-" );        if( !p_sys->psz_prefix )        {            free( p_sys );            return VLC_ENOMEM;        }    }    p_sys->i_date_start = -1;    p_sys->i_size = 0;#ifdef OPTIMIZE_MEMORY    p_sys->i_max_wait = 5*CLOCK_FREQ; /* 5s */    p_sys->i_max_size = 1*1024*1024; /* 1 MiB */#else    p_sys->i_max_wait = 30*CLOCK_FREQ; /* 30s */    p_sys->i_max_size = 20*1024*1024; /* 20 MiB */#endif    p_sys->b_drop = false;    p_sys->i_dts_start = 0;    TAB_INIT( p_sys->i_id, p_sys->id );    return VLC_SUCCESS;}

/****************************************************************************** Set the preset specified by preset id*****************************************************************************/static int vlclua_equalizer_setpreset( lua_State *L ){    int presetid = luaL_checknumber( L, 1 );    if( presetid >= NB_PRESETS || presetid < 0 )        return 0;    input_thread_t *p_input = vlclua_get_input_internal( L );    if( p_input )    {        audio_output_t *p_aout = input_GetAout( p_input );        vlc_object_release( p_input );        if( !p_aout )        {            return 0;        }        char *psz_af = var_GetNonEmptyString( p_aout, "audio-filter" );        if( !psz_af || strstr ( psz_af, "equalizer" ) == NULL )        {            free( psz_af );            vlc_object_release( p_aout );            return 0;        }        free( psz_af );        char *newstr;        if( asprintf( &newstr , "%6.1f" , eqz_preset_10b[presetid].f_amp[0] ) == -1 )            return 0;        for ( int i = 1 ; i < 10 ; i++ )        {            if( asprintf( &newstr, "%s%6.1f",newstr ,eqz_preset_10b[presetid].f_amp[i]) == -1 )                return 0;        }        var_SetString( p_aout, "equalizer-bands",newstr );        var_SetFloat( p_aout, "equalizer-preamp", eqz_preset_10b[presetid].f_preamp );        var_SetString( p_aout , "equalizer-preset" , preset_list[presetid] );        vlc_object_release( p_aout );        free( newstr );        return 1;    }    return 0;}

char *vlc_sdp_Start (vlc_object_t *obj, const char *cfgpref,                     const struct sockaddr *src, size_t srclen,                     const struct sockaddr *addr, size_t addrlen){    size_t cfglen = strlen (cfgpref);    if (cfglen > 100)        return NULL;    char varname[cfglen + sizeof ("description")], *subvar = varname + cfglen;    strcpy (varname, cfgpref);    strcpy (subvar, "name");    char *name = var_GetNonEmptyString (obj, varname);    strcpy (subvar, "description");    char *description = var_GetNonEmptyString (obj, varname);    strcpy (subvar, "url");    char *url = var_GetNonEmptyString (obj, varname);    strcpy (subvar, "email");    char *email = var_GetNonEmptyString (obj, varname);    strcpy (subvar, "phone");    char *phone = var_GetNonEmptyString (obj, varname);    char *sdp = sdp_Start (name, description, url, email, phone,                           src, srclen, addr, addrlen);    free (name);    free (description);    free (url);    free (email);    free (phone);    if (sdp == NULL)        return NULL;    strcpy (subvar, "cat");    char *cat = var_GetNonEmptyString (obj, varname);    if (cat != NULL)    {        sdp_AddAttribute (&sdp, "cat", "%s", cat);        /* Totally non-standard */        sdp_AddAttribute (&sdp, "x-plgroup", "%s", cat);        free (cat);    }    return sdp;}

static void msgLoad(sout_stream_t *p_stream){    sout_stream_sys_t *p_sys = p_stream->p_sys;    char *psz_mime = var_GetNonEmptyString(p_stream, SOUT_CFG_PREFIX "mime");    if (psz_mime == NULL)        return;    std::stringstream ss;    ss << "{/"type/":/"LOAD/","       <<  "/"media/":{/"contentId/":/"http://" << p_sys->serverIP << ":"           << var_InheritInteger(p_stream, SOUT_CFG_PREFIX"http-port")           << "/stream/","       <<             "/"streamType/":/"LIVE/","       <<             "/"contentType/":/"" << std::string(psz_mime) << "/"},"       <<  "/"requestId/":" << p_stream->p_sys->i_requestId++ << "}";    free(psz_mime);    castchannel::CastMessage msg = buildMessage("urn:x-cast:com.google.cast.media",        castchannel::CastMessage_PayloadType_STRING, ss.str(), p_sys->appTransportId);    p_sys->messagesToSend.push(msg);}

/***************************************************************************** * Open: open the shout connection *****************************************************************************/static int Open( vlc_object_t *p_this ){    sout_access_out_t *p_access = (sout_access_out_t*)p_this;    sout_access_out_sys_t *p_sys;    shout_t *p_shout;    long i_ret;    char *psz_val;    char *psz_name;    char *psz_description;    char *psz_genre;    char *psz_url;    vlc_url_t url;    config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );    if( !p_access->psz_path )    {        msg_Err( p_access,                 "please specify url=user:[email
C++ var_InheritBool函数代码示例
C++ var_GetInteger函数代码示例