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

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

23759
        src->outputs[srcpad]      || dst->inputs[dstpad])
146
        return AVERROR(EINVAL);
147
148
23759
    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
23759
    link = av_mallocz(sizeof(*link));
157
23759
    if (!link)
158
        return AVERROR(ENOMEM);
159
160
23759
    src->outputs[srcpad] = dst->inputs[dstpad] = link;
161
162
23759
    link->src     = src;
163
23759
    link->dst     = dst;
164
23759
    link->srcpad  = &src->output_pads[srcpad];
165
23759
    link->dstpad  = &dst->input_pads[dstpad];
166
23759
    link->type    = src->output_pads[srcpad].type;
167
    av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
168
23759
    link->format  = -1;
169
23759
    ff_framequeue_init(&link->fifo, &src->graph->internal->frame_queues);
170
171
23759
    return 0;
172
}
173
174
23891
void avfilter_link_free(AVFilterLink **link)
175
{
176
23891
    if (!*link)
177
        return;
178
179
23891
    av_frame_free(&(*link)->partial_buf);
180
23891
    ff_framequeue_free(&(*link)->fifo);
181
23891
    ff_frame_pool_uninit((FFFramePool**)&(*link)->frame_pool);
182
183
23891
    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
3604098
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
194
{
195
3604098
    filter->ready = FFMAX(filter->ready, priority);
196
3604098
}
197
198
/**
199
 * Clear frame_blocked_in on all outputs.
200
 * This is necessary whenever something changes on input.
201
 */
202
2340672
static void filter_unblock(AVFilterContext *filter)
203
{
204
    unsigned i;
205
206
4287780
    for (i = 0; i < filter->nb_outputs; i++)
207
1947108
        filter->outputs[i]->frame_blocked_in = 0;
208
2340672
}
209
210
211
23395
void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
212
{
213
23395
    if (link->status_in == status)
214
28
        return;
215
23367
    av_assert0(!link->status_in);
216
23367
    link->status_in = status;
217
23367
    link->status_in_pts = pts;
218
23367
    link->frame_wanted_out = 0;
219
23367
    link->frame_blocked_in = 0;
220
23367
    filter_unblock(link->dst);
221
23367
    ff_filter_set_ready(link->dst, 200);
222
}
223
224
17424
void ff_avfilter_link_set_out_status(AVFilterLink *link, int status, int64_t pts)
225
{
226
17424
    av_assert0(!link->frame_wanted_out);
227
17424
    av_assert0(!link->status_out);
228
17424
    link->status_out = status;
229
17424
    if (pts != AV_NOPTS_VALUE)
230
16886
        ff_update_link_current_pts(link, pts);
231
17424
    filter_unblock(link->dst);
232
17424
    ff_filter_set_ready(link->src, 200);
233
17424
}
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
29465
int avfilter_config_links(AVFilterContext *filter)
278
{
279
    int (*config_link)(AVFilterLink *);
280
    unsigned i;
281
    int ret;
282
283
53099
    for (i = 0; i < filter->nb_inputs; i ++) {
284
23634
        AVFilterLink *link = filter->inputs[i];
285
        AVFilterLink *inlink;
286
287
23634
        if (!link) continue;
288

23634
        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
23634
        inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
295
23634
        link->current_pts =
296
23634
        link->current_pts_us = AV_NOPTS_VALUE;
297
298

23634
        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
23605
        case AVLINK_UNINIT:
305
23605
            link->init_state = AVLINK_STARTINIT;
306
307
23605
            if ((ret = avfilter_config_links(link->src)) < 0)
308
                return ret;
309
310
23605
            if (!(config_link = link->srcpad->config_props)) {
311
12040
                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
11565
            } 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
23605
            switch (link->type) {
326
18708
            case AVMEDIA_TYPE_VIDEO:
327

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

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

13956
                    if (!link->frame_rate.num && !link->frame_rate.den)
336
13777
                        link->frame_rate = inlink->frame_rate;
337
13956
                    if (!link->w)
338
9567
                        link->w = inlink->w;
339
13956
                    if (!link->h)
340
9567
                        link->h = inlink->h;
341

4752
                } 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
18708
                break;
348
349
4897
            case AVMEDIA_TYPE_AUDIO:
350
4897
                if (inlink) {
351

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

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

23605
            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
23605
            if ((config_link = link->dstpad->config_props))
369
1922
                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
23605
            link->init_state = AVLINK_INIT;
377
        }
378
    }
379
380
29465
    return 0;
381
}
382
383
3584701
void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
384
{
385
3584701
    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
2652988
        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
3584701
}
406
407
894727
int ff_request_frame(AVFilterLink *link)
408
{
409
894727
    FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1);
410
411
    av_assert1(!link->dst->filter->activate);
412
894727
    if (link->status_out)
413
1155
        return link->status_out;
414
893572
    if (link->status_in) {
415
16920
        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
16920
            ff_avfilter_link_set_out_status(link, link->status_in, link->status_in_pts);
424
16920
            return link->status_out;
425
        }
426
    }
