GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/avfilter.c Lines: 624 852 73.2 %
Date: 2021-04-15 16:04:23 Branches: 362 551 65.7 %

Line Branch Exec Source
1
/*
2
 * filter layer
3
 * Copyright (c) 2007 Bobby Bingham
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
#include "libavutil/avassert.h"
23
#include "libavutil/avstring.h"
24
#include "libavutil/buffer.h"
25
#include "libavutil/channel_layout.h"
26
#include "libavutil/common.h"
27
#include "libavutil/eval.h"
28
#include "libavutil/hwcontext.h"
29
#include "libavutil/imgutils.h"
30
#include "libavutil/internal.h"
31
#include "libavutil/opt.h"
32
#include "libavutil/pixdesc.h"
33
#include "libavutil/rational.h"
34
#include "libavutil/samplefmt.h"
35
#include "libavutil/thread.h"
36
37
#define FF_INTERNAL_FIELDS 1
38
#include "framequeue.h"
39
40
#include "audio.h"
41
#include "avfilter.h"
42
#include "filters.h"
43
#include "formats.h"
44
#include "internal.h"
45
46
#include "libavutil/ffversion.h"
47
const char av_filter_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
48
49
1352021
void ff_tlog_ref(void *ctx, AVFrame *ref, int end)
50
{
51
    av_unused char buf[16];
52
    ff_tlog(ctx,
53
            "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
54
            ref, ref->buf, ref->data[0],
55
            ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
56
            ref->pts, ref->pkt_pos);
57
58
1352021
    if (ref->width) {
59
        ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
60
                ref->sample_aspect_ratio.num, ref->sample_aspect_ratio.den,
61
                ref->width, ref->height,
62
                !ref->interlaced_frame     ? 'P' :         /* Progressive  */
63
                ref->top_field_first ? 'T' : 'B',    /* Top / Bottom */
64
                ref->key_frame,
65
                av_get_picture_type_char(ref->pict_type));
66
    }
67
1352021
    if (ref->nb_samples) {
68
        ff_tlog(ctx, " cl:%"PRId64"d n:%d r:%d",
69
                ref->channel_layout,
70
                ref->nb_samples,
71
                ref->sample_rate);
72
    }
73
74
    ff_tlog(ctx, "]%s", end ? "\n" : "");
75
1352021
}
76
77
6089
unsigned avfilter_version(void)
78
{
79
    av_assert0(LIBAVFILTER_VERSION_MICRO >= 100);
80
6089
    return LIBAVFILTER_VERSION_INT;
81
}
82
83
6089
const char *avfilter_configuration(void)
84
{
85
6089
    return FFMPEG_CONFIGURATION;
86
}
87
88
const char *avfilter_license(void)
89
{
90
#define LICENSE_PREFIX "libavfilter license: "
91
    return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
92
}
93
94
void ff_command_queue_pop(AVFilterContext *filter)
95
{
96
    AVFilterCommand *c= filter->command_queue;
97
    av_freep(&c->arg);
98
    av_freep(&c->command);
99
    filter->command_queue= c->next;
100
    av_free(c);
101
}
102
103
168
int ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
104
                   AVFilterPad **pads, AVFilterLink ***links,
105
                   AVFilterPad *newpad)
106
{
107
    AVFilterLink **newlinks;
108
    AVFilterPad *newpads;
109
    unsigned i;
110
111
168
    idx = FFMIN(idx, *count);
112
113
168
    newpads  = av_realloc_array(*pads,  *count + 1, sizeof(AVFilterPad));
114
168
    newlinks = av_realloc_array(*links, *count + 1, sizeof(AVFilterLink*));
115
168
    if (newpads)
116
168
        *pads  = newpads;
117
168
    if (newlinks)
118
168
        *links = newlinks;
119

168
    if (!newpads || !newlinks)
120
        return AVERROR(ENOMEM);
121
122
168
    memmove(*pads  + idx + 1, *pads  + idx, sizeof(AVFilterPad)   * (*count - idx));
123
168
    memmove(*links + idx + 1, *links + idx, sizeof(AVFilterLink*) * (*count - idx));
124
168
    memcpy(*pads + idx, newpad, sizeof(AVFilterPad));
125
168
    (*links)[idx] = NULL;
126
127
168
    (*count)++;
128
168
    for (i = idx + 1; i < *count; i++)
129
        if ((*links)[i])
130
            (*(unsigned *)((uint8_t *) (*links)[i] + padidx_off))++;
131
132
168
    return 0;
133
}
134
135
23830
int avfilter_link(AVFilterContext *src, unsigned srcpad,
136
                  AVFilterContext *dst, unsigned dstpad)
137
{
138
    AVFilterLink *link;
139
140
23830
    av_assert0(src->graph);
141
23830
    av_assert0(dst->graph);
142
23830
    av_assert0(src->graph == dst->graph);
143
144

23830
    if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
145

23830
        src->outputs[srcpad]      || dst->inputs[dstpad])
146
        return AVERROR(EINVAL);
147
148
23830
    if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
149
        av_log(src, AV_LOG_ERROR,
150
               "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
151
               src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),
152
               dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));
153
        return AVERROR(EINVAL);
154
    }
155
156
23830
    link = av_mallocz(sizeof(*link));
157
23830
    if (!link)
158
        return AVERROR(ENOMEM);
159
160
23830
    src->outputs[srcpad] = dst->inputs[dstpad] = link;
161
162
23830
    link->src     = src;
163
23830
    link->dst     = dst;
164
23830
    link->srcpad  = &src->output_pads[srcpad];
165
23830
    link->dstpad  = &dst->input_pads[dstpad];
166
23830
    link->type    = src->output_pads[srcpad].type;
167
    av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
168
23830
    link->format  = -1;
169
23830
    ff_framequeue_init(&link->fifo, &src->graph->internal->frame_queues);
170
171
23830
    return 0;
172
}
173
174
23962
void avfilter_link_free(AVFilterLink **link)
175
{
176
23962
    if (!*link)
177
        return;
178
179
23962
    av_frame_free(&(*link)->partial_buf);
180
23962
    ff_framequeue_free(&(*link)->fifo);
181
23962
    ff_frame_pool_uninit((FFFramePool**)&(*link)->frame_pool);
182
183
23962
    av_freep(link);
184
}
185
186
#if FF_API_FILTER_GET_SET
187
int avfilter_link_get_channels(AVFilterLink *link)
188
{
189
    return link->channels;
190
}
191
#endif
192
193
3608292
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
194
{
195
3608292
    filter->ready = FFMAX(filter->ready, priority);
196
3608292
}
197
198
/**
199
 * Clear frame_blocked_in on all outputs.
200
 * This is necessary whenever something changes on input.
201
 */
202
2344073
static void filter_unblock(AVFilterContext *filter)
203
{
204
    unsigned i;
205
206
4294211
    for (i = 0; i < filter->nb_outputs; i++)
207
1950138
        filter->outputs[i]->frame_blocked_in = 0;
208
2344073
}
209
210
211
23458
void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
212
{
213
23458
    if (link->status_in == status)
214
30
        return;
215
23428
    av_assert0(!link->status_in);
216
23428
    link->status_in = status;
217
23428
    link->status_in_pts = pts;
218
23428
    link->frame_wanted_out = 0;
219
23428
    link->frame_blocked_in = 0;
220
23428
    filter_unblock(link->dst);
221
23428
    ff_filter_set_ready(link->dst, 200);
222
}
223
224
17468
void ff_avfilter_link_set_out_status(AVFilterLink *link, int status, int64_t pts)
225
{
226
17468
    av_assert0(!link->frame_wanted_out);
227
17468
    av_assert0(!link->status_out);
228
17468
    link->status_out = status;
229
17468
    if (pts != AV_NOPTS_VALUE)
230
16930
        ff_update_link_current_pts(link, pts);
231
17468
    filter_unblock(link->dst);
232
17468
    ff_filter_set_ready(link->src, 200);
233
17468
}
234
235
#if FF_API_FILTER_LINK_SET_CLOSED
236
void avfilter_link_set_closed(AVFilterLink *link, int closed)
237
{
238
    ff_avfilter_link_set_out_status(link, closed ? AVERROR_EOF : 0, AV_NOPTS_VALUE);
239
}
240
#endif
241
693
int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
242
                           unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
