FFmpeg
avfilter.c
Go to the documentation of this file.
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/bprint.h"
25 #include "libavutil/buffer.h"
27 #include "libavutil/common.h"
28 #include "libavutil/eval.h"
29 #include "libavutil/frame.h"
30 #include "libavutil/hwcontext.h"
31 #include "libavutil/internal.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/rational.h"
35 #include "libavutil/samplefmt.h"
36 
37 #include "audio.h"
38 #include "avfilter.h"
39 #include "avfilter_internal.h"
40 #include "filters.h"
41 #include "formats.h"
42 #include "framequeue.h"
43 #include "framepool.h"
44 #include "internal.h"
45 #include "video.h"
46 
47 static void tlog_ref(void *ctx, AVFrame *ref, int end)
48 {
49 #ifdef TRACE
50  ff_tlog(ctx,
51  "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64,
52  ref, ref->buf, ref->data[0],
53  ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
54  ref->pts);
55 
56  if (ref->width) {
57  ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
58  ref->sample_aspect_ratio.num, ref->sample_aspect_ratio.den,
59  ref->width, ref->height,
60  !(ref->flags & AV_FRAME_FLAG_INTERLACED) ? 'P' : /* Progressive */
61  (ref->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 'T' : 'B', /* Top / Bottom */
62  !!(ref->flags & AV_FRAME_FLAG_KEY),
63  av_get_picture_type_char(ref->pict_type));
64  }
65  if (ref->nb_samples) {
66  AVBPrint bprint;
67 
69  av_channel_layout_describe_bprint(&ref->ch_layout, &bprint);
70  ff_tlog(ctx, " cl:%s n:%d r:%d",
71  bprint.str,
72  ref->nb_samples,
73  ref->sample_rate);
74  av_bprint_finalize(&bprint, NULL);
75  }
76 
77  ff_tlog(ctx, "]%s", end ? "\n" : "");
78 #endif
79 }
80 
82 {
83  AVFilterCommand *c= filter->command_queue;
84  av_freep(&c->arg);
85  av_freep(&c->command);
86  filter->command_queue= c->next;
87  av_free(c);
88 }
89 
90 /**
91  * Append a new pad.
92  *
93  * @param count Pointer to the number of pads in the list
94  * @param pads Pointer to the pointer to the beginning of the list of pads
95  * @param links Pointer to the pointer to the beginning of the list of links
96  * @param newpad The new pad to add. A copy is made when adding.
97  * @return >= 0 in case of success, a negative AVERROR code on error
98  */
99 static int append_pad(unsigned *count, AVFilterPad **pads,
100  AVFilterLink ***links, AVFilterPad *newpad)
101 {
102  AVFilterLink **newlinks;
103  AVFilterPad *newpads;
104  unsigned idx = *count;
105 
106  newpads = av_realloc_array(*pads, idx + 1, sizeof(*newpads));
107  newlinks = av_realloc_array(*links, idx + 1, sizeof(*newlinks));
108  if (newpads)
109  *pads = newpads;
110  if (newlinks)
111  *links = newlinks;
112  if (!newpads || !newlinks) {
113  if (newpad->flags & AVFILTERPAD_FLAG_FREE_NAME)
114  av_freep(&newpad->name);
115  return AVERROR(ENOMEM);
116  }
117 
118  memcpy(*pads + idx, newpad, sizeof(AVFilterPad));
119  (*links)[idx] = NULL;
120 
121  (*count)++;
122 
123  return 0;
124 }
125 
127 {
128  return append_pad(&f->nb_inputs, &f->input_pads, &f->inputs, p);
129 }
130 
132 {
134  return ff_append_inpad(f, p);
135 }
136 
138 {
139  return append_pad(&f->nb_outputs, &f->output_pads, &f->outputs, p);
140 }
141 
143 {
145  return ff_append_outpad(f, p);
146 }
147 
148 int avfilter_link(AVFilterContext *src, unsigned srcpad,
149  AVFilterContext *dst, unsigned dstpad)
150 {
151  FilterLinkInternal *li;
153 
154  av_assert0(src->graph);
155  av_assert0(dst->graph);
156  av_assert0(src->graph == dst->graph);
157 
158  if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
159  src->outputs[srcpad] || dst->inputs[dstpad])
160  return AVERROR(EINVAL);
161 
163  av_log(src, AV_LOG_ERROR, "Filters must be initialized before linking.\n");
164  return AVERROR(EINVAL);
165  }
166 
167  if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
169  "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
170  src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),
171  dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));
172  return AVERROR(EINVAL);
173  }
174 
175  li = av_mallocz(sizeof(*li));
176  if (!li)
177  return AVERROR(ENOMEM);
178  link = &li->l;
179 
180  src->outputs[srcpad] = dst->inputs[dstpad] = link;
181 
182  link->src = src;
183  link->dst = dst;
184  link->srcpad = &src->output_pads[srcpad];
185  link->dstpad = &dst->input_pads[dstpad];
186  link->type = src->output_pads[srcpad].type;
188  link->format = -1;
191 
192  return 0;
193 }
194 
196 {
197  FilterLinkInternal *li;
198 
199  if (!*link)
200  return;
201  li = ff_link_internal(*link);
202 
203  ff_framequeue_free(&li->fifo);
205  av_channel_layout_uninit(&(*link)->ch_layout);
206 
207  av_freep(link);
208 }
209 
210 #if FF_API_LINK_PUBLIC
211 void avfilter_link_free(AVFilterLink **link)
212 {
213  link_free(link);
214 }
215 int avfilter_config_links(AVFilterContext *filter)
216 {
218 }
219 #endif
220 
222 {
223  AVFilterLink *const link = &li->l;
224 
225  if (pts == AV_NOPTS_VALUE)
226  return;
227  link->current_pts = pts;
228  link->current_pts_us = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
229  /* TODO use duration */
230  if (link->graph && li->age_index >= 0)
232 }
233 
234 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
235 {
236  filter->ready = FFMAX(filter->ready, priority);
237 }
238 
239 /**
240  * Clear frame_blocked_in on all outputs.
241  * This is necessary whenever something changes on input.
242  */
244 {
245  unsigned i;
246 
247  for (i = 0; i < filter->nb_outputs; i++) {
248  FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
249  li->frame_blocked_in = 0;
250  }
251 }
252 
253 
255 {
257 
258  if (li->status_in == status)
259  return;
260  av_assert0(!li->status_in);
261  li->status_in = status;
262  li->status_in_pts = pts;
263  link->frame_wanted_out = 0;
264  li->frame_blocked_in = 0;
265  filter_unblock(link->dst);
266  ff_filter_set_ready(link->dst, 200);
267 }
268 
269 /**
270  * Set the status field of a link from the destination filter.
271  * The pts should probably be left unset (AV_NOPTS_VALUE).
272  */
273 static void link_set_out_status(AVFilterLink *link, int status, int64_t pts)
274 {
276 
277  av_assert0(!link->frame_wanted_out);
278  av_assert0(!li->status_out);
279  li->status_out = status;
280  if (pts != AV_NOPTS_VALUE)
282  filter_unblock(link->dst);
283  ff_filter_set_ready(link->src, 200);
284 }
285 
287  unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
288 {
289  int ret;
290  unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
291 
292  av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
293  "between the filter '%s' and the filter '%s'\n",
294  filt->name, link->src->name, link->dst->name);
295 
296  link->dst->inputs[dstpad_idx] = NULL;
297  if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {
298  /* failed to link output filter to new filter */
299  link->dst->inputs[dstpad_idx] = link;
300  return ret;
301  }
302 
303  /* re-hookup the link to the new destination filter we inserted */
304  link->dst = filt;
305  link->dstpad = &filt->input_pads[filt_srcpad_idx];
306  filt->inputs[filt_srcpad_idx] = link;
307 
308  /* if any information on supported media formats already exists on the
309  * link, we need to preserve that */
310  if (link->outcfg.formats)
311  ff_formats_changeref(&link->outcfg.formats,
312  &filt->outputs[filt_dstpad_idx]->outcfg.formats);
313  if (link->outcfg.color_spaces)
314  ff_formats_changeref(&link->outcfg.color_spaces,
315  &filt->outputs[filt_dstpad_idx]->outcfg.color_spaces);
316  if (link->outcfg.color_ranges)
317  ff_formats_changeref(&link->outcfg.color_ranges,
318  &filt->outputs[filt_dstpad_idx]->outcfg.color_ranges);
319  if (link->outcfg.samplerates)
320  ff_formats_changeref(&link->outcfg.samplerates,
321  &filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
322  if (link->outcfg.channel_layouts)
323  ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
324  &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
325 
326  return 0;
327 }
328 
330 {
331  int (*config_link)(AVFilterLink *);
332  unsigned i;
333  int ret;
334 
335  for (i = 0; i < filter->nb_inputs; i ++) {
336  AVFilterLink *link = filter->inputs[i];
339 
340  if (!link) continue;
341  if (!link->src || !link->dst) {
343  "Not all input and output are properly linked (%d).\n", i);
344  return AVERROR(EINVAL);
345  }
346 
347  inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
348  link->current_pts =
349  link->current_pts_us = AV_NOPTS_VALUE;
350 
351  switch (li->init_state) {
352  case AVLINK_INIT:
353  continue;
354  case AVLINK_STARTINIT:
355  av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
356  return 0;
357  case AVLINK_UNINIT:
358  li->init_state = AVLINK_STARTINIT;
359 
360  if ((ret = ff_filter_config_links(link->src)) < 0)
361  return ret;
362 
363  if (!(config_link = link->srcpad->config_props)) {
364  if (link->src->nb_inputs != 1) {
365  av_log(link->src, AV_LOG_ERROR, "Source filters and filters "
366  "with more than one input "
367  "must set config_props() "
368  "callbacks on all outputs\n");
369  return AVERROR(EINVAL);
370  }
371  } else if ((ret = config_link(link)) < 0) {
372  av_log(link->src, AV_LOG_ERROR,
373  "Failed to configure output pad on %s\n",
374  link->src->name);
375  return ret;
376  }
377 
378  switch (link->type) {
379  case AVMEDIA_TYPE_VIDEO:
380  if (!link->time_base.num && !link->time_base.den)
381  link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
382 
385  inlink->sample_aspect_ratio : (AVRational){1,1};
386 
387  if (inlink) {
388  if (!link->frame_rate.num && !link->frame_rate.den)
389  link->frame_rate = inlink->frame_rate;
390  if (!link->w)
391  link->w = inlink->w;
392  if (!link->h)
393  link->h = inlink->h;
394  } else if (!link->w || !link->h) {
395  av_log(link->src, AV_LOG_ERROR,
396  "Video source filters must set their output link's "
397  "width and height\n");
398  return AVERROR(EINVAL);
399  }
400  break;
401 
402  case AVMEDIA_TYPE_AUDIO:
403  if (inlink) {
404  if (!link->time_base.num && !link->time_base.den)
405  link->time_base = inlink->time_base;
406  }
407 
408  if (!link->time_base.num && !link->time_base.den)
410  }
411 
412  if (link->src->nb_inputs && link->src->inputs[0]->hw_frames_ctx &&
413  !(link->src->filter->flags_internal & FF_FILTER_FLAG_HWFRAME_AWARE)) {
415  "should not be set by non-hwframe-aware filter");
416  link->hw_frames_ctx = av_buffer_ref(link->src->inputs[0]->hw_frames_ctx);
417  if (!link->hw_frames_ctx)
418  return AVERROR(ENOMEM);
419  }
420 
421  if ((config_link = link->dstpad->config_props))
422  if ((ret = config_link(link)) < 0) {
423  av_log(link->dst, AV_LOG_ERROR,
424  "Failed to configure input pad on %s\n",
425  link->dst->name);
426  return ret;
427  }
428 
429  li->init_state = AVLINK_INIT;
430  }
431  }
432 
433  return 0;
434 }
435 
436 #ifdef TRACE
437 void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
438 {
439  if (link->type == AVMEDIA_TYPE_VIDEO) {
440  ff_tlog(ctx,
441  "link[%p s:%dx%d fmt:%s %s->%s]%s",
442  link, link->w, link->h,
444  link->src ? link->src->filter->name : "",
445  link->dst ? link->dst->filter->name : "",
446  end ? "\n" : "");
447  } else {
448  char buf[128];
449  av_channel_layout_describe(&link->ch_layout, buf, sizeof(buf));
450 
451  ff_tlog(ctx,
452  "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
453  link, (int)link->sample_rate, buf,
455  link->src ? link->src->filter->name : "",
456  link->dst ? link->dst->filter->name : "",
457  end ? "\n" : "");
458  }
459 }
460 #endif
461 
463 {
465 
467 
468  av_assert1(!link->dst->filter->activate);
469  if (li->status_out)
470  return li->status_out;
471  if (li->status_in) {
472  if (ff_framequeue_queued_frames(&li->fifo)) {
473  av_assert1(!link->frame_wanted_out);
474  av_assert1(link->dst->ready >= 300);
475  return 0;
476  } else {
477  /* Acknowledge status change. Filters using ff_request_frame() will
478  handle the change automatically. Filters can also check the
479  status directly but none do yet. */
481  return li->status_out;
482  }
483  }
484  link->frame_wanted_out = 1;
485  ff_filter_set_ready(link->src, 100);
486  return 0;
487 }
488 
489 static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
490 {
491  unsigned i;
492  int64_t r = INT64_MAX;
493 
494  for (i = 0; i < ctx->nb_inputs; i++) {
495  FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
496  if (li->status_out == status)
497  r = FFMIN(r, av_rescale_q(ctx->inputs[i]->current_pts, ctx->inputs[i]->time_base, link_time_base));
498  }
499  if (r < INT64_MAX)
500  return r;
501  av_log(ctx, AV_LOG_WARNING, "EOF timestamp not reliable\n");
502  for (i = 0; i < ctx->nb_inputs; i++) {
503  FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
504  r = FFMIN(r, av_rescale_q(li->status_in_pts, ctx->inputs[i]->time_base, link_time_base));
505  }
506  if (r < INT64_MAX)
507  return r;
508  return AV_NOPTS_VALUE;
509 }
510 
512 {
514  int ret = -1;
515 
516  FF_TPRINTF_START(NULL, request_frame_to_filter); ff_tlog_link(NULL, link, 1);
517  /* Assume the filter is blocked, let the method clear it if not */
518  li->frame_blocked_in = 1;
519  if (link->srcpad->request_frame)
520  ret = link->srcpad->request_frame(link);
521  else if (link->src->inputs[0])
522  ret = ff_request_frame(link->src->inputs[0]);
523  if (ret < 0) {
524  if (ret != AVERROR(EAGAIN) && ret != li->status_in)
526  if (ret == AVERROR_EOF)
527  ret = 0;
528  }
529  return ret;
530 }
531 
532 static const char *const var_names[] = {
533  "t",
534  "n",
535 #if FF_API_FRAME_PKT
536  "pos",
537 #endif
538  "w",
539  "h",
540  NULL
541 };
542 
543 enum {
546 #if FF_API_FRAME_PKT
547  VAR_POS,
548 #endif
552 };
553 
554 static int set_enable_expr(AVFilterContext *ctx, const char *expr)
555 {
556  int ret;
557  char *expr_dup;
558  AVExpr *old = ctx->enable;
559 
560  if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) {
561  av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
562  "with filter '%s'\n", ctx->filter->name);
563  return AVERROR_PATCHWELCOME;
564  }
565 
566  expr_dup = av_strdup(expr);
567  if (!expr_dup)
568  return AVERROR(ENOMEM);
569 
570  if (!ctx->var_values) {
571  ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values));
572  if (!ctx->var_values) {
573  av_free(expr_dup);
574  return AVERROR(ENOMEM);
575  }
576  }
577 
578  ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names,
579  NULL, NULL, NULL, NULL, 0, ctx->priv);
580  if (ret < 0) {
581  av_log(ctx->priv, AV_LOG_ERROR,
582  "Error when evaluating the expression '%s' for enable\n",
583  expr_dup);
584  av_free(expr_dup);
585  return ret;
586  }
587 
588  av_expr_free(old);
589  av_free(ctx->enable_str);
590  ctx->enable_str = expr_dup;
591  return 0;
592 }
593 
594 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
595 {
596  if(!strcmp(cmd, "ping")){
597  char local_res[256] = {0};
598 
599  if (!res) {
600  res = local_res;
601  res_len = sizeof(local_res);
602  }
603  av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
604  if (res == local_res)
605  av_log(filter, AV_LOG_INFO, "%s", res);
606  return 0;
607  }else if(!strcmp(cmd, "enable")) {
608  return set_enable_expr(filter, arg);
609  }else if(filter->filter->process_command) {
610  return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);
611  }
612  return AVERROR(ENOSYS);
613 }
614 
615 unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
616 {
617  return is_output ? filter->nb_outputs : filter->nb_inputs;
618 }
619 
620 static const char *default_filter_name(void *filter_ctx)
621 {
623  return ctx->name ? ctx->name : ctx->filter->name;
624 }
625 
626 static void *filter_child_next(void *obj, void *prev)
627 {
628  AVFilterContext *ctx = obj;
629  if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
630  return ctx->priv;
631  return NULL;
632 }
633 
634 static const AVClass *filter_child_class_iterate(void **iter)
635 {
636  const AVFilter *f;
637 
638  while ((f = av_filter_iterate(iter)))
639  if (f->priv_class)
640  return f->priv_class;
641 
642  return NULL;
643 }
644 
645 #define OFFSET(x) offsetof(AVFilterContext, x)
646 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
647 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
648 static const AVOption avfilter_options[] = {
649  { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
650  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, .unit = "thread_type" },
651  { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
652  { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = TFLAGS },
653  { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
654  { .i64 = 0 }, 0, INT_MAX, FLAGS },
655  { "extra_hw_frames", "Number of extra hardware frames to allocate for the user",
656  OFFSET(extra_hw_frames), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
657  { NULL },
658 };
659 
660 static const AVClass avfilter_class = {
661  .class_name = "AVFilter",
662  .item_name = default_filter_name,
663  .version = LIBAVUTIL_VERSION_INT,
664  .category = AV_CLASS_CATEGORY_FILTER,
665  .child_next = filter_child_next,
666  .child_class_iterate = filter_child_class_iterate,
668 };
669 
671  int *ret, int nb_jobs)
672 {
673  int i;
674 
675  for (i = 0; i < nb_jobs; i++) {
676  int r = func(ctx, arg, i, nb_jobs);
677  if (ret)
678  ret[i] = r;
679  }
680  return 0;
681 }
682 
683 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
684 {
687  int preinited = 0;
688 
689  if (!filter)
690  return NULL;
691 
692  ctx = av_mallocz(sizeof(*ctx));
693  if (!ctx)
694  return NULL;
695  ret = &ctx->p;
696 
697  ret->av_class = &avfilter_class;
698  ret->filter = filter;
699  ret->name = inst_name ? av_strdup(inst_name) : NULL;
700  if (filter->priv_size) {
701  ret->priv = av_mallocz(filter->priv_size);
702  if (!ret->priv)
703  goto err;
704  }
705  if (filter->preinit) {
706  if (filter->preinit(ret) < 0)
707  goto err;
708  preinited = 1;
709  }
710 
712  if (filter->priv_class) {
713  *(const AVClass**)ret->priv = filter->priv_class;
714  av_opt_set_defaults(ret->priv);
715  }
716 
717  ctx->execute = default_execute;
718 
719  ret->nb_inputs = filter->nb_inputs;
720  if (ret->nb_inputs ) {
721  ret->input_pads = av_memdup(filter->inputs, ret->nb_inputs * sizeof(*filter->inputs));
722  if (!ret->input_pads)
723  goto err;
724  ret->inputs = av_calloc(ret->nb_inputs, sizeof(*ret->inputs));
725  if (!ret->inputs)
726  goto err;
727  }
728 
729  ret->nb_outputs = filter->nb_outputs;
730  if (ret->nb_outputs) {
731  ret->output_pads = av_memdup(filter->outputs, ret->nb_outputs * sizeof(*filter->outputs));
732  if (!ret->output_pads)
733  goto err;
734  ret->outputs = av_calloc(ret->nb_outputs, sizeof(*ret->outputs));
735  if (!ret->outputs)
736  goto err;
737  }
738 
739  return ret;
740 
741 err:
742  if (preinited)
743  filter->uninit(ret);
744  av_freep(&ret->inputs);
745  av_freep(&ret->input_pads);
746  ret->nb_inputs = 0;
747  av_freep(&ret->outputs);
748  av_freep(&ret->output_pads);
749  ret->nb_outputs = 0;
750  av_freep(&ret->priv);
751  av_free(ret);
752  return NULL;
753 }
754 
756 {
757  if (!link)
758  return;
759 
760  if (link->src)
761  link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
762  if (link->dst)
763  link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
764 
766 
767  ff_formats_unref(&link->incfg.formats);
768  ff_formats_unref(&link->outcfg.formats);
769  ff_formats_unref(&link->incfg.color_spaces);
770  ff_formats_unref(&link->outcfg.color_spaces);
771  ff_formats_unref(&link->incfg.color_ranges);
772  ff_formats_unref(&link->outcfg.color_ranges);
773  ff_formats_unref(&link->incfg.samplerates);
774  ff_formats_unref(&link->outcfg.samplerates);
775  ff_channel_layouts_unref(&link->incfg.channel_layouts);
776  ff_channel_layouts_unref(&link->outcfg.channel_layouts);
777  link_free(&link);
778 }
779 
781 {
782  int i;
783 
784  if (!filter)
785  return;
786 
787  if (filter->graph)
789 
790  if (filter->filter->uninit)
791  filter->filter->uninit(filter);
792 
793  for (i = 0; i < filter->nb_inputs; i++) {
794  free_link(filter->inputs[i]);
795  if (filter->input_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
796  av_freep(&filter->input_pads[i].name);
797  }
798  for (i = 0; i < filter->nb_outputs; i++) {
799  free_link(filter->outputs[i]);
800  if (filter->output_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
801  av_freep(&filter->output_pads[i].name);
802  }
803 
804  if (filter->filter->priv_class)
805  av_opt_free(filter->priv);
806 
807  av_buffer_unref(&filter->hw_device_ctx);
808 
809  av_freep(&filter->name);
810  av_freep(&filter->input_pads);
811  av_freep(&filter->output_pads);
812  av_freep(&filter->inputs);
813  av_freep(&filter->outputs);
814  av_freep(&filter->priv);
815  while(filter->command_queue){
817  }
819  av_expr_free(filter->enable);
820  filter->enable = NULL;
821  av_freep(&filter->var_values);
822  av_free(filter);
823 }
824 
826 {
827  if (ctx->nb_threads > 0)
828  return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
829  return ctx->graph->nb_threads;
830 }
831 
832 int ff_filter_opt_parse(void *logctx, const AVClass *priv_class,
833  AVDictionary **options, const char *args)
834 {
835  const AVOption *o = NULL;
836  int ret;
837  char *av_uninit(parsed_key), *av_uninit(value);
838  const char *key;
839  int offset= -1;
840 
841  if (!args)
842  return 0;
843 
844  while (*args) {
845  const char *shorthand = NULL;
846 
847  if (priv_class)
848  o = av_opt_next(&priv_class, o);
849  if (o) {
850  if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
851  continue;
852  offset = o->offset;
853  shorthand = o->name;
854  }
855 
856  ret = av_opt_get_key_value(&args, "=", ":",
857  shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
858  &parsed_key, &value);
859  if (ret < 0) {
860  if (ret == AVERROR(EINVAL))
861  av_log(logctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
862  else
863  av_log(logctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
864  av_err2str(ret));
865  return ret;
866  }
867  if (*args)
868  args++;
869  if (parsed_key) {
870  key = parsed_key;
871 
872  /* discard all remaining shorthand */
873  if (priv_class)
874  while ((o = av_opt_next(&priv_class, o)));
875  } else {
876  key = shorthand;
877  }
878 
879  av_log(logctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
880 
882 
883  av_free(value);
884  av_free(parsed_key);
885  }
886 
887  return 0;
888 }
889 
891  const char *arg, char *res, int res_len, int flags)
892 {
893  const AVOption *o;
894 
895  if (!ctx->filter->priv_class)
896  return 0;
898  if (!o)
899  return AVERROR(ENOSYS);
900  return av_opt_set(ctx->priv, cmd, arg, 0);
901 }
902 
904 {
906  int ret = 0;
907 
908  if (ctxi->initialized) {
909  av_log(ctx, AV_LOG_ERROR, "Filter already initialized\n");
910  return AVERROR(EINVAL);
911  }
912 
914  if (ret < 0) {
915  av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
916  return ret;
917  }
918 
919  if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
920  ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
921  fffiltergraph(ctx->graph)->thread_execute) {
922  ctx->thread_type = AVFILTER_THREAD_SLICE;
923  ctxi->execute = fffiltergraph(ctx->graph)->thread_execute;
924  } else {
925  ctx->thread_type = 0;
926  }
927 
928  if (ctx->filter->init)
929  ret = ctx->filter->init(ctx);
930  if (ret < 0)
931  return ret;
932 
933  if (ctx->enable_str) {
934  ret = set_enable_expr(ctx, ctx->enable_str);
935  if (ret < 0)
936  return ret;
937  }
938 
939  ctxi->initialized = 1;
940 
941  return 0;
942 }
943 
944 int avfilter_init_str(AVFilterContext *filter, const char *args)
945 {
948  int ret = 0;
949 
950  if (args && *args) {
951  ret = ff_filter_opt_parse(filter, filter->filter->priv_class, &options, args);
952  if (ret < 0)
953  goto fail;
954  }
955 
957  if (ret < 0)
958  goto fail;
959 
960  if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
961  av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
963  goto fail;
964  }
965 
966 fail:
968 
969  return ret;
970 }
971 
972 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
973 {
974  return pads[pad_idx].name;
975 }
976 
977 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
978 {
979  return pads[pad_idx].type;
980 }
981 
983 {
984  return ff_filter_frame(link->dst->outputs[0], frame);
985 }
986 
988 {
990  AVFilterContext *dstctx = link->dst;
991  AVFilterPad *dst = link->dstpad;
992  int ret;
993 
994  if (!(filter_frame = dst->filter_frame))
996 
999  if (ret < 0)
1000  goto fail;
1001  }
1002 
1005 
1006  if (dstctx->is_disabled &&
1009  ret = filter_frame(link, frame);
1010  link->frame_count_out++;
1011  return ret;
1012 
1013 fail:
1014  av_frame_free(&frame);
1015  return ret;
1016 }
1017 
1019 {
1021  int ret;
1023 
1024  /* Consistency checks */
1025  if (link->type == AVMEDIA_TYPE_VIDEO) {
1026  if (strcmp(link->dst->filter->name, "buffersink") &&
1027  strcmp(link->dst->filter->name, "format") &&
1028  strcmp(link->dst->filter->name, "idet") &&
1029  strcmp(link->dst->filter->name, "null") &&
1030  strcmp(link->dst->filter->name, "scale")) {
1032  av_assert1(frame->width == link->w);
1033  av_assert1(frame->height == link->h);
1034  }
1035 
1037  } else {
1038  if (frame->format != link->format) {
1039  av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1040  goto error;
1041  }
1043  av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1044  goto error;
1045  }
1046  if (frame->sample_rate != link->sample_rate) {
1047  av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1048  goto error;
1049  }
1050 
1051  frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate },
1052  link->time_base);
1053  }
1054 
1055  li->frame_blocked_in = link->frame_wanted_out = 0;
1056  link->frame_count_in++;
1057  link->sample_count_in += frame->nb_samples;
1058  filter_unblock(link->dst);
1059  ret = ff_framequeue_add(&li->fifo, frame);
1060  if (ret < 0) {
1061  av_frame_free(&frame);
1062  return ret;
1063  }
1064  ff_filter_set_ready(link->dst, 300);
1065  return 0;
1066 
1067 error:
1068  av_frame_free(&frame);
1069  return AVERROR_PATCHWELCOME;
1070 }
1071 
1073 {
1074  return ff_framequeue_queued_frames(&link->fifo) &&
1075  (ff_framequeue_queued_samples(&link->fifo) >= min ||
1076  link->status_in);
1077 }
1078 
1079 static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max,
1080  AVFrame **rframe)
1081 {
1082  AVFilterLink *link = &li->l;
1083  AVFrame *frame0, *frame, *buf;
1084  unsigned nb_samples, nb_frames, i, p;
1085  int ret;
1086 
1087  /* Note: this function relies on no format changes and must only be
1088  called with enough samples. */
1089  av_assert1(samples_ready(li, link->min_samples));
1090  frame0 = frame = ff_framequeue_peek(&li->fifo, 0);
1091  if (!li->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1092  *rframe = ff_framequeue_take(&li->fifo);
1093  return 0;
1094  }
1095  nb_frames = 0;
1096  nb_samples = 0;
1097  while (1) {
1098  if (nb_samples + frame->nb_samples > max) {
1099  if (nb_samples < min)
1100  nb_samples = max;
1101  break;
1102  }
1103  nb_samples += frame->nb_samples;
1104  nb_frames++;
1105  if (nb_frames == ff_framequeue_queued_frames(&li->fifo))
1106  break;
1107  frame = ff_framequeue_peek(&li->fifo, nb_frames);
1108  }
1109 
1110  buf = ff_get_audio_buffer(link, nb_samples);
1111  if (!buf)
1112  return AVERROR(ENOMEM);
1113  ret = av_frame_copy_props(buf, frame0);
1114  if (ret < 0) {
1115  av_frame_free(&buf);
1116  return ret;
1117  }
1118 
1119  p = 0;
1120  for (i = 0; i < nb_frames; i++) {
1121  frame = ff_framequeue_take(&li->fifo);
1124  p += frame->nb_samples;
1125  av_frame_free(&frame);
1126  }
1127  if (p < nb_samples) {
1128  unsigned n = nb_samples - p;
1129  frame = ff_framequeue_peek(&li->fifo, 0);
1133  }
1134 
1135  *rframe = buf;
1136  return 0;
1137 }
1138 
1140 {
1142  AVFrame *frame = NULL;
1143  AVFilterContext *dst = link->dst;
1144  int ret;
1145 
1147  ret = link->min_samples ?
1148  ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1150  av_assert1(ret);
1151  if (ret < 0) {
1152  av_assert1(!frame);
1153  return ret;
1154  }
1155  /* The filter will soon have received a new frame, that may allow it to
1156  produce one or more: unblock its outputs. */
1157  filter_unblock(dst);
1158  /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1159  before the frame; ff_filter_frame_framed() will re-increment it. */
1160  link->frame_count_out--;
1162  if (ret < 0 && ret != li->status_out) {
1164  } else {
1165  /* Run once again, to see if several frames were available, or if
1166  the input status has also changed, or any other reason. */
1167  ff_filter_set_ready(dst, 300);
1168  }
1169  return ret;
1170 }
1171 
1173 {
1174  AVFilterLink *in = &li_in->l;
1175  unsigned out = 0, progress = 0;
1176  int ret;
1177 
1178  av_assert0(!li_in->status_out);
1179  if (!filter->nb_outputs) {
1180  /* not necessary with the current API and sinks */
1181  return 0;
1182  }
1183  while (!li_in->status_out) {
1184  FilterLinkInternal *li_out = ff_link_internal(filter->outputs[out]);
1185 
1186  if (!li_out->status_in) {
1187  progress++;
1189  if (ret < 0)
1190  return ret;
1191  }
1192  if (++out == filter->nb_outputs) {
1193  if (!progress) {
1194  /* Every output already closed: input no longer interesting
1195  (example: overlay in shortest mode, other input closed). */
1196  link_set_out_status(in, li_in->status_in, li_in->status_in_pts);
1197  return 0;
1198  }
1199  progress = 0;
1200  out = 0;
1201  }
1202  }
1204  return 0;
1205 }
1206 
1208 {
1209  unsigned i;
1210 
1211  for (i = 0; i < filter->nb_outputs; i++) {
1212  FilterLinkInternal *li = ff_link_internal(filter->outputs[i]);
1213  int ret = li->status_in;
1214 
1215  if (ret) {
1216  for (int j = 0; j < filter->nb_inputs; j++)
1217  ff_inlink_set_status(filter->inputs[j], ret);
1218  return 0;
1219  }
1220  }
1221 
1222  for (i = 0; i < filter->nb_inputs; i++) {
1223  if (samples_ready(ff_link_internal(filter->inputs[i]),
1224  filter->inputs[i]->min_samples)) {
1225  return ff_filter_frame_to_filter(filter->inputs[i]);
1226  }
1227  }
1228  for (i = 0; i < filter->nb_inputs; i++) {
1229  FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]);
1230  if (li->status_in && !li->status_out) {
1232  return forward_status_change(filter, li);
1233  }
1234  }
1235  for (i = 0; i < filter->nb_outputs; i++) {
1236  FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1237  if (filter->outputs[i]->frame_wanted_out &&
1238  !li->frame_blocked_in) {
1239  return ff_request_frame_to_filter(filter->outputs[i]);
1240  }
1241  }
1242  return FFERROR_NOT_READY;
1243 }
1244 
1245 /*
1246  Filter scheduling and activation
1247 
1248  When a filter is activated, it must:
1249  - if possible, output a frame;
1250  - else, if relevant, forward the input status change;
1251  - else, check outputs for wanted frames and forward the requests.
1252 
1253  The following AVFilterLink fields are used for activation:
1254 
1255  - frame_wanted_out:
1256 
1257  This field indicates if a frame is needed on this input of the
1258  destination filter. A positive value indicates that a frame is needed
1259  to process queued frames or internal data or to satisfy the
1260  application; a zero value indicates that a frame is not especially
1261  needed but could be processed anyway; a negative value indicates that a
1262  frame would just be queued.
1263 
1264  It is set by filters using ff_request_frame() or ff_request_no_frame(),
1265  when requested by the application through a specific API or when it is
1266  set on one of the outputs.
1267 
1268  It is cleared when a frame is sent from the source using
1269  ff_filter_frame().
1270 
1271  It is also cleared when a status change is sent from the source using
1272  ff_avfilter_link_set_in_status().
1273 
1274  - frame_blocked_in:
1275 
1276  This field means that the source filter can not generate a frame as is.
1277  Its goal is to avoid repeatedly calling the request_frame() method on
1278  the same link.
1279 
1280  It is set by the framework on all outputs of a filter before activating it.
1281 
1282  It is automatically cleared by ff_filter_frame().
1283 
1284  It is also automatically cleared by ff_avfilter_link_set_in_status().
1285 
1286  It is also cleared on all outputs (using filter_unblock()) when
1287  something happens on an input: processing a frame or changing the
1288  status.
1289 
1290  - fifo:
1291 
1292  Contains the frames queued on a filter input. If it contains frames and
1293  frame_wanted_out is not set, then the filter can be activated. If that
1294  result in the filter not able to use these frames, the filter must set
1295  frame_wanted_out to ask for more frames.
1296 
1297  - status_in and status_in_pts:
1298 
1299  Status (EOF or error code) of the link and timestamp of the status
1300  change (in link time base, same as frames) as seen from the input of
1301  the link. The status change is considered happening after the frames
1302  queued in fifo.
1303 
1304  It is set by the source filter using ff_avfilter_link_set_in_status().
1305 
1306  - status_out:
1307 
1308  Status of the link as seen from the output of the link. The status
1309  change is considered having already happened.
1310 
1311  It is set by the destination filter using
1312  link_set_out_status().
1313 
1314  Filters are activated according to the ready field, set using the
1315  ff_filter_set_ready(). Eventually, a priority queue will be used.
1316  ff_filter_set_ready() is called whenever anything could cause progress to
1317  be possible. Marking a filter ready when it is not is not a problem,
1318  except for the small overhead it causes.
1319 
1320  Conditions that cause a filter to be marked ready are:
1321 
1322  - frames added on an input link;
1323 
1324  - changes in the input or output status of an input link;
1325 
1326  - requests for a frame on an output link;
1327 
1328  - after any actual processing using the legacy methods (filter_frame(),
1329  and request_frame() to acknowledge status changes), to run once more
1330  and check if enough input was present for several frames.
1331 
1332  Examples of scenarios to consider:
1333 
1334  - buffersrc: activate if frame_wanted_out to notify the application;
1335  activate when the application adds a frame to push it immediately.
1336 
1337  - testsrc: activate only if frame_wanted_out to produce and push a frame.
1338 
1339  - concat (not at stitch points): can process a frame on any output.
1340  Activate if frame_wanted_out on output to forward on the corresponding
1341  input. Activate when a frame is present on input to process it
1342  immediately.
1343 
1344  - framesync: needs at least one frame on each input; extra frames on the
1345  wrong input will accumulate. When a frame is first added on one input,
1346  set frame_wanted_out<0 on it to avoid getting more (would trigger
1347  testsrc) and frame_wanted_out>0 on the other to allow processing it.
1348 
1349  Activation of old filters:
1350 
1351  In order to activate a filter implementing the legacy filter_frame() and
1352  request_frame() methods, perform the first possible of the following
1353  actions:
1354 
1355  - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1356  frame and call filter_frame().
1357 
1358  Rationale: filter frames as soon as possible instead of leaving them
1359  queued; frame_wanted_out < 0 is not possible since the old API does not
1360  set it nor provides any similar feedback; frame_wanted_out > 0 happens
1361  when min_samples > 0 and there are not enough samples queued.
1362 
1363  - If an input has status_in set but not status_out, try to call
1364  request_frame() on one of the outputs in the hope that it will trigger
1365  request_frame() on the input with status_in and acknowledge it. This is
1366  awkward and fragile, filters with several inputs or outputs should be
1367  updated to direct activation as soon as possible.
1368 
1369  - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1370  request_frame().
1371 
1372  Rationale: checking frame_blocked_in is necessary to avoid requesting
1373  repeatedly on a blocked input if another is not blocked (example:
1374  [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1375  */
1376 
1378 {
1379  int ret;
1380 
1381  /* Generic timeline support is not yet implemented but should be easy */
1383  filter->filter->activate));
1384  filter->ready = 0;
1385  ret = filter->filter->activate ? filter->filter->activate(filter) :
1387  if (ret == FFERROR_NOT_READY)
1388  ret = 0;
1389  return ret;
1390 }
1391 
1392 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1393 {
1395  *rpts = link->current_pts;
1397  return *rstatus = 0;
1398  if (li->status_out)
1399  return *rstatus = li->status_out;
1400  if (!li->status_in)
1401  return *rstatus = 0;
1402  *rstatus = li->status_out = li->status_in;
1404  *rpts = link->current_pts;
1405  return 1;
1406 }
1407 
1409 {
1411  return ff_framequeue_queued_frames(&li->fifo);
1412 }
1413 
1415 {
1417  return ff_framequeue_queued_frames(&li->fifo) > 0;
1418 }
1419 
1421 {
1423  return ff_framequeue_queued_samples(&li->fifo);
1424 }
1425 
1427 {
1429  uint64_t samples = ff_framequeue_queued_samples(&li->fifo);
1430  av_assert1(min);
1431  return samples >= min || (li->status_in && samples);
1432 }
1433 
1435 {
1436  AVFilterLink *const link = &li->l;
1439  if (link == link->dst->inputs[0])
1440  link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1441  link->frame_count_out++;
1442  link->sample_count_out += frame->nb_samples;
1443 }
1444 
1446 {
1448  AVFrame *frame;
1449 
1450  *rframe = NULL;
1452  return 0;
1453 
1454  if (li->fifo.samples_skipped) {
1455  frame = ff_framequeue_peek(&li->fifo, 0);
1457  }
1458 
1459  frame = ff_framequeue_take(&li->fifo);
1460  consume_update(li, frame);
1461  *rframe = frame;
1462  return 1;
1463 }
1464 
1466  AVFrame **rframe)
1467 {
1469  AVFrame *frame;
1470  int ret;
1471 
1472  av_assert1(min);
1473  *rframe = NULL;
1475  return 0;
1476  if (li->status_in)
1478  ret = take_samples(li, min, max, &frame);
1479  if (ret < 0)
1480  return ret;
1481  consume_update(li, frame);
1482  *rframe = frame;
1483  return 1;
1484 }
1485 
1487 {
1489  return ff_framequeue_peek(&li->fifo, idx);
1490 }
1491 
1493 {
1494  AVFrame *frame = *rframe;
1495  AVFrame *out;
1496  int ret;
1497 
1499  return 0;
1500  av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1501 
1502  switch (link->type) {
1503  case AVMEDIA_TYPE_VIDEO:
1504  out = ff_get_video_buffer(link, link->w, link->h);
1505  break;
1506  case AVMEDIA_TYPE_AUDIO:
1508  break;
1509  default:
1510  return AVERROR(EINVAL);
1511  }
1512  if (!out)
1513  return AVERROR(ENOMEM);
1514 
1516  if (ret < 0) {
1517  av_frame_free(&out);
1518  return ret;
1519  }
1520 
1521  ret = av_frame_copy(out, frame);
1522  if (ret < 0) {
1523  av_frame_free(&out);
1524  return ret;
1525  }
1526 
1527  av_frame_free(&frame);
1528  *rframe = out;
1529  return 0;
1530 }
1531 
1533 {
1534  AVFilterCommand *cmd = link->dst->command_queue;
1535 
1536  while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1537  av_log(link->dst, AV_LOG_DEBUG,
1538  "Processing command time:%f command:%s arg:%s\n",
1539  cmd->time, cmd->command, cmd->arg);
1540  avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1541  command_queue_pop(link->dst);
1542  cmd= link->dst->command_queue;
1543  }
1544  return 0;
1545 }
1546 
1548 {
1549  AVFilterContext *dstctx = link->dst;
1550  int64_t pts = frame->pts;
1551 #if FF_API_FRAME_PKT
1553  int64_t pos = frame->pkt_pos;
1555 #endif
1556 
1557  if (!dstctx->enable_str)
1558  return 1;
1559 
1560  dstctx->var_values[VAR_N] = link->frame_count_out;
1561  dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1562  dstctx->var_values[VAR_W] = link->w;
1563  dstctx->var_values[VAR_H] = link->h;
1564 #if FF_API_FRAME_PKT
1565  dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1566 #endif
1567 
1568  return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
1569 }
1570 
1572 {
1574  av_assert1(!li->status_in);
1575  av_assert1(!li->status_out);
1576  link->frame_wanted_out = 1;
1577  ff_filter_set_ready(link->src, 100);
1578 }
1579 
1581 {
1583  if (li->status_out)
1584  return;
1585  link->frame_wanted_out = 0;
1586  li->frame_blocked_in = 0;
1588  while (ff_framequeue_queued_frames(&li->fifo)) {
1590  av_frame_free(&frame);
1591  }
1592  if (!li->status_in)
1593  li->status_in = status;
1594 }
1595 
1597 {
1599  return li->status_in;
1600 }
1601 
1603 {
1604  FilterLinkInternal * const li_in = ff_link_internal(inlink);
1605  return ff_outlink_frame_wanted(outlink) ||
1607  li_in->status_out;
1608 }
1609 
1610 
1612 {
1613  return &avfilter_class;
1614 }
1615 
1617  int default_pool_size)
1618 {
1620 
1621  // Must already be set by caller.
1623 
1625 
1626  if (frames->initial_pool_size == 0) {
1627  // Dynamic allocation is necessarily supported.
1628  } else if (avctx->extra_hw_frames >= 0) {
1629  frames->initial_pool_size += avctx->extra_hw_frames;
1630  } else {
1631  frames->initial_pool_size = default_pool_size;
1632  }
1633 
1634  return 0;
1635 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:522
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:112
func
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:68
av_samples_copy
int av_samples_copy(uint8_t *const *dst, uint8_t *const *src, int dst_offset, int src_offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Copy samples from src to dst.
Definition: samplefmt.c:222
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:97
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
avfilter_filter_pad_count
unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
Get the number of elements in an AVFilter's inputs or outputs array.
Definition: avfilter.c:615
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1638
ff_link_internal
static FilterLinkInternal * ff_link_internal(AVFilterLink *link)
Definition: avfilter_internal.h:82
r
const char * r
Definition: vf_curves.c:126
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
filter_child_class_iterate
static const AVClass * filter_child_class_iterate(void **iter)
Definition: avfilter.c:634
avfilter_pad_get_name
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
Definition: avfilter.c:972
out
FILE * out
Definition: movenc.c:54
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
FF_FILTER_FLAG_HWFRAME_AWARE
#define FF_FILTER_FLAG_HWFRAME_AWARE
The filter is aware of hardware frames, and any hardware frame context should not be automatically pr...
Definition: internal.h:351
update_link_current_pts
static void update_link_current_pts(FilterLinkInternal *li, int64_t pts)
Definition: avfilter.c:221
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1018
ff_filter_opt_parse
int ff_filter_opt_parse(void *logctx, const AVClass *priv_class, AVDictionary **options, const char *args)
Parse filter options into a dictionary.
Definition: avfilter.c:832
avfilter_action_func
int() avfilter_action_func(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
A function pointer passed to the AVFilterGraph::execute callback to be executed multiple times,...
Definition: avfilter.h:796
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:746
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
AVFilterContext::var_values
double * var_values
variable values for the enable expression
Definition: avfilter.h:455
rational.h
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_unused
#define av_unused
Definition: attributes.h:131
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:88
AVFilterContext::is_disabled
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:456
ff_filter_activate
int ff_filter_activate(AVFilterContext *filter)
Definition: avfilter.c:1377
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:630
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
free_link
static void free_link(AVFilterLink *link)
Definition: avfilter.c:755
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
link_free
static void link_free(AVFilterLink **link)
Definition: avfilter.c:195
AVFrame::width
int width
Definition: frame.h:412
command_queue_pop
static void command_queue_pop(AVFilterContext *filter)
Definition: avfilter.c:81
AVOption
AVOption.
Definition: opt.h:346
av_opt_find2
const AVOption * av_opt_find2(void *obj, const char *name, const char *unit, int opt_flags, int search_flags, void **target_obj)
Look for an option in an object.
Definition: opt.c:1956
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:462
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
max
#define max(a, b)
Definition: cuda_runtime.h:33
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
AVDictionary
Definition: dict.c:34
ff_framequeue_init
void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg)
Init a frame queue and attach it to a global structure.
Definition: framequeue.c:47
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
default_filter_name
static const char * default_filter_name(void *filter_ctx)
Definition: avfilter.c:620
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
video.h
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
ff_filter_alloc
AVFilterContext * ff_filter_alloc(const AVFilter *filter, const char *inst_name)
Allocate a new filter context and return it.
Definition: avfilter.c:683
av_channel_layout_describe_bprint
int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout, AVBPrint *bp)
bprint variant of av_channel_layout_describe().
Definition: channel_layout.c:590
ff_inoutlink_check_flow
int ff_inoutlink_check_flow(AVFilterLink *inlink, AVFilterLink *outlink)
Check for flow control between input and output.
Definition: avfilter.c:1602
FilterLinkInternal
Definition: avfilter_internal.h:33
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:604
formats.h
av_expr_parse
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:711
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:302
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1445
ff_framequeue_skip_samples
void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t samples, AVRational time_base)
Skip samples from the first frame in the queue.
Definition: framequeue.c:125
ff_append_inpad
int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
Append a new input/output pad to the filter's list of such pads.
Definition: avfilter.c:126
VAR_W
@ VAR_W
Definition: avfilter.c:549
AVFilterContext::graph
struct AVFilterGraph * graph
filtergraph this filter belongs to
Definition: avfilter.h:424
fail
#define fail()
Definition: checkasm.h:179
AVOption::offset
int offset
Native access only.
Definition: opt.h:361
av_opt_get_key_value
int av_opt_get_key_value(const char **ropts, const char *key_val_sep, const char *pairs_sep, unsigned flags, char **rkey, char **rval)
Extract a key-value pair from the beginning of a string.
Definition: opt.c:1834
AVFilterContext::enable_str
char * enable_str
enable expression string
Definition: avfilter.h:453
AVFilterCommand::flags
int flags
Definition: avfilter_internal.h:91
frames
if it could not because there are no more frames
Definition: filter_design.txt:266
avfilter_insert_filter
int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
Insert a filter in the middle of an existing link.
Definition: avfilter.c:286
av_filter_iterate
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:618
samplefmt.h
take_samples
static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max, AVFrame **rframe)
Definition: avfilter.c:1079
AVFilterContext::extra_hw_frames
int extra_hw_frames
Sets the number of extra hardware frames which the filter will allocate on its output links for use i...
Definition: avfilter.h:492
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1908
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:63
filter_ctx
static FilteringContext * filter_ctx
Definition: transcode.c:51
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:741
pts
static int64_t pts
Definition: transcode_aac.c:643
AVFILTER_THREAD_SLICE
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
Definition: avfilter.h:404
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:738
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:359
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
ff_filter_config_links
int ff_filter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
Definition: avfilter.c:329
FFFrameQueue::samples_skipped
int samples_skipped
Indicate that samples are skipped.
Definition: framequeue.h:106
AVFilterContext::input_pads
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:414
avassert.h
FFFilterGraph::thread_execute
avfilter_execute_func * thread_execute
Definition: avfilter_internal.h:107
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_inlink_check_available_samples
int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
Test if enough samples are available on the link.
Definition: avfilter.c:1426
FFFilterContext::initialized
int initialized
Definition: internal.h:126
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:591
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:644
ff_request_frame_to_filter
static int ff_request_frame_to_filter(AVFilterLink *link)
Definition: avfilter.c:511
initialized
static int initialized
Definition: vaapi_transcode.c:43
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1571
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:215
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1406
avfilter_process_command
int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
Make the filter instance process a command.
Definition: avfilter.c:594
AVDictionaryEntry::key
char * key
Definition: dict.h:90
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
filters.h
AVFilter::flags
int flags
A combination of AVFILTER_FLAG_*.
Definition: avfilter.h:210
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:793
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVExpr
Definition: eval.c:159
av_get_sample_fmt_name
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:51
key
const char * key
Definition: hwcontext_opencl.c:189
ff_filter_frame_to_filter
static int ff_filter_frame_to_filter(AVFilterLink *link)
Definition: avfilter.c:1139
NAN
#define NAN
Definition: mathematics.h:115
link
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
Definition: filter_design.txt:23
frame
static AVFrame * frame
Definition: demux_decode.c:54
ff_framequeue_take
AVFrame * ff_framequeue_take(FFFrameQueue *fq)
Take the first frame in the queue.
Definition: framequeue.c:97
ff_inlink_make_frame_writable
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
Definition: avfilter.c:1492
arg
const char * arg
Definition: jacosubdec.c:67
if
if(ret)
Definition: filter_design.txt:179
ff_formats_changeref
void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
Definition: formats.c:753
ff_inlink_peek_frame
AVFrame * ff_inlink_peek_frame(AVFilterLink *link, size_t idx)
Access a frame in the link fifo without consuming it.
Definition: avfilter.c:1486
ff_avfilter_graph_update_heap
void ff_avfilter_graph_update_heap(AVFilterGraph *graph, struct FilterLinkInternal *li)
Update the position of a link in the age heap.
Definition: avfiltergraph.c:1441
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
filter_unblock
static void filter_unblock(AVFilterContext *filter)
Clear frame_blocked_in on all outputs.
Definition: avfilter.c:243
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
ff_inlink_consume_samples
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
Definition: avfilter.c:1465
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:637
VAR_POS
@ VAR_POS
Definition: noise.c:55
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AV_DICT_MULTIKEY
#define AV_DICT_MULTIKEY
Allow to store several equal keys in the dictionary.
Definition: dict.h:84
consume_update
static void consume_update(FilterLinkInternal *li, const AVFrame *frame)
Definition: avfilter.c:1434
ff_framequeue_add
int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
Add a frame.
Definition: framequeue.c:63
ff_framequeue_free
void ff_framequeue_free(FFFrameQueue *fq)
Free the queue and all queued frames.
Definition: framequeue.c:53
VAR_VARS_NB
@ VAR_VARS_NB
Definition: avfilter.c:551
framequeue.h
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_append_inpad_free_name
int ff_append_inpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:131
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:415
AVFilterContext::name
char * name
name of this filter instance
Definition: avfilter.h:412
fffiltergraph
static FFFilterGraph * fffiltergraph(AVFilterGraph *graph)
Definition: avfilter_internal.h:111
AVFilterPad::filter_frame
int(* filter_frame)(AVFilterLink *link, AVFrame *frame)
Filtering callback.
Definition: internal.h:88
avfilter_internal.h
filter_frame
static int filter_frame(DBEDecodeContext *s, AVFrame *frame)
Definition: dolby_e.c:1059
avfilter_class
static const AVClass avfilter_class
Definition: avfilter.c:660
ff_channel_layouts_unref
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition: formats.c:729
ff_inlink_acknowledge_status
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1392
ff_tlog_link
#define ff_tlog_link(ctx, link, end)
Definition: internal.h:268
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ff_inlink_queued_frames
size_t ff_inlink_queued_frames(AVFilterLink *link)
Get the number of frames available on the link.
Definition: avfilter.c:1408
tlog_ref
static void tlog_ref(void *ctx, AVFrame *ref, int end)
Definition: avfilter.c:47
AV_CLASS_CATEGORY_FILTER
@ AV_CLASS_CATEGORY_FILTER
Definition: log.h:36
FilterLinkInternal::status_out
int status_out
Link output status.
Definition: avfilter_internal.h:67
ff_frame_pool_uninit
void ff_frame_pool_uninit(FFFramePool **pool)
Deallocate the frame pool.
Definition: framepool.c:278
options
const OptionDef options[]
eval.h
FilterLinkInternal::init_state
enum FilterLinkInternal::@244 init_state
stage of the initialization of the link properties (dimensions, etc)
AV_OPT_FLAG_FILTERING_PARAM
#define AV_OPT_FLAG_FILTERING_PARAM
A generic parameter which can be set by the user for filtering.
Definition: opt.h:298
f
f
Definition: af_crystalizer.c:121
AVFilterContext::nb_inputs
unsigned nb_inputs
number of input pads
Definition: avfilter.h:416
default_execute
static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: avfilter.c:670
AVMediaType
AVMediaType
Definition: avutil.h:199
guess_status_pts
static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
Definition: avfilter.c:489
VAR_N
@ VAR_N
Definition: avfilter.c:545
ff_inlink_set_status
void ff_inlink_set_status(AVFilterLink *link, int status)
Set the status on an input link.
Definition: avfilter.c:1580
ff_inlink_check_available_frame
int ff_inlink_check_available_frame(AVFilterLink *link)
Test if a frame is available on the link.
Definition: avfilter.c:1414
ff_inlink_evaluate_timeline_at_frame
int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
Evaluate the timeline expression of the link for the time and properties of the frame.
Definition: avfilter.c:1547
FF_TPRINTF_START
#define FF_TPRINTF_START(ctx, func)
Definition: internal.h:263
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
FilterLinkInternal::age_index
int age_index
Index in the age array.
Definition: avfilter_internal.h:72
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:769
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:539
avfilter_link
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
Definition: avfilter.c:148
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
FFFilterGraph::frame_queues
FFFrameQueueGlobal frame_queues
Definition: avfilter_internal.h:108
set_enable_expr
static int set_enable_expr(AVFilterContext *ctx, const char *expr)
Definition: avfilter.c:554
AVFrame::time_base
AVRational time_base
Time base for the timestamps in this frame.
Definition: frame.h:467
OFFSET
#define OFFSET(x)
Definition: avfilter.c:645
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:573
AVFrame::pkt_pos
attribute_deprecated int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:650
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
AVOption::name
const char * name
Definition: opt.h:347
frame.h
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:890
buffer.h
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:800
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
internal.h
avfilter_init_str
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:944
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:147
ff_framequeue_peek
AVFrame * ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
Access a frame in the queue, without removing it.
Definition: framequeue.c:114
FilterLinkInternal::frame_blocked_in
int frame_blocked_in
If set, the source filter can not generate a frame as is.
Definition: avfilter_internal.h:48
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
av_opt_next
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:48
ff_formats_unref
void ff_formats_unref(AVFilterFormats **ref)
If *ref is non-NULL, remove *ref as a reference to the format list it currently points to,...
Definition: formats.c:717
avfilter_options
static const AVOption avfilter_options[]
Definition: avfilter.c:648
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
bprint.h
append_pad
static int append_pad(unsigned *count, AVFilterPad **pads, AVFilterLink ***links, AVFilterPad *newpad)
Append a new pad.
Definition: avfilter.c:99
ff_filter_frame_framed
static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:987
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
link_set_out_status
static void link_set_out_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the destination filter.
Definition: avfilter.c:273
filter_child_next
static void * filter_child_next(void *obj, void *prev)
Definition: avfilter.c:626
ff_avfilter_link_set_in_status
void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: avfilter.c:254
av_opt_set_dict2
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1921
internal.h
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
AVFilterCommand
Definition: avfilter_internal.h:87
FilterLinkInternal::status_in
int status_in
Link input status.
Definition: avfilter_internal.h:55
common.h
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:825
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
ff_framequeue_queued_samples
static uint64_t ff_framequeue_queued_samples(const FFFrameQueue *fq)
Get the number of queued samples.
Definition: framequeue.h:154
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
AVFilterPad::flags
int flags
A combination of AVFILTERPAD_FLAG_* flags.
Definition: internal.h:62
filt
static const int8_t filt[NUMTAPS *2]
Definition: af_earwax.c:39
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1420
forward_status_change
static int forward_status_change(AVFilterContext *filter, FilterLinkInternal *li_in)
Definition: avfilter.c:1172
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:599
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
AVFilter
Filter definition.
Definition: avfilter.h:166
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:44
links
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output links
Definition: filter_design.txt:14
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
framepool.h
pos
unsigned int pos
Definition: spdifenc.c:413
AVOption::type
enum AVOptionType type
Definition: opt.h:362
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:447
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: af_aecho.c:272
VAR_T
@ VAR_T
Definition: avfilter.c:544
VAR_H
@ VAR_H
Definition: avfilter.c:550
ff_framequeue_queued_frames
static size_t ff_framequeue_queued_frames(const FFFrameQueue *fq)
Get the number of queued frames.
Definition: framequeue.h:146
avfilter_pad_get_type
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:977
AVFrame::hw_frames_ctx
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame.
Definition: frame.h:691
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
AVFrame::height
int height
Definition: frame.h:412
ff_filter_graph_remove_filter
void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
Remove a filter from a graph;.
Definition: avfiltergraph.c:98
status
ov_status_e status
Definition: dnn_backend_openvino.c:120
channel_layout.h
FFFilterContext::execute
avfilter_execute_func * execute
Definition: internal.h:122
AVClass::option
const struct AVOption * option
a pointer to the first option specified in the class if any or NULL
Definition: log.h:84
avfilter_init_dict
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
Initialize a filter with the supplied dictionary of options.
Definition: avfilter.c:903
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_FLAG_RUNTIME_PARAM
#define AV_OPT_FLAG_RUNTIME_PARAM
A generic parameter which can be set by the user at runtime.
Definition: opt.h:294
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
avfilter.h
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:432
AVFilterContext::enable
void * enable
parsed expression (AVExpr*)
Definition: avfilter.h:454
AVFilterCommand::command
char * command
command
Definition: avfilter_internal.h:89
AV_OPT_FLAG_IMPLICIT_KEY
@ AV_OPT_FLAG_IMPLICIT_KEY
Accept to parse a value without a key; the key will then be returned as NULL.
Definition: opt.h:635
FFFilterContext
Definition: internal.h:116
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
AVFilterCommand::arg
char * arg
optional argument for the command
Definition: avfilter_internal.h:90
ff_outlink_get_status
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
Definition: avfilter.c:1596
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FilterLinkInternal::l
AVFilterLink l
Definition: avfilter_internal.h:34
audio.h
TFLAGS
#define TFLAGS
Definition: avfilter.c:647
avfilter_free
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:780
ff_append_outpad
int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:137
FLAGS
#define FLAGS
Definition: avfilter.c:646
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:153
default_filter_frame
static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:982
ff_inlink_process_commands
int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
Process the commands queued in the link up to the time of the frame.
Definition: avfilter.c:1532
AVFILTER_FLAG_SUPPORT_TIMELINE
#define AVFILTER_FLAG_SUPPORT_TIMELINE
Handy mask to test whether the filter supports or no the timeline feature (internally or generically)...
Definition: avfilter.h:160
ff_append_outpad_free_name
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:142
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
var_names
static const char *const var_names[]
Definition: avfilter.c:532
ff_filter_activate_default
static int ff_filter_activate_default(AVFilterContext *filter)
Definition: avfilter.c:1207
samples_ready
static int samples_ready(FilterLinkInternal *link, unsigned min)
Definition: avfilter.c:1072
FilterLinkInternal::frame_pool
struct FFFramePool * frame_pool
Definition: avfilter_internal.h:36
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:234
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
hwcontext.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
FilterLinkInternal::fifo
FFFrameQueue fifo
Queue of frames waiting to be filtered.
Definition: avfilter_internal.h:41
ff_channel_layouts_changeref
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref, AVFilterChannelLayouts **newref)
Definition: formats.c:747
avstring.h
AVFilterContext::filter
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:410
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
int
int
Definition: ffmpeg_filter.c:425
AVFILTERPAD_FLAG_FREE_NAME
#define AVFILTERPAD_FLAG_FREE_NAME
The pad's name is allocated and should be freed generically.
Definition: internal.h:57
avfilter_get_class
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:1611
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
FilterLinkInternal::status_in_pts
int64_t status_in_pts
Timestamp of the input status change.
Definition: avfilter_internal.h:60
av_x_if_null
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:312
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2882
ff_filter_set_ready
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
Definition: avfilter.c:234
ff_filter_init_hw_frames
int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link, int default_pool_size)
Perform any additional setup required for hardware frames.
Definition: avfilter.c:1616
AVFilterCommand::time
double time
time expressed in seconds
Definition: avfilter_internal.h:88
fffilterctx
static FFFilterContext * fffilterctx(AVFilterContext *ctx)
Definition: internal.h:129
min
float min
Definition: vorbis_enc_data.h:429
AVFILTERPAD_FLAG_NEEDS_WRITABLE
#define AVFILTERPAD_FLAG_NEEDS_WRITABLE
The filter expects writable frames from its input link, duplicating data buffers if needed.
Definition: internal.h:52