427
876652
    link->frame_wanted_out = 1;
428
876652
    ff_filter_set_ready(link->src, 100);
429
876652
    return 0;
430
}
431
432
17445
static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
433
{
434
    unsigned i;
435
17445
    int64_t r = INT64_MAX;
436
437
34858
    for (i = 0; i < ctx->nb_inputs; i++)
438
17413
        if (ctx->inputs[i]->status_out == status)
439
17413
            r = FFMIN(r, av_rescale_q(ctx->inputs[i]->current_pts, ctx->inputs[i]->time_base, link_time_base));
440
17445
    if (r < INT64_MAX)
441
17413
        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
1255175
static int ff_request_frame_to_filter(AVFilterLink *link)
451
{
452
1255175
    int ret = -1;
453
454
1255175
    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
1255175
    link->frame_blocked_in = 1;
457
1255175
    if (link->srcpad->request_frame)
458
577630
        ret = link->srcpad->request_frame(link);
459
677545
    else if (link->src->inputs[0])
460
677545
        ret = ff_request_frame(link->src->inputs[0]);
461
1255175
    if (ret < 0) {
462

365152
        if (ret != AVERROR(EAGAIN) && ret != link->status_in)
463
17445
            ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base));
464
365152
        if (ret == AVERROR_EOF)
465
17445
            ret = 0;
466
    }
467
1255175
    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
1390993
void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)
529
{
530
1390993
    if (pts == AV_NOPTS_VALUE)
531
26
        return;
532
1390967
    link->current_pts = pts;
533
1390967
    link->current_pts_us = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
534
    /* TODO use duration */
535

1390967
    if (link->graph && link->age_index >= 0)
536
413533
        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
59460
int avfilter_pad_count(const AVFilterPad *pads)
561
{
562
    int count;
563
564
59460
    if (!pads)
565
11910
        return 0;
566
567
95174
    for (count = 0; pads->name; count++)
568
47624
        pads++;
569
47550
    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
1343
static void *filter_child_next(void *obj, void *prev)
579
{
580
1343
    AVFilterContext *ctx = obj;
581


1343
    if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
582
1343
        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
29730
AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
662
{
663
    AVFilterContext *ret;
664
29730
    int preinited = 0;
665
666
29730
    if (!filter)
667
        return NULL;
668
669
29730
    ret = av_mallocz(sizeof(AVFilterContext));
670
29730
    if (!ret)
671
        return NULL;
672
673
29730
    ret->av_class = &avfilter_class;
674
29730
    ret->filter   = filter;
675
29730
    ret->name     = inst_name ? av_strdup(inst_name) : NULL;
676
29730
    if (filter->priv_size) {
677
26739
        ret->priv     = av_mallocz(filter->priv_size);
678
26739
        if (!ret->priv)
679
            goto err;
680
    }
681
29730
    if (filter->preinit) {
682
52
        if (filter->preinit(ret) < 0)
683
            goto err;
684
52
        preinited = 1;
685
    }
686
687
29730
    av_opt_set_defaults(ret);
688
29730
    if (filter->priv_class) {
689
26559
        *(const AVClass**)ret->priv = filter->priv_class;
690
26559
        av_opt_set_defaults(ret->priv);
691
    }
692
693
29730
    ret->internal = av_mallocz(sizeof(*ret->internal));
694
29730
    if (!ret->internal)
695
        goto err;
696
29730
    ret->internal->execute = default_execute;
697
698
29730
    ret->nb_inputs = avfilter_pad_count(filter->inputs);
699
29730
    if (ret->nb_inputs ) {
700
23749
        ret->input_pads   = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad));
701
23749
        if (!ret->input_pads)
702
            goto err;
703
23749
        memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
704
23749
        ret->inputs       = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*));
705
23749
        if (!ret->inputs)
706
            goto err;
707
    }