243
{
244
    int ret;
245
693
    unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
246
247
693
    av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
248
           "between the filter '%s' and the filter '%s'\n",
249
693
           filt->name, link->src->name, link->dst->name);
250
251
693
    link->dst->inputs[dstpad_idx] = NULL;
252
693
    if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {
253
        /* failed to link output filter to new filter */
254
        link->dst->inputs[dstpad_idx] = link;
255
        return ret;
256
    }
257
258
    /* re-hookup the link to the new destination filter we inserted */
259
693
    link->dst                     = filt;
260
693
    link->dstpad                  = &filt->input_pads[filt_srcpad_idx];
261
693
    filt->inputs[filt_srcpad_idx] = link;
262
263
    /* if any information on supported media formats already exists on the
264
     * link, we need to preserve that */
265
693
    if (link->outcfg.formats)
266
693
        ff_formats_changeref(&link->outcfg.formats,
267
693
                             &filt->outputs[filt_dstpad_idx]->outcfg.formats);
268
693
    if (link->outcfg.samplerates)
269
395
        ff_formats_changeref(&link->outcfg.samplerates,
270
395
                             &filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
271
693
    if (link->outcfg.channel_layouts)
272
395
        ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
273
395
                                     &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
274
275
693
    return 0;
276
}
277
278
29549
int avfilter_config_links(AVFilterContext *filter)
279
{
280
    int (*config_link)(AVFilterLink *);
281
    unsigned i;
282
    int ret;
283
284
53250
    for (i = 0; i < filter->nb_inputs; i ++) {
285
23701
        AVFilterLink *link = filter->inputs[i];
286
        AVFilterLink *inlink;
287
288
23701
        if (!link) continue;
289

23701
        if (!link->src || !link->dst) {
290
            av_log(filter, AV_LOG_ERROR,
291
                   "Not all input and output are properly linked (%d).\n", i);
292
            return AVERROR(EINVAL);
293
        }
294
295
23701
        inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
296
23701
        link->current_pts =
297
23701
        link->current_pts_us = AV_NOPTS_VALUE;
298
299

23701
        switch (link->init_state) {
300
29
        case AVLINK_INIT:
301
29
            continue;
302
        case AVLINK_STARTINIT:
303
            av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
304
            return 0;
305
23672
        case AVLINK_UNINIT:
306
23672
            link->init_state = AVLINK_STARTINIT;
307
308
23672
            if ((ret = avfilter_config_links(link->src)) < 0)
309
                return ret;
310
311
23672
            if (!(config_link = link->srcpad->config_props)) {
312
12064
                if (link->src->nb_inputs != 1) {
313
                    av_log(link->src, AV_LOG_ERROR, "Source filters and filters "
314
                                                    "with more than one input "
315
                                                    "must set config_props() "
316
                                                    "callbacks on all outputs\n");
317
                    return AVERROR(EINVAL);
318
                }
319
11608
            } else if ((ret = config_link(link)) < 0) {
320
                av_log(link->src, AV_LOG_ERROR,
321
                       "Failed to configure output pad on %s\n",
322
                       link->src->name);
323
                return ret;
324
            }
325
326
23672
            switch (link->type) {
327
18751
            case AVMEDIA_TYPE_VIDEO:
328

18751
                if (!link->time_base.num && !link->time_base.den)
329
13756
                    link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
330
331

18751
                if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
332
10006
                    link->sample_aspect_ratio = inlink ?
333
                        inlink->sample_aspect_ratio : (AVRational){1,1};
334
335
18751
                if (inlink) {
336

13989
                    if (!link->frame_rate.num && !link->frame_rate.den)
337
13810
                        link->frame_rate = inlink->frame_rate;
338
13989
                    if (!link->w)
339
9590
                        link->w = inlink->w;
340
13989
                    if (!link->h)
341
9590
                        link->h = inlink->h;
342

4762
                } else if (!link->w || !link->h) {
343
                    av_log(link->src, AV_LOG_ERROR,
344
                           "Video source filters must set their output link's "
345
                           "width and height\n");
346
                    return AVERROR(EINVAL);
347
                }
348
18751
                break;
349
350
4921
            case AVMEDIA_TYPE_AUDIO:
351
4921
                if (inlink) {
352

3767
                    if (!link->time_base.num && !link->time_base.den)
353
2541
                        link->time_base = inlink->time_base;
354
                }
355
356

4921
                if (!link->time_base.num && !link->time_base.den)
357
7
                    link->time_base = (AVRational) {1, link->sample_rate};
358
            }
359
360

23672
            if (link->src->nb_inputs && link->src->inputs[0]->hw_frames_ctx &&
361
                !(link->src->filter->flags_internal & FF_FILTER_FLAG_HWFRAME_AWARE)) {
362
                av_assert0(!link->hw_frames_ctx &&
363
                           "should not be set by non-hwframe-aware filter");
364
                link->hw_frames_ctx = av_buffer_ref(link->src->inputs[0]->hw_frames_ctx);
365
                if (!link->hw_frames_ctx)
366
                    return AVERROR(ENOMEM);
367
            }
368
369
23672
            if ((config_link = link->dstpad->config_props))
370
1925
                if ((ret = config_link(link)) < 0) {
371
                    av_log(link->dst, AV_LOG_ERROR,
372
                           "Failed to configure input pad on %s\n",
373
                           link->dst->name);
374
                    return ret;
375
                }
376
377
23672
            link->init_state = AVLINK_INIT;
378
        }
379
    }
380
381
29549
    return 0;
382
}
383
384
3588361
void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
385
{
386
3588361
    if (link->type == AVMEDIA_TYPE_VIDEO) {
387
        ff_tlog(ctx,
388
                "link[%p s:%dx%d fmt:%s %s->%s]%s",
389
                link, link->w, link->h,
390
                av_get_pix_fmt_name(link->format),
391
                link->src ? link->src->filter->name : "",
392
                link->dst ? link->dst->filter->name : "",
393
                end ? "\n" : "");
394
    } else {
395
        char buf[128];
396
2655259
        av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);
397
398
        ff_tlog(ctx,
399
                "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
400
                link, (int)link->sample_rate, buf,
401
                av_get_sample_fmt_name(link->format),
402
                link->src ? link->src->filter->name : "",
403
                link->dst ? link->dst->filter->name : "",
404
                end ? "\n" : "");
405
    }
406
3588361
}
407
408
895452
int ff_request_frame(AVFilterLink *link)
409
{
410
895452
    FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1);
411
412
    av_assert1(!link->dst->filter->activate);
413
895452
    if (link->status_out)
414
1155
        return link->status_out;
