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

static uint32_t var_InheritCodeRate (vlc_object_t *obj, const char *varname){    char *code_rate = var_InheritString (obj, varname);    if (code_rate == NULL)        return VLC_FEC_AUTO;    uint16_t a, b;    int v = sscanf (code_rate, "%"SCNu16"/%"SCNu16, &a, &b);    free (code_rate);    switch (v)    {        case 2:            return VLC_FEC(a, b);        case 1:            if (a == 0)                return 0;            /* Backward compatibility with VLC < 1.2 (= Linux DVBv3 enum) */            if (a < 9)            {                msg_Warn (obj, "/"%s=%"PRIu16"/" option is obsolete. "                          "Use /"%s=%"PRIu16"/%"PRIu16"/" instead.",                          varname + 4, a, varname + 4, a, a + 1);                return VLC_FEC(a, a + 1);            }            else                msg_Warn (obj, "/"fec=9/" option is obsolete.");    }    return VLC_FEC_AUTO;}

/** * Checks for help command line options such as --help or --version. * If one is found, print the corresponding text. * /return true if a command line options caused some help message to be * printed, false otherwise.  */bool config_PrintHelp (vlc_object_t *obj){    char *str;    /* Check for short help option */    if (var_InheritBool (obj, "help"))    {        Help (obj, "help");        return true;    }    /* Check for version option */    if (var_InheritBool (obj, "version"))    {        Version();        return true;    }    /* Check for help on modules */    str = var_InheritString (obj, "module");    if (str != NULL)    {        Help (obj, str);        free (str);        return true;    }    /* Check for full help option */    if (var_InheritBool (obj, "full-help"))    {        var_Create (obj, "advanced", VLC_VAR_BOOL);        var_SetBool (obj, "advanced", true);        var_Create (obj, "help-verbose", VLC_VAR_BOOL);        var_SetBool (obj, "help-verbose", true);        Help (obj, "full-help");        return true;    }    /* Check for long help option */    if (var_InheritBool (obj, "longhelp"))    {        Help (obj, "longhelp");        return true;    }    /* Check for module list option */    if (var_InheritBool (obj, "list"))    {        ListModules (obj, false );        return true;    }    if (var_InheritBool (obj, "list-verbose"))    {        ListModules (obj, true);        return true;    }    return false;}

static void WINAPI ServiceDispatch( DWORD numArgs, char **args ){    (void)numArgs;    (void)args;    intf_thread_t *p_intf = (intf_thread_t *)p_global_intf;    intf_sys_t    *p_sys  = p_intf->p_sys;    char *psz_modules, *psz_parser;    /* We have to initialize the service-specific stuff */    memset( &p_sys->status, 0, sizeof(SERVICE_STATUS) );    p_sys->status.dwServiceType = SERVICE_WIN32;    p_sys->status.dwCurrentState = SERVICE_START_PENDING;    p_sys->status.dwControlsAccepted = SERVICE_ACCEPT_STOP;    p_sys->hStatus =        RegisterServiceCtrlHandler( p_sys->psz_service, &ServiceCtrlHandler );    if( p_sys->hStatus == (SERVICE_STATUS_HANDLE)0 )    {        msg_Err( p_intf, "failed to register service control handler" );        return;    }    /*     * Load background interfaces     */    psz_modules = var_InheritString( p_intf, "ntservice-extraintf" );    psz_parser = psz_modules;    while( psz_parser && *psz_parser )    {        char *psz_module, *psz_temp;        psz_module = psz_parser;        psz_parser = strchr( psz_module, ',' );        if( psz_parser )        {            *psz_parser = '/0';            psz_parser++;        }        if( asprintf( &psz_temp, "%s,none", psz_module ) != -1 )        {            /* Try to create the interface */            if( intf_Create( p_intf, psz_temp ) )            {                msg_Err( p_intf, "interface /"%s/" initialization failed",                         psz_temp );                free( psz_temp );                continue;            }            free( psz_temp );        }    }    free( psz_modules );    /* Initialization complete - report running status */    p_sys->status.dwCurrentState = SERVICE_RUNNING;    p_sys->status.dwCheckPoint   = 0;    p_sys->status.dwWaitHint     = 0;    SetServiceStatus( p_sys->hStatus, &p_sys->status );}

