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

static int ParseImageAttachments( decoder_t *p_dec ){    decoder_sys_t        *p_sys = p_dec->p_sys;    input_attachment_t  **pp_attachments;    int                   i_attachments_cnt;    int                   k = 0;    if( VLC_SUCCESS != decoder_GetInputAttachments( p_dec, &pp_attachments, &i_attachments_cnt ))        return VLC_EGENERIC;    for( k = 0; k < i_attachments_cnt; k++ )    {        input_attachment_t *p_attach = pp_attachments[k];        vlc_fourcc_t type = image_Mime2Fourcc( p_attach->psz_mime );        if( ( type != 0 ) &&            ( p_attach->i_data > 0 ) &&            ( p_attach->p_data != NULL ) )        {            picture_t         *p_pic = NULL;            image_handler_t   *p_image;            p_image = image_HandlerCreate( p_dec );            if( p_image != NULL )            {                block_t   *p_block;                p_block = block_Alloc( p_attach->i_data );                if( p_block != NULL )                {                    video_format_t     fmt_in;                    video_format_t     fmt_out;                    memcpy( p_block->p_buffer, p_attach->p_data, p_attach->i_data );                    memset( &fmt_in,  0, sizeof( video_format_t));                    memset( &fmt_out, 0, sizeof( video_format_t));                    fmt_in.i_chroma  = type;                    fmt_out.i_chroma = VLC_CODEC_YUVA;                    /* Find a suitable decoder module */                    if( module_exists( "sdl_image" ) )                    {                        /* ffmpeg thinks it can handle bmp properly but it can't (at least                         * not all of them), so use sdl_image if it is available */                        var_Create( p_dec, "codec", VLC_VAR_STRING | VLC_VAR_DOINHERIT );                        var_SetString( p_dec, "codec", "sdl_image" );                    }                    p_pic = image_Read( p_image, p_block, &fmt_in, &fmt_out );                    var_Destroy( p_dec, "codec" );                }                image_HandlerDelete( p_image );            }            if( p_pic )            {                image_attach_t *p_picture = malloc( sizeof(image_attach_t) );                if( p_picture )                {                    p_picture->psz_filename = strdup( p_attach->psz_name );                    p_picture->p_pic = p_pic;                    TAB_APPEND( (image_attach_t **), p_sys->i_images, p_sys->pp_images, p_picture );			// sunqueen modify                }            }        }        vlc_input_attachment_Delete( pp_attachments[ k ] );    }

void vout_IntfInit( vout_thread_t *p_vout ){    vlc_value_t val, text;    char *psz_buf;    /* Create a few object variables we'll need later on */    var_Create( p_vout, "snapshot-num", VLC_VAR_INTEGER );    var_SetInteger( p_vout, "snapshot-num", 1 );    var_Create( p_vout, "width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "align", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "mouse-hide-timeout",                VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    /* Add variables to manage scaling video */    var_Create( p_vout, "autoscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT                | VLC_VAR_ISCOMMAND );    text.psz_string = _("Autoscale video");    var_Change( p_vout, "autoscale", VLC_VAR_SETTEXT, &text, NULL );    var_AddCallback( p_vout, "autoscale", AutoScaleCallback, NULL );    var_Create( p_vout, "zoom", VLC_VAR_FLOAT | VLC_VAR_ISCOMMAND |                VLC_VAR_DOINHERIT );    text.psz_string = _("Zoom");    var_Change( p_vout, "zoom", VLC_VAR_SETTEXT, &text, NULL );    for( size_t i = 0; i < ARRAY_SIZE(p_zoom_values); i++ )    {        val.f_float = p_zoom_values[i].f_value;        text.psz_string = vlc_gettext( p_zoom_values[i].psz_label );        var_Change( p_vout, "zoom", VLC_VAR_ADDCHOICE, &val, &text );    }    var_AddCallback( p_vout, "zoom", ZoomCallback, NULL );    /* Crop offset vars */    var_Create( p_vout, "crop-left", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_Create( p_vout, "crop-top", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_Create( p_vout, "crop-right", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_Create( p_vout, "crop-bottom", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_AddCallback( p_vout, "crop-left", CropBorderCallback, NULL );    var_AddCallback( p_vout, "crop-top", CropBorderCallback, NULL );    var_AddCallback( p_vout, "crop-right", CropBorderCallback, NULL );    var_AddCallback( p_vout, "crop-bottom", CropBorderCallback, NULL );    /* Crop object var */    var_Create( p_vout, "crop", VLC_VAR_STRING | VLC_VAR_ISCOMMAND |                VLC_VAR_DOINHERIT );    text.psz_string = _("Crop");    var_Change( p_vout, "crop", VLC_VAR_SETTEXT, &text, NULL );    for( size_t i = 0; i < ARRAY_SIZE(p_crop_values); i++ )    {        val.psz_string = (char*)p_crop_values[i].psz_value;        text.psz_string = _( p_crop_values[i].psz_label );        var_Change( p_vout, "crop", VLC_VAR_ADDCHOICE, &val, &text );    }    /* Add custom crop ratios */    psz_buf = var_CreateGetNonEmptyString( p_vout, "custom-crop-ratios" );    if( psz_buf )    {        AddCustomRatios( p_vout, "crop", psz_buf );        free( psz_buf );    }    var_AddCallback( p_vout, "crop", CropCallback, NULL );    /* Monitor pixel aspect-ratio */    var_Create( p_vout, "monitor-par", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    /* Aspect-ratio object var */    var_Create( p_vout, "aspect-ratio", VLC_VAR_STRING | VLC_VAR_ISCOMMAND |                VLC_VAR_DOINHERIT );    text.psz_string = _("Aspect ratio");    var_Change( p_vout, "aspect-ratio", VLC_VAR_SETTEXT, &text, NULL );    for( size_t i = 0; i < ARRAY_SIZE(p_aspect_ratio_values); i++ )    {        val.psz_string = (char*)p_aspect_ratio_values[i].psz_value;        text.psz_string = _( p_aspect_ratio_values[i].psz_label );        var_Change( p_vout, "aspect-ratio", VLC_VAR_ADDCHOICE, &val, &text );    }    /* Add custom aspect ratios */    psz_buf = var_CreateGetNonEmptyString( p_vout, "custom-aspect-ratios" );    if( psz_buf )    {        AddCustomRatios( p_vout, "aspect-ratio", psz_buf );        free( psz_buf );    }    var_AddCallback( p_vout, "aspect-ratio", AspectCallback, NULL );//.........这里部分代码省略.........

static void VariablesInit( playlist_t *p_playlist ){    /* These variables control updates */    var_Create( p_playlist, "intf-change", VLC_VAR_BOOL );    var_SetBool( p_playlist, "intf-change", true );    var_Create( p_playlist, "item-change", VLC_VAR_ADDRESS );    var_Create( p_playlist, "leaf-to-parent", VLC_VAR_INTEGER );    var_Create( p_playlist, "playlist-item-deleted", VLC_VAR_INTEGER );    var_SetInteger( p_playlist, "playlist-item-deleted", -1 );    var_Create( p_playlist, "playlist-item-append", VLC_VAR_ADDRESS );    var_Create( p_playlist, "input-current", VLC_VAR_ADDRESS );    /* Variables to control playback */    var_Create( p_playlist, "playlist-autostart", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "random", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_AddCallback( p_playlist, "random", RandomCallback, NULL );    var_Create( p_playlist, "repeat", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "loop", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "corks", VLC_VAR_INTEGER );    var_AddCallback( p_playlist, "corks", CorksCallback, NULL );    var_Create( p_playlist, "rate", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );    var_AddCallback( p_playlist, "rate", RateCallback, NULL );    var_Create( p_playlist, "rate-slower", VLC_VAR_VOID );    var_AddCallback( p_playlist, "rate-slower", RateOffsetCallback, NULL );    var_Create( p_playlist, "rate-faster", VLC_VAR_VOID );    var_AddCallback( p_playlist, "rate-faster", RateOffsetCallback, NULL );    var_Create( p_playlist, "video-splitter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    var_AddCallback( p_playlist, "video-splitter", VideoSplitterCallback, NULL );    /* */    var_Create( p_playlist, "album-art", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "metadata-network-access", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    /* Variables to preserve video output parameters */    var_Create( p_playlist, "fullscreen", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "video-on-top", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "video-wallpaper", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    /* Audio output parameters */    var_Create( p_playlist, "mute", VLC_VAR_BOOL );    var_Create( p_playlist, "volume", VLC_VAR_FLOAT );    var_SetFloat( p_playlist, "volume", -1.f );}

/** This function allocates and initialize the DirectX vout display. */static int Open(vlc_object_t *object){    vout_display_t *vd = (vout_display_t *)object;    vout_display_sys_t *sys;    /* Allocate structure */    vd->sys = sys = calloc(1, sizeof(*sys));    if (!sys)        return VLC_ENOMEM;    /* Load direct draw DLL */    sys->hddraw_dll = LoadLibrary(_T("DDRAW.DLL"));    if (!sys->hddraw_dll) {        msg_Warn(vd, "DirectXInitDDraw failed loading ddraw.dll");        free(sys);        return VLC_EGENERIC;    }    /* */    sys->use_wallpaper = var_CreateGetBool(vd, "video-wallpaper");    /* FIXME */    sys->use_overlay = false;//var_CreateGetBool(vd, "overlay"); /* FIXME */    sys->restore_overlay = false;    var_Create(vd, "directx-device", VLC_VAR_STRING | VLC_VAR_DOINHERIT);    /* Initialisation */    if (CommonInit(vd))        goto error;    /* */    video_format_t fmt = vd->fmt;    if (DirectXOpen(vd, &fmt))        goto error;    /* */    vout_display_info_t info = vd->info;    info.is_slow = true;    info.has_double_click = true;    info.has_hide_mouse = false;    info.has_pictures_invalid = true;    info.has_event_thread = true;    /* Interaction TODO support starting with wallpaper mode */    vlc_mutex_init(&sys->lock);    sys->ch_wallpaper = sys->use_wallpaper;    sys->wallpaper_requested = sys->use_wallpaper;    sys->use_wallpaper = false;    vlc_value_t val;    val.psz_string = _("Wallpaper");    var_Change(vd, "video-wallpaper", VLC_VAR_SETTEXT, &val, NULL);    var_AddCallback(vd, "video-wallpaper", WallpaperCallback, NULL);    /* Setup vout_display now that everything is fine */    video_format_Clean(&vd->fmt);    video_format_Copy(&vd->fmt, &fmt);    vd->info    = info;    vd->pool    = Pool;    vd->prepare = NULL;    vd->display = Display;    vd->control = Control;    vd->manage  = Manage;    return VLC_SUCCESS;error:    DirectXClose(vd);    CommonClean(vd);    if (sys->hddraw_dll)        FreeLibrary(sys->hddraw_dll);    free(sys);    return VLC_EGENERIC;}

//.........这里部分代码省略.........    if ( i_nb_channels > 2 )    {        /* KAI doesn't support more than two channels. */        i_nb_channels = 2;        format.i_physical_channels            = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;    }    /* Support s16l only */    format.i_format = VLC_CODEC_S16L;    aout_FormatPrepare( &format );    i_bytes_per_frame = format.i_bytes_per_frame;    /* Initialize library */    if( kaiInit( i_kai_mode ))    {        msg_Err( p_aout, "cannot initialize KAI");        return VLC_EGENERIC;    }    ks_wanted.usDeviceIndex   = 0;    ks_wanted.ulType          = KAIT_PLAY;    ks_wanted.ulBitsPerSample = BPS_16;    ks_wanted.ulSamplingRate  = format.i_rate;    ks_wanted.ulDataFormat    = MCI_WAVE_FORMAT_PCM;    ks_wanted.ulChannels      = i_nb_channels;    ks_wanted.ulNumBuffers    = 2;    ks_wanted.ulBufferSize    = FRAME_SIZE * i_bytes_per_frame;    ks_wanted.fShareable      = !var_InheritBool( p_aout,                                                  "kai-audio-exclusive-mode");    ks_wanted.pfnCallBack     = KaiCallback;    ks_wanted.pCallBackData   = p_aout;    msg_Dbg( p_aout, "requested ulBufferSize = %ld", ks_wanted.ulBufferSize );    /* Open the sound device. */    if( kaiOpen( &ks_wanted, &ks_obtained, &p_sys->hkai ))    {        msg_Err( p_aout, "cannot open KAI device");        goto exit_kai_done;    }    msg_Dbg( p_aout, "open in %s mode",             ks_obtained.fShareable ? "shareable" : "exclusive" );    msg_Dbg( p_aout, "obtained i_nb_samples = %lu",             ks_obtained.ulBufferSize / i_bytes_per_frame );    msg_Dbg( p_aout, "obtained i_bytes_per_frame = %d",             format.i_bytes_per_frame );    p_sys->format = *fmt = format;    p_aout->time_get = aout_PacketTimeGet;    p_aout->play  = Play;    p_aout->pause = NULL;    p_aout->flush = aout_PacketFlush;    aout_SoftVolumeStart( p_aout );    aout_PacketInit( p_aout, &p_sys->packet,                     ks_obtained.ulBufferSize / i_bytes_per_frame, &format );    if ( var_Type( p_aout, "audio-device" ) == 0 )    {        /* First launch. */        var_Create( p_aout, "audio-device",                    VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );        text.psz_string = _("Audio Device");        var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );        val.i_int = AOUT_VAR_STEREO;        text.psz_string = _("Stereo");        var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );        val.i_int = AOUT_VAR_MONO;        text.psz_string = _("Mono");        var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );        if ( i_nb_channels == 2 )        {            val.i_int = AOUT_VAR_STEREO;        }        else        {            val.i_int = AOUT_VAR_MONO;        }        var_Change( p_aout, "audio-device", VLC_VAR_SETDEFAULT, &val, NULL );        var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL );    }    /* Prevent SIG_FPE */    _control87(MCW_EM, MCW_EM);    return VLC_SUCCESS;exit_kai_done :    kaiDone();    return VLC_EGENERIC;}

static int PAOpenDevice( audio_output_t *p_aout ){    aout_sys_t *p_sys = p_aout->sys;    const PaDeviceInfo *p_pdi;    PaError i_err;    vlc_value_t val, text;    int i;    /* Initialize portaudio */    i_err = Pa_Initialize();    if( i_err != paNoError )    {        msg_Err( p_aout, "Pa_Initialize returned %d : %s",                 i_err, Pa_GetErrorText( i_err ) );        return VLC_EGENERIC;    }    p_sys->i_devices = Pa_GetDeviceCount();    if( p_sys->i_devices < 0 )    {        i_err = p_sys->i_devices;        msg_Err( p_aout, "Pa_GetDeviceCount returned %d : %s", i_err,                 Pa_GetErrorText( i_err ) );        goto error;    }    /* Display all devices info */    msg_Dbg( p_aout, "number of devices = %d", p_sys->i_devices );    for( i = 0; i < p_sys->i_devices; i++ )    {        p_pdi = Pa_GetDeviceInfo( i );        msg_Dbg( p_aout, "------------------------------------- #%d", i );        msg_Dbg( p_aout, "Name         = %s", p_pdi->name );        msg_Dbg( p_aout, "Max Inputs   = %d, Max Outputs = %d",                  p_pdi->maxInputChannels, p_pdi->maxOutputChannels );    }    msg_Dbg( p_aout, "-------------------------------------" );    msg_Dbg( p_aout, "requested device is #%d", p_sys->i_device_id );    if( p_sys->i_device_id >= p_sys->i_devices )    {        msg_Err( p_aout, "device %d does not exist", p_sys->i_device_id );        goto error;    }    p_sys->deviceInfo = Pa_GetDeviceInfo( p_sys->i_device_id );    if( p_sys->deviceInfo->maxOutputChannels < 1 )    {        msg_Err( p_aout, "no channel available" );        goto error;    }    if( var_Type( p_aout, "audio-device" ) == 0 )    {        var_Create( p_aout, "audio-device", VLC_VAR_INTEGER|VLC_VAR_HASCHOICE);        text.psz_string = _("Audio Device");        var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );        if( p_sys->deviceInfo->maxOutputChannels >= 1 )        {            val.i_int = AOUT_VAR_MONO;            text.psz_string = _("Mono");            var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE,                        &val, &text );            msg_Dbg( p_aout, "device supports 1 channel" );        }        if( p_sys->deviceInfo->maxOutputChannels >= 2 )        {            val.i_int = AOUT_VAR_STEREO;            text.psz_string = _("Stereo");            var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE,                        &val, &text );            var_Change( p_aout, "audio-device", VLC_VAR_SETDEFAULT,                        &val, NULL );            var_Set( p_aout, "audio-device", val );            msg_Dbg( p_aout, "device supports 2 channels" );        }        if( p_sys->deviceInfo->maxOutputChannels >= 4 )        {            val.i_int = AOUT_VAR_2F2R;            text.psz_string = _("2 Front 2 Rear");            var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE,                        &val, &text );            msg_Dbg( p_aout, "device supports 4 channels" );        }        if( p_sys->deviceInfo->maxOutputChannels >= 5 )        {            val.i_int = AOUT_VAR_3F2R;            text.psz_string = _("3 Front 2 Rear");            var_Change( p_aout, "audio-device",                        VLC_VAR_ADDCHOICE, &val, &text );            msg_Dbg( p_aout, "device supports 5 channels" );        }        if( p_sys->deviceInfo->maxOutputChannels >= 6 )        {            val.i_int = AOUT_VAR_5_1;            text.psz_string = _("5.1");            var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE,//.........这里部分代码省略.........

/** * Creates an audio output object and initializes an output module. */audio_output_t *aout_New (vlc_object_t *parent){    vlc_value_t val, text;    audio_output_t *aout = vlc_custom_create (parent, sizeof (aout_instance_t),                                              "audio output");    if (unlikely(aout == NULL))        return NULL;    aout_owner_t *owner = aout_owner (aout);    vlc_mutex_init (&owner->lock);    vlc_mutex_init (&owner->req.lock);    vlc_mutex_init (&owner->dev.lock);    owner->req.device = (char *)unset_str;    owner->req.volume = -1.f;    owner->req.mute = -1;    vlc_object_set_destructor (aout, aout_Destructor);    /* Audio output module callbacks */    var_Create (aout, "volume", VLC_VAR_FLOAT);    var_AddCallback (aout, "volume", var_Copy, parent);    var_Create (aout, "mute", VLC_VAR_BOOL | VLC_VAR_DOINHERIT);    var_AddCallback (aout, "mute", var_Copy, parent);    var_Create (aout, "device", VLC_VAR_STRING);    aout->event.volume_report = aout_VolumeNotify;    aout->event.mute_report = aout_MuteNotify;    aout->event.policy_report = aout_PolicyNotify;    aout->event.device_report = aout_DeviceNotify;    aout->event.hotplug_report = aout_HotplugNotify;    aout->event.gain_request = aout_GainNotify;    aout->event.restart_request = aout_RestartNotify;    /* Audio output module initialization */    aout->start = NULL;    aout->stop = NULL;    aout->volume_set = NULL;    aout->mute_set = NULL;    aout->device_select = NULL;    owner->module = module_need (aout, "audio output", "$aout", false);    if (owner->module == NULL)    {        msg_Err (aout, "no suitable audio output module");        vlc_object_release (aout);        return NULL;    }    /*     * Persistent audio output variables     */    module_config_t *cfg;    char *str;    /* Visualizations */    var_Create (aout, "visual", VLC_VAR_STRING | VLC_VAR_HASCHOICE);    text.psz_string = _("Visualizations");    var_Change (aout, "visual", VLC_VAR_SETTEXT, &text, NULL);    val.psz_string = (char *)"";    text.psz_string = _("Disable");    var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    val.psz_string = (char *)"spectrometer";    text.psz_string = _("Spectrometer");    var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    val.psz_string = (char *)"scope";    text.psz_string = _("Scope");    var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    val.psz_string = (char *)"spectrum";    text.psz_string = _("Spectrum");    var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    val.psz_string = (char *)"vuMeter";    text.psz_string = _("Vu meter");    var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    /* Look for goom plugin */    if (module_exists ("goom"))    {        val.psz_string = (char *)"goom";        text.psz_string = (char *)"Goom";        var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    }    /* Look for libprojectM plugin */    if (module_exists ("projectm"))    {        val.psz_string = (char *)"projectm";        text.psz_string = (char*)"projectM";        var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    }    /* Look for VSXu plugin */    if (module_exists ("vsxu"))    {        val.psz_string = (char *)"vsxu";        text.psz_string = (char*)"Vovoid VSXu";        var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    }    str = var_GetNonEmptyString (aout, "effect-list");    if (str != NULL)//.........这里部分代码省略.........

/** * Probes and initializes. */static int Open (vlc_object_t *obj){    demux_t *demux = (demux_t *)obj;    int tp; /* transport protocol */    if (!strcmp (demux->psz_access, "dccp"))        tp = IPPROTO_DCCP;    else if (!strcmp (demux->psz_access, "rtptcp"))        tp = IPPROTO_TCP;    else if (!strcmp (demux->psz_access, "rtp"))        tp = IPPROTO_UDP;    else if (!strcmp (demux->psz_access, "udplite"))        tp = IPPROTO_UDPLITE;    else        return VLC_EGENERIC;    char *tmp = strdup (demux->psz_path);    char *shost = tmp;    if (shost == NULL)        return VLC_ENOMEM;    char *dhost = strchr (shost, '@');    if (dhost)        *dhost++ = '/0';    /* Parses the port numbers */    int sport = 0, dport = 0;    sport = extract_port (&shost);    if (dhost != NULL)        dport = extract_port (&dhost);    if (dport == 0)        dport = 5004; /* avt-profile-1 port */    int rtcp_dport = var_CreateGetInteger (obj, "rtcp-port");    /* Try to connect */    int fd = -1, rtcp_fd = -1;    switch (tp)    {    case IPPROTO_UDP:    case IPPROTO_UDPLITE:        fd = net_OpenDgram (obj, dhost, dport,                            shost, sport, AF_UNSPEC, tp);        if (fd == -1)            break;        if (rtcp_dport > 0) /* XXX: source port is unknown */            rtcp_fd = net_OpenDgram (obj, dhost, rtcp_dport, shost, 0,                                     AF_UNSPEC, tp);        break;    case IPPROTO_DCCP:#ifndef SOCK_DCCP /* provisional API (FIXME) */# ifdef __linux__#  define SOCK_DCCP 6# endif#endif#ifdef SOCK_DCCP        var_Create (obj, "dccp-service", VLC_VAR_STRING);        var_SetString (obj, "dccp-service", "RTPV"); /* FIXME: RTPA? */        fd = net_Connect (obj, shost, sport, SOCK_DCCP, tp);#else        msg_Err (obj, "DCCP support not included");#endif        break;    case IPPROTO_TCP:        fd = net_Connect (obj, shost, sport, SOCK_STREAM, tp);        break;    }    free (tmp);    if (fd == -1)        return VLC_EGENERIC;    net_SetCSCov (fd, -1, 12);    /* Initializes demux */    demux_sys_t *p_sys = malloc (sizeof (*p_sys));    if (p_sys == NULL)    {        net_Close (fd);        if (rtcp_fd != -1)            net_Close (rtcp_fd);        return VLC_EGENERIC;    }    vlc_mutex_init (&p_sys->lock);#ifdef HAVE_SRTP    p_sys->srtp         = NULL;#endif    p_sys->fd           = fd;    p_sys->rtcp_fd      = rtcp_fd;    p_sys->caching      = var_CreateGetInteger (obj, "rtp-caching");    p_sys->max_src      = var_CreateGetInteger (obj, "rtp-max-src");    p_sys->timeout      = var_CreateGetInteger (obj, "rtp-timeout");    p_sys->max_dropout  = var_CreateGetInteger (obj, "rtp-max-dropout");    p_sys->max_misorder = var_CreateGetInteger (obj, "rtp-max-misorder");//.........这里部分代码省略.........

// TODO don't leak shit.static PP_Bool vlc_did_create(PP_Instance instance, uint32_t _argc,                              const char *_argn[], const char *_argv[]) {  vlc_setPPAPI_InitializingInstance(instance);  VLC_UNUSED(_argc); VLC_UNUSED(_argn); VLC_UNUSED(_argv);  if(vlc_PPAPI_InitializeInstance(instance) != VLC_SUCCESS) {    return PP_FALSE;  }  PP_Bool ret = PP_FALSE;  libvlc_instance_t* vlc_inst = NULL;  libvlc_media_player_t* media_player = NULL;  libvlc_media_list_player_t* media_list_player = NULL;  libvlc_media_list_t* playlist = NULL;  instance_t* new_inst = add_instance(instance);  if(new_inst == NULL) {    vlc_ppapi_log_error(instance, "failed to create the plugin instance object!/n");    goto error;  }  vlc_inst = libvlc_new(0, NULL);  if(vlc_inst == NULL) {    vlc_ppapi_log_error(instance, "failed to create the vlc instance!/n");    goto error;  } else {    new_inst->vlc = vlc_inst;  }  libvlc_log_set(vlc_inst, libvlc_logging_callback, (void*)new_inst);  media_player = libvlc_media_player_new(vlc_inst);  if(media_player == NULL) {    vlc_ppapi_log_error(instance, "libvlc_media_player_t creation failed");    goto error;  } else {    new_inst->media_player = media_player;  }  var_Create(media_player, "ppapi-instance", VLC_VAR_INTEGER);  var_SetInteger(media_player, "ppapi-instance", instance);  var_SetString(media_player, "vout", "ppapi_vout_graphics3d");  if(-1 == libvlc_add_intf(vlc_inst, "ppapi_control")) {    vlc_ppapi_log_error(instance, "failed to start `ppapi-control`");    goto error;  }  ret = PP_TRUE;  goto done; error:  ret = PP_FALSE;  if(new_inst != NULL) {    remove_instance(new_inst);  } done:  vlc_setPPAPI_InitializingInstance(0);  return ret;}

/***************************************************************************** * aout_DecNew : create a decoder *****************************************************************************/static aout_input_t * DecNew( vlc_object_t * p_this, aout_instance_t * p_aout,                              audio_sample_format_t * p_format ){    aout_input_t * p_input;    input_thread_t * p_input_thread;    vlc_value_t val;    /* We can only be called by the decoder, so no need to lock     * p_input->lock. */    vlc_mutex_lock( &p_aout->mixer_lock );    if ( p_aout->i_nb_inputs >= AOUT_MAX_INPUTS )    {        msg_Err( p_aout, "too many inputs already (%d)", p_aout->i_nb_inputs );        return NULL;    }    p_input = malloc(sizeof(aout_input_t));    if ( p_input == NULL )    {        msg_Err( p_aout, "out of memory" );        return NULL;    }    vlc_mutex_init( p_aout, &p_input->lock );    p_input->b_changed = 0;    p_input->b_error = 1;    aout_FormatPrepare( p_format );    memcpy( &p_input->input, p_format,            sizeof(audio_sample_format_t) );    p_aout->pp_inputs[p_aout->i_nb_inputs] = p_input;    p_aout->i_nb_inputs++;    if ( p_aout->mixer.b_error )    {        int i;        var_Destroy( p_aout, "audio-device" );        var_Destroy( p_aout, "audio-channels" );        /* Recreate the output using the new format. */        if ( aout_OutputNew( p_aout, p_format ) < 0 )        {            for ( i = 0; i < p_aout->i_nb_inputs - 1; i++ )            {                vlc_mutex_lock( &p_aout->pp_inputs[i]->lock );                aout_InputDelete( p_aout, p_aout->pp_inputs[i] );                vlc_mutex_unlock( &p_aout->pp_inputs[i]->lock );            }            vlc_mutex_unlock( &p_aout->mixer_lock );            return p_input;        }        /* Create other input streams. */        for ( i = 0; i < p_aout->i_nb_inputs - 1; i++ )        {            vlc_mutex_lock( &p_aout->pp_inputs[i]->lock );            aout_InputDelete( p_aout, p_aout->pp_inputs[i] );            aout_InputNew( p_aout, p_aout->pp_inputs[i] );            vlc_mutex_unlock( &p_aout->pp_inputs[i]->lock );        }    }    else    {        aout_MixerDelete( p_aout );    }    if ( aout_MixerNew( p_aout ) == -1 )    {        aout_OutputDelete( p_aout );        vlc_mutex_unlock( &p_aout->mixer_lock );        return NULL;    }    aout_InputNew( p_aout, p_input );    vlc_mutex_unlock( &p_aout->mixer_lock );    var_Create( p_this, "audio-desync", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Get( p_this, "audio-desync", &val );    p_input->i_desync = val.i_int * 1000;    p_input_thread = (input_thread_t *)vlc_object_find( p_this,                                           VLC_OBJECT_INPUT, FIND_PARENT );    if( p_input_thread )    {        p_input->i_pts_delay = p_input_thread->i_pts_delay;        p_input->i_pts_delay += p_input->i_desync;        vlc_object_release( p_input_thread );    }    else    {        p_input->i_pts_delay = DEFAULT_PTS_DELAY;        p_input->i_pts_delay += p_input->i_desync;    }//.........这里部分代码省略.........

void vout_IntfInit( vout_thread_t *p_vout ){    vlc_value_t val, text, old_val;    bool b_force_par = false;    char *psz_buf;    int i;    /* Create a few object variables we'll need later on */    var_Create( p_vout, "snapshot-path", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    var_Create( p_vout, "snapshot-prefix", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    var_Create( p_vout, "snapshot-format", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    var_Create( p_vout, "snapshot-preview", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_vout, "snapshot-sequential",                VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_vout, "snapshot-num", VLC_VAR_INTEGER );    var_SetInteger( p_vout, "snapshot-num", 1 );    var_Create( p_vout, "snapshot-width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "snapshot-height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    p_vout->i_alignment = var_CreateGetInteger( p_vout, "align" );    var_Create( p_vout, "video-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "video-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "mouse-hide-timeout",                VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    p_vout->p->b_title_show = var_CreateGetBool( p_vout, "video-title-show" );    p_vout->p->i_title_timeout =        (mtime_t)var_CreateGetInteger( p_vout, "video-title-timeout" );    p_vout->p->i_title_position =        var_CreateGetInteger( p_vout, "video-title-position" );    p_vout->p->psz_title =  NULL;    var_AddCallback( p_vout, "video-title-show", TitleShowCallback, NULL );    var_AddCallback( p_vout, "video-title-timeout", TitleTimeoutCallback, NULL );    var_AddCallback( p_vout, "video-title-position", TitlePositionCallback, NULL );    /* Zoom object var */    var_Create( p_vout, "zoom", VLC_VAR_FLOAT | VLC_VAR_ISCOMMAND |                VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );    text.psz_string = _("Zoom");    var_Change( p_vout, "zoom", VLC_VAR_SETTEXT, &text, NULL );    var_Get( p_vout, "zoom", &old_val );    for( i = 0; p_zoom_values[i].f_value; i++ )    {        if( old_val.f_float == p_zoom_values[i].f_value )            var_Change( p_vout, "zoom", VLC_VAR_DELCHOICE, &old_val, NULL );        val.f_float = p_zoom_values[i].f_value;        text.psz_string = _( p_zoom_values[i].psz_label );        var_Change( p_vout, "zoom", VLC_VAR_ADDCHOICE, &val, &text );    }    var_Set( p_vout, "zoom", old_val ); /* Is this really needed? */    var_AddCallback( p_vout, "zoom", ZoomCallback, NULL );    /* Crop offset vars */    var_Create( p_vout, "crop-left", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_Create( p_vout, "crop-top", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_Create( p_vout, "crop-right", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_Create( p_vout, "crop-bottom", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_AddCallback( p_vout, "crop-left", CropCallback, NULL );    var_AddCallback( p_vout, "crop-top", CropCallback, NULL );    var_AddCallback( p_vout, "crop-right", CropCallback, NULL );    var_AddCallback( p_vout, "crop-bottom", CropCallback, NULL );    /* Crop object var */    var_Create( p_vout, "crop", VLC_VAR_STRING | VLC_VAR_ISCOMMAND |                VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );    text.psz_string = _("Crop");    var_Change( p_vout, "crop", VLC_VAR_SETTEXT, &text, NULL );    val.psz_string = (char*)"";    var_Change( p_vout, "crop", VLC_VAR_DELCHOICE, &val, 0 );    for( i = 0; p_crop_values[i].psz_value; i++ )    {        val.psz_string = (char*)p_crop_values[i].psz_value;        text.psz_string = _( p_crop_values[i].psz_label );        var_Change( p_vout, "crop", VLC_VAR_ADDCHOICE, &val, &text );    }    /* update triggered every time the vout's crop parameters are changed */    var_Create( p_vout, "crop-update", VLC_VAR_VOID );    /* Add custom crop ratios */    psz_buf = config_GetPsz( p_vout, "custom-crop-ratios" );    AddCustomRatios( p_vout, "crop", psz_buf );    free( psz_buf );    var_AddCallback( p_vout, "crop", CropCallback, NULL );    var_Get( p_vout, "crop", &old_val );//.........这里部分代码省略.........

/***************************************************************************** * Probe: probe the audio device for available formats and channels *****************************************************************************/static void Probe( aout_instance_t * p_aout ){    struct aout_sys_t * p_sys = p_aout->output.p_sys;    vlc_value_t val, text;    int i_format, i_nb_channels;    var_Create( p_aout, "audio-device", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );    text.psz_string = _("Audio Device");    var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );    /* Test for multi-channel. */#ifdef SNDCTL_DSP_GETCHANNELMASK    if ( aout_FormatNbChannels( &p_aout->output.output ) > 2 )    {        /* Check that the device supports this. */        int i_chanmask;        /* Reset all. */        i_format = AFMT_S16_NE;        if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 ||            ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 )        {            msg_Err( p_aout, "cannot reset OSS audio device" );            var_Destroy( p_aout, "audio-device" );            return;        }        if ( ioctl( p_sys->i_fd, SNDCTL_DSP_GETCHANNELMASK,                    &i_chanmask ) == 0 )        {            if ( !(i_chanmask & DSP_BIND_FRONT) )            {                msg_Err( p_aout, "No front channels ! (%x)",                         i_chanmask );                return;            }            if ( (i_chanmask & (DSP_BIND_SURR | DSP_BIND_CENTER_LFE))                  && (p_aout->output.output.i_physical_channels ==                       (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER                         | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT                         | AOUT_CHAN_LFE)) )            {                val.i_int = AOUT_VAR_5_1;                text.psz_string = N_("5.1");                var_Change( p_aout, "audio-device",                            VLC_VAR_ADDCHOICE, &val, &text );            }            if ( (i_chanmask & DSP_BIND_SURR)                  && (p_aout->output.output.i_physical_channels &                       (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT                         | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT)) )            {                val.i_int = AOUT_VAR_2F2R;                text.psz_string = N_("2 Front 2 Rear");                var_Change( p_aout, "audio-device",                            VLC_VAR_ADDCHOICE, &val, &text );            }        }    }#endif    /* Reset all. */    i_format = AFMT_S16_NE;    if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 ||        ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 )    {        msg_Err( p_aout, "cannot reset OSS audio device" );        var_Destroy( p_aout, "audio-device" );        return;    }    /* Test for stereo. */    i_nb_channels = 2;    if( ioctl( p_sys->i_fd, SNDCTL_DSP_CHANNELS, &i_nb_channels ) >= 0         && i_nb_channels == 2 )    {        val.i_int = AOUT_VAR_STEREO;        text.psz_string = N_("Stereo");        var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );    }    /* Reset all. */    i_format = AFMT_S16_NE;    if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 ||        ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 )    {        msg_Err( p_aout, "cannot reset OSS audio device" );        var_Destroy( p_aout, "audio-device" );        return;    }    /* Test for mono. */    i_nb_channels = 1;    if( ioctl( p_sys->i_fd, SNDCTL_DSP_CHANNELS, &i_nb_channels ) >= 0//.........这里部分代码省略.........

/***************************************************************************** * 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;    vlc_object_t         *p_libvlc = VLC_OBJECT( p_this->p_libvlc );    vlc_value_t           val;    config_ChainParse( p_stream, CFG_PREFIX, ppsz_sout_options,                       p_stream->p_cfg );    p_sys = malloc( sizeof( sout_stream_sys_t ) );    if( !p_sys )        return VLC_ENOMEM;    p_stream->p_sys = p_sys;    p_sys->b_inited = false;    var_Create( p_libvlc, "mosaic-lock", VLC_VAR_MUTEX );    var_Get( p_libvlc, "mosaic-lock", &val );    p_sys->p_lock = val.p_address;    p_sys->psz_id = var_CreateGetString( p_stream, CFG_PREFIX "id" );    p_sys->i_height =        var_CreateGetIntegerCommand( p_stream, CFG_PREFIX "height" );    var_AddCallback( p_stream, CFG_PREFIX "height", HeightCallback, p_stream );    p_sys->i_width =        var_CreateGetIntegerCommand( p_stream, CFG_PREFIX "width" );    var_AddCallback( p_stream, CFG_PREFIX "width", WidthCallback, p_stream );    var_Get( p_stream, CFG_PREFIX "sar", &val );    if( val.psz_string )    {        char *psz_parser = strchr( val.psz_string, ':' );        if( psz_parser )        {            *psz_parser++ = '/0';            p_sys->i_sar_num = atoi( val.psz_string );            p_sys->i_sar_den = atoi( psz_parser );            vlc_ureduce( &p_sys->i_sar_num, &p_sys->i_sar_den,                         p_sys->i_sar_num, p_sys->i_sar_den, 0 );        }        else        {            msg_Warn( p_stream, "bad aspect ratio %s", val.psz_string );            p_sys->i_sar_num = p_sys->i_sar_den = 1;        }        free( val.psz_string );    }    else    {        p_sys->i_sar_num = p_sys->i_sar_den = 1;    }    p_sys->i_chroma = 0;    val.psz_string = var_GetNonEmptyString( p_stream, CFG_PREFIX "chroma" );    if( val.psz_string && strlen( val.psz_string ) >= 4 )    {        memcpy( &p_sys->i_chroma, val.psz_string, 4 );        msg_Dbg( p_stream, "Forcing image chroma to 0x%.8x (%4.4s)", p_sys->i_chroma, (char*)&p_sys->i_chroma );    }    free( val.psz_string );#define INT_COMMAND( a ) do { /    var_Create( p_stream, CFG_PREFIX #a, /                VLC_VAR_INTEGER | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND ); /    var_AddCallback( p_stream, CFG_PREFIX #a, a ## Callback, /                     p_stream ); } while(0)    INT_COMMAND( alpha );    INT_COMMAND( x );    INT_COMMAND( y );#undef INT_COMMAND    p_stream->pf_add    = Add;    p_stream->pf_del    = Del;    p_stream->pf_send   = Send;    p_stream->p_sout->i_out_pace_nocontrol++;    return VLC_SUCCESS;}

static sout_stream_id_t * Add( sout_stream_t *p_stream, es_format_t *p_fmt ){    sout_stream_sys_t *p_sys = p_stream->p_sys;    bridge_t *p_bridge;    bridged_es_t *p_es;    char *psz_chain;    int i;    if( p_sys->b_inited || p_fmt->i_cat != VIDEO_ES )        return NULL;    /* Create decoder object */    p_sys->p_decoder = (decoder_t *)vlc_object_create( p_stream, sizeof( decoder_t ) );			// sunqueen modify    if( !p_sys->p_decoder )        return NULL;    p_sys->p_decoder->p_module = NULL;    p_sys->p_decoder->fmt_in = *p_fmt;    p_sys->p_decoder->b_pace_control = false;    p_sys->p_decoder->fmt_out = p_sys->p_decoder->fmt_in;    p_sys->p_decoder->fmt_out.i_extra = 0;    p_sys->p_decoder->fmt_out.p_extra = 0;    p_sys->p_decoder->pf_decode_video = 0;    p_sys->p_decoder->pf_vout_buffer_new = video_new_buffer_decoder;    p_sys->p_decoder->pf_vout_buffer_del = video_del_buffer_decoder;    p_sys->p_decoder->pf_picture_link    = video_link_picture_decoder;    p_sys->p_decoder->pf_picture_unlink  = video_unlink_picture_decoder;    p_sys->p_decoder->p_owner = (decoder_owner_sys_t *)malloc( sizeof(decoder_owner_sys_t) );			// sunqueen modify    if( !p_sys->p_decoder->p_owner )    {        vlc_object_release( p_sys->p_decoder );        return NULL;    }    p_sys->p_decoder->p_owner->video = p_fmt->video;    //p_sys->p_decoder->p_cfg = p_sys->p_video_cfg;    p_sys->p_decoder->p_module =        module_need( p_sys->p_decoder, "decoder", "$codec", false );    if( !p_sys->p_decoder->p_module || !p_sys->p_decoder->pf_decode_video )    {        if( p_sys->p_decoder->p_module )        {            msg_Err( p_stream, "instanciated a non video decoder" );            module_unneed( p_sys->p_decoder, p_sys->p_decoder->p_module );        }        else        {            msg_Err( p_stream, "cannot find decoder" );        }        free( p_sys->p_decoder->p_owner );        vlc_object_release( p_sys->p_decoder );        return NULL;    }    p_sys->b_inited = true;    vlc_global_lock( VLC_MOSAIC_MUTEX );    p_bridge = GetBridge( p_stream );    if ( p_bridge == NULL )    {        vlc_object_t *p_libvlc = VLC_OBJECT( p_stream->p_libvlc );        vlc_value_t val;        p_bridge = (bridge_t *)xmalloc( sizeof( bridge_t ) );			// sunqueen modify        var_Create( p_libvlc, "mosaic-struct", VLC_VAR_ADDRESS );        val.p_address = p_bridge;        var_Set( p_libvlc, "mosaic-struct", val );        p_bridge->i_es_num = 0;        p_bridge->pp_es = NULL;    }    for ( i = 0; i < p_bridge->i_es_num; i++ )    {        if ( p_bridge->pp_es[i]->b_empty )            break;    }    if ( i == p_bridge->i_es_num )    {        p_bridge->pp_es = (bridged_es_t **)xrealloc( p_bridge->pp_es,			// sunqueen modify                          (p_bridge->i_es_num + 1) * sizeof(bridged_es_t *) );        p_bridge->i_es_num++;        p_bridge->pp_es[i] = (bridged_es_t *)xmalloc( sizeof(bridged_es_t) );			// sunqueen modify    }    p_sys->p_es = p_es = p_bridge->pp_es[i];    p_es->i_alpha = var_GetInteger( p_stream, CFG_PREFIX "alpha" );    p_es->i_x = var_GetInteger( p_stream, CFG_PREFIX "x" );    p_es->i_y = var_GetInteger( p_stream, CFG_PREFIX "y" );    //p_es->fmt = *p_fmt;    p_es->psz_id = p_sys->psz_id;    p_es->p_picture = NULL;    p_es->pp_last = &p_es->p_picture;    p_es->b_empty = false;//.........这里部分代码省略.........

static int EqzInit( filter_t *p_filter, int i_rate ){    filter_sys_t *p_sys = p_filter->p_sys;    const eqz_config_t *p_cfg;    int i, ch;    vlc_value_t val1, val2, val3;    vlc_object_t *p_aout = p_filter->p_parent;    int i_ret = VLC_ENOMEM;    /* Select the config */    if( i_rate == 48000 )    {        p_cfg = &eqz_config_48000_10b;    }    else if( i_rate == 44100 )    {        p_cfg = &eqz_config_44100_10b;    }    else    {        /* TODO compute the coeffs on the fly */        msg_Err( p_filter, "rate not supported" );        return VLC_EGENERIC;    }    /* Create the static filter config */    p_sys->i_band = p_cfg->i_band;    p_sys->f_alpha = malloc( p_sys->i_band * sizeof(float) );    p_sys->f_beta  = malloc( p_sys->i_band * sizeof(float) );    p_sys->f_gamma = malloc( p_sys->i_band * sizeof(float) );    if( !p_sys->f_alpha || !p_sys->f_beta || !p_sys->f_gamma )        goto error;    for( i = 0; i < p_sys->i_band; i++ )    {        p_sys->f_alpha[i] = p_cfg->band[i].f_alpha;        p_sys->f_beta[i]  = p_cfg->band[i].f_beta;        p_sys->f_gamma[i] = p_cfg->band[i].f_gamma;    }    /* Filter dyn config */    p_sys->b_2eqz = false;    p_sys->f_gamp = 1.0;    p_sys->f_amp  = malloc( p_sys->i_band * sizeof(float) );    if( !p_sys->f_amp )        goto error;    for( i = 0; i < p_sys->i_band; i++ )    {        p_sys->f_amp[i] = 0.0;    }    /* Filter state */    for( ch = 0; ch < 32; ch++ )    {        p_sys->x[ch][0]  =        p_sys->x[ch][1]  =        p_sys->x2[ch][0] =        p_sys->x2[ch][1] = 0.0;        for( i = 0; i < p_sys->i_band; i++ )        {            p_sys->y[ch][i][0]  =            p_sys->y[ch][i][1]  =            p_sys->y2[ch][i][0] =            p_sys->y2[ch][i][1] = 0.0;        }    }    var_Create( p_aout, "equalizer-bands", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    var_Create( p_aout, "equalizer-preset", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    p_sys->b_2eqz = var_CreateGetBool( p_aout, "equalizer-2pass" );    var_Create( p_aout, "equalizer-preamp", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );    /* Get initial values */    var_Get( p_aout, "equalizer-preset", &val1 );    var_Get( p_aout, "equalizer-bands", &val2 );    var_Get( p_aout, "equalizer-preamp", &val3 );    p_sys->b_first = true;    PresetCallback( VLC_OBJECT( p_aout ), NULL, val1, val1, p_sys );    BandsCallback(  VLC_OBJECT( p_aout ), NULL, val2, val2, p_sys );    PreampCallback( VLC_OBJECT( p_aout ), NULL, val3, val3, p_sys );    p_sys->b_first = false;    free( val1.psz_string );    /* Register preset bands (for intf) if : */    /* We have no bands info --> the preset info must be given to the intf */    /* or The bands info matches the preset */    if (p_sys->psz_newbands == NULL)    {        msg_Err(p_filter, "No preset selected");        free( val2.psz_string );        free( p_sys->f_amp );        i_ret = VLC_EGENERIC;        goto error;    }//.........这里部分代码省略.........

/** * ProjectM update thread which do the rendering * @param p_this: the p_thread object */static void *Thread( void *p_data ){    filter_t  *p_filter = (filter_t*)p_data;    filter_sys_t *p_sys = p_filter->p_sys;    video_format_t fmt;    vlc_gl_t *gl;    unsigned int i_last_width  = 0;    unsigned int i_last_height = 0;    locale_t loc;    locale_t oldloc;    projectM *p_projectm;#ifndef HAVE_PROJECTM2    char *psz_config;#else    char *psz_preset_path;    char *psz_title_font;    char *psz_menu_font;    projectM::Settings settings;#endif    vlc_savecancel();    /* Create the openGL provider */    p_sys->p_vout =        (vout_thread_t *)vlc_object_create( p_filter, sizeof(vout_thread_t) );    if( !p_sys->p_vout )        goto error;    /* */    video_format_Init( &fmt, 0 );    video_format_Setup( &fmt, VLC_CODEC_RGB32,                        p_sys->i_width, p_sys->i_height, 0, 1 );    fmt.i_sar_num = 1;    fmt.i_sar_den = 1;    vout_display_state_t state;    memset( &state, 0, sizeof(state) );    state.cfg.display.sar.num = 1;    state.cfg.display.sar.den = 1;    state.cfg.is_display_filled = true;    state.cfg.zoom.num = 1;    state.cfg.zoom.den = 1;    state.sar.num = 1;    state.sar.den = 1;    p_sys->p_vd = vout_NewDisplay( p_sys->p_vout, &fmt, &state, "opengl",                                   300000, 1000000 );    if( !p_sys->p_vd )    {        vlc_object_release( p_sys->p_vout );        goto error;    }    var_Create( p_sys->p_vout, "fullscreen", VLC_VAR_BOOL );    var_AddCallback( p_sys->p_vout, "fullscreen", VoutCallback, p_sys->p_vd );    gl = vout_GetDisplayOpengl( p_sys->p_vd );    if( !gl )    {        var_DelCallback( p_sys->p_vout, "fullscreen", VoutCallback, p_sys->p_vd );        vout_DeleteDisplay( p_sys->p_vd, NULL );        vlc_object_release( p_sys->p_vout );        goto error;    }    /* Work-around the projectM locale bug */    loc = newlocale (LC_NUMERIC_MASK, "C", NULL);    oldloc = uselocale (loc);    /* Create the projectM object */#ifndef HAVE_PROJECTM2    psz_config = var_InheritString( p_filter, "projectm-config" );    p_projectm = new projectM( psz_config );    free( psz_config );#else    psz_preset_path = var_InheritString( p_filter, "projectm-preset-path" );#ifdef _WIN32    if ( psz_preset_path == NULL )    {        char *psz_data_path = config_GetDataDir();        asprintf( &psz_preset_path, "%s" DIR_SEP "visualization", psz_data_path );        free( psz_data_path );    }#endif    psz_title_font                = var_InheritString( p_filter, "projectm-title-font" );    psz_menu_font                 = var_InheritString( p_filter, "projectm-menu-font" );    settings.meshX                = var_InheritInteger( p_filter, "projectm-meshx" );    settings.meshY                = var_InheritInteger( p_filter, "projectm-meshy" );    settings.fps                  = 35;    settings.textureSize          = var_InheritInteger( p_filter, "projectm-texture-size" );    settings.windowWidth          = p_sys->i_width;    settings.windowHeight         = p_sys->i_height;    settings.presetURL            = psz_preset_path;//.........这里部分代码省略.........

/***************************************************************************** * aout_New: initialize aout structure *****************************************************************************/audio_output_t *aout_New( vlc_object_t * p_parent ){    audio_output_t *aout = vlc_custom_create (p_parent,                                              sizeof (aout_instance_t),                                              "audio output");    if (unlikely(aout == NULL))        return NULL;    aout_owner_t *owner = aout_owner (aout);    vlc_mutex_init (&owner->lock);    owner->module = NULL;    owner->input = NULL;    vlc_mutex_init (&owner->volume.lock);    owner->volume.multiplier = 1.0;    owner->volume.mixer = NULL;    aout->pf_play = aout_DecDeleteBuffer;    aout_VolumeNoneInit (aout);    vlc_object_set_destructor (aout, aout_Destructor);    /*     * Persistent audio output variables     */    vlc_value_t val, text;    char *str;    var_Create (aout, "intf-change", VLC_VAR_VOID);    /* Visualizations */    var_Create (aout, "visual", VLC_VAR_STRING | VLC_VAR_HASCHOICE);    text.psz_string = _("Visualizations");    var_Change (aout, "visual", VLC_VAR_SETTEXT, &text, NULL);    val.psz_string = (char *)"";    text.psz_string = _("Disable");    var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    val.psz_string = (char *)"spectrometer";    text.psz_string = _("Spectrometer");    var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    val.psz_string = (char *)"scope";    text.psz_string = _("Scope");    var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    val.psz_string = (char *)"spectrum";    text.psz_string = _("Spectrum");    var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    val.psz_string = (char *)"vuMeter";    text.psz_string = _("Vu meter");    var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    /* Look for goom plugin */    if (module_exists ("goom"))    {        val.psz_string = (char *)"goom";        text.psz_string = (char *)"Goom";        var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    }    /* Look for libprojectM plugin */    if (module_exists ("projectm"))    {        val.psz_string = (char *)"projectm";        text.psz_string = (char*)"projectM";        var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);    }    str = var_GetNonEmptyString (aout, "effect-list");    if (str != NULL)    {        var_SetString (aout, "visual", str);        free (str);    }    /* Equalizer */    var_Create (aout, "equalizer", VLC_VAR_STRING | VLC_VAR_HASCHOICE);    text.psz_string = _("Equalizer");    var_Change (aout, "equalizer", VLC_VAR_SETTEXT, &text, NULL);    val.psz_string = (char*)"";    text.psz_string = _("Disable");    var_Change (aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text);    {        module_config_t *cfg = config_FindConfig (VLC_OBJECT(aout),                                                  "equalizer-preset");        if (cfg != NULL)            for (int i = 0; i < cfg->i_list; i++)            {                val.psz_string = (char *)cfg->ppsz_list[i];                text.psz_string = (char *)cfg->ppsz_list_text[i];                var_Change (aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text);            }    }    var_Create (aout, "audio-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT);    text.psz_string = _("Audio filters");    var_Change (aout, "audio-filter", VLC_VAR_SETTEXT, &text, NULL);    var_Create (aout, "audio-visual", VLC_VAR_STRING | VLC_VAR_DOINHERIT);    text.psz_string = _("Audio visualizations");    var_Change (aout, "audio-visual", VLC_VAR_SETTEXT, &text, NULL);//.........这里部分代码省略.........

void *vlc_custom_create( vlc_object_t *p_this, size_t i_size,                         int i_type, const char *psz_type ){    vlc_object_t *p_new;    vlc_object_internals_t *p_priv;    /* NOTE:     * VLC objects are laid out as follow:     * - first the LibVLC-private per-object data,     * - then VLC_COMMON members from vlc_object_t,     * - finally, the type-specific data (if any).     *     * This function initializes the LibVLC and common data,     * and zeroes the rest.     */    p_priv = calloc( 1, sizeof( *p_priv ) + i_size );    if( p_priv == NULL )        return NULL;    assert (i_size >= sizeof (vlc_object_t));    p_new = (vlc_object_t *)(p_priv + 1);    p_priv->i_object_type = i_type;    p_new->psz_object_type = psz_type;    p_priv->psz_name = NULL;    p_new->b_die = false;    p_new->b_force = false;    p_new->psz_header = NULL;    if (p_this)        p_new->i_flags = p_this->i_flags            & (OBJECT_FLAGS_NODBG|OBJECT_FLAGS_QUIET|OBJECT_FLAGS_NOINTERACT);    p_priv->var_root = NULL;    if( p_this == NULL )    {        libvlc_int_t *self = (libvlc_int_t*)p_new;        p_new->p_libvlc = self;        vlc_mutex_init (&(libvlc_priv (self)->structure_lock));        p_this = p_new;    }    else        p_new->p_libvlc = p_this->p_libvlc;    vlc_spin_init( &p_priv->ref_spin );    p_priv->i_refcount = 1;    p_priv->pf_destructor = NULL;    p_priv->b_thread = false;    p_new->p_parent = NULL;    p_priv->first = NULL;    /* Initialize mutexes and condvars */    vlc_mutex_init( &p_priv->var_lock );    vlc_cond_init( &p_priv->var_wait );    p_priv->pipes[0] = p_priv->pipes[1] = -1;    if (p_new == VLC_OBJECT(p_new->p_libvlc))    {   /* TODO: should be in src/libvlc.c */        int canc = vlc_savecancel ();        var_Create( p_new, "tree", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );        var_AddCallback( p_new, "tree", DumpCommand, NULL );        var_Create( p_new, "vars", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );        var_AddCallback( p_new, "vars", DumpCommand, NULL );        vlc_restorecancel (canc);    }    return p_new;}

//.........这里部分代码省略.........    // Create and register VLC variables    VarManager *pVarManager = VarManager::instance( getIntf() );#define REGISTER_VAR( var, type, name ) /    var = VariablePtr( new type( getIntf() ) ); /    pVarManager->registerVar( var, name );    REGISTER_VAR( m_cVarRandom, VarBoolImpl, "playlist.isRandom" )    REGISTER_VAR( m_cVarLoop, VarBoolImpl, "playlist.isLoop" )    REGISTER_VAR( m_cVarRepeat, VarBoolImpl, "playlist.isRepeat" )    REGISTER_VAR( m_cPlaytree, Playtree, "playtree" )    pVarManager->registerVar( getPlaytreeVar().getPositionVarPtr(),                              "playtree.slider" );    pVarManager->registerVar( m_cVarRandom, "playtree.isRandom" );    pVarManager->registerVar( m_cVarLoop, "playtree.isLoop" );    REGISTER_VAR( m_cVarPlaying, VarBoolImpl, "vlc.isPlaying" )    REGISTER_VAR( m_cVarStopped, VarBoolImpl, "vlc.isStopped" )    REGISTER_VAR( m_cVarPaused, VarBoolImpl, "vlc.isPaused" )    /* Input variables */    pVarManager->registerVar( m_cVarRepeat, "playtree.isRepeat" );    REGISTER_VAR( m_cVarTime, StreamTime, "time" )    REGISTER_VAR( m_cVarSeekable, VarBoolImpl, "vlc.isSeekable" )    REGISTER_VAR( m_cVarDvdActive, VarBoolImpl, "dvd.isActive" )    REGISTER_VAR( m_cVarRecordable, VarBoolImpl, "vlc.canRecord" )    REGISTER_VAR( m_cVarRecording, VarBoolImpl, "vlc.isRecording" )    /* Vout variables */    REGISTER_VAR( m_cVarFullscreen, VarBoolImpl, "vlc.isFullscreen" )    REGISTER_VAR( m_cVarHasVout, VarBoolImpl, "vlc.hasVout" )    /* Aout variables */    REGISTER_VAR( m_cVarHasAudio, VarBoolImpl, "vlc.hasAudio" )    REGISTER_VAR( m_cVarVolume, Volume, "volume" )    REGISTER_VAR( m_cVarMute, VarBoolImpl, "vlc.isMute" )    REGISTER_VAR( m_cVarEqualizer, VarBoolImpl, "equalizer.isEnabled" )    REGISTER_VAR( m_cVarEqPreamp, EqualizerPreamp, "equalizer.preamp" )#undef REGISTER_VAR    m_cVarStreamName = VariablePtr( new VarText( getIntf(), false ) );    pVarManager->registerVar( m_cVarStreamName, "streamName" );    m_cVarStreamURI = VariablePtr( new VarText( getIntf(), false ) );    pVarManager->registerVar( m_cVarStreamURI, "streamURI" );    m_cVarStreamBitRate = VariablePtr( new VarText( getIntf(), false ) );    pVarManager->registerVar( m_cVarStreamBitRate, "bitrate" );    m_cVarStreamSampleRate = VariablePtr( new VarText( getIntf(), false ) );    pVarManager->registerVar( m_cVarStreamSampleRate, "samplerate" );    m_cVarStreamArt = VariablePtr( new VarString( getIntf() ) );    pVarManager->registerVar( m_cVarStreamArt, "streamArt" );    // Register the equalizer bands    for( int i = 0; i < EqualizerBands::kNbBands; i++)    {        stringstream ss;        ss << "equalizer.band(" << i << ")";        pVarManager->registerVar( m_varEqBands.getBand( i ), ss.str() );    }    // XXX WARNING XXX    // The object variable callbacks are called from other VLC threads,    // so they must put commands in the queue and NOT do anything else    // (X11 calls are not reentrant)#define ADD_CALLBACK( p_object, var ) /    var_AddCallback( p_object, var, onGenericCallback, this );    ADD_CALLBACK( pIntf->p_sys->p_playlist, "volume" )    ADD_CALLBACK( pIntf->p_libvlc, "intf-show" )    ADD_CALLBACK( pIntf->p_sys->p_playlist, "item-current" )    ADD_CALLBACK( pIntf->p_sys->p_playlist, "random" )    ADD_CALLBACK( pIntf->p_sys->p_playlist, "loop" )    ADD_CALLBACK( pIntf->p_sys->p_playlist, "repeat" )#undef ADD_CALLBACK    // Called when a playlist item is added    var_AddCallback( pIntf->p_sys->p_playlist, "playlist-item-append",                     onItemAppend, this );    // Called when a playlist item is deleted    // TODO: properly handle item-deleted    var_AddCallback( pIntf->p_sys->p_playlist, "playlist-item-deleted",                     onItemDelete, this );    // Called when the current input changes    var_AddCallback( pIntf->p_sys->p_playlist, "input-current",                     onInputNew, this );    // Called when a playlist item changed    var_AddCallback( pIntf->p_sys->p_playlist, "item-change",                     onItemChange, this );    // Called when we have an interaction dialog to display    var_Create( pIntf, "interaction", VLC_VAR_ADDRESS );    var_AddCallback( pIntf, "interaction", onInteraction, this );    interaction_Register( pIntf );    // initialize variables refering to liblvc and playlist objects    init_variables();}

static ass_handle_t *AssHandleHold( decoder_t *p_dec ){    vlc_mutex_lock( &libass_lock );    ass_handle_t *p_ass = NULL;    ASS_Library *p_library = NULL;    ASS_Renderer *p_renderer = NULL;    vlc_value_t val;    var_Create( p_dec->p_libvlc, "libass-handle", VLC_VAR_ADDRESS );    if( var_Get( p_dec->p_libvlc, "libass-handle", &val ) )        val.p_address = NULL;    if( val.p_address )    {        p_ass = val.p_address;        p_ass->i_refcount++;        vlc_mutex_unlock( &libass_lock );        return p_ass;    }    /* */    p_ass = malloc( sizeof(*p_ass) );    if( !p_ass )        goto error;    /* */    p_ass->p_libvlc = VLC_OBJECT(p_dec->p_libvlc);    p_ass->i_refcount = 1;    /* Create libass library */    p_ass->p_library = p_library = ass_library_init();    if( !p_library )        goto error;    /* load attachments */    input_attachment_t  **pp_attachments;    int                   i_attachments;    if( decoder_GetInputAttachments( p_dec, &pp_attachments, &i_attachments ))    {        i_attachments = 0;        pp_attachments = NULL;    }    for( int k = 0; k < i_attachments; k++ )    {        input_attachment_t *p_attach = pp_attachments[k];        if( !strcasecmp( p_attach->psz_mime, "application/x-truetype-font" ) )        {            msg_Dbg( p_dec, "adding embedded font %s", p_attach->psz_name );            ass_add_font( p_ass->p_library, p_attach->psz_name, p_attach->p_data, p_attach->i_data );        }        vlc_input_attachment_Delete( p_attach );    }    free( pp_attachments );    ass_set_extract_fonts( p_library, true );    ass_set_style_overrides( p_library, NULL );    /* Create the renderer */    p_ass->p_renderer = p_renderer = ass_renderer_init( p_library );    if( !p_renderer )        goto error;    ass_set_use_margins( p_renderer, false);    //if( false )    //    ass_set_margins( p_renderer, int t, int b, int l, int r);    ass_set_hinting( p_renderer, ASS_HINTING_LIGHT );    ass_set_font_scale( p_renderer, 1.0 );    ass_set_line_spacing( p_renderer, 0.0 );    const char *psz_font = NULL; /* We don't ship a default font with VLC */    const char *psz_family = "Arial"; /* Use Arial if we can't find anything more suitable */#ifdef HAVE_FONTCONFIG#if defined(WIN32)    dialog_progress_bar_t *p_dialog = dialog_ProgressCreate( p_dec,        _("Building font cache"),        _( "Please wait while your font cache is rebuilt./n"        "This should take less than a minute." ), NULL );    if( p_dialog )        dialog_ProgressSet( p_dialog, NULL, 0.2 );#endif#if defined( LIBASS_VERSION ) && LIBASS_VERSION >= 0x00907000    ass_set_fonts( p_renderer, psz_font, psz_family, true, NULL, 1 );  // setup default font/family#else    ass_set_fonts( p_renderer, psz_font, psz_family );  // setup default font/family#endif#ifdef WIN32    if( p_dialog )    {        dialog_ProgressSet( p_dialog, NULL, 1.0 );        dialog_ProgressDestroy( p_dialog );        p_dialog = NULL;    }#endif//.........这里部分代码省略.........

/***************************************************************************** * 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_user;    char                *psz_pwd;    char                *psz_mime;    if( !( p_sys = p_access->p_sys = (sout_access_out_sys_t *)                malloc( sizeof( sout_access_out_sys_t ) ) ) )			// sunqueen modify        return VLC_ENOMEM ;    config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );    const char *path = p_access->psz_path;    path += strcspn( path, "/" );    if( path > p_access->psz_path )    {        const char *port = strrchr( p_access->psz_path, ':' );        if( port != NULL && strchr( port, ']' ) != NULL )            port = NULL; /* IPv6 numeral */        if( port != p_access->psz_path )        {            int len = (port ? port : path) - p_access->psz_path;            msg_Warn( p_access, "/"%.*s/" HTTP host might be ignored in "                      "multiple-host configurations, use at your own risks.",                      len, p_access->psz_path );            msg_Info( p_access, "Consider passing --http-host=IP on the "                                "command line instead." );            // sunqueen modify start//            char host[len + 1];			char *host = (char *)malloc(len + 1);			// sunqueen modify end            strncpy( host, p_access->psz_path, len );            host[len] = '/0';            var_Create( p_access, "http-host", VLC_VAR_STRING );            var_SetString( p_access, "http-host", host );			free(host);			// sunqueen add        }        if( port != NULL )        {            /* int len = path - ++port;            msg_Info( p_access, "Consider passing --%s-port=%.*s on the "                                "command line instead.",                      strcasecmp( p_access->psz_access, "https" )                      ? "http" : "https", len, port ); */            port++;            int bind_port = atoi( port );            if( bind_port > 0 )            {                const char *var = strcasecmp( p_access->psz_access, "https" )                                  ? "http-port" : "https-port";                var_Create( p_access, var, VLC_VAR_INTEGER );                var_SetInteger( p_access, var, bind_port );            }        }    }    if( !*path )        path = "/";    /* TLS support */    if( p_access->psz_access && !strcmp( p_access->psz_access, "https" ) )        p_sys->p_httpd_host = vlc_https_HostNew( VLC_OBJECT(p_access) );    else        p_sys->p_httpd_host = vlc_http_HostNew( VLC_OBJECT(p_access) );    if( p_sys->p_httpd_host == NULL )    {        msg_Err( p_access, "cannot start HTTP server" );        free( p_sys );        return VLC_EGENERIC;    }    psz_user = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "user" );    psz_pwd = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "pwd" );    if( p_access->psz_access && !strcmp( p_access->psz_access, "mmsh" ) )    {        psz_mime = strdup( "video/x-ms-asf-stream" );    }    else    {        psz_mime = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "mime" );    }    p_sys->p_httpd_stream =        httpd_StreamNew( p_sys->p_httpd_host, path, psz_mime,                         psz_user, psz_pwd );    free( psz_user );    free( psz_pwd );    free( psz_mime );    if( p_sys->p_httpd_stream == NULL )    {//.........这里部分代码省略.........

/***************************************************************************** * OpenFilter *****************************************************************************/static int OpenFilter( vlc_object_t *p_this ){    filter_t * p_filter = (filter_t *)p_this;    filter_sys_t *p_sys = NULL;    if( aout_FormatNbChannels( &(p_filter->fmt_in.audio) ) == 1 )    {        /*msg_Dbg( p_filter, "filter discarded (incompatible format)" );*/        return VLC_EGENERIC;    }    if( (p_filter->fmt_in.i_codec != VLC_CODEC_S16N) ||        (p_filter->fmt_out.i_codec != VLC_CODEC_S16N) )    {        /*msg_Err( p_this, "filter discarded (invalid format)" );*/        return VLC_EGENERIC;    }    if( (p_filter->fmt_in.audio.i_format != p_filter->fmt_out.audio.i_format) &&        (p_filter->fmt_in.audio.i_rate != p_filter->fmt_out.audio.i_rate) &&        (p_filter->fmt_in.audio.i_format != VLC_CODEC_S16N) &&        (p_filter->fmt_out.audio.i_format != VLC_CODEC_S16N) &&        (p_filter->fmt_in.audio.i_bitspersample !=                                    p_filter->fmt_out.audio.i_bitspersample))    {        /*msg_Err( p_this, "couldn't load mono filter" );*/        return VLC_EGENERIC;    }    /* Allocate the memory needed to store the module's structure */    p_sys = p_filter->p_sys = malloc( sizeof(filter_sys_t) );    if( p_sys == NULL )        return VLC_EGENERIC;    var_Create( p_this, MONO_CFG "downmix",                VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    p_sys->b_downmix = var_GetBool( p_this, MONO_CFG "downmix" );    var_Create( p_this, MONO_CFG "channel",                VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    p_sys->i_channel_selected =            (unsigned int) var_GetInteger( p_this, MONO_CFG "channel" );    if( p_sys->b_downmix )    {        msg_Dbg( p_this, "using stereo to mono downmix" );        p_filter->fmt_out.audio.i_physical_channels = AOUT_CHAN_CENTER;        p_filter->fmt_out.audio.i_channels = 1;    }    else    {        msg_Dbg( p_this, "using pseudo mono" );        p_filter->fmt_out.audio.i_physical_channels =                            (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT);        p_filter->fmt_out.audio.i_channels = 2;    }    p_filter->fmt_out.audio.i_rate = p_filter->fmt_in.audio.i_rate;    p_filter->fmt_out.audio.i_format = p_filter->fmt_out.i_codec;    p_sys->i_nb_channels = aout_FormatNbChannels( &(p_filter->fmt_in.audio) );    p_sys->i_bitspersample = p_filter->fmt_out.audio.i_bitspersample;    p_sys->i_overflow_buffer_size = 0;    p_sys->p_overflow_buffer = NULL;    p_sys->i_nb_atomic_operations = 0;    p_sys->p_atomic_operations = NULL;    if( Init( VLC_OBJECT(p_filter), p_filter->p_sys,              aout_FormatNbChannels( &p_filter->fmt_in.audio ),              p_filter->fmt_in.audio.i_physical_channels,              p_filter->fmt_in.audio.i_rate ) < 0 )    {        var_Destroy( p_this, MONO_CFG "channel" );        var_Destroy( p_this, MONO_CFG "downmix" );        free( p_sys );        return VLC_EGENERIC;    }    p_filter->pf_audio_filter = Convert;    msg_Dbg( p_this, "%4.4s->%4.4s, channels %d->%d, bits per sample: %i->%i",             (char *)&p_filter->fmt_in.i_codec,             (char *)&p_filter->fmt_out.i_codec,             p_filter->fmt_in.audio.i_physical_channels,             p_filter->fmt_out.audio.i_physical_channels,             p_filter->fmt_in.audio.i_bitspersample,             p_filter->fmt_out.audio.i_bitspersample );    return VLC_SUCCESS;}

void vout_InitInterlacingSupport(vout_thread_t *vout){    vlc_value_t val;    msg_Dbg(vout, "Deinterlacing available");    vout->p->filter.has_deint = false;    /* Create the configuration variables */    /* */    var_Create(vout, "deinterlace", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    int deinterlace_state = var_GetInteger(vout, "deinterlace");    var_Change(vout, "deinterlace", VLC_VAR_SETTEXT, _("Deinterlace"));    const module_config_t *optd = config_FindConfig("deinterlace");    var_Change(vout, "deinterlace", VLC_VAR_CLEARCHOICES);    if (likely(optd != NULL))        for (unsigned i = 0; i < optd->list_count; i++) {            val.i_int = optd->list.i[i];            var_Change(vout, "deinterlace", VLC_VAR_ADDCHOICE, val,                       vlc_gettext(optd->list_text[i]));        }    var_AddCallback(vout, "deinterlace", DeinterlaceCallback, NULL);    /* */    var_Create(vout, "deinterlace-mode", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    char *deinterlace_mode = var_GetNonEmptyString(vout, "deinterlace-mode");    var_Change(vout, "deinterlace-mode", VLC_VAR_SETTEXT,               _("Deinterlace mode"));    const module_config_t *optm = config_FindConfig("deinterlace-mode");    var_Change(vout, "deinterlace-mode", VLC_VAR_CLEARCHOICES);    if (likely(optm != NULL))        for (unsigned i = 0; i < optm->list_count; i++) {             if (!DeinterlaceIsModeValid(optm->list.psz[i]))                 continue;             val.psz_string  = (char *)optm->list.psz[i];             var_Change(vout, "deinterlace-mode", VLC_VAR_ADDCHOICE,                        val, vlc_gettext(optm->list_text[i]));         }    var_AddCallback(vout, "deinterlace-mode", DeinterlaceCallback, NULL);    /* */    var_Create(vout, "deinterlace-needed", VLC_VAR_BOOL);    var_AddCallback(vout, "deinterlace-needed", DeinterlaceCallback, NULL);    /* Override the initial value from filters if present */    char *filter_mode = NULL;    if (vout->p->filter.has_deint)        filter_mode = var_CreateGetNonEmptyString(vout, "sout-deinterlace-mode");    if (filter_mode) {        deinterlace_state = 1;        free(deinterlace_mode);        deinterlace_mode = filter_mode;    }    /* */    val.psz_string = deinterlace_mode ? deinterlace_mode : optm->orig.psz;    var_Change(vout, "deinterlace-mode", VLC_VAR_SETVALUE, val);    var_SetInteger(vout, "deinterlace", deinterlace_state);    free(deinterlace_mode);    vout->p->interlacing.is_interlaced = false;}

static void DoFingerprint( fingerprinter_thread_t *p_fingerprinter,                           acoustid_fingerprint_t *fp,                           const char *psz_uri ){    input_item_t *p_item = input_item_New( NULL, NULL );    if ( unlikely(p_item == NULL) )         return;    char *psz_sout_option;    /* Note: need at -max- 2 channels, but we can't guess it before playing */    /* the stereo upmix could make the mono tracks fingerprint to differ :/ */    if ( asprintf( &psz_sout_option,                   "sout=#transcode{acodec=%s,channels=2}:chromaprint",                   ( VLC_CODEC_S16L == VLC_CODEC_S16N ) ? "s16l" : "s16b" )         == -1 )    {        input_item_Release( p_item );        return;    }    input_item_AddOption( p_item, psz_sout_option, VLC_INPUT_OPTION_TRUSTED );    free( psz_sout_option );    input_item_AddOption( p_item, "vout=dummy", VLC_INPUT_OPTION_TRUSTED );    input_item_AddOption( p_item, "aout=dummy", VLC_INPUT_OPTION_TRUSTED );    if ( fp->i_duration )    {        if ( asprintf( &psz_sout_option, "stop-time=%u", fp->i_duration ) == -1 )        {            input_item_Release( p_item );            return;        }        input_item_AddOption( p_item, psz_sout_option, VLC_INPUT_OPTION_TRUSTED );        free( psz_sout_option );    }    input_item_SetURI( p_item, psz_uri ) ;    input_thread_t *p_input = input_Create( p_fingerprinter, p_item, "fingerprinter", NULL, NULL );    input_item_Release( p_item );    if( p_input == NULL )        return;    chromaprint_fingerprint_t chroma_fingerprint;    chroma_fingerprint.psz_fingerprint = NULL;    chroma_fingerprint.i_duration = fp->i_duration;    var_Create( p_input, "fingerprint-data", VLC_VAR_ADDRESS );    var_SetAddress( p_input, "fingerprint-data", &chroma_fingerprint );    var_AddCallback( p_input, "intf-event", InputEventHandler, p_fingerprinter->p_sys );    if( input_Start( p_input ) != VLC_SUCCESS )    {        var_DelCallback( p_input, "intf-event", InputEventHandler, p_fingerprinter->p_sys );        input_Close( p_input );    }    else    {        p_fingerprinter->p_sys->processing.b_working = true;        while( p_fingerprinter->p_sys->processing.b_working )        {            vlc_cond_wait( &p_fingerprinter->p_sys->processing.cond,                           &p_fingerprinter->p_sys->processing.lock );        }        var_DelCallback( p_input, "intf-event", InputEventHandler, p_fingerprinter->p_sys );        input_Stop( p_input );        input_Close( p_input );        fp->psz_fingerprint = chroma_fingerprint.psz_fingerprint;        if( !fp->i_duration ) /* had not given hint */            fp->i_duration = chroma_fingerprint.i_duration;    }}

/** * Create playlist * * Create a playlist structure. * /param p_parent the vlc object that is to be the parent of this playlist * /return a pointer to the created playlist, or NULL on error */playlist_t *playlist_Create( vlc_object_t *p_parent ){    playlist_t *p_playlist;    playlist_private_t *p;    /* Allocate structure */    p = vlc_custom_create( p_parent, sizeof( *p ), "playlist" );    if( !p )        return NULL;    assert( offsetof( playlist_private_t, public_data ) == 0 );    p_playlist = &p->public_data;    TAB_INIT( pl_priv(p_playlist)->i_sds, pl_priv(p_playlist)->pp_sds );    VariablesInit( p_playlist );    vlc_mutex_init( &p->lock );    vlc_cond_init( &p->signal );    p->killed = false;    /* Initialise data structures */    pl_priv(p_playlist)->i_last_playlist_id = 0;    pl_priv(p_playlist)->p_input = NULL;    ARRAY_INIT( p_playlist->items );    ARRAY_INIT( p_playlist->all_items );    ARRAY_INIT( pl_priv(p_playlist)->items_to_delete );    ARRAY_INIT( p_playlist->current );    p_playlist->i_current_index = 0;    pl_priv(p_playlist)->b_reset_currently_playing = true;    pl_priv(p_playlist)->b_tree = var_InheritBool( p_parent, "playlist-tree" );    /* Create the root, playing items and meida library nodes */    playlist_item_t *root, *playing, *ml;    PL_LOCK;    root = playlist_NodeCreate( p_playlist, NULL, NULL,                                PLAYLIST_END, 0, NULL );    playing = playlist_NodeCreate( p_playlist, _( "Playlist" ), root,                                   PLAYLIST_END, PLAYLIST_RO_FLAG, NULL );    if( var_InheritBool( p_parent, "media-library") )        ml = playlist_NodeCreate( p_playlist, _( "Media Library" ), root,                                  PLAYLIST_END, PLAYLIST_RO_FLAG, NULL );    else        ml = NULL;    PL_UNLOCK;    if( unlikely(root == NULL || playing == NULL) )        abort();    p_playlist->p_root = root;    p_playlist->p_playing = playing;    p_playlist->p_media_library = ml;    p_playlist->p_root_category = p_playlist->p_root;    p_playlist->p_root_onelevel = p_playlist->p_root;    p_playlist->p_local_category = p_playlist->p_playing;    p_playlist->p_local_onelevel = p_playlist->p_playing;    p_playlist->p_ml_category = p_playlist->p_media_library;    p_playlist->p_ml_onelevel = p_playlist->p_media_library;;    /* Initial status */    pl_priv(p_playlist)->status.p_item = NULL;    pl_priv(p_playlist)->status.p_node = p_playlist->p_playing;    pl_priv(p_playlist)->request.b_request = false;    if (ml != NULL)        playlist_MLLoad( p_playlist );    /* Preparser (and meta retriever) _after_ the Media Library*/    if( var_InheritBool( p_parent, "auto-preparse" ) )    {        p->p_preparser = playlist_preparser_New( VLC_OBJECT(p_playlist) );        if( unlikely(p->p_preparser == NULL) )            msg_Err( p_playlist, "cannot create preparser" );    }    /* Input resources */    p->p_input_resource = input_resource_New( VLC_OBJECT( p_playlist ) );    if( unlikely(p->p_input_resource == NULL) )        abort();    /* Audio output (needed for volume and device controls). */    audio_output_t *aout = input_resource_GetAout( p->p_input_resource );    if( aout != NULL )        input_resource_PutAout( p->p_input_resource, aout );    /* Initialize the shared HTTP cookie jar */    vlc_value_t cookies;    cookies.p_address = vlc_http_cookies_new();    if ( likely(cookies.p_address) )    {        var_Create( p_playlist, "http-cookies", VLC_VAR_ADDRESS );//.........这里部分代码省略.........

/***************************************************************************** * OSD menu Funtions *****************************************************************************/osd_menu_t *__osd_MenuCreate( vlc_object_t *p_this, const char *psz_file ){    osd_menu_t  *p_osd = NULL;    vlc_value_t lockval;    int         i_volume = 0;    int         i_steps = 0;    /* to be sure to avoid multiple creation */    var_Create( p_this->p_libvlc, "osd_mutex", VLC_VAR_MUTEX );    var_Get( p_this->p_libvlc, "osd_mutex", &lockval );    vlc_mutex_lock( lockval.p_address );    p_osd = vlc_object_find( p_this, VLC_OBJECT_OSDMENU, FIND_ANYWHERE );    if( p_osd == NULL )    {        static const char osdmenu_name[] = "osd menu";        vlc_value_t val;        p_osd = vlc_custom_create( p_this, sizeof( *p_osd ), VLC_OBJECT_OSDMENU,                                    osdmenu_name );        if( !p_osd )            return NULL;        p_osd->p_parser = NULL;        vlc_object_attach( p_osd, p_this->p_libvlc );        /* Parse configuration file */        if ( !osd_ParserLoad( p_osd, psz_file ) )            goto error;        if( !p_osd->p_state )            goto error;        /* Setup default button (first button) */        p_osd->p_state->p_visible = p_osd->p_button;        p_osd->p_state->p_visible->p_current_state =            osd_StateChange( p_osd->p_state->p_visible, OSD_BUTTON_SELECT );        p_osd->i_width  = p_osd->p_state->p_visible->p_current_state->p_pic->p[Y_PLANE].i_visible_pitch;        p_osd->i_height = p_osd->p_state->p_visible->p_current_state->p_pic->p[Y_PLANE].i_visible_lines;        if( p_osd->p_state->p_volume )        {            /* Update the volume state images to match the current volume */            i_volume = config_GetInt( p_this, "volume" );            i_steps = osd_VolumeStep( p_this, i_volume, p_osd->p_state->p_volume->i_ranges );            p_osd->p_state->p_volume->p_current_state = osd_VolumeStateChange(                                    p_osd->p_state->p_volume->p_states, i_steps );        }        /* Initialize OSD state */        osd_UpdateState( p_osd->p_state, p_osd->i_x, p_osd->i_y,                         p_osd->i_width, p_osd->i_height, NULL );        /* Signal when an update of OSD menu is needed */        var_Create( p_osd, "osd-menu-update", VLC_VAR_BOOL );        var_Create( p_osd, "osd-menu-visible", VLC_VAR_BOOL );        val.b_bool = false;        var_Set( p_osd, "osd-menu-update", val );        var_Set( p_osd, "osd-menu-visible", val );    }    vlc_mutex_unlock( lockval.p_address );    return p_osd;error:    vlc_mutex_unlock( lockval.p_address );    __osd_MenuDelete( p_this, p_osd );    return NULL;}

/***************************************************************************** * input_ConfigVarInit: *  Create all config object variables *****************************************************************************/void input_ConfigVarInit ( input_thread_t *p_input ){    /* Create Object Variables for private use only */    if( !p_input->b_preparsing )    {        var_Create( p_input, "video", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );        var_Create( p_input, "audio", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );        var_Create( p_input, "spu", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );        var_Create( p_input, "audio-track", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );        var_Create( p_input, "sub-track", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );        var_Create( p_input, "audio-language",                    VLC_VAR_STRING|VLC_VAR_DOINHERIT );        var_Create( p_input, "sub-language",                    VLC_VAR_STRING|VLC_VAR_DOINHERIT );        var_Create( p_input, "menu-language",                    VLC_VAR_STRING|VLC_VAR_DOINHERIT );        var_Create( p_input, "audio-track-id",                    VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );        var_Create( p_input, "sub-track-id",                    VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );        var_Create( p_input, "sub-file", VLC_VAR_STRING | VLC_VAR_DOINHERIT );        var_Create( p_input, "sub-autodetect-file", VLC_VAR_BOOL |                    VLC_VAR_DOINHERIT );        var_Create( p_input, "sub-autodetect-path", VLC_VAR_STRING |                    VLC_VAR_DOINHERIT );        var_Create( p_input, "sub-autodetect-fuzzy", VLC_VAR_INTEGER |                    VLC_VAR_DOINHERIT );        var_Create( p_input, "sout", VLC_VAR_STRING | VLC_VAR_DOINHERIT );        var_Create( p_input, "sout-all",   VLC_VAR_BOOL | VLC_VAR_DOINHERIT );        var_Create( p_input, "sout-audio", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );        var_Create( p_input, "sout-video", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );        var_Create( p_input, "sout-spu", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );        var_Create( p_input, "sout-keep",  VLC_VAR_BOOL | VLC_VAR_DOINHERIT );        var_Create( p_input, "input-repeat",                    VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );        var_Create( p_input, "start-time", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT );        var_Create( p_input, "stop-time", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT );        var_Create( p_input, "run-time", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT );        var_Create( p_input, "input-fast-seek", VLC_VAR_BOOL|VLC_VAR_DOINHERIT );        var_Create( p_input, "input-slave",                    VLC_VAR_STRING | VLC_VAR_DOINHERIT );        var_Create( p_input, "audio-desync",                    VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );        var_Create( p_input, "cr-average",                    VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );        var_Create( p_input, "clock-synchro",                    VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);    }    var_Create( p_input, "can-seek", VLC_VAR_BOOL );    var_SetBool( p_input, "can-seek", true ); /* Fixed later*/    var_Create( p_input, "can-pause", VLC_VAR_BOOL );    var_SetBool( p_input, "can-pause", true ); /* Fixed later*/    var_Create( p_input, "can-rate", VLC_VAR_BOOL );    var_SetBool( p_input, "can-rate", false );    var_Create( p_input, "can-rewind", VLC_VAR_BOOL );    var_SetBool( p_input, "can-rewind", false );    var_Create( p_input, "can-record", VLC_VAR_BOOL );    var_SetBool( p_input, "can-record", false ); /* Fixed later*/    var_Create( p_input, "record", VLC_VAR_BOOL );    var_SetBool( p_input, "record", false );    var_Create( p_input, "teletext-es", VLC_VAR_INTEGER );    var_SetInteger( p_input, "teletext-es", -1 );    var_Create( p_input, "signal-quality", VLC_VAR_FLOAT );    var_SetFloat( p_input, "signal-quality", -1 );    var_Create( p_input, "signal-strength", VLC_VAR_FLOAT );    var_SetFloat( p_input, "signal-strength", -1 );    var_Create( p_input, "program-scrambled", VLC_VAR_BOOL );    var_SetBool( p_input, "program-scrambled", false );    var_Create( p_input, "cache", VLC_VAR_FLOAT );    var_SetFloat( p_input, "cache", 0.0 );    /* */    var_Create( p_input, "input-record-native", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    /* */    var_Create( p_input, "access", VLC_VAR_STRING | VLC_VAR_DOINHERIT );//.........这里部分代码省略.........