415
894297
    if (link->status_in) {
416
16964
        if (ff_framequeue_queued_frames(&link->fifo)) {
417
            av_assert1(!link->frame_wanted_out);
418
            av_assert1(link->dst->ready >= 300);
419
            return 0;
420
        } else {
421
            /* Acknowledge status change. Filters using ff_request_frame() will
422
               handle the change automatically. Filters can also check the
423
               status directly but none do yet. */
424
16964
            ff_avfilter_link_set_out_status(link, link->status_in, link->status_in_pts);
425
16964
            return link->status_out;
426
        }
427
    }
428
877333
    link->frame_wanted_out = 1;
429
877333
    ff_filter_set_ready(link->src, 100);
430
877333
    return 0;
431
}
432
433
17489
static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
434
{
435
    unsigned i;
436
17489
    int64_t r = INT64_MAX;
437
438
34946
    for (i = 0; i < ctx->nb_inputs; i++)
439
17457
        if (ctx->inputs[i]->status_out == status)
440
17457
            r = FFMIN(r, av_rescale_q(ctx->inputs[i]->current_pts, ctx->inputs[i]->time_base, link_time_base));
441
17489
    if (r < INT64_MAX)
442
17457
        return r;
443
32
    av_log(ctx, AV_LOG_WARNING, "EOF timestamp not reliable\n");
444
32
    for (i = 0; i < ctx->nb_inputs; i++)
445
        r = FFMIN(r, av_rescale_q(ctx->inputs[i]->status_in_pts, ctx->inputs[i]->time_base, link_time_base));
446
32
    if (r < INT64_MAX)
447
        return r;
448
32
    return AV_NOPTS_VALUE;
449
}
450
451
1256204
static int ff_request_frame_to_filter(AVFilterLink *link)
452
{
453
1256204
    int ret = -1;
454
455
1256204
    FF_TPRINTF_START(NULL, request_frame_to_filter); ff_tlog_link(NULL, link, 1);
456
    /* Assume the filter is blocked, let the method clear it if not */
457
1256204
    link->frame_blocked_in = 1;
458
1256204
    if (link->srcpad->request_frame)
459
578075
        ret = link->srcpad->request_frame(link);
460
678129
    else if (link->src->inputs[0])
461
678129
        ret = ff_request_frame(link->src->inputs[0]);
462
1256204
    if (ret < 0) {
463

365500
        if (ret != AVERROR(EAGAIN) && ret != link->status_in)
464
17489
            ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base));
465
365500
        if (ret == AVERROR_EOF)
466
17489
            ret = 0;
467
    }
468
1256204
    return ret;
469
}
470
471
static const char *const var_names[] = {
472
    "t",
473
    "n",
474
    "pos",
475
    "w",
476
    "h",
477
    NULL
478
};
479
480
enum {
481
    VAR_T,
482
    VAR_N,
483
    VAR_POS,
484
    VAR_W,
485
    VAR_H,
486
    VAR_VARS_NB
487
};
488
489
4
static int set_enable_expr(AVFilterContext *ctx, const char *expr)
490
{
491
    int ret;
492
    char *expr_dup;
493
4
    AVExpr *old = ctx->enable;
494
495
4
    if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) {
496
        av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
497
               "with filter '%s'\n", ctx->filter->name);
498
        return AVERROR_PATCHWELCOME;
499
    }
500
501
4
    expr_dup = av_strdup(expr);
502
4
    if (!expr_dup)
503
        return AVERROR(ENOMEM);
504
505
4
    if (!ctx->var_values) {
506
4
        ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values));
507
4
        if (!ctx->var_values) {
508
            av_free(expr_dup);
509
            return AVERROR(ENOMEM);
510
        }
511
    }
512
513
4
    ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names,
514
                        NULL, NULL, NULL, NULL, 0, ctx->priv);
515
4
    if (ret < 0) {
516
        av_log(ctx->priv, AV_LOG_ERROR,
517
               "Error when evaluating the expression '%s' for enable\n",
518
               expr_dup);
519
        av_free(expr_dup);
520
        return ret;
521
    }
522
523
4
    av_expr_free(old);
524
4
    av_free(ctx->enable_str);
525
4
    ctx->enable_str = expr_dup;
526
4
    return 0;
527
}
528
529
1392770
void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)
530
{
531
1392770
    if (pts == AV_NOPTS_VALUE)
532
26
        return;
533
1392744
    link->current_pts = pts;
534
1392744
    link->current_pts_us = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
535
    /* TODO use duration */
536

1392744
    if (link->graph && link->age_index >= 0)
537
413795
        ff_avfilter_graph_update_heap(link->graph, link);
538
}
539
540
int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
541
{
542
    if(!strcmp(cmd, "ping")){
543
        char local_res[256] = {0};
544
545
        if (!res) {
546
            res = local_res;
547
            res_len = sizeof(local_res);
548
        }
549
        av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
550
        if (res == local_res)
551
            av_log(filter, AV_LOG_INFO, "%s", res);
552
        return 0;
553
    }else if(!strcmp(cmd, "enable")) {
554
        return set_enable_expr(filter, arg);
555
    }else if(filter->filter->process_command) {
556
        return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);
557
    }
558
    return AVERROR(ENOSYS);
559
}
560
561
59638
int avfilter_pad_count(const AVFilterPad *pads)
562
{
563
    int count;
564
565
59638
    if (!pads)
566
11945
        return 0;
567
568
95460
    for (count = 0; pads->name; count++)
569
47767
        pads++;
570
47693
    return count;
571
}
572
573
318
static const char *default_filter_name(void *filter_ctx)
574
{
575
318
    AVFilterContext *ctx = filter_ctx;
576
318
    return ctx->name ? ctx->name : ctx->filter->name;
577
}
578
579
1351
static void *filter_child_next(void *obj, void *prev)
580
{
581
1351
    AVFilterContext *ctx = obj;
582


1351
    if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
583
1351
        return ctx->priv;
584
    return NULL;
585
}
586
587
#if FF_API_CHILD_CLASS_NEXT
588
static const AVClass *filter_child_class_next(const AVClass *prev)
589
{
590
    void *opaque = NULL;
591
    const AVFilter *f = NULL;
592
593
    /* find the filter that corresponds to prev */
594
    while (prev && (f = av_filter_iterate(&opaque)))
595
        if (f->priv_class == prev)
596
            break;
597
598
    /* could not find filter corresponding to prev */
599
    if (prev && !f)
600
        return NULL;
601
602
    /* find next filter with specific options */
603
    while ((f = av_filter_iterate(&opaque)))
604
        if (f->priv_class)
605
            return f->priv_class;
606
607
    return NULL;
608
}
609
#endif
610
611
static const AVClass *filter_child_class_iterate(void **iter)
612
{
613
    const AVFilter *f;
614
615
    while ((f = av_filter_iterate(iter)))
616
        if (f->priv_class)
617
            return f->priv_class;
618
619
    return NULL;
620
}
621
622
#define OFFSET(x) offsetof(AVFilterContext, x)
623
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM
624
#define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
625
static const AVOption avfilter_options[] = {
626
    { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
627
        { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
628
        { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
629
    { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = TFLAGS },
630
    { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
631
        { .i64 = 0 }, 0, INT_MAX, FLAGS },
632
    { "extra_hw_frames", "Number of extra hardware frames to allocate for the user",
633
        OFFSET(extra_hw_frames), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
634
    { NULL },
635
};
636
637
static const AVClass avfilter_class = {
638
    .class_name = "AVFilter",
639
    .item_name  = default_filter_name,
640
    .version    = LIBAVUTIL_VERSION_INT,
641
    .category   = AV_CLASS_CATEGORY_FILTER,
642
    .child_next = filter_child_next,
643
#if FF_API_CHILD_CLASS_NEXT
644
    .child_class_next = filter_child_class_next,
645
#endif
646
    .child_class_iterate = filter_child_class_iterate,
647
    .option           = avfilter_options,
648
};
649
650
500
static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg,
651
                           int *ret, int nb_jobs)
652
{
653
    int i;
654
655
1000
    for (i = 0; i < nb_jobs; i++) {
656
500
        int r = func(ctx, arg, i, nb_jobs);
657
500
        if (ret)
658
            ret[i] = r;
659
    }
660
500
    return 0;
661
}
662
663
29819
AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
664
{
665
    AVFilterContext *ret;
666
29819
    int preinited = 0;
667
668
29819
    if (!filter)
669
        return NULL;
670
671
29819
    ret = av_mallocz(sizeof(AVFilterContext));
672
29819
    if (!ret)
673
        return NULL;
674
675
29819
    ret->av_class = &avfilter_class;
676
29819
    ret->filter   = filter;
677
29819
    ret->name     = inst_name ? av_strdup(inst_name) : NULL;
678
29819
    if (filter->priv_size) {
679
26828
        ret->priv     = av_mallocz(filter->priv_size);
680
26828
        if (!ret->priv)
681
            goto err;
682
    }
683
29819
    if (filter->preinit) {
684
52
        if (filter->preinit(ret) < 0)
685
            goto err;
686
52
        preinited = 1;
687
    }
688
689
29819
    av_opt_set_defaults(ret);
690
29819
    if (filter->priv_class) {
691
26648
        *(const AVClass**)ret->priv = filter->priv_class;
692
26648
        av_opt_set_defaults(ret->priv);
693
    }
694
695
29819
    ret->internal = av_mallocz(sizeof(*ret->internal));
696
29819
    if (!ret->internal)
697
        goto err;
698
29819
    ret->internal->execute = default_execute;
699
700
29819
    ret->nb_inputs = avfilter_pad_count(filter->inputs);
701
29819
    if (ret->nb_inputs ) {
702
23820
        ret->input_pads   = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad));
703
23820
        if (!ret->input_pads)
704
            goto err;
705
23820
        memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
706
23820
        ret->inputs       = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*));
707
23820
        if (!ret->inputs)
708
            goto err;
709
    }