708
709
29730
    ret->nb_outputs = avfilter_pad_count(filter->outputs);
710
29730
    if (ret->nb_outputs) {
711
23801
        ret->output_pads  = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad));
712
23801
        if (!ret->output_pads)
713
            goto err;
714
23801
        memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
715
23801
        ret->outputs      = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*));
716
23801
        if (!ret->outputs)
717
            goto err;
718
    }
719
720
29730
    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
47792
static void free_link(AVFilterLink *link)
738
{
739
47792
    if (!link)
740
23901
        return;
741
742
23891
    if (link->src)
743
23759
        link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
744
23891
    if (link->dst)
745
23759
        link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
746
747
23891
    av_buffer_unref(&link->hw_frames_ctx);
748
749
23891
    ff_formats_unref(&link->incfg.formats);
750
23891
    ff_formats_unref(&link->outcfg.formats);
751
23891
    ff_formats_unref(&link->incfg.samplerates);
752
23891
    ff_formats_unref(&link->outcfg.samplerates);
753
23891
    ff_channel_layouts_unref(&link->incfg.channel_layouts);
754
23891
    ff_channel_layouts_unref(&link->outcfg.channel_layouts);
755
23891
    avfilter_link_free(&link);
756
}
757
758
29730
void avfilter_free(AVFilterContext *filter)
759
{
760
    int i;
761
762
29730
    if (!filter)
763
        return;
764
765
29730
    if (filter->graph)
766
29730
        ff_filter_graph_remove_filter(filter->graph, filter);
767
768
29730
    if (filter->filter->uninit)
769
19035
        filter->filter->uninit(filter);
770
771
53615
    for (i = 0; i < filter->nb_inputs; i++) {
772
23885
        free_link(filter->inputs[i]);
773
    }
774
53637
    for (i = 0; i < filter->nb_outputs; i++) {
775
23907
        free_link(filter->outputs[i]);
776
    }
777
778
29730
    if (filter->filter->priv_class)
779
26559
        av_opt_free(filter->priv);
780
781
29730
    av_buffer_unref(&filter->hw_device_ctx);
782
783
29730
    av_freep(&filter->name);
784
29730
    av_freep(&filter->input_pads);
785
29730
    av_freep(&filter->output_pads);
786
29730
    av_freep(&filter->inputs);
787
29730
    av_freep(&filter->outputs);
788
29730
    av_freep(&filter->priv);
789
29730
    while(filter->command_queue){
790
        ff_command_queue_pop(filter);
791
    }
792
29730
    av_opt_free(filter);
793
29730
    av_expr_free(filter->enable);
794
29730
    filter->enable = NULL;
795
29730
    av_freep(&filter->var_values);
796
29730
    av_freep(&filter->internal);
797
29730
    av_free(filter);
798
}
799
800
5641
int ff_filter_get_nb_threads(AVFilterContext *ctx)
801
{
802
5641
    if (ctx->nb_threads > 0)
803
        return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
804
5641
    return ctx->graph->nb_threads;
805
}
806
807
19345
static int process_options(AVFilterContext *ctx, AVDictionary **options,
808
                           const char *args)
