GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/avfilter.c Lines: 624 852 73.2 %
Date: 2021-01-20 23:14:43 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
1351253
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
1351253
    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
1351253
    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
1351253
}
76
77
6058
unsigned avfilter_version(void)
78
{
79
    av_assert0(LIBAVFILTER_VERSION_MICRO >= 100);
80
6058
    return LIBAVFILTER_VERSION_INT;
81
}
82
83
6058
const char *avfilter_configuration(void)
84
{
85
6058
    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
23804
int avfilter_link(AVFilterContext *src, unsigned srcpad,
136
                  AVFilterContext *dst, unsigned dstpad)
137
{
138
    AVFilterLink *link;
139
140
23804
    av_assert0(src->graph);
141
23804
    av_assert0(dst->graph);
142
23804
    av_assert0(src->graph == dst->graph);
143
144

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

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

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

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

18737
                if (!link->time_base.num && !link->time_base.den)
328
13748
                    link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
329
330

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

13981
                    if (!link->frame_rate.num && !link->frame_rate.den)
336
13802
                        link->frame_rate = inlink->frame_rate;
337
13981
                    if (!link->w)
338
9583
                        link->w = inlink->w;
339
13981
                    if (!link->h)
340
9583
                        link->h = inlink->h;
341

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

3759
                    if (!link->time_base.num && !link->time_base.den)
352
2546
                        link->time_base = inlink->time_base;
353
                }
354
355

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

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

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

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


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

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

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

14
                while ((p = strchr(p, ':')) && p[1] != ':') {
989
14
                    const char *epos = strchr(p + 1, '=');
990
14
                    const char *spos = strchr(p + 1, ':');
991

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

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

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

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

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

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

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