710
711
29819
    ret->nb_outputs = avfilter_pad_count(filter->outputs);
712
29819
    if (ret->nb_outputs) {
713
23873
        ret->output_pads  = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad));
714
23873
        if (!ret->output_pads)
715
            goto err;
716
23873
        memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
717
23873
        ret->outputs      = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*));
718
23873
        if (!ret->outputs)
719
            goto err;
720
    }
721
722
29819
    return ret;
723
724
err:
725
    if (preinited)
726
        filter->uninit(ret);
727
    av_freep(&ret->inputs);
728
    av_freep(&ret->input_pads);
729
    ret->nb_inputs = 0;
730
    av_freep(&ret->outputs);
731
    av_freep(&ret->output_pads);
732
    ret->nb_outputs = 0;
733
    av_freep(&ret->priv);
734
    av_freep(&ret->internal);
735
    av_free(ret);
736
    return NULL;
737
}
738
739
47935
static void free_link(AVFilterLink *link)
740
{
741
47935
    if (!link)
742
23973
        return;
743
744
23962
    if (link->src)
745
23830
        link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
746
23962
    if (link->dst)
747
23830
        link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
748
749
23962
    av_buffer_unref(&link->hw_frames_ctx);
750
751
23962
    ff_formats_unref(&link->incfg.formats);
752
23962
    ff_formats_unref(&link->outcfg.formats);
753
23962
    ff_formats_unref(&link->incfg.samplerates);
754
23962
    ff_formats_unref(&link->outcfg.samplerates);
755
23962
    ff_channel_layouts_unref(&link->incfg.channel_layouts);
756
23962
    ff_channel_layouts_unref(&link->outcfg.channel_layouts);
757
23962
    avfilter_link_free(&link);
758
}
759
760
29819
void avfilter_free(AVFilterContext *filter)
761
{
762
    int i;
763
764
29819
    if (!filter)
765
        return;
766
767
29819
    if (filter->graph)
768
29819
        ff_filter_graph_remove_filter(filter->graph, filter);
769
770
29819
    if (filter->filter->uninit)
771
19107
        filter->filter->uninit(filter);
772
773
53775
    for (i = 0; i < filter->nb_inputs; i++) {
774
23956
        free_link(filter->inputs[i]);
775
    }
776
53798
    for (i = 0; i < filter->nb_outputs; i++) {
777
23979
        free_link(filter->outputs[i]);
778
    }
779
780
29819
    if (filter->filter->priv_class)
781
26648
        av_opt_free(filter->priv);
782
783
29819
    av_buffer_unref(&filter->hw_device_ctx);
784
785
29819
    av_freep(&filter->name);
786
29819
    av_freep(&filter->input_pads);
787
29819
    av_freep(&filter->output_pads);
788
29819
    av_freep(&filter->inputs);
789
29819
    av_freep(&filter->outputs);
790
29819
    av_freep(&filter->priv);
791
29819
    while(filter->command_queue){
792
        ff_command_queue_pop(filter);
793
    }
794
29819
    av_opt_free(filter);
795
29819
    av_expr_free(filter->enable);
796
29819
    filter->enable = NULL;
797
29819
    av_freep(&filter->var_values);
798
29819
    av_freep(&filter->internal);
799
29819
    av_free(filter);
800
}
801
802
6100
int ff_filter_get_nb_threads(AVFilterContext *ctx)
803
{
804
6100
    if (ctx->nb_threads > 0)
805
        return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
806
6100
    return ctx->graph->nb_threads;
807
}
808
809
19396
static int process_options(AVFilterContext *ctx, AVDictionary **options,
810
                           const char *args)
811
{
812
19396
    const AVOption *o = NULL;
813
19396
    int ret, count = 0;
814
19396
    char *av_uninit(parsed_key), *av_uninit(value);
815
    const char *key;
816
19396
    int offset= -1;
817
818
19396
    if (!args)
819
        return 0;
820
821
101931
    while (*args) {
822
82535
        const char *shorthand = NULL;
823
824
82535
        o = av_opt_next(ctx->priv, o);
825
82535
        if (o) {
826

80487
            if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
827
32110
                continue;
828
48377
            offset = o->offset;
829
48377
            shorthand = o->name;
830
        }
831
832
50425
        ret = av_opt_get_key_value(&args, "=", ":",
833
                                   shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
834
                                   &parsed_key, &value);
835
50425
        if (ret < 0) {
836
            if (ret == AVERROR(EINVAL))
837
                av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
838
            else
839
                av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
840
                       av_err2str(ret));
841
            return ret;
842
        }
843
50425
        if (*args)
844
32157
            args++;
845
50425
        if (parsed_key) {
846
39808
            key = parsed_key;
847
534754
            while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */
848
        } else {
849
10617
            key = shorthand;
850
        }
851
852
50425
        av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
853
854
50425
        if (av_opt_find(ctx, key, NULL, 0, 0)) {
855
4
            ret = av_opt_set(ctx, key, value, 0);
856
4
            if (ret < 0) {
857
                av_free(value);
858
                av_free(parsed_key);
859
                return ret;
860
            }
861
        } else {
862
50421
            av_dict_set(options, key, value, 0);
863
50421
            if ((ret = av_opt_set(ctx->priv, key, value, AV_OPT_SEARCH_CHILDREN)) < 0) {
864
5279
                if (!av_opt_find(ctx->priv, key, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) {
865
                    if (ret == AVERROR_OPTION_NOT_FOUND)
866
                        av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
867
                    av_free(value);
868
                    av_free(parsed_key);
869
                    return ret;
870
                }
871
            }
872
        }
873
874
50425
        av_free(value);
875
50425
        av_free(parsed_key);
876
50425
        count++;
877
    }
878
879
19396
    return count;
880
}
881
882
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd,
883
                              const char *arg, char *res, int res_len, int flags)