static int GetVideoConn(demux_t *demux){    demux_sys_t *sys = demux->p_sys;    char *opt = var_InheritString(demux, "decklink-video-connection");    if (!opt)        return VLC_SUCCESS;    BMDVideoConnection c;    if (!strcmp(opt, "sdi"))        c = bmdVideoConnectionSDI;    else if (!strcmp(opt, "hdmi"))        c = bmdVideoConnectionHDMI;    else if (!strcmp(opt, "opticalsdi"))        c = bmdVideoConnectionOpticalSDI;    else if (!strcmp(opt, "component"))        c = bmdVideoConnectionComponent;    else if (!strcmp(opt, "composite"))        c = bmdVideoConnectionComposite;    else if (!strcmp(opt, "svideo"))        c = bmdVideoConnectionSVideo;    else {        msg_Err(demux, "Invalid video-connection: `%s/' specified", opt);        free(opt);        return VLC_EGENERIC;    }    free(opt);    if (sys->config->SetInt(bmdDeckLinkConfigVideoInputConnection, c) != S_OK) {        msg_Err(demux, "Failed to set video input connection");        return VLC_EGENERIC;    }    return VLC_SUCCESS;}

/*** DVB-S ***/static char var_InheritPolarization (vlc_object_t *obj){    char pol;    char *polstr = var_InheritString (obj, "dvb-polarization");    if (polstr != NULL)    {        pol = *polstr;        free (polstr);        if (unlikely(pol >= 'a' && pol <= 'z'))            pol -= 'a' - 'A';        return pol;    }    /* Backward compatibility with VLC for Linux < 1.2 */    unsigned voltage = var_InheritInteger (obj, "dvb-voltage");    switch (voltage)    {        case 13:  pol = 'V'; break;        case 18:  pol = 'H'; break;        default:  return 0;    }    msg_Warn (obj, "/"voltage=%u/" option is obsolete. "                   "Use /"polarization=%c/" instead.", voltage, pol);    return pol;}

void RendererDialog::discoveryEventReceived( const vlc_event_t * p_event ){    if ( p_event->type == vlc_RendererDiscoveryItemAdded )    {        vlc_renderer_item *p_item =  p_event->u.renderer_discovery_item_added.p_new_item;        int row = 0;        for ( ; row < ui.receiversListWidget->count(); row++ )        {            RendererItem *rowItem = reinterpret_cast<RendererItem*>( ui.receiversListWidget->item( row ) );            if ( rowItem->isItemSout( vlc_renderer_item_sout( p_item ), false ) )                return;        }        RendererItem *newItem = new RendererItem(p_item);        ui.receiversListWidget->addItem( newItem );        char *psz_renderer = var_InheritString( THEPL, "sout" );        if ( psz_renderer != NULL )        {            if ( newItem->isItemSout( psz_renderer, true ) )                ui.receiversListWidget->setCurrentItem( newItem );            free( psz_renderer );        }    }}

/* * Obtain the window type from the window type variable. */void window_get_param( vlc_object_t * p_aout, window_param * p_param ){    /* Fetch Kaiser parameter */    p_param->f_kaiser_alpha = var_InheritFloat( p_aout, "effect-kaiser-param" );    /* Fetch window type */    char * psz_preset = var_InheritString( p_aout, "effect-fft-window" );    if( !psz_preset )    {        goto no_preset;    }    for( int i = 0; i < NB_WINDOWS; i++ )    {        if( !strcasecmp( psz_preset, window_list[i] ) )        {            p_param->wind_type = i;            return;        }    }no_preset:    msg_Warn( p_aout, "No matching window preset found; using rectangular "                      "window (i.e. no window)" );    p_param->wind_type = NONE;}

