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

static int MarshalStatus( intf_thread_t* p_intf, DBusMessageIter* args ){ /* This is NOT the right way to do that, it would be better to sore     the status information in p_sys and update it on change, thus     avoiding a long lock */    DBusMessageIter status;    dbus_int32_t i_state, i_random, i_repeat, i_loop;    playlist_t* p_playlist = p_intf->p_sys->p_playlist;    vlc_mutex_lock( &p_intf->p_sys->lock );    i_state = p_intf->p_sys->i_playing_state;    vlc_mutex_unlock( &p_intf->p_sys->lock );    i_random = var_CreateGetBool( p_playlist, "random" );    i_repeat = var_CreateGetBool( p_playlist, "repeat" );    i_loop = var_CreateGetBool( p_playlist, "loop" );    dbus_message_iter_open_container( args, DBUS_TYPE_STRUCT, NULL, &status );    dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_state );    dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_random );    dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_repeat );    dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_loop );    dbus_message_iter_close_container( args, &status );    return VLC_SUCCESS;}

/***************************************************************************** * OpenDecoder: probe the decoder and return score ***************************************************************************** * Tries to launch a decoder and return score so that the interface is able * to chose. *****************************************************************************/static int OpenDecoder( vlc_object_t *p_this ){    decoder_t     *p_dec = (decoder_t*)p_this;    decoder_sys_t *p_sys;    if( p_dec->fmt_in.i_codec != VLC_CODEC_USF )        return VLC_EGENERIC;    /* Allocate the memory needed to store the decoder's structure */    if( ( p_dec->p_sys = p_sys = calloc(1, sizeof(decoder_sys_t)) ) == NULL )        return VLC_ENOMEM;    p_dec->pf_decode_sub = DecodeBlock;    p_dec->fmt_out.i_cat = SPU_ES;    p_dec->fmt_out.i_codec = 0;    /* init of p_sys */    TAB_INIT( p_sys->i_ssa_styles, p_sys->pp_ssa_styles );    TAB_INIT( p_sys->i_images, p_sys->pp_images );    /* USF subtitles are mandated to be UTF-8, so don't need vlc_iconv */    p_sys->i_align = var_CreateGetInteger( p_dec, "subsdec-align" );    ParseImageAttachments( p_dec );    if( var_CreateGetBool( p_dec, "subsdec-formatted" ) )    {        if( p_dec->fmt_in.i_extra > 0 )            ParseUSFHeader( p_dec );    }    return VLC_SUCCESS;}

/** * @brief Remove a directory to monitor * @param p_ml A media library object * @param psz_dir the directory to remove * @return VLC_SUCCESS or VLC_EGENERIC */int RemoveDirToMonitor( media_library_t *p_ml, const char *psz_dir ){    assert( p_ml );    char **pp_results = NULL;    int i_cols = 0, i_rows = 0, i_ret = VLC_SUCCESS;    int i;    bool b_recursive = var_CreateGetBool( p_ml, "ml-recursive-scan" );    if( b_recursive )    {        i_ret = Query( p_ml, &pp_results, &i_rows, &i_cols,                          "SELECT media.id FROM media JOIN directories ON "                          "(media.directory_id = directories.id) WHERE "                          "directories.uri LIKE '%q%%'",                          psz_dir );        if( i_ret != VLC_SUCCESS )        {            msg_Err( p_ml, "Error occured while making a query to the database" );            return i_ret;        }        QuerySimple( p_ml, "DELETE FROM directories WHERE uri LIKE '%q%%'",                        psz_dir );    }    else    {        i_ret = Query( p_ml, &pp_results, &i_rows, &i_cols,                          "SELECT media.id FROM media JOIN directories ON "                          "(media.directory_id = directories.id) WHERE "                          "directories.uri = %Q",                          psz_dir );        if( i_ret != VLC_SUCCESS )        {            msg_Err( p_ml, "Error occured while making a query to the database" );            return i_ret;        }        QuerySimple( p_ml, "DELETE FROM directories WHERE uri = %Q",                        psz_dir );    }    vlc_array_t *p_where = vlc_array_new();    for( i = 1; i <= i_rows; i++ )    {        int id = atoi( pp_results[i*i_cols] );        ml_element_t* p_find = ( ml_element_t * ) calloc( 1, sizeof( ml_element_t ) );        p_find->criteria = ML_ID;        p_find->value.i = id;        vlc_array_append( p_where, p_find );    }    Delete( p_ml, p_where );    FreeSQLResult( p_ml, pp_results );    for( i = 0; i < vlc_array_count( p_where ); i++ )    {        free( vlc_array_item_at_index( p_where, i ) );    }    vlc_array_destroy( p_where );    return VLC_SUCCESS;}

static int MarshalStatus( intf_thread_t* p_intf, DBusMessageIter* args ){ /* This is NOT the right way to do that, it would be better to sore     the status information in p_sys and update it on change, thus     avoiding a long lock */    DBusMessageIter status;    dbus_int32_t i_state, i_random, i_repeat, i_loop;    vlc_value_t val;    playlist_t* p_playlist = NULL;    input_thread_t* p_input = NULL;    p_playlist = pl_Hold( p_intf );    i_state = 2;    p_input = playlist_CurrentInput( p_playlist );    if( p_input )    {        var_Get( p_input, "state", &val );        if( val.i_int >= END_S )            i_state = 2;        else if( val.i_int == PAUSE_S )            i_state = 1;        else if( val.i_int <= PLAYING_S )            i_state = 0;        vlc_object_release( p_input );    }    i_random = var_CreateGetBool( p_playlist, "random" );    i_repeat = var_CreateGetBool( p_playlist, "repeat" );    i_loop = var_CreateGetBool( p_playlist, "loop" );    pl_Release( p_intf );    dbus_message_iter_open_container( args, DBUS_TYPE_STRUCT, NULL, &status );    dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_state );    dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_random );    dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_repeat );    dbus_message_iter_append_basic( &status, DBUS_TYPE_INT32, &i_loop );    dbus_message_iter_close_container( args, &status );    return VLC_SUCCESS;}

static int LoopInput( playlist_t *p_playlist ){    playlist_private_t *p_sys = pl_priv(p_playlist);    input_thread_t *p_input = p_sys->p_input;    if( !p_input )        return VLC_EGENERIC;    if( ( p_sys->request.b_request || !vlc_object_alive( p_playlist ) ) && !p_input->b_die )    {        PL_DEBUG( "incoming request - stopping current input" );        input_Stop( p_input, true );    }    /* This input is dead. Remove it ! */    if( p_input->b_dead )    {        PL_DEBUG( "dead input" );        PL_UNLOCK;        /* We can unlock as we return VLC_EGENERIC (no event will be lost) */        /* input_resource_t must be manipulated without playlist lock */        if( !var_CreateGetBool( p_input, "sout-keep" ) )            input_resource_TerminateSout( p_sys->p_input_resource );        /* The DelCallback must be issued without playlist lock */        var_DelCallback( p_input, "intf-event", InputEvent, p_playlist );        PL_LOCK;        p_sys->p_input = NULL;        input_Close( p_input );        UpdateActivity( p_playlist, -DEFAULT_INPUT_ACTIVITY );        return VLC_EGENERIC;    }    /* This input is dying, let it do */    else if( p_input->b_die )    {        PL_DEBUG( "dying input" );    }    /* This input has finished, ask it to die ! */    else if( p_input->b_error || p_input->b_eof )    {        PL_DEBUG( "finished input" );        input_Stop( p_input, false );    }    return VLC_SUCCESS;}

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