884
{
885
    const AVOption *o;
886
887
    if (!ctx->filter->priv_class)
888
        return 0;
889
    o = av_opt_find2(ctx->priv, cmd, NULL, AV_OPT_FLAG_RUNTIME_PARAM | AV_OPT_FLAG_FILTERING_PARAM, AV_OPT_SEARCH_CHILDREN, NULL);
890
    if (!o)
891
        return AVERROR(ENOSYS);
892
    return av_opt_set(ctx->priv, cmd, arg, 0);
893
}
894
895
29819
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
896
{
897
29819
    int ret = 0;
898
899
29819
    ret = av_opt_set_dict(ctx, options);
900
29819
    if (ret < 0) {
901
        av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
902
        return ret;
903
    }
904
905
29819
    if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
906
565
        ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
907
138
        ctx->graph->internal->thread_execute) {
908
138
        ctx->thread_type       = AVFILTER_THREAD_SLICE;
909
138
        ctx->internal->execute = ctx->graph->internal->thread_execute;
910
    } else {
911
29681
        ctx->thread_type = 0;
912
    }
913
914
29819
    if (ctx->filter->priv_class) {
915
26648
        ret = av_opt_set_dict2(ctx->priv, options, AV_OPT_SEARCH_CHILDREN);
916
26648
        if (ret < 0) {
917
            av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
918
            return ret;
919
        }
920
    }
921
922
29819
    if (ctx->filter->init_opaque)
923
        ret = ctx->filter->init_opaque(ctx, NULL);
924
29819
    else if (ctx->filter->init)
925
20264
        ret = ctx->filter->init(ctx);
926
9555
    else if (ctx->filter->init_dict)
927
4877
        ret = ctx->filter->init_dict(ctx, options);
928
929
29819
    if (ctx->enable_str) {
930
4
        ret = set_enable_expr(ctx, ctx->enable_str);
931
4
        if (ret < 0)
932
            return ret;
933
    }
934
935
29819
    return ret;
936
}
937
938
29819
int avfilter_init_str(AVFilterContext *filter, const char *args)
939
{
940
29819
    AVDictionary *options = NULL;
941
    AVDictionaryEntry *e;
942
29819
    int ret = 0;
943
944

29819
    if (args && *args) {
945
19396
        if (!filter->filter->priv_class) {
946
            av_log(filter, AV_LOG_ERROR, "This filter does not take any "
947
                   "options, but options were provided: %s.\n", args);
948
            return AVERROR(EINVAL);
949
        }
950
951
#if FF_API_OLD_FILTER_OPTS_ERROR
952
19396
            if (   !strcmp(filter->filter->name, "format")     ||
953
13551
                   !strcmp(filter->filter->name, "noformat")   ||
954
13551
                   !strcmp(filter->filter->name, "frei0r")     ||
955
13551
                   !strcmp(filter->filter->name, "frei0r_src") ||
956
13551
                   !strcmp(filter->filter->name, "ocv")        ||
957
13551
                   !strcmp(filter->filter->name, "pan")        ||
958
13535
                   !strcmp(filter->filter->name, "pp")         ||
959
19410
                   !strcmp(filter->filter->name, "aevalsrc")) {
960
            /* a hack for compatibility with the old syntax
961
             * replace colons with |s */
962
5883
            char *copy = av_strdup(args);
963
5883
            char *p    = copy;
964
5883
            int nb_leading = 0; // number of leading colons to skip
965
5883
            int deprecated = 0;
966
967
5883
            if (!copy) {
968
                ret = AVERROR(ENOMEM);
969
                goto fail;
970
            }
971
972
5883
            if (!strcmp(filter->filter->name, "frei0r") ||
973
5883
                !strcmp(filter->filter->name, "ocv"))
974
                nb_leading = 1;
975
5883
            else if (!strcmp(filter->filter->name, "frei0r_src"))
976
                nb_leading = 3;
977
978
5883
            while (nb_leading--) {
979
                p = strchr(p, ':');
980
                if (!p) {
981
                    p = copy + strlen(copy);
982
                    break;
983
                }
984
                p++;
985
            }
986
987
5883
            deprecated = strchr(p, ':') != NULL;
988
989
5883
            if (!strcmp(filter->filter->name, "aevalsrc")) {
990
14
                deprecated = 0;
991

14
                while ((p = strchr(p, ':')) && p[1] != ':') {
992
14
                    const char *epos = strchr(p + 1, '=');
993
14
                    const char *spos = strchr(p + 1, ':');
994

14
                    const int next_token_is_opt = epos && (!spos || epos < spos);
995
14
                    if (next_token_is_opt) {
996
14
                        p++;
997
14
                        break;
998
                    }
999
                    /* next token does not contain a '=', assume a channel expression */
1000
                    deprecated = 1;
1001
                    *p++ = '|';
1002
                }
1003

14
                if (p && *p == ':') { // double sep '::' found
1004
                    deprecated = 1;
1005
                    memmove(p, p + 1, strlen(p));
1006
                }
1007
            } else
1008
5869
            while ((p = strchr(p, ':')))
1009
                *p++ = '|';
1010
1011
5883
            if (deprecated) {
1012
                av_log(filter, AV_LOG_ERROR, "This syntax is deprecated. Use "
1013
                       "'|' to separate the list items ('%s' instead of '%s')\n",
1014
                       copy, args);
1015
                ret = AVERROR(EINVAL);
1016
            } else {
1017
5883
                ret = process_options(filter, &options, copy);
1018
            }
1019
5883
            av_freep(&copy);
1020
1021
5883
            if (ret < 0)
1022
                goto fail;
1023
        } else
1024
#endif
1025
        {
1026
13513
            ret = process_options(filter, &options, args);
1027
13513
            if (ret < 0)
1028
                goto fail;
1029
        }
1030
    }
1031
1032
29819
    ret = avfilter_init_dict(filter, &options);
1033
29819
    if (ret < 0)
1034
        goto fail;
1035
1036
29819
    if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1037
        av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
1038
        ret = AVERROR_OPTION_NOT_FOUND;
1039
        goto fail;
1040
    }
1041
1042
29819
fail:
1043
29819
    av_dict_free(&options);
1044
1045
29819
    return ret;