static const char *var_InheritModulation (vlc_object_t *obj, const char *var){    char *mod = var_InheritString (obj, var);    if (mod == NULL)        return "";    size_t n = sizeof (modulation_vlc) / sizeof (modulation_vlc[0]);    const char *const *p = lfind (mod, modulation_vlc, &n, sizeof (mod), modcmp);    if (p != NULL)    {        free (mod);        return *p;    }    /* Backward compatibility with VLC < 1.2 */    const char *str;    switch (atoi (mod))    {        case -1:  str = "QPSK";   break;        case 0:   str = "QAM";    break;        case 8:   str = "8VSB";   break;        case 16:  str = "16QAM";  break;        case 32:  str = "32QAM";  break;        case 64:  str = "64QAM";  break;        case 128: str = "128QAM"; break;        case 256: str = "256QAM"; break;        default:  return "";    }    msg_Warn (obj, "/"modulation=%s/" option is obsolete. "                   "Use /"modulation=%s/" instead.", mod, str);    free (mod);    return str;}

int OutOpenAvio(vlc_object_t *object){    sout_access_out_t *access = (sout_access_out_t*)object;    config_ChainParse( access, "sout-avio-", ppsz_sout_options, access->p_cfg );    sout_access_out_sys_t *sys = malloc(sizeof(*sys));    if (!sys)        return VLC_ENOMEM;    sys->context = NULL;    /* */    vlc_init_avformat(object);    if (!access->psz_path)        goto error;    int ret;#if LIBAVFORMAT_VERSION_MAJOR < 54    ret = avio_open(&sys->context, access->psz_path, AVIO_FLAG_WRITE);#else    AVDictionary *options = NULL;    char *psz_opts = var_InheritString(access, "sout-avio-options");    if (psz_opts && *psz_opts) {        options = vlc_av_get_options(psz_opts);        free(psz_opts);    }    ret = avio_open2(&sys->context, access->psz_path, AVIO_FLAG_WRITE,                     NULL, &options);    AVDictionaryEntry *t = NULL;    while ((t = av_dict_get(options, "", t, AV_DICT_IGNORE_SUFFIX)))        msg_Err( access, "unknown option /"%s/"", t->key );    av_dict_free(&options);#endif    if (ret < 0) {        errno = AVUNERROR(ret);        msg_Err(access, "Failed to open %s", access->psz_path);        goto error;    }#if LIBAVFORMAT_VERSION_MAJOR < 54    /* We can accept only one active user at any time */    if (SetupAvioCb(VLC_OBJECT(access))) {        msg_Err(access, "Module aready in use");        goto error;    }#endif    access->pf_write = Write;    access->pf_control = OutControl;    access->pf_seek = OutSeek;    access->p_sys = sys;    return VLC_SUCCESS;error:    free(sys);    return VLC_EGENERIC;}

UpnpInstanceWrapper *UpnpInstanceWrapper::get(vlc_object_t *p_obj, Upnp_FunPtr callback, SD::MediaServerList *opaque){    vlc_mutex_locker lock( &s_lock );    if ( s_instance == NULL )    {        UpnpInstanceWrapper* instance = new(std::nothrow) UpnpInstanceWrapper;        if ( unlikely( !instance ) )            return NULL;    #ifdef UPNP_ENABLE_IPV6        char* psz_miface = var_InheritString( p_obj, "miface" );        msg_Info( p_obj, "Initializing libupnp on '%s' interface", psz_miface );        int i_res = UpnpInit2( psz_miface, 0 );        free( psz_miface );    #else        /* If UpnpInit2 isnt available, initialize on first IPv4-capable interface */        int i_res = UpnpInit( 0, 0 );    #endif        if( i_res != UPNP_E_SUCCESS )        {            msg_Err( p_obj, "Initialization failed: %s", UpnpGetErrorMessage( i_res ) );            delete instance;            return NULL;        }        ixmlRelaxParser( 1 );        /* Register a control point */        i_res = UpnpRegisterClient( Callback, instance, &instance->handle_ );        if( i_res != UPNP_E_SUCCESS )        {            msg_Err( p_obj, "Client registration failed: %s", UpnpGetErrorMessage( i_res ) );            delete instance;            return NULL;        }        /* libupnp does not treat a maximum content length of 0 as unlimited         * until 64dedf (~ pupnp v1.6.7) and provides no sane way to discriminate         * between versions */        if( (i_res = UpnpSetMaxContentLength( INT_MAX )) != UPNP_E_SUCCESS )        {            msg_Err( p_obj, "Failed to set maximum content length: %s",                    UpnpGetErrorMessage( i_res ));            delete instance;            return NULL;        }        s_instance = instance;    }    s_instance->refcount_++;    // This assumes a single UPNP SD instance    if (callback && opaque)    {        assert(!s_instance->callback_ && !s_instance->opaque_);        s_instance->opaque_ = opaque;        s_instance->callback_ = callback;    }    return s_instance;}

static bool preConnectHandler( freerdp *p_instance ){    vlcrdp_context_t * p_vlccontext = (vlcrdp_context_t *) p_instance->context;    demux_sys_t *p_sys = p_vlccontext->p_demux->p_sys;    /* Configure connexion */    p_instance->settings->SoftwareGdi = true; /* render in buffer */    p_instance->settings->Fullscreen = true;    p_instance->settings->ServerHostname = strdup( p_sys->psz_hostname );    p_instance->settings->Username =            var_InheritString( p_vlccontext->p_demux, CFG_PREFIX "user" );    p_instance->settings->Password =            var_InheritString( p_vlccontext->p_demux, CFG_PREFIX "password" );    p_instance->settings->ServerPort = p_sys->i_port;    p_instance->settings->EncryptionMethods =            var_InheritBool( p_vlccontext->p_demux, CFG_PREFIX "encrypt" );    return true;}

/***************************************************************************** * 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;    char              *outputFile;    p_sys = calloc( 1, sizeof( sout_stream_sys_t ) );    if( !p_sys )        return VLC_ENOMEM;    config_ChainParse( p_stream, SOUT_CFG_PREFIX, ppsz_sout_options,                   p_stream->p_cfg );    outputFile = var_InheritString( p_stream, SOUT_CFG_PREFIX "output" );    if( outputFile )    {        p_sys->output = vlc_fopen( outputFile, "wt" );        if( !p_sys->output )        {            msg_Err( p_stream, "Unable to open file '%s' for writing", outputFile );            free( p_sys );            free( outputFile );            return VLC_EGENERIC;        } else {            fprintf( p_sys->output,"#prefix/ttrack/ttype/tsegment_number/tdts_difference/tlength/tmd5/n");        }        free( outputFile );    }    p_sys->prefix = var_InheritString( p_stream, SOUT_CFG_PREFIX "prefix" );    p_stream->p_sys     = p_sys;    p_stream->pf_add    = Add;    p_stream->pf_del    = Del;    p_stream->pf_send   = Send;    return VLC_SUCCESS;}

/** * @brief VLC module construct callback * @return */static int y4m_open(vlc_object_t* obj){    filter_t* intf = (filter_t*)obj;    // todo: defer this check until we know if its needed or not    if( !intf->b_allow_fmt_out_change )    {        msg_Err(intf, "picture format change isn't allowed");        return VLC_EGENERIC;    }    filter_sys_t* sys = malloc(sizeof(*sys));    if (unlikely(sys == NULL))        return VLC_ENOMEM;    intf->p_sys = sys;    memset(sys, 0, sizeof(*sys));    sys->cmd = var_InheritString(intf, "y4m-cmd");    if (sys->cmd == NULL)    {        msg_Err(intf, "argument parse failed");        free(sys);        return VLC_EGENERIC;    }    sys->echo = var_InheritBool(intf, "y4m-echo");    sys->stdin = -1;    sys->stdout = -1;    sys->bufferRatio = 1;    msg_Info(intf, "open");    sys->inputFifo = picture_fifo_New();    sys->outputFifo = picture_fifo_New();    vlc_cond_init(&sys->inputCond);    vlc_cond_init(&sys->outputCond);    vlc_mutex_init(&sys->inputMutex);    vlc_mutex_init(&sys->outputMutex);    intf->pf_video_filter = y4m_filter;    intf->pf_flush = y4m_flush;    // todo: the conversion needed isn't known until    // a frame is read back from the filter, for now    // filters in/out format needs to be the same    //intf->fmt_out.video.i_frame_rate *= 2;    //intf->fmt_out.i_codec = VLC_CODEC_I420;    //intf->fmt_out.video.i_chroma = VLC_CODEC_I420;    return VLC_SUCCESS;}

vlc_keystore *vlc_keystore_create(vlc_object_t *p_parent){    assert(p_parent);    char *modlist = var_InheritString(p_parent, "keystore");    vlc_keystore *p_keystore = keystore_create(p_parent, modlist);    free(modlist);    return p_keystore;}

/** * Initializes the raw dump pseudo-demuxer. */static int Open( vlc_object_t * p_this ){    demux_t *p_demux = (demux_t*)p_this;    /* Accept only if forced */    if( !p_demux->b_force )        return VLC_EGENERIC;    char *access = var_InheritString( p_demux, "demuxdump-access" );    if( access == NULL )        return VLC_EGENERIC;    /* --sout-file-append (defaults to false) */    var_Create( p_demux, "sout-file-append", VLC_VAR_BOOL );    if( var_InheritBool( p_demux, "demuxdump-append" ) )        var_SetBool( p_demux, "sout-file-append", true );    /* --sout-file-format (always false) */    var_Create( p_demux, "sout-file-format", VLC_VAR_BOOL );    char *path = var_InheritString( p_demux, "demuxdump-file" );    if( path == NULL )    {        free( access );        msg_Err( p_demux, "no dump file name given" );        return VLC_EGENERIC;    }    sout_access_out_t *out = sout_AccessOutNew( p_demux, access, path );    free( path );    free( access );    if( out == NULL )    {        msg_Err( p_demux, "cannot create output" );        return VLC_EGENERIC;    }    p_demux->p_sys = (void *)out;    p_demux->pf_demux = Demux;    p_demux->pf_control = Control;    return VLC_SUCCESS;}

static vlc_fourcc_t var_InheritFourCC (vlc_object_t *obj, const char *varname){    char *str = var_InheritString (obj, varname);    if (str == NULL)        return 0;    vlc_fourcc_t fourcc = vlc_fourcc_GetCodecFromString (VIDEO_ES, str);    if (fourcc == 0)        msg_Err (obj, "invalid codec %s", str);    free (str);    return fourcc;}

static int vlc_sd_probe_Open (vlc_object_t *obj){    vlc_probe_t *probe = (vlc_probe_t *)obj;    char *display = var_InheritString (obj, "x11-display");    xcb_connection_t *conn = xcb_connect (display, NULL);    free (display);    if (xcb_connection_has_error (conn))        return VLC_PROBE_CONTINUE;    xcb_disconnect (conn);    return vlc_sd_probe_Add (probe, "xcb_apps",                             N_("Screen capture"), SD_CAT_DEVICES);}

int DemuxOpen( vlc_object_t *obj ){    demux_t *demux = (demux_t *)obj;    demux_sys_t *sys = malloc (sizeof (*sys));    if (unlikely(sys == NULL))        return VLC_ENOMEM;    demux->p_sys = sys;    ParseMRL( obj, demux->psz_location );    char *path = var_InheritString (obj, CFG_PREFIX"dev");    if (unlikely(path == NULL))        goto error; /* probably OOM */    msg_Dbg (obj, "opening device '%s'", path);    int rawfd = vlc_open (path, O_RDWR);    if (rawfd == -1)    {        msg_Err (obj, "cannot open device '%s': %m", path);        free (path);        goto error;    }    free (path);    int fd = v4l2_fd_open (rawfd, 0);    if (fd == -1)    {        msg_Warn (obj, "cannot initialize user-space library: %m");        /* fallback to direct kernel mode anyway */        fd = rawfd;    }    sys->fd = fd;    if (InitVideo (demux, fd))    {        v4l2_close (fd);        goto error;    }    sys->controls = ControlsInit (VLC_OBJECT(demux), fd);    demux->pf_demux = NULL;    demux->pf_control = DemuxControl;    demux->info.i_update = 0;    demux->info.i_title = 0;    demux->info.i_seekpoint = 0;    return VLC_SUCCESS;error:    free (sys);    return VLC_EGENERIC;}

/* Get credentials from uri or variables. */static void get_credentials( access_t *p_access ){    access_sys_t *p_sys = p_access->p_sys;    /* Fetch credentials, either from URI or from options if not provided */    if( p_sys->url.psz_password == NULL )        p_sys->creds.password = var_InheritString( p_access, "smb-pwd" );    else        p_sys->creds.password = strdup( p_sys->url.psz_password );    /* Here we support smb://DOMAIN/User:[email
C++ var_Set函数代码示例
C++ var_InheritInteger函数代码示例