← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavfilter/graphparser.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-01-12 22:23:28 UTC
  • mfrom: (0.4.7 sid)
  • mto: This revision was merged to the branch mainline in revision 76.
  • Revision ID: package-import@ubuntu.com-20120112222328-8jqdyodym3p84ygu
Tags: 2:1.0~rc4.dfsg1+svn34540-1
* New upstream snapshot
* upload to unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavfilter/graphparser.c
36
36
 */
37
37
static int link_filter(AVFilterContext *src, int srcpad,
38
38
                       AVFilterContext *dst, int dstpad,
39
 
                       AVClass *log_ctx)
 
39
                       void *log_ctx)
40
40
{
41
41
    int ret;
42
42
    if ((ret = avfilter_link(src, srcpad, dst, dstpad))) {
55
55
 * @return a pointer (that need to be freed after use) to the name
56
56
 * between parenthesis
57
57
 */
58
 
static char *parse_link_name(const char **buf, AVClass *log_ctx)
 
58
static char *parse_link_name(const char **buf, void *log_ctx)
59
59
{
60
60
    const char *start = *buf;
61
61
    char *name;
83
83
 * Create an instance of a filter, initialize and insert it in the
84
84
 * filtergraph in *ctx.
85
85
 *
 
86
 * @param filt_ctx put here a filter context in case of successful creation and configuration, NULL otherwise.
86
87
 * @param ctx the filtergraph context
87
 
 * @param put here a filter context in case of successful creation and configuration, NULL otherwise.
88
88
 * @param index an index which is supposed to be unique for each filter instance added to the filtergraph
89
89
 * @param filt_name the name of the filter to create
90
90
 * @param args the arguments provided to the filter during its initialization
92
92
 * @return 0 in case of success, a negative AVERROR code otherwise
93
93
 */
94
94
static int create_filter(AVFilterContext **filt_ctx, AVFilterGraph *ctx, int index,
95
 
                         const char *filt_name, const char *args, AVClass *log_ctx)
 
95
                         const char *filt_name, const char *args, void *log_ctx)
96
96
{
97
97
    AVFilter *filt;
98
98
    char inst_name[30];
141
141
 * corresponding filter instance which is added to graph with
142
142
 * create_filter().
143
143
 *
 
144
 * @param filt_ctx Pointer that is set to the created and configured filter
 
145
 *                 context on success, set to NULL on failure.
144
146
 * @param filt_ctx put here a pointer to the created filter context on
145
147
 * success, NULL otherwise
146
148
 * @param buf pointer to the buffer to parse, *buf will be updated to
151
153
 * @return 0 in case of success, a negative AVERROR code otherwise
152
154
 */
153
155
static int parse_filter(AVFilterContext **filt_ctx, const char **buf, AVFilterGraph *graph,
154
 
                        int index, AVClass *log_ctx)
 
156
                        int index, void *log_ctx)
155
157
{
156
158
    char *opts = NULL;
157
159
    char *name = av_get_token(buf, "=,;[\n");
201
203
 
202
204
static int link_filter_inouts(AVFilterContext *filt_ctx,
203
205
                              AVFilterInOut **curr_inputs,
204
 
                              AVFilterInOut **open_inputs, AVClass *log_ctx)
 
206
                              AVFilterInOut **open_inputs, void *log_ctx)
205
207
{
206
208
    int pad = filt_ctx->input_count, ret;
207
209
 
249
251
}
250
252
 
251
253
static int parse_inputs(const char **buf, AVFilterInOut **curr_inputs,
252
 
                        AVFilterInOut **open_outputs, AVClass *log_ctx)
 
254
                        AVFilterInOut **open_outputs, void *log_ctx)
253
255
{
254
256
    int pad = 0;
255
257
 
284
286
 
285
287
static int parse_outputs(const char **buf, AVFilterInOut **curr_inputs,
286
288
                         AVFilterInOut **open_inputs,
287
 
                         AVFilterInOut **open_outputs, AVClass *log_ctx)
 
289
                         AVFilterInOut **open_outputs, void *log_ctx)
288
290
{
289
291
    int ret, pad = 0;
290
292
 
329
331
 
330
332
int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
331
333
                         AVFilterInOut *open_inputs,
332
 
                         AVFilterInOut *open_outputs, AVClass *log_ctx)
 
334
                         AVFilterInOut *open_outputs, void *log_ctx)
333
335
{
334
336
    int index = 0, ret;
335
337
    char chr = 0;