1046
}
1047
1048
19082
const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
1049
{
1050
19082
    return pads[pad_idx].name;
1051
}
1052
1053
23646
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
1054
{
1055
23646
    return pads[pad_idx].type;
1056
}
1057
1058
634330
static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
1059
{
1060
634330
    return ff_filter_frame(link->dst->outputs[0], frame);
1061
}
1062
1063
951156
static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
1064
{
1065
    int (*filter_frame)(AVFilterLink *, AVFrame *);
1066
951156
    AVFilterContext *dstctx = link->dst;
1067
951156
    AVFilterPad *dst = link->dstpad;
1068
    int ret;
1069
1070
951156
    if (!(filter_frame = dst->filter_frame))
1071
634321
        filter_frame = default_filter_frame;
1072
1073
951156
    if (dst->needs_writable) {
1074
1973
        ret = ff_inlink_make_frame_writable(link, &frame);
1075
1973
        if (ret < 0)
1076
            goto fail;
1077
    }
1078
1079
951156
    ff_inlink_process_commands(link, frame);
1080
951156
    dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1081
1082
951156
    if (dstctx->is_disabled &&
1083
19
        (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
1084
9
        filter_frame = default_filter_frame;
1085
951156
    ret = filter_frame(link, frame);
1086
951156
    link->frame_count_out++;
1087
951156
    return ret;
1088
1089
fail:
1090
    av_frame_free(&frame);
1091
    return ret;
1092
}
1093
1094
1352021
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1095
{
1096
    int ret;
1097
1352021
    FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);
1098
1099
    /* Consistency checks */
1100
1352021
    if (link->type == AVMEDIA_TYPE_VIDEO) {
1101
317783
        if (strcmp(link->dst->filter->name, "buffersink") &&
1102
217076
            strcmp(link->dst->filter->name, "format") &&
1103
149475
            strcmp(link->dst->filter->name, "idet") &&
1104
149449
            strcmp(link->dst->filter->name, "null") &&
1105
67698
            strcmp(link->dst->filter->name, "scale")) {
1106
            av_assert1(frame->format                 == link->format);
1107
            av_assert1(frame->width               == link->w);
1108
            av_assert1(frame->height               == link->h);
1109
        }
1110
    } else {
1111
1034238
        if (frame->format != link->format) {
1112
            av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1113
            goto error;
1114
        }
1115
1034238
        if (frame->channels != link->channels) {
1116
            av_log(link->dst, AV_LOG_ERROR, "Channel count change is not supported\n");
1117
            goto error;
1118
        }
1119
1034238
        if (frame->channel_layout != link->channel_layout) {
1120
            av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1121
            goto error;
1122
        }
1123
1034238
        if (frame->sample_rate != link->sample_rate) {
1124
            av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1125
            goto error;
1126
        }
1127
    }
1128
1129
1352021
    link->frame_blocked_in = link->frame_wanted_out = 0;
1130
1352021
    link->frame_count_in++;
1131
1352021
    filter_unblock(link->dst);
1132
1352021
    ret = ff_framequeue_add(&link->fifo, frame);
1133
1352021
    if (ret < 0) {
1134
        av_frame_free(&frame);
1135
        return ret;
1136
    }
1137
1352021
    ff_filter_set_ready(link->dst, 300);
1138
1352021
    return 0;
1139
1140
error:
1141
    av_frame_free(&frame);
1142
    return AVERROR_PATCHWELCOME;
1143
}
1144
1145
2812018
static int samples_ready(AVFilterLink *link, unsigned min)
1146
{
1147
3763755
    return ff_framequeue_queued_frames(&link->fifo) &&
1148
951737
           (ff_framequeue_queued_samples(&link->fifo) >= min ||
1149
583
            link->status_in);
1150
}
1151
1152
63843
static int take_samples(AVFilterLink *link, unsigned min, unsigned max,
1153
                        AVFrame **rframe)
1154
{
1155
    AVFrame *frame0, *frame, *buf;
1156
    unsigned nb_samples, nb_frames, i, p;
1157
    int ret;
1158
1159
    /* Note: this function relies on no format changes and must only be
1160
       called with enough samples. */
1161
    av_assert1(samples_ready(link, link->min_samples));
1162
63843
    frame0 = frame = ff_framequeue_peek(&link->fifo, 0);
1163

63843
    if (!link->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1164
5231
        *rframe = ff_framequeue_take(&link->fifo);
1165
5231
        return 0;
1166
    }
1167
58612
    nb_frames = 0;
1168
58612
    nb_samples = 0;
1169
    while (1) {
1170
91137
        if (nb_samples + frame->nb_samples > max) {
1171
52734
            if (nb_samples < min)
1172
52734
                nb_samples = max;
1173
52734
            break;
1174
        }
1175
38403
        nb_samples += frame->nb_samples;
1176
38403
        nb_frames++;
1177
38403
        if (nb_frames == ff_framequeue_queued_frames(&link->fifo))
1178
5878
            break;
1179
32525
        frame = ff_framequeue_peek(&link->fifo, nb_frames);
1180
    }
1181
1182
58612
    buf = ff_get_audio_buffer(link, nb_samples);
1183
58612
    if (!buf)
1184
        return AVERROR(ENOMEM);
1185
58612
    ret = av_frame_copy_props(buf, frame0);
1186
58612
    if (ret < 0) {
1187
        av_frame_free(&buf);
1188
        return ret;
1189
    }
1190
58612
    buf->pts = frame0->pts;
1191
1192
58612
    p = 0;
1193
97015
    for (i = 0; i < nb_frames; i++) {
1194
38403
        frame = ff_framequeue_take(&link->fifo);
1195
38403
        av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1196
38403
                        frame->nb_samples, link->channels, link->format);
1197
38403
        p += frame->nb_samples;
1198
38403
        av_frame_free(&frame);
1199
    }
1200
58612
    if (p < nb_samples) {
1201
52734
        unsigned n = nb_samples - p;
1202
52734
        frame = ff_framequeue_peek(&link->fifo, 0);
1203
52734
        av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1204
52734
                        link->channels, link->format);
1205
52734
        ff_framequeue_skip_samples(&link->fifo, n, link->time_base);
1206
    }
1207
1208
58612
    *rframe = buf;
1209
58612
    return 0;