809
{
810
19345
    const AVOption *o = NULL;
811
19345
    int ret, count = 0;
812
19345
    char *av_uninit(parsed_key), *av_uninit(value);
813
    const char *key;
814
19345
    int offset= -1;
815
816
19345
    if (!args)
817
        return 0;
818
819
101689
    while (*args) {
820
82344
        const char *shorthand = NULL;
821
822
82344
        o = av_opt_next(ctx->priv, o);
823
82344
        if (o) {
824

80296
            if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
825
32042
                continue;
826
48254
            offset = o->offset;
827
48254
            shorthand = o->name;
828
        }
829
830
50302
        ret = av_opt_get_key_value(&args, "=", ":",
831
                                   shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
832
                                   &parsed_key, &value);
833
50302
        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
50302
        if (*args)
842
32078
            args++;
843
50302
        if (parsed_key) {
844
39713
            key = parsed_key;
845
533643
            while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */
846
        } else {
847
10589
            key = shorthand;
848
        }
849
850
50302
        av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
851
852
50302
        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
50298
            av_dict_set(options, key, value, 0);
861
50298
            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
50302
        av_free(value);
873
50302
        av_free(parsed_key);
874
50302
        count++;
875
    }
876
877
19345
    if (ctx->enable_str) {
878
4
        ret = set_enable_expr(ctx, ctx->enable_str);
879
4
        if (ret < 0)
880
            return ret;
881
    }
882
19345
    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
29730
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
899
{
900
29730
    int ret = 0;
901
902
29730
    ret = av_opt_set_dict(ctx, options);
903
29730
    if (ret < 0) {
904
        av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
905
        return ret;
906
    }
907
908
29730
    if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
909
533
        ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
910
126
        ctx->graph->internal->thread_execute) {
911
126
        ctx->thread_type       = AVFILTER_THREAD_SLICE;
912
126
        ctx->internal->execute = ctx->graph->internal->thread_execute;
913
    } else {
914
29604
        ctx->thread_type = 0;
915
    }
916
917
29730
    if (ctx->filter->priv_class) {
918
26559
        ret = av_opt_set_dict2(ctx->priv, options, AV_OPT_SEARCH_CHILDREN);
919
26559
        if (ret < 0) {
920
            av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
921
            return ret;
922
        }
923
    }
924
925
29730
    if (ctx->filter->init_opaque)
926
        ret = ctx->filter->init_opaque(ctx, NULL);
927
29730
    else if (ctx->filter->init)
928
20203
        ret = ctx->filter->init(ctx);
929
9527
    else if (ctx->filter->init_dict)
930
4849
        ret = ctx->filter->init_dict(ctx, options);
931
932
29730
    return ret;
933
}
934
935
29730
int avfilter_init_str(AVFilterContext *filter, const char *args)
936
{
937
29730
    AVDictionary *options = NULL;
938
    AVDictionaryEntry *e;
939
29730
    int ret = 0;
940
941

29730
    if (args && *args) {
942
19345
        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
19345
            if (   !strcmp(filter->filter->name, "format")     ||
950
13516
                   !strcmp(filter->filter->name, "noformat")   ||
951
13516
                   !strcmp(filter->filter->name, "frei0r")     ||
952
13516
                   !strcmp(filter->filter->name, "frei0r_src") ||
953
13516
                   !strcmp(filter->filter->name, "ocv")        ||
954
13516
                   !strcmp(filter->filter->name, "pan")        ||
955
13500
                   !strcmp(filter->filter->name, "pp")         ||
956
19359
                   !strcmp(filter->filter->name, "aevalsrc")) {
957
            /* a hack for compatibility with the old syntax
958
             * replace colons with |s */
959
5867
            char *copy = av_strdup(args);
960
5867
            char *p    = copy;
961
5867
            int nb_leading = 0; // number of leading colons to skip
962
5867
            int deprecated = 0;
963
964
5867
            if (!copy) {
965
                ret = AVERROR(ENOMEM);
966
                goto fail;
967
            }
968
969
5867
            if (!strcmp(filter->filter->name, "frei0r") ||
970
5867
                !strcmp(filter->filter->name, "ocv"))
971
                nb_leading = 1;
972
5867
            else if (!strcmp(filter->filter->name, "frei0r_src"))
973
                nb_leading = 3;
974
975
5867
            while (nb_leading--) {
976
                p = strchr(p, ':');
977
                if (!p) {
978
                    p = copy + strlen(copy);
979
                    break;
980
                }
981
                p++;
982
            }
983
984
5867
            deprecated = strchr(p, ':') != NULL;
985
986
5867
            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
5853
            while ((p = strchr(p, ':')))
1006
                *p++ = '|';
1007
1008
5867
            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
5867
                ret = process_options(filter, &options, copy);
1015
            }
1016
5867
            av_freep(&copy);
1017
1018
5867
            if (ret < 0)
1019
                goto fail;
1020
        } else
1021
#endif
1022
        {
1023
13478
            ret = process_options(filter, &options, args);
1024
13478
            if (ret < 0)
1025
                goto fail;
1026
        }
1027
    }