/***************************************************************************** * OpenDecoder: Open the decoder *****************************************************************************/static int OpenDecoderCommon( vlc_object_t *p_this, bool b_force_dump ){    decoder_t *p_dec = (decoder_t*)p_this;    decoder_sys_t *p_sys;    char psz_file[ PATH_MAX ];    /* Allocate the memory needed to store the decoder's structure */    if( ( p_dec->p_sys = p_sys =          (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )    {        return VLC_ENOMEM;    }    snprintf( psz_file, sizeof( psz_file), "stream.%p", p_dec );#ifndef UNDER_CE    if( !b_force_dump )    {        b_force_dump = var_CreateGetBool( p_dec, "dummy-save-es" );    }    if( b_force_dump )    {        p_sys->i_fd = vlc_open( psz_file, O_WRONLY | O_CREAT | O_TRUNC, 00644 );        if( p_sys->i_fd == -1 )        {            msg_Err( p_dec, "cannot create `%s'", psz_file );            free( p_sys );            return VLC_EGENERIC;        }        msg_Dbg( p_dec, "dumping stream to file `%s'", psz_file );    }    else#endif    {        p_sys->i_fd = -1;    }    /* Set callbacks */    p_dec->pf_decode_video = (picture_t *(*)(decoder_t *, block_t **))        DecodeBlock;    p_dec->pf_decode_audio = (aout_buffer_t *(*)(decoder_t *, block_t **))        DecodeBlock;    p_dec->pf_decode_sub = (subpicture_t *(*)(decoder_t *, block_t **))        DecodeBlock;    es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );    return VLC_SUCCESS;}

static bool FindLength( demux_t *p_demux ){    demux_sys_t *p_sys = p_demux->p_sys;    int64_t i_current_pos = -1, i_size = 0, i_end = 0;    if( !var_CreateGetBool( p_demux, "ps-trust-timestamps" ) )        return true;    if( p_sys->i_length == VLC_TICK_INVALID ) /* First time */    {        p_sys->i_length = VLC_TICK_0;        /* Check beginning */        int i = 0;        i_current_pos = vlc_stream_Tell( p_demux->s );        while( i < 40 && Probe( p_demux, false ) > 0 ) i++;        /* Check end */        i_size = stream_Size( p_demux->s );        i_end = VLC_CLIP( i_size, 0, 200000 );        if( vlc_stream_Seek( p_demux->s, i_size - i_end ) == VLC_SUCCESS )        {            i = 0;            while( i < 400 && Probe( p_demux, true ) > 0 ) i++;            if( i_current_pos >= 0 &&                vlc_stream_Seek( p_demux->s, i_current_pos ) != VLC_SUCCESS )                    return false;        }        else return false;    }    /* Find the longest track */    for( int i = 0; i < PS_TK_COUNT; i++ )    {        ps_track_t *tk = &p_sys->tk[i];        if( tk->i_first_pts != VLC_TICK_INVALID &&            tk->i_last_pts > tk->i_first_pts )        {            vlc_tick_t i_length = tk->i_last_pts - tk->i_first_pts;            if( i_length > p_sys->i_length )            {                p_sys->i_length = i_length;                p_sys->i_time_track_index = i;                msg_Dbg( p_demux, "we found a length of: %"PRId64 "s", SEC_FROM_VLC_TICK(p_sys->i_length) );            }        }    }    return true;}

/** * Open() */static int Open (vlc_object_t *obj){    access_t *access = (access_t*)obj;    access_t *src = access->p_source;    if (!var_CreateGetBool (access, "dump-force"))    {        bool b;        if ((access_Control (src, ACCESS_CAN_FASTSEEK, &b) == 0) && b)        {            msg_Dbg (obj, "dump filter useless");            return VLC_EGENERIC;        }    }    if (src->pf_read != NULL)        access->pf_read = Read;    else        access->pf_block = Block;    if (src->pf_seek != NULL)        access->pf_seek = Seek;    access->pf_control = Control;    access->info = src->info;    access_sys_t *p_sys = access->p_sys = calloc( 1, sizeof (*p_sys) );    if( !p_sys )        return VLC_ENOMEM;# ifndef UNDER_CE    if ((p_sys->stream = tmpfile ()) == NULL)# else    char buf[75];    if(GetTempFileName("//Temp//","vlc",0,buf) || ((p_sys->stream = fopen(buf,"wb+")) ==NULL))#endif    {        msg_Err (access, "cannot create temporary file: %m");        free (p_sys);        return VLC_EGENERIC;    }    p_sys->tmp_max = ((int64_t)var_CreateGetInteger (access, "dump-margin")) << 20;    var_AddCallback (access->p_libvlc, "key-action", KeyHandler, access);    return VLC_SUCCESS;}

/***************************************************************************** * Open: *****************************************************************************/static int Open( vlc_object_t *p_this ){    char* psz_tmp;    sout_stream_t *p_stream = (sout_stream_t*)p_this;    sout_stream_sys_t *p_sys;    p_sys = calloc( 1, sizeof( sout_stream_sys_t ) );    if( !p_sys )        return VLC_ENOMEM;    p_stream->p_sys = p_sys;    p_sys->time_sync = var_CreateGetBool( p_stream, SOUT_CFG_PREFIX "time-sync" );    psz_tmp = var_CreateGetString( p_stream, SOUT_PREFIX_VIDEO "prerender-callback" );    p_sys->pf_video_prerender_callback = (void (*) (void *, uint8_t**, int))(intptr_t)atoll( psz_tmp );    free( psz_tmp );    psz_tmp = var_CreateGetString( p_stream, SOUT_PREFIX_AUDIO "prerender-callback" );    p_sys->pf_audio_prerender_callback = (void (*) (void* , uint8_t**, unsigned int))(intptr_t)atoll( psz_tmp );    free( psz_tmp );    psz_tmp = var_CreateGetString( p_stream, SOUT_PREFIX_VIDEO "postrender-callback" );    p_sys->pf_video_postrender_callback = (void (*) (void*, uint8_t*, int, int, int, int, int))(intptr_t)atoll( psz_tmp );    free( psz_tmp );    psz_tmp = var_CreateGetString( p_stream, SOUT_PREFIX_AUDIO "postrender-callback" );    p_sys->pf_audio_postrender_callback = (void (*) (void*, uint8_t*, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, int))(intptr_t)atoll( psz_tmp );    free( psz_tmp );    /* Create the remaining variables for a later use */    var_Create( p_stream, SOUT_PREFIX_VIDEO "data", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    var_Create( p_stream, SOUT_PREFIX_AUDIO "data", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    /* Setting stream out module callbacks */    p_stream->pf_add    = Add;    p_stream->pf_del    = Del;    p_stream->pf_send   = Send;    /* Does the module need out_pace_control? */    if ( p_sys->time_sync )        p_stream->p_sout->i_out_pace_nocontrol++;    return VLC_SUCCESS;}

/***************************************************************************** * InitVideo: initialize the video decoder ***************************************************************************** * the ffmpeg codec will be opened, some memory allocated. The vout is not yet * opened (done after the first decoded frame). *****************************************************************************/int InitVideoDec( decoder_t *p_dec, AVCodecContext *p_context,                      AVCodec *p_codec, int i_codec_id, const char *psz_namecodec ){    decoder_sys_t *p_sys;    int i_val;    /* Allocate the memory needed to store the decoder's structure */    if( ( p_dec->p_sys = p_sys = calloc( 1, sizeof(decoder_sys_t) ) ) == NULL )        return VLC_ENOMEM;    p_codec->type = AVMEDIA_TYPE_VIDEO;    p_context->codec_type = AVMEDIA_TYPE_VIDEO;    p_context->codec_id = i_codec_id;    p_sys->p_context = p_context;    p_sys->p_codec = p_codec;    p_sys->i_codec_id = i_codec_id;    p_sys->psz_namecodec = psz_namecodec;    p_sys->p_ff_pic = avcodec_alloc_frame();    p_sys->b_delayed_open = true;    p_sys->p_va = NULL;    vlc_sem_init( &p_sys->sem_mt, 0 );    /* ***** Fill p_context with init values ***** */    p_sys->p_context->codec_tag = ffmpeg_CodecTag( p_dec->fmt_in.i_original_fourcc ? p_dec->fmt_in.i_original_fourcc : p_dec->fmt_in.i_codec );			// sunqueen modify    /*  ***** Get configuration of ffmpeg plugin ***** */    p_sys->p_context->workaround_bugs =        var_InheritInteger( p_dec, "avcodec-workaround-bugs" );    p_sys->p_context->err_recognition =        var_InheritInteger( p_dec, "avcodec-error-resilience" );    if( var_CreateGetBool( p_dec, "grayscale" ) )        p_sys->p_context->flags |= CODEC_FLAG_GRAY;    /* ***** Output always the frames ***** */#if LIBAVCODEC_VERSION_CHECK(55, 23, 1, 40, 101)    p_sys->p_context->flags |= CODEC_FLAG_OUTPUT_CORRUPT;#endif    i_val = var_CreateGetInteger( p_dec, "avcodec-vismv" );    if( i_val ) p_sys->p_context->debug_mv = i_val;    i_val = var_CreateGetInteger( p_dec, "avcodec-skiploopfilter" );    if( i_val >= 4 ) p_sys->p_context->skip_loop_filter = AVDISCARD_ALL;    else if( i_val == 3 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONKEY;    else if( i_val == 2 ) p_sys->p_context->skip_loop_filter = AVDISCARD_BIDIR;    else if( i_val == 1 ) p_sys->p_context->skip_loop_filter = AVDISCARD_NONREF;    if( var_CreateGetBool( p_dec, "avcodec-fast" ) )        p_sys->p_context->flags2 |= CODEC_FLAG2_FAST;    /* ***** libavcodec frame skipping ***** */    p_sys->b_hurry_up = var_CreateGetBool( p_dec, "avcodec-hurry-up" );    i_val = var_CreateGetInteger( p_dec, "avcodec-skip-frame" );    if( i_val >= 4 ) p_sys->p_context->skip_frame = AVDISCARD_ALL;    else if( i_val == 3 ) p_sys->p_context->skip_frame = AVDISCARD_NONKEY;    else if( i_val == 2 ) p_sys->p_context->skip_frame = AVDISCARD_BIDIR;    else if( i_val == 1 ) p_sys->p_context->skip_frame = AVDISCARD_NONREF;    else if( i_val == -1 ) p_sys->p_context->skip_frame = AVDISCARD_NONE;    else p_sys->p_context->skip_frame = AVDISCARD_DEFAULT;    p_sys->i_skip_frame = p_sys->p_context->skip_frame;    i_val = var_CreateGetInteger( p_dec, "avcodec-skip-idct" );    if( i_val >= 4 ) p_sys->p_context->skip_idct = AVDISCARD_ALL;    else if( i_val == 3 ) p_sys->p_context->skip_idct = AVDISCARD_NONKEY;    else if( i_val == 2 ) p_sys->p_context->skip_idct = AVDISCARD_BIDIR;    else if( i_val == 1 ) p_sys->p_context->skip_idct = AVDISCARD_NONREF;    else if( i_val == -1 ) p_sys->p_context->skip_idct = AVDISCARD_NONE;    else p_sys->p_context->skip_idct = AVDISCARD_DEFAULT;    p_sys->i_skip_idct = p_sys->p_context->skip_idct;    /* ***** libavcodec direct rendering ***** */    p_sys->b_direct_rendering = false;    p_sys->i_direct_rendering_used = -1;    if( var_CreateGetBool( p_dec, "avcodec-dr" ) &&       (p_sys->p_codec->capabilities & CODEC_CAP_DR1) &&        /* No idea why ... but this fixes flickering on some TSCC streams */        p_sys->i_codec_id != AV_CODEC_ID_TSCC && p_sys->i_codec_id != AV_CODEC_ID_CSCD &&        p_sys->i_codec_id != AV_CODEC_ID_CINEPAK &&        !p_sys->p_context->debug_mv )    {        /* Some codecs set pix_fmt only after the 1st frame has been decoded,         * so we need to do another check in ffmpeg_GetFrameBuf() */        p_sys->b_direct_rendering = true;    }    /* libavcodec doesn't properly release old pictures when frames are skipped */    //if( p_sys->b_hurry_up ) p_sys->b_direct_rendering = false;    if( p_sys->b_direct_rendering )    {        msg_Dbg( p_dec, "trying to use direct rendering" );        p_sys->p_context->flags |= CODEC_FLAG_EMU_EDGE;    }//.........这里部分代码省略.........

static int Activate( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    unsigned i_canvas_width; /* width of output canvas */    unsigned i_canvas_height; /* height of output canvas */    unsigned i_canvas_aspect; /* canvas PictureAspectRatio */    es_format_t fmt; /* target format after up/down conversion */    char psz_croppadd[100];    int i_padd,i_offset;    char *psz_aspect, *psz_parser;    bool b_padd;    unsigned i_fmt_in_aspect;    if( !p_filter->b_allow_fmt_out_change )    {        msg_Err( p_filter, "Picture format change isn't allowed" );        return VLC_EGENERIC;    }    if( p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma )    {        msg_Err( p_filter, "Input and output chromas don't match" );        return VLC_EGENERIC;    }    config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,                       p_filter->p_cfg );    i_canvas_width = var_CreateGetInteger( p_filter, CFG_PREFIX "width" );    i_canvas_height = var_CreateGetInteger( p_filter, CFG_PREFIX "height" );    if( i_canvas_width == 0 || i_canvas_height == 0 )    {        msg_Err( p_filter, "Width and height options must be set" );        return VLC_EGENERIC;    }    if( i_canvas_width & 1 || i_canvas_height & 1 )    {        /* If this restriction were ever relaxed, it is very important to         * get the field polatiry correct */        msg_Err( p_filter, "Width and height options must be even integers" );        return VLC_EGENERIC;    }    i_fmt_in_aspect = (int64_t)p_filter->fmt_in.video.i_sar_num *                      p_filter->fmt_in.video.i_width *                      VOUT_ASPECT_FACTOR /                      p_filter->fmt_in.video.i_sar_den /                      p_filter->fmt_in.video.i_height;    psz_aspect = var_CreateGetNonEmptyString( p_filter, CFG_PREFIX "aspect" );    if( psz_aspect )    {        psz_parser = strchr( psz_aspect, ':' );        int numerator = atoi( psz_aspect );        int denominator = psz_parser ? atoi( psz_parser+1 ) : 0;        denominator = denominator == 0 ? 1 : denominator;        i_canvas_aspect = numerator * VOUT_ASPECT_FACTOR / denominator;        free( psz_aspect );        if( numerator <= 0 || denominator < 0 )        {            msg_Err( p_filter, "Aspect ratio must be strictly positive" );            return VLC_EGENERIC;        }    }    else    {        /* if there is no user supplied aspect ratio, assume the canvas         * has the same sample aspect ratio as the subpicture */        /* aspect = subpic_sar * canvas_width / canvas_height         *  where subpic_sar = subpic_ph * subpic_par / subpic_pw */        i_canvas_aspect = (uint64_t) p_filter->fmt_in.video.i_height                        * i_fmt_in_aspect                        * i_canvas_width                        / (i_canvas_height * p_filter->fmt_in.video.i_width);    }    b_padd = var_CreateGetBool( p_filter, CFG_PREFIX "padd" );    filter_sys_t *p_sys = (filter_sys_t *)malloc( sizeof( filter_sys_t ) );    if( !p_sys )        return VLC_ENOMEM;    p_filter->p_sys = p_sys;    p_sys->p_chain = filter_chain_New( p_filter, "video filter2", true,                                       alloc_init, NULL, p_filter );    if( !p_sys->p_chain )    {        msg_Err( p_filter, "Could not allocate filter chain" );        free( p_sys );        return VLC_EGENERIC;    }    es_format_Copy( &fmt, &p_filter->fmt_in );    /* one dimension will end up with one of the following: */    fmt.video.i_width = i_canvas_width;    fmt.video.i_height = i_canvas_height;//.........这里部分代码省略.........

//.........这里部分代码省略.........    luaopen_stream( L );    luaopen_strings( L );    luaopen_variables( L );    luaopen_video( L );    luaopen_vlm( L );    luaopen_volume( L );    luaopen_gettext( L );    luaopen_xml( L );    luaopen_equalizer( L );    /* clean up */    lua_pop( L, 1 );    /* Setup the module search path */    if( vlclua_add_modules_path( p_intf, L, p_sys->psz_filename ) )    {        msg_Warn( p_intf, "Error while setting the module search path for %s",                  p_sys->psz_filename );        lua_close( L );        goto error;    }    /*     * Get the lua-config string.     * If the string is empty, try with the old http-* or telnet-* options     * and build the right configuration line     */    psz_config = var_CreateGetNonEmptyString( p_intf, "lua-config" );    if( !psz_config )    {        if( !strcmp( name, "http" ) )        {            char *psz_http_src = var_CreateGetNonEmptyString( p_intf, "http-src" );            bool b_http_index = var_CreateGetBool( p_intf, "http-index" );            if( psz_http_src )            {                char *psz_esc = config_StringEscape( psz_http_src );                if( psz_config )                {                    char *psz_tmp;                    asprintf( &psz_tmp, "%s,dir='%s'", psz_config, psz_esc );                    free( psz_config );                    psz_config = psz_tmp;                }                else                    asprintf( &psz_config, "http={dir='%s'", psz_esc );                free( psz_esc );                free( psz_http_src );            }            if( psz_config )            {                char *psz_tmp;                asprintf( &psz_tmp, "%s,no_index=%s}", psz_config, b_http_index ? "true" : "false" );                free( psz_config );                psz_config = psz_tmp;            }            else                asprintf( &psz_config, "http={no_index=%s}", b_http_index ? "true" : "false" );        }        else if( !strcmp( name, "telnet" ) )        {            char *psz_telnet_host = var_CreateGetString( p_intf, "telnet-host" );            if( !strcmp( psz_telnet_host, "*console" ) )                ;            else            {

/***************************************************************************** * OpenDecoder: probe the decoder and return score ***************************************************************************** * Tries to launch a decoder and return score so that the interface is able * to chose. *****************************************************************************/static int OpenDecoder( vlc_object_t *p_this ){    decoder_t     *p_dec = (decoder_t*)p_this;    decoder_sys_t *p_sys;    if( p_dec->fmt_in.i_codec != VLC_CODEC_KATE )    {        return VLC_EGENERIC;    }    msg_Dbg( p_dec, "kate: OpenDecoder");    /* Set callbacks */    p_dec->pf_decode_sub = (subpicture_t *(*)(decoder_t *, block_t **))        DecodeBlock;    p_dec->pf_packetize    = (block_t *(*)(decoder_t *, block_t **))        DecodeBlock;    /* Allocate the memory needed to store the decoder's structure */    if( ( p_dec->p_sys = p_sys = (decoder_sys_t *)malloc(sizeof(*p_sys)) ) == NULL )			// sunqueen modify        return VLC_ENOMEM;    vlc_mutex_init( &p_sys->lock );    p_sys->i_refcount = 0;    DecSysHold( p_sys );    /* init of p_sys */#ifdef ENABLE_PACKETIZER    p_sys->b_packetizer = false;#endif    p_sys->b_ready = false;    p_sys->i_pts =    p_sys->i_max_stop = VLC_TS_INVALID;    kate_comment_init( &p_sys->kc );    kate_info_init( &p_sys->ki );    p_sys->b_has_headers = false;    /* retrieve options */    p_sys->b_formatted = var_CreateGetBool( p_dec, "kate-formatted" );    vlc_mutex_lock( &kate_decoder_list_mutex );#ifdef HAVE_TIGER    p_sys->b_use_tiger = var_CreateGetBool( p_dec, "kate-use-tiger" );    p_sys->p_tr = NULL;    /* get initial value of configuration */    p_sys->i_tiger_default_font_color = GetTigerColor( p_dec, "kate-tiger-default-font" );    p_sys->i_tiger_default_background_color = GetTigerColor( p_dec, "kate-tiger-default-background" );    p_sys->e_tiger_default_font_effect = GetTigerInteger( p_dec, "kate-tiger-default-font-effect" );    p_sys->f_tiger_default_font_effect_strength = GetTigerFloat( p_dec, "kate-tiger-default-font-effect-strength" );    p_sys->psz_tiger_default_font_desc = GetTigerString( p_dec, "kate-tiger-default-font-desc" );    p_sys->f_tiger_quality = GetTigerFloat( p_dec, "kate-tiger-quality" );    if( p_sys->b_use_tiger )    {        int i_ret = tiger_renderer_create( &p_sys->p_tr );        if( i_ret < 0 )        {            msg_Warn ( p_dec, "Failed to create Tiger renderer, falling back to basic rendering" );            p_sys->p_tr = NULL;            p_sys->b_use_tiger = false;        }        else {            CHECK_TIGER_RET( tiger_renderer_set_surface_clear_color( p_sys->p_tr, 1, 0, 0, 0, 0 ) );            UpdateTigerFontEffect( p_dec );            UpdateTigerFontColor( p_dec );            UpdateTigerBackgroundColor( p_dec );            UpdateTigerQuality( p_dec );            UpdateTigerFontDesc( p_dec );        }    }#else    p_sys->b_use_tiger = false;#endif    es_format_Init( &p_dec->fmt_out, SPU_ES, 0 );    /* add the decoder to the global list */    decoder_t **list = (decoder_t **)realloc( kate_decoder_list, (kate_decoder_list_size+1) * sizeof( *list ));			// sunqueen modify    if( list )    {        list[ kate_decoder_list_size++ ] = p_dec;        kate_decoder_list = list;    }//.........这里部分代码省略.........

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->b_title_show = var_CreateGetBool( p_vout, "video-title-show" );    p_vout->i_title_timeout =        (mtime_t)var_CreateGetInteger( p_vout, "video-title-timeout" );    p_vout->i_title_position =        var_CreateGetInteger( p_vout, "video-title-position" );    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 );    if( old_val.psz_string && *old_val.psz_string )//.........这里部分代码省略.........

static void PMThread( void *arg ){    vout_display_t *vd = ( vout_display_t * )arg;    vout_display_sys_t * sys = vd->sys;    ULONG i_frame_flags;    QMSG qm;    char *psz_mode;    ULONG i_kva_mode;    /* */    video_format_t fmt = vd->fmt;    /* */    vout_display_info_t info = vd->info;    info.is_slow = false;    info.has_double_click = true;    info.has_hide_mouse = false;    info.has_pictures_invalid = false;    MorphToPM();    sys->hab = WinInitialize( 0 );    sys->hmq = WinCreateMsgQueue( sys->hab, 0);    WinRegisterClass( sys->hab,                      WC_VLC_KVA,                      WndProc,                      CS_SIZEREDRAW | CS_MOVENOTIFY,                      sizeof( PVOID ));    sys->b_fixt23 = var_CreateGetBool( vd, "kva-fixt23");    if( !sys->b_fixt23 )    {        vout_window_cfg_t wnd_cfg;        wnd_cfg.is_standalone = false;        wnd_cfg.type          = VOUT_WINDOW_TYPE_HWND;        wnd_cfg.x             = var_InheritInteger(vd, "video-x");        wnd_cfg.y             = var_InheritInteger(vd, "video-y");        wnd_cfg.width         = vd->cfg->display.width;        wnd_cfg.height        = vd->cfg->display.height;        /* If an external window was specified, we'll draw in it. */        sys->parent_window =            vout_display_NewWindow( vd, &wnd_cfg );    }    if( sys->parent_window )    {        sys->parent = ( HWND )sys->parent_window->handle.hwnd;        /* Workaround :         * When an embedded window opened first, it is not positioned         * correctly. So reposition it here, again.         */        WinSetWindowPos( WinQueryWindow( sys->parent, QW_PARENT ),                         HWND_TOP, 0, 0, 0, 0, SWP_MOVE );        ULONG i_style = WinQueryWindowULong( sys->parent, QWL_STYLE );        WinSetWindowULong( sys->parent, QWL_STYLE,                           i_style | WS_CLIPCHILDREN );        i_frame_flags = FCF_TITLEBAR;    }    else    {        sys->parent = HWND_DESKTOP;        i_frame_flags = FCF_SYSMENU    | FCF_TITLEBAR | FCF_MINMAX |                        FCF_SIZEBORDER | FCF_TASKLIST;    }    sys->frame =        WinCreateStdWindow( sys->parent,      /* parent window handle */                            WS_VISIBLE,       /* frame window style */                            &i_frame_flags,   /* window style */                            WC_VLC_KVA,       /* class name */                            "",               /* window title */                            0L,               /* default client style */                            NULLHANDLE,       /* resource in exe file */                            1,                /* frame window id */                            &sys->client );   /* client window handle */    if( sys->frame == NULLHANDLE )    {        msg_Err( vd, "cannot create a frame window");        goto exit_frame;    }    WinSetWindowPtr( sys->client, 0, vd );    if( sys->b_fixt23 )    {        WinSetWindowPtr( sys->frame, 0, vd );        sys->p_old_frame = WinSubclassWindow( sys->frame, MyFrameWndProc );    }    psz_mode = var_CreateGetString( vd, "kva-video-mode" );//.........这里部分代码省略.........

/***************************************************************************** * Open: open a dummy audio device *****************************************************************************/static int Open( vlc_object_t * p_this ){    aout_instance_t * p_aout = (aout_instance_t *)p_this;    char * psz_name, * psz_format;    const char * const * ppsz_compare = format_list;    int i_channels, i = 0;    psz_name = var_CreateGetString( p_this, "audiofile-file" );    if( !psz_name || !*psz_name )    {        msg_Err( p_aout, "you need to specify an output file name" );        free( psz_name );        return VLC_EGENERIC;    }    /* Allocate structure */    p_aout->output.p_sys = malloc( sizeof( aout_sys_t ) );    if( p_aout->output.p_sys == NULL )        return VLC_ENOMEM;    if( !strcmp( psz_name, "-" ) )        p_aout->output.p_sys->p_file = stdout;    else        p_aout->output.p_sys->p_file = utf8_fopen( psz_name, "wb" );    free( psz_name );    if ( p_aout->output.p_sys->p_file == NULL )    {        free( p_aout->output.p_sys );        return VLC_EGENERIC;    }    p_aout->output.pf_play = Play;    /* Audio format */    psz_format = var_CreateGetString( p_this, "audiofile-format" );    while ( *ppsz_compare != NULL )    {        if ( !strncmp( *ppsz_compare, psz_format, strlen(*ppsz_compare) ) )        {            break;        }        ppsz_compare++; i++;    }    if ( *ppsz_compare == NULL )    {        msg_Err( p_aout, "cannot understand the format string (%s)",                 psz_format );        if( p_aout->output.p_sys->p_file != stdout )            fclose( p_aout->output.p_sys->p_file );        free( p_aout->output.p_sys );        free( psz_format );        return VLC_EGENERIC;    }    free( psz_format );    p_aout->output.output.i_format = format_int[i];    if ( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) )    {        p_aout->output.i_nb_samples = A52_FRAME_NB;        p_aout->output.output.i_bytes_per_frame = AOUT_SPDIF_SIZE;        p_aout->output.output.i_frame_length = A52_FRAME_NB;        aout_VolumeNoneInit( p_aout );    }    else    {        p_aout->output.i_nb_samples = FRAME_SIZE;        aout_VolumeSoftInit( p_aout );    }    /* Channels number */    i_channels = var_CreateGetInteger( p_this, "audiofile-channels" );    if( i_channels > 0 && i_channels <= CHANNELS_MAX )    {        p_aout->output.output.i_physical_channels =            pi_channels_maps[i_channels];    }    /* WAV header */    p_aout->output.p_sys->b_add_wav_header = var_CreateGetBool( p_this,                                                        "audiofile-wav" );    if( p_aout->output.p_sys->b_add_wav_header )    {        /* Write wave header */        WAVEHEADER *wh = &p_aout->output.p_sys->waveh;        memset( wh, 0, sizeof(wh) );        switch( p_aout->output.output.i_format )        {        case VLC_CODEC_FL32:            wh->Format     = WAVE_FORMAT_IEEE_FLOAT;            wh->BitsPerSample = sizeof(float) * 8;//.........这里部分代码省略.........

static int Open( vlc_object_t *p_this ){ /* initialisation of the connection */    intf_thread_t   *p_intf = (intf_thread_t*)p_this;    intf_sys_t      *p_sys  = malloc( sizeof( intf_sys_t ) );    playlist_t      *p_playlist;    DBusConnection  *p_conn;    DBusError       error;    char            *psz_service_name = NULL;    if( !p_sys || !dbus_threads_init_default())        return VLC_ENOMEM;    p_sys->b_meta_read = false;    p_sys->i_caps = CAPS_NONE;    p_sys->b_dead = false;    p_sys->p_input = NULL;    p_sys->i_playing_state = -1;    if( vlc_pipe( p_sys->p_pipe_fds ) )    {        free( p_sys );        msg_Err( p_intf, "Could not create pipe" );        return VLC_EGENERIC;    }    p_sys->b_unique = var_CreateGetBool( p_intf, "dbus-unique-service-id" );    if( p_sys->b_unique )    {        if( asprintf( &psz_service_name, "%s-%d",            DBUS_MPRIS_BUS_NAME, getpid() ) < 0 )        {            free( p_sys );            return VLC_ENOMEM;        }    }    else    {        psz_service_name = strdup(DBUS_MPRIS_BUS_NAME);    }    dbus_error_init( &error );    /* connect privately to the session bus     * the connection will not be shared with other vlc modules which use dbus,     * thus avoiding a whole class of concurrency issues */    p_conn = dbus_bus_get_private( DBUS_BUS_SESSION, &error );    if( !p_conn )    {        msg_Err( p_this, "Failed to connect to the D-Bus session daemon: %s",                error.message );        dbus_error_free( &error );        free( psz_service_name );        free( p_sys );        return VLC_EGENERIC;    }    dbus_connection_set_exit_on_disconnect( p_conn, FALSE );    /* register a well-known name on the bus */    dbus_bus_request_name( p_conn, psz_service_name, 0, &error );    if( dbus_error_is_set( &error ) )    {        msg_Err( p_this, "Error requesting service %s: %s",                 psz_service_name, error.message );        dbus_error_free( &error );        free( psz_service_name );        free( p_sys );        return VLC_EGENERIC;    }    msg_Info( p_intf, "listening on dbus as: %s", psz_service_name );    free( psz_service_name );    /* we register the objects */    dbus_connection_register_object_path( p_conn, DBUS_MPRIS_ROOT_PATH,            &dbus_mpris_root_vtable, p_this );    dbus_connection_register_object_path( p_conn, DBUS_MPRIS_PLAYER_PATH,            &dbus_mpris_player_vtable, p_this );    dbus_connection_register_object_path( p_conn, DBUS_MPRIS_TRACKLIST_PATH,            &dbus_mpris_tracklist_vtable, p_this );    dbus_connection_flush( p_conn );    p_intf->pf_run = Run;    p_intf->p_sys = p_sys;    p_sys->p_conn = p_conn;    p_sys->p_events = vlc_array_new();    p_sys->p_timeouts = vlc_array_new();    p_sys->p_watches = vlc_array_new();    vlc_mutex_init( &p_sys->lock );    p_playlist = pl_Get( p_intf );    p_sys->p_playlist = p_playlist;    var_AddCallback( p_playlist, "item-current", AllCallback, p_intf );    var_AddCallback( p_playlist, "intf-change", AllCallback, p_intf );    var_AddCallback( p_playlist, "playlist-item-append", AllCallback, p_intf );    var_AddCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf );    var_AddCallback( p_playlist, "random", AllCallback, p_intf );    var_AddCallback( p_playlist, "repeat", AllCallback, p_intf );    var_AddCallback( p_playlist, "loop", AllCallback, p_intf );//.........这里部分代码省略.........

static int EqzInit( aout_filter_t *p_filter, int i_rate ){    aout_filter_sys_t *p_sys = p_filter->p_sys;    const eqz_config_t *p_cfg;    int i, ch;    vlc_value_t val1, val2, val3;    aout_instance_t *p_aout = (aout_instance_t *)p_filter->p_parent;    /* 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, "unsupported rate" );        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) );    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 = VLC_FALSE;    p_sys->f_gamp = 1.0;    p_sys->f_amp   = malloc( p_sys->i_band * sizeof(float) );    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_CreateGetString( p_aout,"equalizer-bands" );    var_CreateGetString( p_aout, "equalizer-preset" );    p_sys->b_2eqz = var_CreateGetBool( p_aout, "equalizer-2pass" );    var_CreateGetFloat( p_aout, "equalizer-preamp" );    /* 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 = VLC_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 = VLC_FALSE;    /* 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");        return (VLC_EGENERIC);    }    if( ( *(val2.psz_string) &&        strstr( p_sys->psz_newbands, val2.psz_string ) ) || !*val2.psz_string )    {        var_SetString( p_aout, "equalizer-bands", p_sys->psz_newbands );        var_SetFloat( p_aout, "equalizer-preamp", p_sys->f_newpreamp );    }    /* Add our own callbacks */    var_AddCallback( p_aout, "equalizer-preset", PresetCallback, p_sys );    var_AddCallback( p_aout, "equalizer-bands", BandsCallback, p_sys );    var_AddCallback( p_aout, "equalizer-preamp", PreampCallback, p_sys );//.........这里部分代码省略.........

/***************************************************************************** * Open: *****************************************************************************/static int Open( vlc_object_t *p_this ){    decoder_t *p_dec = (decoder_t*)p_this;    decoder_sys_t *p_sys;    if( p_dec->fmt_in.i_codec != VLC_CODEC_MPGV )        return VLC_EGENERIC;    es_format_Init( &p_dec->fmt_out, VIDEO_ES, VLC_CODEC_MPGV );    p_dec->fmt_out.i_original_fourcc = p_dec->fmt_in.i_original_fourcc;    p_dec->pf_packetize = Packetize;    p_dec->pf_get_cc = GetCc;    p_dec->p_sys = p_sys = malloc( sizeof( decoder_sys_t ) );    if( !p_dec->p_sys )        return VLC_ENOMEM;    memset( p_dec->p_sys, 0, sizeof( decoder_sys_t ) );    /* Misc init */    packetizer_Init( &p_sys->packetizer,                     p_mp2v_startcode, sizeof(p_mp2v_startcode),                     NULL, 0, 4,                     PacketizeReset, PacketizeParse, PacketizeValidate, p_dec );    p_sys->p_seq = NULL;    p_sys->p_ext = NULL;    p_sys->p_frame = NULL;    p_sys->pp_last = &p_sys->p_frame;    p_sys->b_frame_slice = false;    p_sys->i_dts = p_sys->i_pts = VLC_TS_INVALID;    p_sys->i_frame_rate = 1;    p_sys->i_frame_rate_base = 1;    p_sys->b_seq_progressive = true;    p_sys->b_low_delay = true;    p_sys->i_seq_old = 0;    p_sys->i_temporal_ref = 0;    p_sys->i_picture_type = 0;    p_sys->i_picture_structure = 0x03; /* frame */    p_sys->i_top_field_first = 0;    p_sys->i_repeat_first_field = 0;    p_sys->i_progressive_frame = 0;    p_sys->b_inited = 0;    p_sys->i_interpolated_dts = VLC_TS_INVALID;    p_sys->i_last_ref_pts = VLC_TS_INVALID;    p_sys->b_second_field = 0;    p_sys->b_discontinuity = false;    p_sys->b_sync_on_intra_frame = var_CreateGetBool( p_dec, "packetizer-mpegvideo-sync-iframe" );    if( p_sys->b_sync_on_intra_frame )        msg_Dbg( p_dec, "syncing on intra frame now" );    p_sys->b_cc_reset = false;    p_sys->i_cc_pts = 0;    p_sys->i_cc_dts = 0;    p_sys->i_cc_flags = 0;    cc_Init( &p_sys->cc );    return VLC_SUCCESS;}

/***************************************************************************** * CreateFilter: allocates RSS video filter *****************************************************************************/static int CreateFilter( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys;    char *psz_urls;    int i_ttl;    /* Allocate structure */    p_sys = p_filter->p_sys = (filter_sys_t *)malloc( sizeof( filter_sys_t ) );			// sunqueen modify    if( p_sys == NULL )        return VLC_ENOMEM;    config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,                       p_filter->p_cfg );    /* Get the urls to parse: must be non empty */    psz_urls = var_CreateGetNonEmptyString( p_filter, CFG_PREFIX "urls" );    if( !psz_urls )    {        msg_Err( p_filter, "The list of urls must not be empty" );        free( p_sys );        return VLC_EGENERIC;    }    /* Fill the p_sys structure with the configuration */    p_sys->i_title = var_CreateGetInteger( p_filter, CFG_PREFIX "title" );    p_sys->i_cur_feed = 0;    p_sys->i_cur_item = p_sys->i_title == scroll_title ? -1 : 0;    p_sys->i_cur_char = 0;    p_sys->i_feeds = 0;    p_sys->p_feeds = NULL;    p_sys->i_speed = var_CreateGetInteger( p_filter, CFG_PREFIX "speed" );    p_sys->i_length = var_CreateGetInteger( p_filter, CFG_PREFIX "length" );    p_sys->b_images = var_CreateGetBool( p_filter, CFG_PREFIX "images" );    i_ttl = __MAX( 0, var_CreateGetInteger( p_filter, CFG_PREFIX "ttl" ) );    p_sys->psz_marquee = (char *)malloc( p_sys->i_length + 1 );			// sunqueen modify    if( p_sys->psz_marquee == NULL )    {        free( psz_urls );        free( p_sys );        return VLC_ENOMEM;    }    p_sys->psz_marquee[p_sys->i_length] = '/0';    p_sys->p_style = text_style_New();    if( p_sys->p_style == NULL )        goto error;    p_sys->i_xoff = var_CreateGetInteger( p_filter, CFG_PREFIX "x" );    p_sys->i_yoff = var_CreateGetInteger( p_filter, CFG_PREFIX "y" );    p_sys->i_pos = var_CreateGetInteger( p_filter, CFG_PREFIX "position" );    p_sys->p_style->i_font_alpha = 255 - var_CreateGetInteger( p_filter, CFG_PREFIX "opacity" );    p_sys->p_style->i_font_color = var_CreateGetInteger( p_filter, CFG_PREFIX "color" );    p_sys->p_style->i_font_size = var_CreateGetInteger( p_filter, CFG_PREFIX "size" );    if( p_sys->b_images && p_sys->p_style->i_font_size == -1 )    {        msg_Warn( p_filter, "rss-size wasn't specified. Feed images will thus be displayed without being resized" );    }    /* Parse the urls */    if( ParseUrls( p_filter, psz_urls ) )        goto error;    /* Misc init */    vlc_mutex_init( &p_sys->lock );    p_filter->pf_sub_source = Filter;    p_sys->last_date = (mtime_t)0;    p_sys->b_fetched = false;    /* Create and arm the timer */    if( vlc_timer_create( &p_sys->timer, Fetch, p_filter ) )    {        vlc_mutex_destroy( &p_sys->lock );        goto error;    }    vlc_timer_schedule( p_sys->timer, false, 1,                        (mtime_t)(i_ttl)*1000000 );    free( psz_urls );    return VLC_SUCCESS;error:    if( p_sys->p_style )        text_style_Delete( p_sys->p_style );    free( p_sys->psz_marquee );    free( psz_urls );    free( p_sys );    return VLC_ENOMEM;}

//.........这里部分代码省略.........    p_sys->p_thread->metadata_received = 0;    p_sys->p_thread->first_media_packet = 1;    p_sys->p_thread->flv_tag_previous_tag_size = 0x00000000; /* FLV_TAG_FIRST_PREVIOUS_TAG_SIZE */    p_sys->p_thread->flv_body = rtmp_body_new( -1 );    p_sys->p_thread->flv_length_body = 0;    p_sys->p_thread->chunk_size_recv = 128; /* RTMP_DEFAULT_CHUNK_SIZE */    p_sys->p_thread->chunk_size_send = 128; /* RTMP_DEFAULT_CHUNK_SIZE */    for(i = 0; i < 64; i++)    {        memset( &p_sys->p_thread->rtmp_headers_recv[i], 0, sizeof( rtmp_packet_t ) );        p_sys->p_thread->rtmp_headers_send[i].length_header = -1;        p_sys->p_thread->rtmp_headers_send[i].stream_index = -1;        p_sys->p_thread->rtmp_headers_send[i].timestamp = -1;        p_sys->p_thread->rtmp_headers_send[i].timestamp_relative = -1;        p_sys->p_thread->rtmp_headers_send[i].length_encoded = -1;        p_sys->p_thread->rtmp_headers_send[i].length_body = -1;        p_sys->p_thread->rtmp_headers_send[i].content_type = -1;        p_sys->p_thread->rtmp_headers_send[i].src_dst = -1;        p_sys->p_thread->rtmp_headers_send[i].body = NULL;    }    vlc_cond_init( &p_sys->p_thread->wait );    vlc_mutex_init( &p_sys->p_thread->lock );    p_sys->p_thread->result_connect = 1;    /* p_sys->p_thread->result_publish = only used on access */    p_sys->p_thread->result_play = 1;    p_sys->p_thread->result_stop = 0;    p_sys->p_thread->fd = -1;    /* Open connection */    if( var_CreateGetBool( p_access, "rtmp-connect" ) > 0 )    {#if 0        p_sys->p_thread->fd = net_ConnectTCP( p_access,                                              p_sys->p_thread->url.psz_host,                                              p_sys->p_thread->url.i_port );#endif        msg_Err( p_access, "to be implemented" );        goto error2;    }    else    {        int *p_fd_listen;        p_sys->active = 0;        p_fd_listen = net_ListenTCP( p_access, p_sys->p_thread->url.psz_host,                                     p_sys->p_thread->url.i_port );        if( p_fd_listen == NULL )        {            msg_Warn( p_access, "cannot listen to %s port %i",                      p_sys->p_thread->url.psz_host,                      p_sys->p_thread->url.i_port );            goto error2;        }        do            p_sys->p_thread->fd = net_Accept( p_access, p_fd_listen );        while( p_sys->p_thread->fd == -1 );        net_ListenClose( p_fd_listen );        if( rtmp_handshake_passive( p_this, p_sys->p_thread->fd ) < 0 )        {            msg_Err( p_access, "handshake passive failed");

static int EqzInit( filter_t *p_filter, int i_rate ){    filter_sys_t *p_sys = p_filter->p_sys;    eqz_config_t cfg;    int i, ch;    vlc_value_t val1, val2, val3;    vlc_object_t *p_aout = p_filter->p_parent;    int i_ret = VLC_ENOMEM;    bool b_vlcFreqs = var_InheritBool( p_aout, "equalizer-vlcfreqs" );    EqzCoeffs( i_rate, 1.0f, b_vlcFreqs, &cfg );    /* Create the static filter config */    p_sys->i_band = 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] = cfg.band[i].f_alpha;        p_sys->f_beta[i]  = cfg.band[i].f_beta;        p_sys->f_gamma[i] = cfg.band[i].f_gamma;    }    /* Filter dyn config */    p_sys->b_2eqz = false;    p_sys->f_gamp = 1.0f;    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.0f;    }    /* 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.0f;        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.0f;        }    }    p_sys->psz_newbands = NULL;    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 );    /* Exit if we have no preset and no bands value */    if (p_sys->psz_newbands == NULL && (!val2.psz_string || !*val2.psz_string))    {        msg_Err(p_filter, "No preset selected");        free( val2.psz_string );        free( p_sys->f_amp );        i_ret = VLC_EGENERIC;        goto error;    }    /* 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 && *(val2.psz_string) &&         strstr( p_sys->psz_newbands, val2.psz_string ) ) || !*val2.psz_string )    {        var_SetString( p_aout, "equalizer-bands", p_sys->psz_newbands );        if( p_sys->f_newpreamp == p_sys->f_gamp )            var_SetFloat( p_aout, "equalizer-preamp", p_sys->f_newpreamp );    }    free( val2.psz_string );    /* Add our own callbacks *///.........这里部分代码省略.........

/** * It creates a Direct3D 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(vout_display_sys_t));    if (!sys)        return VLC_ENOMEM;    if (Direct3DCreate(vd)) {        msg_Err(vd, "Direct3D could not be initialized");        Direct3DDestroy(vd);        free(sys);        return VLC_EGENERIC;    }    sys->use_desktop = var_CreateGetBool(vd, "direct3d-desktop");    sys->reset_device = false;    sys->reset_device = false;    sys->allow_hw_yuv = var_CreateGetBool(vd, "directx-hw-yuv");    sys->desktop_save.is_fullscreen = vd->cfg->is_fullscreen;    sys->desktop_save.is_on_top     = false;    sys->desktop_save.win.left      = var_InheritInteger(vd, "video-x");    sys->desktop_save.win.right     = vd->cfg->display.width;    sys->desktop_save.win.top       = var_InheritInteger(vd, "video-y");    sys->desktop_save.win.bottom    = vd->cfg->display.height;    if (CommonInit(vd))        goto error;    /* */    video_format_t fmt;    if (Direct3DOpen(vd, &fmt)) {        msg_Err(vd, "Direct3D could not be opened");        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 */    vlc_mutex_init(&sys->lock);    sys->ch_desktop = false;    sys->desktop_requested = sys->use_desktop;    vlc_value_t val;    val.psz_string = _("Desktop");    var_Change(vd, "direct3d-desktop", VLC_VAR_SETTEXT, &val, NULL);    var_AddCallback(vd, "direct3d-desktop", DesktopCallback, NULL);    /* Setup vout_display now that everything is fine */    vd->fmt  = fmt;    vd->info = info;    vd->pool    = Pool;    vd->prepare = Prepare;    vd->display = Display;    vd->control = Control;    vd->manage  = Manage;    /* Fix state in case of desktop mode */    if (sys->use_desktop && vd->cfg->is_fullscreen)        vout_display_SendEventFullscreen(vd, false);    return VLC_SUCCESS;error:    Direct3DClose(vd);    CommonClean(vd);    Direct3DDestroy(vd);    free(vd->sys);    return VLC_EGENERIC;}

//.........这里部分代码省略.........    sys->display_flags = SDL_ANYFORMAT | SDL_HWPALETTE | SDL_HWSURFACE | SDL_DOUBLEBUF;    sys->display_flags |= vd->cfg->is_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE;    sys->display_bpp = SDL_VideoModeOK(display_width, display_height,                                       16, sys->display_flags);    if (sys->display_bpp == 0) {        msg_Err(vd, "no video mode available");        goto error;    }    sys->display = SDL_SetVideoMode(display_width, display_height,                                    sys->display_bpp, sys->display_flags);    if (!sys->display) {        msg_Err(vd, "cannot set video mode");        goto error;    }    /* We keep the surface locked forever */    SDL_LockSurface(sys->display);    /* */    vlc_fourcc_t forced_chroma = 0;    char *psz_chroma = var_CreateGetNonEmptyString(vd, "sdl-chroma");    if (psz_chroma) {        forced_chroma = vlc_fourcc_GetCodecFromString(VIDEO_ES, psz_chroma);        if (forced_chroma)            msg_Dbg(vd, "Forcing chroma to 0x%.8x (%4.4s)",                    forced_chroma, (const char*)&forced_chroma);        free(psz_chroma);    }    /* Try to open an overlay if requested */    sys->overlay = NULL;    const bool is_overlay = var_CreateGetBool(vd, "overlay");    if (is_overlay) {        static const struct        {            vlc_fourcc_t vlc;            uint32_t     sdl;        } vlc_to_sdl[] = {            { VLC_CODEC_YV12, SDL_YV12_OVERLAY },            { VLC_CODEC_I420, SDL_IYUV_OVERLAY },            { VLC_CODEC_YUYV, SDL_YUY2_OVERLAY },            { VLC_CODEC_UYVY, SDL_UYVY_OVERLAY },            { VLC_CODEC_YVYU, SDL_YVYU_OVERLAY },            { 0, 0 }        };        const vlc_fourcc_t forced_chromas[] = {            forced_chroma, 0        };        const vlc_fourcc_t *fallback_chromas =            vlc_fourcc_GetYUVFallback(fmt.i_chroma);        const vlc_fourcc_t *chromas = forced_chroma ? forced_chromas : fallback_chromas;        for (int pass = forced_chroma ? 1 : 0; pass < 2 && !sys->overlay; pass++) {            for (int i = 0; chromas[i] != 0; i++) {                const vlc_fourcc_t vlc = chromas[i];                uint32_t sdl = 0;                for (int j = 0; vlc_to_sdl[j].vlc != 0 && !sdl; j++) {                    if (vlc_to_sdl[j].vlc == vlc)                        sdl = vlc_to_sdl[j].sdl;                }                if (!sdl)                    continue;

/***************************************************************************** * 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;    p_sys->b_downmix = var_CreateGetBool( p_this, MONO_CFG "downmix" );    p_sys->i_channel_selected =            (unsigned int) var_CreateGetInteger( 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;}