1210
}
1211
1212
951156
static int ff_filter_frame_to_filter(AVFilterLink *link)
1213
{
1214
951156
    AVFrame *frame = NULL;
1215
951156
    AVFilterContext *dst = link->dst;
1216
    int ret;
1217
1218
    av_assert1(ff_framequeue_queued_frames(&link->fifo));
1219
1902312
    ret = link->min_samples ?
1220
951156
          ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1221
950840
          ff_inlink_consume_frame(link, &frame);
1222
    av_assert1(ret);
1223
951156
    if (ret < 0) {
1224
        av_assert1(!frame);
1225
        return ret;
1226
    }
1227
    /* The filter will soon have received a new frame, that may allow it to
1228
       produce one or more: unblock its outputs. */
1229
951156
    filter_unblock(dst);
1230
    /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1231
       before the frame; ff_filter_frame_framed() will re-increment it. */
1232
951156
    link->frame_count_out--;
1233
951156
    ret = ff_filter_frame_framed(link, frame);
1234

951156
    if (ret < 0 && ret != link->status_out) {
1235
        ff_avfilter_link_set_out_status(link, ret, AV_NOPTS_VALUE);
1236
    } else {
1237
        /* Run once again, to see if several frames were available, or if
1238
           the input status has also changed, or any other reason. */
1239
951156
        ff_filter_set_ready(dst, 300);
1240
    }
1241
951156
    return ret;
1242
}
1243
1244
16966
static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
1245
{
1246
16966
    unsigned out = 0, progress = 0;
1247
    int ret;
1248
1249
16966
    av_assert0(!in->status_out);
1250
16966
    if (!filter->nb_outputs) {
1251
        /* not necessary with the current API and sinks */
1252
        return 0;
1253
    }
1254
33931
    while (!in->status_out) {
1255
16967
        if (!filter->outputs[out]->status_in) {
1256
16965
            progress++;
1257
16965
            ret = ff_request_frame_to_filter(filter->outputs[out]);
1258
16965
            if (ret < 0)
1259
                return ret;
1260
        }
1261
16967
        if (++out == filter->nb_outputs) {
1262
16952
            if (!progress) {
1263
                /* Every output already closed: input no longer interesting
1264
                   (example: overlay in shortest mode, other input closed). */
1265
2
                ff_avfilter_link_set_out_status(in, in->status_in, in->status_in_pts);
1266
2
                return 0;
1267
            }
1268
16950
            progress = 0;
1269
16950
            out = 0;
1270
        }
1271
    }
1272
16964
    ff_filter_set_ready(filter, 200);
1273
16964
    return 0;
1274
}
1275
1276
3178380
static int ff_filter_activate_default(AVFilterContext *filter)
1277
{
1278
    unsigned i;
1279
1280
5039242
    for (i = 0; i < filter->nb_inputs; i++) {
1281
2812018
        if (samples_ready(filter->inputs[i], filter->inputs[i]->min_samples)) {
1282
951156
            return ff_filter_frame_to_filter(filter->inputs[i]);
1283
        }
1284
    }
1285
4071115
    for (i = 0; i < filter->nb_inputs; i++) {
1286

1860857
        if (filter->inputs[i]->status_in && !filter->inputs[i]->status_out) {
1287
            av_assert1(!ff_framequeue_queued_frames(&filter->inputs[i]->fifo));
1288
16966
            return forward_status_change(filter, filter->inputs[i]);
1289
        }
1290
    }
1291
3182553
    for (i = 0; i < filter->nb_outputs; i++) {
1292
2211534
        if (filter->outputs[i]->frame_wanted_out &&
1293
1239553
            !filter->outputs[i]->frame_blocked_in) {
1294
1239239
            return ff_request_frame_to_filter(filter->outputs[i]);
1295
        }
1296
    }
1297
971019
    return FFERROR_NOT_READY;
1298
}
1299
1300
/*
1301
   Filter scheduling and activation
1302
1303
   When a filter is activated, it must:
1304
   - if possible, output a frame;
1305
   - else, if relevant, forward the input status change;
1306
   - else, check outputs for wanted frames and forward the requests.
1307
1308
   The following AVFilterLink fields are used for activation:
1309
1310
   - frame_wanted_out:
1311
1312
     This field indicates if a frame is needed on this input of the
1313
     destination filter. A positive value indicates that a frame is needed
1314
     to process queued frames or internal data or to satisfy the
1315
     application; a zero value indicates that a frame is not especially
1316
     needed but could be processed anyway; a negative value indicates that a
1317
     frame would just be queued.
1318
1319
     It is set by filters using ff_request_frame() or ff_request_no_frame(),
1320
     when requested by the application through a specific API or when it is
1321
     set on one of the outputs.
1322
1323
     It is cleared when a frame is sent from the source using
1324
     ff_filter_frame().
1325
1326
     It is also cleared when a status change is sent from the source using
1327
     ff_avfilter_link_set_in_status().
1328
1329
   - frame_blocked_in:
1330
1331
     This field means that the source filter can not generate a frame as is.
1332
     Its goal is to avoid repeatedly calling the request_frame() method on
1333
     the same link.
1334
1335
     It is set by the framework on all outputs of a filter before activating it.
1336
1337
     It is automatically cleared by ff_filter_frame().
1338
1339
     It is also automatically cleared by ff_avfilter_link_set_in_status().
1340
1341
     It is also cleared on all outputs (using filter_unblock()) when
1342
     something happens on an input: processing a frame or changing the
1343
     status.
1344
1345
   - fifo:
1346
1347
     Contains the frames queued on a filter input. If it contains frames and
1348
     frame_wanted_out is not set, then the filter can be activated. If that
1349
     result in the filter not able to use these frames, the filter must set
1350
     frame_wanted_out to ask for more frames.
1351
1352
   - status_in and status_in_pts:
1353
1354
     Status (EOF or error code) of the link and timestamp of the status
1355
     change (in link time base, same as frames) as seen from the input of
1356
     the link. The status change is considered happening after the frames
1357
     queued in fifo.
1358
1359
     It is set by the source filter using ff_avfilter_link_set_in_status().
1360
1361
   - status_out:
1362
1363
     Status of the link as seen from the output of the link. The status
1364
     change is considered having already happened.
1365
1366
     It is set by the destination filter using
1367
     ff_avfilter_link_set_out_status().
1368
1369
   Filters are activated according to the ready field, set using the
1370
   ff_filter_set_ready(). Eventually, a priority queue will be used.
1371
   ff_filter_set_ready() is called whenever anything could cause progress to
1372
   be possible. Marking a filter ready when it is not is not a problem,
1373
   except for the small overhead it causes.
1374
1375
   Conditions that cause a filter to be marked ready are:
1376
1377
   - frames added on an input link;
1378
1379
   - changes in the input or output status of an input link;
1380
1381
   - requests for a frame on an output link;
1382
1383
   - after any actual processing using the legacy methods (filter_frame(),
1384
     and request_frame() to acknowledge status changes), to run once more
1385
     and check if enough input was present for several frames.
1386
1387
   Examples of scenarios to consider:
1388
1389
   - buffersrc: activate if frame_wanted_out to notify the application;
1390
     activate when the application adds a frame to push it immediately.
1391
1392
   - testsrc: activate only if frame_wanted_out to produce and push a frame.
1393
1394
   - concat (not at stitch points): can process a frame on any output.
1395
     Activate if frame_wanted_out on output to forward on the corresponding
1396
     input. Activate when a frame is present on input to process it
1397
     immediately.
1398
1399
   - framesync: needs at least one frame on each input; extra frames on the
1400
     wrong input will accumulate. When a frame is first added on one input,
1401
     set frame_wanted_out<0 on it to avoid getting more (would trigger
1402
     testsrc) and frame_wanted_out>0 on the other to allow processing it.
1403
1404
   Activation of old filters:
1405
1406
   In order to activate a filter implementing the legacy filter_frame() and
1407
   request_frame() methods, perform the first possible of the following
1408
   actions:
1409
1410
   - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1411
     frame and call filter_frame().
1412
1413
     Rationale: filter frames as soon as possible instead of leaving them
1414
     queued; frame_wanted_out < 0 is not possible since the old API does not
1415
     set it nor provides any similar feedback; frame_wanted_out > 0 happens
1416
     when min_samples > 0 and there are not enough samples queued.
1417
1418
   - If an input has status_in set but not status_out, try to call
1419
     request_frame() on one of the outputs in the hope that it will trigger
1420
     request_frame() on the input with status_in and acknowledge it. This is
1421
     awkward and fragile, filters with several inputs or outputs should be
1422
     updated to direct activation as soon as possible.
1423
1424
   - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1425
     request_frame().
1426
1427
     Rationale: checking frame_blocked_in is necessary to avoid requesting
1428
     repeatedly on a blocked input if another is not blocked (example:
1429
     [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1430
 */