1028
1029
29730
    ret = avfilter_init_dict(filter, &options);
1030
29730
    if (ret < 0)
1031
        goto fail;
1032
1033
29730
    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
29730
fail:
1040
29730
    av_dict_free(&options);
1041
1042
29730
    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
23579
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
1051
{
1052
23579
    return pads[pad_idx].type;
1053
}
1054
1055
633776
static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
1056
{
1057
633776
    return ff_filter_frame(link->dst->outputs[0], frame);
1058
}
1059
1060
949685
static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
1061
{
1062
    int (*filter_frame)(AVFilterLink *, AVFrame *);
1063
949685
    AVFilterContext *dstctx = link->dst;
1064
949685
    AVFilterPad *dst = link->dstpad;
1065
    int ret;
1066
1067
949685
    if (!(filter_frame = dst->filter_frame))
1068
633767
        filter_frame = default_filter_frame;
1069
1070
949685
    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
949685
    ff_inlink_process_commands(link, frame);
1077
949685
    dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1078
1079
949685
    if (dstctx->is_disabled &&
1080
19
        (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
1081
9
        filter_frame = default_filter_frame;
1082
949685
    ret = filter_frame(link, frame);
1083
949685
    link->frame_count_out++;
1084
949685
    return ret;
1085
1086
fail:
1087
    av_frame_free(&frame);
1088
    return ret;
1089
}
1090
1091
1350196
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
1092
{
1093
    int ret;
1094
1350196
    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
1350196
    if (link->type == AVMEDIA_TYPE_VIDEO) {
1098
317168
        if (strcmp(link->dst->filter->name, "buffersink") &&
1099
216705
            strcmp(link->dst->filter->name, "format") &&
1100
149185
            strcmp(link->dst->filter->name, "idet") &&
1101
149159
            strcmp(link->dst->filter->name, "null") &&
1102
67606
            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
1033028
        if (frame->format != link->format) {
1109
            av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1110
            goto error;
1111
        }
1112
1033028
        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
1033028
        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
1033028
        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
1350196
    link->frame_blocked_in = link->frame_wanted_out = 0;
1127
1350196
    link->frame_count_in++;
1128
1350196
    filter_unblock(link->dst);
1129
1350196
    ret = ff_framequeue_add(&link->fifo, frame);
1130
1350196
    if (ret < 0) {
1131
        av_frame_free(&frame);
1132
        return ret;
1133
    }
1134
1350196
    ff_filter_set_ready(link->dst, 300);
1135
1350196
    return 0;
1136
1137
error:
1138
    av_frame_free(&frame);
1139
    return AVERROR_PATCHWELCOME;
1140
}
1141
1142
2808559
static int samples_ready(AVFilterLink *link, unsigned min)
1143
{
1144
3758825
    return ff_framequeue_queued_frames(&link->fifo) &&
1145
950266
           (ff_framequeue_queued_samples(&link->fifo) >= min ||
1146
583
            link->status_in);
1147
}
1148
1149
63951
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
63951
    frame0 = frame = ff_framequeue_peek(&link->fifo, 0);
1160

63951
    if (!link->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1161
4975
        *rframe = ff_framequeue_take(&link->fifo);
1162
4975
        return 0;
1163
    }
1164
58976
    nb_frames = 0;
1165
58976
    nb_samples = 0;
1166
    while (1) {
1167
91478
        if (nb_samples + frame->nb_samples > max) {
1168
52820
            if (nb_samples < min)
1169
52820
                nb_samples = max;
1170
52820
            break;
1171
        }
1172
38658
        nb_samples += frame->nb_samples;
1173
38658
        nb_frames++;
1174
38658
        if (nb_frames == ff_framequeue_queued_frames(&link->fifo))
1175
6156
            break;
1176
32502
        frame = ff_framequeue_peek(&link->fifo, nb_frames);
1177
    }
1178
1179
58976
    buf = ff_get_audio_buffer(link, nb_samples);
1180
58976
    if (!buf)
1181
        return AVERROR(ENOMEM);
1182
58976
    ret = av_frame_copy_props(buf, frame0);
1183
58976
    if (ret < 0) {
1184
        av_frame_free(&buf);
1185
        return ret;
1186
    }
1187
58976
    buf->pts = frame0->pts;
1188
1189
58976
    p = 0;
1190
97634
    for (i = 0; i < nb_frames; i++) {
1191
38658
        frame = ff_framequeue_take(&link->fifo);
1192
38658
        av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1193
38658
                        frame->nb_samples, link->channels, link->format);
1194
38658
        p += frame->nb_samples;
1195
38658
        av_frame_free(&frame);
1196
    }
1197
58976
    if (p < nb_samples) {
1198
52820
        unsigned n = nb_samples - p;
1199
52820
        frame = ff_framequeue_peek(&link->fifo, 0);
1200
52820
        av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1201
52820
                        link->channels, link->format);
1202
52820
        ff_framequeue_skip_samples(&link->fifo, n, link->time_base);
1203
    }
1204
1205
58976
    *rframe = buf;
1206
58976
    return 0;
1207
}
1208
1209
949685
static int ff_filter_frame_to_filter(AVFilterLink *link)
1210
{
1211
949685
    AVFrame *frame = NULL;
1212
949685
    AVFilterContext *dst = link->dst;
1213
    int ret;
1214
1215
    av_assert1(ff_framequeue_queued_frames(&link->fifo));
1216
1899370
    ret = link->min_samples ?
1217
949685
          ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1218
949369
          ff_inlink_consume_frame(link, &frame);
1219
    av_assert1(ret);
1220
949685
    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
949685
    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
949685
    link->frame_count_out--;
1230
949685
    ret = ff_filter_frame_framed(link, frame);
1231

949685
    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
949685
        ff_filter_set_ready(dst, 300);
1237
    }
1238
949685
    return ret;
1239
}
1240
1241
16922
static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
1242
{
1243
16922
    unsigned out = 0, progress = 0;
1244
    int ret;
1245
1246
16922
    av_assert0(!in->status_out);
1247
16922
    if (!filter->nb_outputs) {
1248
        /* not necessary with the current API and sinks */
1249
        return 0;
1250
    }
1251
33843
    while (!in->status_out) {
1252
16923
        if (!filter->outputs[out]->status_in) {
1253
16921
            progress++;
1254
16921
            ret = ff_request_frame_to_filter(filter->outputs[out]);
1255
16921
            if (ret < 0)
1256
                return ret;
1257
        }
1258
16923
        if (++out == filter->nb_outputs) {
1259
16908
            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
16906
            progress = 0;
1266
16906
            out = 0;
1267
        }
1268
    }
1269
16920
    ff_filter_set_ready(filter, 200);
1270
16920
    return 0;
1271
}
1272
1273
3174601
static int ff_filter_activate_default(AVFilterContext *filter)
1274
{
1275
    unsigned i;
1276
1277
5033475
    for (i = 0; i < filter->nb_inputs; i++) {
1278
2808559
        if (samples_ready(filter->inputs[i], filter->inputs[i]->min_samples)) {
1279
949685
            return ff_filter_frame_to_filter(filter->inputs[i]);
1280
        }
1281
    }
1282
4066863
    for (i = 0; i < filter->nb_inputs; i++) {
1283

1858869
        if (filter->inputs[i]->status_in && !filter->inputs[i]->status_out) {
1284
            av_assert1(!ff_framequeue_queued_frames(&filter->inputs[i]->fifo));
1285
16922
            return forward_status_change(filter, filter->inputs[i]);
1286
        }
1287
    }
1288
3179010
    for (i = 0; i < filter->nb_outputs; i++) {
1289
2209270
        if (filter->outputs[i]->frame_wanted_out &&
1290
1238568
            !filter->outputs[i]->frame_blocked_in) {
1291
1238254
            return ff_request_frame_to_filter(filter->outputs[i]);
1292
        }
1293
    }
1294
969740
    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
3589527
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
3589527
    filter->ready = 0;
1437
3589527
    ret = filter->filter->activate ? filter->filter->activate(filter) :
1438
3174601
          ff_filter_activate_default(filter);
1439
3589527
    if (ret == FFERROR_NOT_READY)
1440
969750
        ret = 0;
1441
3589527
    return ret;
1442
}
1443
1444
2037644
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1445
{
1446
2037644
    *rpts = link->current_pts;
1447
2037644
    if (ff_framequeue_queued_frames(&link->fifo))
1448
180896
        return *rstatus = 0;
1449
1856748
    if (link->status_out)
1450
4995
        return *rstatus = link->status_out;
1451
1851753
    if (!link->status_in)
1452
1848122
        return *rstatus = 0;
1453
3631
    *rstatus = link->status_out = link->status_in;
1454
3631
    ff_update_link_current_pts(link, link->status_in_pts);
1455
3631
    *rpts = link->current_pts;
1456
3631
    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
3101724
int ff_inlink_check_available_frame(AVFilterLink *link)
1465
{
1466
3101724
    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
304047
int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
1475
{
1476
304047
    uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
1477
    av_assert1(min);
1478

304047
    return samples >= min || (link->status_in && samples);
1479
}
1480
1481
1370476
static void consume_update(AVFilterLink *link, const AVFrame *frame)
1482
{
1483
1370476
    ff_update_link_current_pts(link, frame->pts);
1484
1370476
    ff_inlink_process_commands(link, frame);
1485
1370476
    link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1486
1370476
    link->frame_count_out++;
1487
1370476
}
1488
1489
3101115
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
1490
{
1491
    AVFrame *frame;
1492
1493
3101115
    *rframe = NULL;
1494
3101115
    if (!ff_inlink_check_available_frame(link))
1495
1794589
        return 0;
1496
1497
1306526
    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
1306525
    frame = ff_framequeue_take(&link->fifo);
1503
1306525
    consume_update(link, frame);
1504
1306525
    *rframe = frame;
1505
1306525
    return 1;
1506
}
1507
1508
303399
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
303399
    *rframe = NULL;
1516
303399
    if (!ff_inlink_check_available_samples(link, min))
1517
239448
        return 0;
1518
63951
    if (link->status_in)
1519
99
        min = FFMIN(min, ff_framequeue_queued_samples(&link->fifo));
1520
63951
    ret = take_samples(link, min, max, &frame);
1521
63951
    if (ret < 0)
1522
        return ret;
1523
63951
    consume_update(link, frame);
1524
63951
    *rframe = frame;
1525
63951
    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
2320161
int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
1583
{
1584
2320161
    AVFilterCommand *cmd = link->dst->command_queue;
1585
1586

2320161
    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
2320161
    return 0;
1595
}
1596
1597
2320161
int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
1598
{
1599
2320161
    AVFilterContext *dstctx = link->dst;
1600
2320161
    int64_t pts = frame->pts;
1601
2320161
    int64_t pos = frame->pkt_pos;
1602
1603
2320161
    if (!dstctx->enable_str)
1604
2319965
        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
368308
void ff_inlink_request_frame(AVFilterLink *link)
1616
{
1617
    av_assert1(!link->status_in);
1618
    av_assert1(!link->status_out);
1619
368308
    link->frame_wanted_out = 1;
1620
368308
    ff_filter_set_ready(link->src, 100);
1621
368308
}
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
}