1431
1432
3593698
int ff_filter_activate(AVFilterContext *filter)
1433
{
1434
    int ret;
1435
1436
    /* Generic timeline support is not yet implemented but should be easy */
1437
    av_assert1(!(filter->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC &&
1438
                 filter->filter->activate));
1439
3593698
    filter->ready = 0;
1440
3593698
    ret = filter->filter->activate ? filter->filter->activate(filter) :
1441
3178380
          ff_filter_activate_default(filter);
1442
3593698
    if (ret == FFERROR_NOT_READY)
1443
971030
        ret = 0;
1444
3593698
    return ret;
1445
}
1446
1447
2038201
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1448
{
1449
2038201
    *rpts = link->current_pts;
1450
2038201
    if (ff_framequeue_queued_frames(&link->fifo))
1451
180846
        return *rstatus = 0;
1452
1857355
    if (link->status_out)
1453
5020
        return *rstatus = link->status_out;
1454
1852335
    if (!link->status_in)
1455
1848687
        return *rstatus = 0;
1456
3648
    *rstatus = link->status_out = link->status_in;
1457
3648
    ff_update_link_current_pts(link, link->status_in_pts);
1458
3648
    *rpts = link->current_pts;
1459
3648
    return 1;
1460
}
1461
1462
size_t ff_inlink_queued_frames(AVFilterLink *link)
1463
{
1464
    return ff_framequeue_queued_frames(&link->fifo);
1465
}
1466
1467
3104353
int ff_inlink_check_available_frame(AVFilterLink *link)
1468
{
1469
3104353
    return ff_framequeue_queued_frames(&link->fifo) > 0;
1470
}
1471
1472
3892
int ff_inlink_queued_samples(AVFilterLink *link)
1473
{
1474
3892
    return ff_framequeue_queued_samples(&link->fifo);
1475
}
1476
1477
303691
int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1478
{
1479
303691
    uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
1480
    av_assert1(min);
1481

303691
    return samples >= min || (link->status_in && samples);
1482
}
1483
1484
1372192
static void consume_update(AVFilterLink *link, const AVFrame *frame)
1485
{
1486
1372192
    ff_update_link_current_pts(link, frame->pts);
1487
1372192
    ff_inlink_process_commands(link, frame);
1488
1372192
    link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1489
1372192
    link->frame_count_out++;
1490
1372192
}
1491
1492
3103744
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1493
{
1494
    AVFrame *frame;
1495
1496
3103744
    *rframe = NULL;
1497
3103744
    if (!ff_inlink_check_available_frame(link))
1498
1795394
        return 0;
1499
1500
1308350
    if (link->fifo.samples_skipped) {
1501
1
        frame = ff_framequeue_peek(&link->fifo, 0);
1502
1
        return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1503
    }
1504
1505
1308349
    frame = ff_framequeue_take(&link->fifo);
1506
1308349
    consume_update(link, frame);
1507
1308349
    *rframe = frame;
1508
1308349
    return 1;
1509
}
1510
1511
303043
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1512
                            AVFrame **rframe)
1513
{
1514
    AVFrame *frame;
1515
    int ret;
1516
1517
    av_assert1(min);
1518
303043
    *rframe = NULL;
1519
303043
    if (!ff_inlink_check_available_samples(link, min))
1520
239200
        return 0;
1521
63843
    if (link->status_in)
1522
100
        min = FFMIN(min, ff_framequeue_queued_samples(&link->fifo));
1523
63843
    ret = take_samples(link, min, max, &frame);
1524
63843
    if (ret < 0)
1525
        return ret;
1526
63843
    consume_update(link, frame);
1527
63843
    *rframe = frame;
1528
63843
    return 1;
1529
}
1530
1531
AVFrame *ff_inlink_peek_frame(AVFilterLink *link, size_t idx)
1532
{
1533
    return ff_framequeue_peek(&link->fifo, idx);
1534
}
1535
1536
3115
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
1537
{
1538
3115
    AVFrame *frame = *rframe;
1539
    AVFrame *out;
1540
    int ret;
1541
1542
3115
    if (av_frame_is_writable(frame))
1543
3035
        return 0;
1544
80
    av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1545
1546
80
    switch (link->type) {
1547
80
    case AVMEDIA_TYPE_VIDEO:
1548
80
        out = ff_get_video_buffer(link, link->w, link->h);
1549
80
        break;
1550
    case AVMEDIA_TYPE_AUDIO:
1551
        out = ff_get_audio_buffer(link, frame->nb_samples);
1552
        break;
1553
    default:
1554
        return AVERROR(EINVAL);
1555
    }
1556
80
    if (!out)
1557
        return AVERROR(ENOMEM);
1558
1559
80
    ret = av_frame_copy_props(out, frame);
1560
80
    if (ret < 0) {
1561
        av_frame_free(&out);
1562
        return ret;
1563
    }
1564
1565
80
    switch (link->type) {
1566
80
    case AVMEDIA_TYPE_VIDEO:
1567
80
        av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
1568
80
                      frame->format, frame->width, frame->height);
1569
80
        break;
1570
    case AVMEDIA_TYPE_AUDIO:
1571
        av_samples_copy(out->extended_data, frame->extended_data,
1572
                        0, 0, frame->nb_samples,
1573
                        frame->channels,
1574
                        frame->format);
1575
        break;
1576
    default:
1577
        av_assert0(!"reached");
1578
    }
1579
1580
80
    av_frame_free(&frame);
1581
80
    *rframe = out;
1582
80
    return 0;
1583
}
1584
1585
2323348
int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1586
{
1587
2323348
    AVFilterCommand *cmd = link->dst->command_queue;
1588
1589

2323348
    while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1590
        av_log(link->dst, AV_LOG_DEBUG,
1591
               "Processing command time:%f command:%s arg:%s\n",
1592
               cmd->time, cmd->command, cmd->arg);
1593
        avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1594
        ff_command_queue_pop(link->dst);
1595
        cmd= link->dst->command_queue;
1596
    }
1597
2323348
    return 0;
1598
}
1599
1600
2323348
int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1601
{
1602
2323348
    AVFilterContext *dstctx = link->dst;
1603
2323348
    int64_t pts = frame->pts;
1604
2323348
    int64_t pos = frame->pkt_pos;
1605
1606
2323348
    if (!dstctx->enable_str)
1607
2323152
        return 1;
1608
1609
196
    dstctx->var_values[VAR_N] = link->frame_count_out;
1610
196
    dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1611
196
    dstctx->var_values[VAR_W] = link->w;
1612
196
    dstctx->var_values[VAR_H] = link->h;
1613
196
    dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1614
1615
196
    return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
1616
}
1617
1618
368376
void ff_inlink_request_frame(AVFilterLink *link)
1619
{
1620
    av_assert1(!link->status_in);
1621
    av_assert1(!link->status_out);
1622
368376
    link->frame_wanted_out = 1;
1623
368376
    ff_filter_set_ready(link->src, 100);
1624
368376
}
1625
1626
89
void ff_inlink_set_status(AVFilterLink *link, int status)
1627
{
1628
89
    if (link->status_out)
1629
80
        return;
1630
9
    link->frame_wanted_out = 0;
1631
9
    link->frame_blocked_in = 0;
1632
9
    ff_avfilter_link_set_out_status(link, status, AV_NOPTS_VALUE);
1633
9
    while (ff_framequeue_queued_frames(&link->fifo)) {
1634
           AVFrame *frame = ff_framequeue_take(&link->fifo);
1635
           av_frame_free(&frame);
1636
    }
1637
9
    if (!link->status_in)
1638
3
        link->status_in = status;
1639
}
1640
1641
17896
int ff_outlink_get_status(AVFilterLink *link)
1642
{
1643
17896
    return link->status_in;
1644
}
1645
1646
const AVClass *avfilter_get_class(void)
1647
{
1648
    return &avfilter_class;
1649
}
1650
1651
int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link,
1652
                             int default_pool_size)
1653
{
1654
    AVHWFramesContext *frames;
1655
1656
    // Must already be set by caller.
1657
    av_assert0(link->hw_frames_ctx);
1658
1659
    frames = (AVHWFramesContext*)link->hw_frames_ctx->data;
1660
1661
    if (frames->initial_pool_size == 0) {
1662
        // Dynamic allocation is necessarily supported.
1663
    } else if (avctx->extra_hw_frames >= 0) {
1664
        frames->initial_pool_size += avctx->extra_hw_frames;
1665
    } else {
1666
        frames->initial_pool_size = default_pool_size;
1667
    }
1668
1669
    return 0;
1670
}