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/mem.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/rational.h"
36 #include "libavutil/samplefmt.h"
37 
38 #include "audio.h"
39 #include "avfilter.h"
40 #include "avfilter_internal.h"
41 #include "filters.h"
42 #include "formats.h"
43 #include "framequeue.h"
44 #include "framepool.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 {
85  av_freep(&c->arg);
86  av_freep(&c->command);
87  ctxi->command_queue = c->next;
88  av_free(c);
89 }
90 
91 /**
92  * Append a new pad.
93  *
94  * @param count Pointer to the number of pads in the list
95  * @param pads Pointer to the pointer to the beginning of the list of pads
96  * @param links Pointer to the pointer to the beginning of the list of links
97  * @param newpad The new pad to add. A copy is made when adding.
98  * @return >= 0 in case of success, a negative AVERROR code on error
99  */
100 static int append_pad(unsigned *count, AVFilterPad **pads,
101  AVFilterLink ***links, AVFilterPad *newpad)
102 {
103  AVFilterLink **newlinks;
104  AVFilterPad *newpads;
105  unsigned idx = *count;
106 
107  newpads = av_realloc_array(*pads, idx + 1, sizeof(*newpads));
108  newlinks = av_realloc_array(*links, idx + 1, sizeof(*newlinks));
109  if (newpads)
110  *pads = newpads;
111  if (newlinks)
112  *links = newlinks;
113  if (!newpads || !newlinks) {
114  if (newpad->flags & AVFILTERPAD_FLAG_FREE_NAME)
115  av_freep(&newpad->name);
116  return AVERROR(ENOMEM);
117  }
118 
119  memcpy(*pads + idx, newpad, sizeof(AVFilterPad));
120  (*links)[idx] = NULL;
121 
122  (*count)++;
123 
124  return 0;
125 }
126 
128 {
129  return append_pad(&f->nb_inputs, &f->input_pads, &f->inputs, p);
130 }
131 
133 {
135  return ff_append_inpad(f, p);
136 }
137 
139 {
140  return append_pad(&f->nb_outputs, &f->output_pads, &f->outputs, p);
141 }
142 
144 {
146  return ff_append_outpad(f, p);
147 }
148 
149 int avfilter_link(AVFilterContext *src, unsigned srcpad,
150  AVFilterContext *dst, unsigned dstpad)
151 {
152  FilterLinkInternal *li;
154 
155  av_assert0(src->graph);
156  av_assert0(dst->graph);
157  av_assert0(src->graph == dst->graph);
158 
159  if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
160  src->outputs[srcpad] || dst->inputs[dstpad])
161  return AVERROR(EINVAL);
162 
163  if (!(fffilterctx(src)->state_flags & AV_CLASS_STATE_INITIALIZED) ||
164  !(fffilterctx(dst)->state_flags & AV_CLASS_STATE_INITIALIZED)) {
165  av_log(src, AV_LOG_ERROR, "Filters must be initialized before linking.\n");
166  return AVERROR(EINVAL);
167  }
168 
169  if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
171  "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
172  src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),
173  dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));
174  return AVERROR(EINVAL);
175  }
176 
177  li = av_mallocz(sizeof(*li));
178  if (!li)
179  return AVERROR(ENOMEM);
180  link = &li->l.pub;
181 
182  src->outputs[srcpad] = dst->inputs[dstpad] = link;
183 
184  link->src = src;
185  link->dst = dst;
186  link->srcpad = &src->output_pads[srcpad];
187  link->dstpad = &dst->input_pads[dstpad];
188  link->type = src->output_pads[srcpad].type;
189  li->l.graph = src->graph;
191  link->format = -1;
194 
195  return 0;
196 }
197 
199 {
200  FilterLinkInternal *li;
201 
202  if (!*link)
203  return;
204  li = ff_link_internal(*link);
205 
206  ff_framequeue_free(&li->fifo);
208  av_channel_layout_uninit(&(*link)->ch_layout);
209  av_frame_side_data_free(&(*link)->side_data, &(*link)->nb_side_data);
210 
212 
213  av_freep(link);
214 }
215 
217 {
218  AVFilterLink *const link = &li->l.pub;
219 
220  if (pts == AV_NOPTS_VALUE)
221  return;
222  li->l.current_pts = pts;
224  /* TODO use duration */
225  if (li->l.graph && li->age_index >= 0)
227 }
228 
229 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
230 {
232  ctxi->ready = FFMAX(ctxi->ready, priority);
233 }
234 
235 /**
236  * Clear frame_blocked_in on all outputs.
237  * This is necessary whenever something changes on input.
238  */
240 {
241  unsigned i;
242 
243  for (i = 0; i < filter->nb_outputs; i++) {
244  FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
245  li->frame_blocked_in = 0;
246  }
247 }
248 
249 
251 {
253 
254  if (li->status_in == status)
255  return;
256  av_assert0(!li->status_in);
257  li->status_in = status;
258  li->status_in_pts = pts;
259  li->frame_wanted_out = 0;
260  li->frame_blocked_in = 0;
261  filter_unblock(link->dst);
262  ff_filter_set_ready(link->dst, 200);
263 }
264 
265 /**
266  * Set the status field of a link from the destination filter.
267  * The pts should probably be left unset (AV_NOPTS_VALUE).
268  */
270 {
272 
274  av_assert0(!li->status_out);
275  li->status_out = status;
276  if (pts != AV_NOPTS_VALUE)
278  filter_unblock(link->dst);
279  ff_filter_set_ready(link->src, 200);
280 }
281 
283  unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
284 {
285  int ret;
286  unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
287 
288  av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
289  "between the filter '%s' and the filter '%s'\n",
290  filt->name, link->src->name, link->dst->name);
291 
292  link->dst->inputs[dstpad_idx] = NULL;
293  if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {
294  /* failed to link output filter to new filter */
295  link->dst->inputs[dstpad_idx] = link;
296  return ret;
297  }
298 
299  /* re-hookup the link to the new destination filter we inserted */
300  link->dst = filt;
301  link->dstpad = &filt->input_pads[filt_srcpad_idx];
302  filt->inputs[filt_srcpad_idx] = link;
303 
304  /* if any information on supported media formats already exists on the
305  * link, we need to preserve that */
306  if (link->outcfg.formats)
307  ff_formats_changeref(&link->outcfg.formats,
308  &filt->outputs[filt_dstpad_idx]->outcfg.formats);
309  if (link->outcfg.color_spaces)
310  ff_formats_changeref(&link->outcfg.color_spaces,
311  &filt->outputs[filt_dstpad_idx]->outcfg.color_spaces);
312  if (link->outcfg.color_ranges)
313  ff_formats_changeref(&link->outcfg.color_ranges,
314  &filt->outputs[filt_dstpad_idx]->outcfg.color_ranges);
315  if (link->outcfg.alpha_modes)
316  ff_formats_changeref(&link->outcfg.alpha_modes,
317  &filt->outputs[filt_dstpad_idx]->outcfg.alpha_modes);
318  if (link->outcfg.samplerates)
319  ff_formats_changeref(&link->outcfg.samplerates,
320  &filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
321  if (link->outcfg.channel_layouts)
322  ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
323  &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
324 
325  return 0;
326 }
327 
329 {
330  int (*config_link)(AVFilterLink *);
331  unsigned i;
332  int ret;
333 
334  for (i = 0; i < filter->nb_inputs; i ++) {
335  AVFilterLink *link = filter->inputs[i];
338  FilterLinkInternal *li_in;
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  li_in = inlink ? ff_link_internal(inlink) : NULL;
349  li->l.current_pts =
351 
352  switch (li->init_state) {
353  case AVLINK_INIT:
354  continue;
355  case AVLINK_STARTINIT:
356  av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
357  return 0;
358  case AVLINK_UNINIT:
359  li->init_state = AVLINK_STARTINIT;
360 
361  if ((ret = ff_filter_config_links(link->src)) < 0)
362  return ret;
363 
364  if (!(config_link = link->srcpad->config_props)) {
365  if (link->src->nb_inputs != 1) {
366  av_log(link->src, AV_LOG_ERROR, "Source filters and filters "
367  "with more than one input "
368  "must set config_props() "
369  "callbacks on all outputs\n");
370  return AVERROR(EINVAL);
371  }
372  }
373 
374  /* Copy side data before link->srcpad->config_props() is called, so the filter
375  * may remove it for the next filter in the chain */
376  if (inlink && inlink->nb_side_data && !link->nb_side_data) {
377  for (int j = 0; j < inlink->nb_side_data; j++) {
379  inlink->side_data[j], 0);
380  if (ret < 0) {
382  return ret;
383  }
384  }
385  }
386 
387  if (config_link && (ret = config_link(link)) < 0) {
388  av_log(link->src, AV_LOG_ERROR,
389  "Failed to configure output pad on %s\n",
390  link->src->name);
391  return ret;
392  }
393 
394  switch (link->type) {
395  case AVMEDIA_TYPE_VIDEO:
396  if (!link->time_base.num && !link->time_base.den)
397  link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
398 
401  inlink->sample_aspect_ratio : (AVRational){1,1};
402 
403  if (inlink) {
404  if (!li->l.frame_rate.num && !li->l.frame_rate.den)
405  li->l.frame_rate = li_in->l.frame_rate;
406  if (!link->w)
407  link->w = inlink->w;
408  if (!link->h)
409  link->h = inlink->h;
410  } else if (!link->w || !link->h) {
411  av_log(link->src, AV_LOG_ERROR,
412  "Video source filters must set their output link's "
413  "width and height\n");
414  return AVERROR(EINVAL);
415  }
416  break;
417 
418  case AVMEDIA_TYPE_AUDIO:
419  if (inlink) {
420  if (!link->time_base.num && !link->time_base.den)
421  link->time_base = inlink->time_base;
422  }
423 
424  if (!link->time_base.num && !link->time_base.den)
426  }
427 
428  if (link->src->nb_inputs &&
430  FilterLink *l0 = ff_filter_link(link->src->inputs[0]);
431 
432  av_assert0(!li->l.hw_frames_ctx &&
433  "should not be set by non-hwframe-aware filter");
434 
435  if (l0->hw_frames_ctx) {
437  if (!li->l.hw_frames_ctx)
438  return AVERROR(ENOMEM);
439  }
440  }
441 
442  if ((config_link = link->dstpad->config_props))
443  if ((ret = config_link(link)) < 0) {
444  av_log(link->dst, AV_LOG_ERROR,
445  "Failed to configure input pad on %s\n",
446  link->dst->name);
447  return ret;
448  }
449 
450  li->init_state = AVLINK_INIT;
451  }
452  }
453 
454  return 0;
455 }
456 
457 #ifdef TRACE
458 void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
459 {
460  if (link->type == AVMEDIA_TYPE_VIDEO) {
461  ff_tlog(ctx,
462  "link[%p s:%dx%d fmt:%s %s->%s]%s",
463  link, link->w, link->h,
465  link->src ? link->src->filter->name : "",
466  link->dst ? link->dst->filter->name : "",
467  end ? "\n" : "");
468  } else {
469  char buf[128];
470  av_channel_layout_describe(&link->ch_layout, buf, sizeof(buf));
471 
472  ff_tlog(ctx,
473  "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
474  link, (int)link->sample_rate, buf,
476  link->src ? link->src->filter->name : "",
477  link->dst ? link->dst->filter->name : "",
478  end ? "\n" : "");
479  }
480 }
481 #endif
482 
484 {
486 
488 
489  av_assert1(!fffilter(link->dst->filter)->activate);
490  if (li->status_out)
491  return li->status_out;
492  if (li->status_in) {
493  if (ff_framequeue_queued_frames(&li->fifo)) {
495  av_assert1(fffilterctx(link->dst)->ready >= 300);
496  return 0;
497  } else {
498  /* Acknowledge status change. Filters using ff_request_frame() will
499  handle the change automatically. Filters can also check the
500  status directly but none do yet. */
502  return li->status_out;
503  }
504  }
505  li->frame_wanted_out = 1;
506  ff_filter_set_ready(link->src, 100);
507  return 0;
508 }
509 
511 {
512  unsigned i;
513  int64_t r = INT64_MAX;
514 
515  for (i = 0; i < ctx->nb_inputs; i++) {
516  FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
517  if (li->status_out == status)
518  r = FFMIN(r, av_rescale_q(li->l.current_pts, ctx->inputs[i]->time_base, link_time_base));
519  }
520  if (r < INT64_MAX)
521  return r;
522  av_log(ctx, AV_LOG_WARNING, "EOF timestamp not reliable\n");
523  for (i = 0; i < ctx->nb_inputs; i++) {
524  FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
525  r = FFMIN(r, av_rescale_q(li->status_in_pts, ctx->inputs[i]->time_base, link_time_base));
526  }
527  if (r < INT64_MAX)
528  return r;
529  return AV_NOPTS_VALUE;
530 }
531 
533 {
535  int ret = -1;
536 
538  /* Assume the filter is blocked, let the method clear it if not */
539  li->frame_blocked_in = 1;
540  if (link->srcpad->request_frame)
541  ret = link->srcpad->request_frame(link);
542  else if (link->src->inputs[0])
543  ret = ff_request_frame(link->src->inputs[0]);
544  if (ret < 0) {
545  if (ret != AVERROR(EAGAIN) && ret != li->status_in)
547  if (ret == AVERROR_EOF)
548  ret = 0;
549  }
550  return ret;
551 }
552 
553 static const char *const var_names[] = {
554  "t",
555  "n",
556  "w",
557  "h",
558  NULL
559 };
560 
561 enum {
567 };
568 
569 static int set_enable_expr(FFFilterContext *ctxi, const char *expr)
570 {
571  AVFilterContext *ctx = &ctxi->p;
572  int ret;
573  char *expr_dup;
574  AVExpr *old = ctxi->enable;
575 
576  if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) {
577  av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
578  "with filter '%s'\n", ctx->filter->name);
579  return AVERROR_PATCHWELCOME;
580  }
581 
582  expr_dup = av_strdup(expr);
583  if (!expr_dup)
584  return AVERROR(ENOMEM);
585 
586  if (!ctxi->var_values) {
587  ctxi->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctxi->var_values));
588  if (!ctxi->var_values) {
589  av_free(expr_dup);
590  return AVERROR(ENOMEM);
591  }
592  }
593 
594  ret = av_expr_parse(&ctxi->enable, expr_dup, var_names,
595  NULL, NULL, NULL, NULL, 0, ctx->priv);
596  if (ret < 0) {
597  av_log(ctx->priv, AV_LOG_ERROR,
598  "Error when evaluating the expression '%s' for enable\n",
599  expr_dup);
600  av_free(expr_dup);
601  return ret;
602  }
603 
604  av_expr_free(old);
605  av_free(ctx->enable_str);
606  ctx->enable_str = expr_dup;
607  return 0;
608 }
609 
610 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
611 {
612  if(!strcmp(cmd, "ping")){
613  char local_res[256] = {0};
614 
615  if (!res) {
616  res = local_res;
617  res_len = sizeof(local_res);
618  }
619  av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
620  if (res == local_res)
621  av_log(filter, AV_LOG_INFO, "%s", res);
622  return 0;
623  }else if(!strcmp(cmd, "enable")) {
625  }else if (fffilter(filter->filter)->process_command) {
626  return fffilter(filter->filter)->process_command(filter, cmd, arg, res, res_len, flags);
627  }
628  return AVERROR(ENOSYS);
629 }
630 
631 unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
632 {
633  return is_output ? fffilter(filter)->nb_outputs : fffilter(filter)->nb_inputs;
634 }
635 
636 static const char *default_filter_name(void *filter_ctx)
637 {
639  return ctx->name ? ctx->name : ctx->filter->name;
640 }
641 
642 static void *filter_child_next(void *obj, void *prev)
643 {
644  AVFilterContext *ctx = obj;
645  if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
646  return ctx->priv;
647  return NULL;
648 }
649 
650 static const AVClass *filter_child_class_iterate(void **iter)
651 {
652  const AVFilter *f;
653 
654  while ((f = av_filter_iterate(iter)))
655  if (f->priv_class)
656  return f->priv_class;
657 
658  return NULL;
659 }
660 
661 #define OFFSET(x) offsetof(AVFilterContext, x)
662 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
663 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
664 static const AVOption avfilter_options[] = {
665  { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
666  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, .unit = "thread_type" },
667  { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
668  { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = TFLAGS },
669  { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
670  { .i64 = 0 }, 0, INT_MAX, FLAGS, .unit = "threads" },
671  {"auto", "autodetect a suitable number of threads to use", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, .flags = FLAGS, .unit = "threads"},
672  { "extra_hw_frames", "Number of extra hardware frames to allocate for the user",
673  OFFSET(extra_hw_frames), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
674  { NULL },
675 };
676 
677 static const AVClass avfilter_class = {
678  .class_name = "AVFilter",
679  .item_name = default_filter_name,
680  .version = LIBAVUTIL_VERSION_INT,
681  .category = AV_CLASS_CATEGORY_FILTER,
682  .child_next = filter_child_next,
683  .child_class_iterate = filter_child_class_iterate,
685  .state_flags_offset = offsetof(FFFilterContext, state_flags),
686 };
687 
689  int *ret, int nb_jobs)
690 {
691  int i;
692 
693  for (i = 0; i < nb_jobs; i++) {
694  int r = func(ctx, arg, i, nb_jobs);
695  if (ret)
696  ret[i] = r;
697  }
698  return 0;
699 }
700 
701 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
702 {
705  const FFFilter *const fi = fffilter(filter);
706  int preinited = 0;
707 
708  if (!filter)
709  return NULL;
710 
711  ctx = av_mallocz(sizeof(*ctx));
712  if (!ctx)
713  return NULL;
714  ret = &ctx->p;
715 
716  ret->av_class = &avfilter_class;
717  ret->filter = filter;
718  ret->name = inst_name ? av_strdup(inst_name) : NULL;
719  if (fi->priv_size) {
720  ret->priv = av_mallocz(fi->priv_size);
721  if (!ret->priv)
722  goto err;
723  }
724  if (fi->preinit) {
725  if (fi->preinit(ret) < 0)
726  goto err;
727  preinited = 1;
728  }
729 
731  if (filter->priv_class) {
732  *(const AVClass**)ret->priv = filter->priv_class;
733  av_opt_set_defaults(ret->priv);
734  }
735 
736  ctx->execute = default_execute;
737 
738  ret->nb_inputs = fi->nb_inputs;
739  if (ret->nb_inputs ) {
740  ret->input_pads = av_memdup(filter->inputs, ret->nb_inputs * sizeof(*filter->inputs));
741  if (!ret->input_pads)
742  goto err;
743  ret->inputs = av_calloc(ret->nb_inputs, sizeof(*ret->inputs));
744  if (!ret->inputs)
745  goto err;
746  }
747 
748  ret->nb_outputs = fi->nb_outputs;
749  if (ret->nb_outputs) {
750  ret->output_pads = av_memdup(filter->outputs, ret->nb_outputs * sizeof(*filter->outputs));
751  if (!ret->output_pads)
752  goto err;
753  ret->outputs = av_calloc(ret->nb_outputs, sizeof(*ret->outputs));
754  if (!ret->outputs)
755  goto err;
756  }
757 
758  return ret;
759 
760 err:
761  if (preinited)
762  fi->uninit(ret);
763  av_freep(&ret->inputs);
764  av_freep(&ret->input_pads);
765  ret->nb_inputs = 0;
766  av_freep(&ret->outputs);
767  av_freep(&ret->output_pads);
768  ret->nb_outputs = 0;
769  av_freep(&ret->priv);
770  av_free(ret);
771  return NULL;
772 }
773 
775 {
776  if (!link)
777  return;
778 
779  if (link->src)
780  link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
781  if (link->dst)
782  link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
783 
784  ff_formats_unref(&link->incfg.formats);
785  ff_formats_unref(&link->outcfg.formats);
786  ff_formats_unref(&link->incfg.color_spaces);
787  ff_formats_unref(&link->outcfg.color_spaces);
788  ff_formats_unref(&link->incfg.color_ranges);
789  ff_formats_unref(&link->outcfg.color_ranges);
790  ff_formats_unref(&link->incfg.alpha_modes);
791  ff_formats_unref(&link->outcfg.alpha_modes);
792  ff_formats_unref(&link->incfg.samplerates);
793  ff_formats_unref(&link->outcfg.samplerates);
794  ff_channel_layouts_unref(&link->incfg.channel_layouts);
795  ff_channel_layouts_unref(&link->outcfg.channel_layouts);
796  link_free(&link);
797 }
798 
800 {
801  FFFilterContext *ctxi;
802  int i;
803 
804  if (!filter)
805  return;
806  ctxi = fffilterctx(filter);
807 
808  if (filter->graph)
810 
811  if (fffilter(filter->filter)->uninit)
812  fffilter(filter->filter)->uninit(filter);
813 
814  for (i = 0; i < filter->nb_inputs; i++) {
815  free_link(filter->inputs[i]);
816  if (filter->input_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
817  av_freep(&filter->input_pads[i].name);
818  }
819  for (i = 0; i < filter->nb_outputs; i++) {
820  free_link(filter->outputs[i]);
821  if (filter->output_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
822  av_freep(&filter->output_pads[i].name);
823  }
824 
825  if (filter->filter->priv_class)
826  av_opt_free(filter->priv);
827 
828  av_buffer_unref(&filter->hw_device_ctx);
829 
830  av_freep(&filter->name);
831  av_freep(&filter->input_pads);
832  av_freep(&filter->output_pads);
833  av_freep(&filter->inputs);
834  av_freep(&filter->outputs);
835  av_freep(&filter->priv);
836  while (ctxi->command_queue)
839  av_expr_free(ctxi->enable);
840  ctxi->enable = NULL;
841  av_freep(&ctxi->var_values);
842  av_free(filter);
843 }
844 
846 {
847  if (ctx->nb_threads > 0)
848  return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
849  return ctx->graph->nb_threads;
850 }
851 
852 int ff_filter_opt_parse(void *logctx, const AVClass *priv_class,
853  AVDictionary **options, const char *args)
854 {
855  const AVOption *o = NULL;
856  int ret;
857  int offset= -1;
858 
859  if (!args)
860  return 0;
861 
862  while (*args) {
863  char *parsed_key, *value;
864  const char *key;
865  const char *shorthand = NULL;
866  int additional_flags = 0;
867 
868  if (priv_class && (o = av_opt_next(&priv_class, o))) {
869  if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
870  continue;
871  offset = o->offset;
872  shorthand = o->name;
873  }
874 
875  ret = av_opt_get_key_value(&args, "=", ":",
876  shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
877  &parsed_key, &value);
878  if (ret < 0) {
879  if (ret == AVERROR(EINVAL))
880  av_log(logctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
881  else
882  av_log(logctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
883  av_err2str(ret));
884  return ret;
885  }
886  if (*args)
887  args++;
888  if (parsed_key) {
889  key = parsed_key;
890  additional_flags = AV_DICT_DONT_STRDUP_KEY;
891  priv_class = NULL; /* reject all remaining shorthand */
892  } else {
893  key = shorthand;
894  }
895 
896  av_log(logctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
897 
899  additional_flags | AV_DICT_DONT_STRDUP_VAL | AV_DICT_MULTIKEY);
900  }
901 
902  return 0;
903 }
904 
906  const char *arg, char *res, int res_len, int flags)
907 {
908  const AVOption *o;
909 
910  if (!ctx->filter->priv_class)
911  return 0;
913  if (!o)
914  return AVERROR(ENOSYS);
915  return av_opt_set(ctx->priv, cmd, arg, 0);
916 }
917 
919 {
921  int ret = 0;
922 
924  av_log(ctx, AV_LOG_ERROR, "Filter already initialized\n");
925  return AVERROR(EINVAL);
926  }
927 
929  if (ret < 0) {
930  av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
931  return ret;
932  }
933 
934  if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
935  ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
936  fffiltergraph(ctx->graph)->thread_execute) {
937  ctx->thread_type = AVFILTER_THREAD_SLICE;
938  ctxi->execute = fffiltergraph(ctx->graph)->thread_execute;
939  } else {
940  ctx->thread_type = 0;
941  }
942 
943  if (fffilter(ctx->filter)->init)
944  ret = fffilter(ctx->filter)->init(ctx);
945  if (ret < 0)
946  return ret;
947 
948  if (ctx->enable_str) {
949  ret = set_enable_expr(ctxi, ctx->enable_str);
950  if (ret < 0)
951  return ret;
952  }
953 
955 
956  return 0;
957 }
958 
959 int avfilter_init_str(AVFilterContext *filter, const char *args)
960 {
962  const AVDictionaryEntry *e;
963  int ret = 0;
964 
965  if (args && *args) {
966  ret = ff_filter_opt_parse(filter, filter->filter->priv_class, &options, args);
967  if (ret < 0)
968  goto fail;
969  }
970 
972  if (ret < 0)
973  goto fail;
974 
975  if ((e = av_dict_iterate(options, NULL))) {
976  av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
978  goto fail;
979  }
980 
981 fail:
983 
984  return ret;
985 }
986 
987 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
988 {
989  return pads[pad_idx].name;
990 }
991 
992 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
993 {
994  return pads[pad_idx].type;
995 }
996 
998 {
999  FilterLink *plink = ff_filter_link(link);
1000  if (plink->hw_frames_ctx)
1001  return av_buffer_ref(plink->hw_frames_ctx);
1002 
1003  return NULL;
1004 }
1005 
1007 {
1008  return ff_filter_frame(link->dst->outputs[0], frame);
1009 }
1010 
1011 /**
1012  * Evaluate the timeline expression of the link for the time and properties
1013  * of the frame.
1014  * @return >0 if enabled, 0 if disabled
1015  * @note It does not update link->dst->is_disabled.
1016  */
1018 {
1020  AVFilterContext *dstctx = link->dst;
1021  FFFilterContext *dsti = fffilterctx(dstctx);
1022  int64_t pts = frame->pts;
1023 
1024  if (!dstctx->enable_str)
1025  return 1;
1026 
1027  dsti->var_values[VAR_N] = l->frame_count_out;
1029  dsti->var_values[VAR_W] = link->w;
1030  dsti->var_values[VAR_H] = link->h;
1031 
1032  return fabs(av_expr_eval(dsti->enable, dsti->var_values, NULL)) >= 0.5;
1033 }
1034 
1036 {
1038  int (*filter_frame)(AVFilterLink *, AVFrame *);
1039  AVFilterContext *dstctx = link->dst;
1040  AVFilterPad *dst = link->dstpad;
1041  int ret;
1042 
1043  if (!(filter_frame = dst->filter_frame))
1045 
1046  if (dst->flags & AVFILTERPAD_FLAG_NEEDS_WRITABLE) {
1048  if (ret < 0)
1049  goto fail;
1050  }
1051 
1054 
1055  if (dstctx->is_disabled &&
1058  ret = filter_frame(link, frame);
1059  l->frame_count_out++;
1060  return ret;
1061 
1062 fail:
1063  av_frame_free(&frame);
1064  return ret;
1065 }
1066 
1068 {
1070  int ret;
1072 
1073  /* Consistency checks */
1074  if (link->type == AVMEDIA_TYPE_VIDEO) {
1075  if (strcmp(link->dst->filter->name, "buffersink") &&
1076  strcmp(link->dst->filter->name, "format") &&
1077  strcmp(link->dst->filter->name, "idet") &&
1078  strcmp(link->dst->filter->name, "null") &&
1079  strcmp(link->dst->filter->name, "scale") &&
1080  strcmp(link->dst->filter->name, "libplacebo")) {
1081  av_assert1(frame->format == link->format);
1082  av_assert1(frame->width == link->w);
1083  av_assert1(frame->height == link->h);
1085  av_assert1(frame->alpha_mode == link->alpha_mode);
1086  }
1087 
1088  frame->sample_aspect_ratio = link->sample_aspect_ratio;
1089  } else {
1090  if (frame->format != link->format) {
1091  av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1092  goto error;
1093  }
1094  if (av_channel_layout_compare(&frame->ch_layout, &link->ch_layout)) {
1095  av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1096  goto error;
1097  }
1098  if (frame->sample_rate != link->sample_rate) {
1099  av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1100  goto error;
1101  }
1102 
1103  frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate },
1104  link->time_base);
1105  }
1106 
1107  li->frame_blocked_in = li->frame_wanted_out = 0;
1108  li->l.frame_count_in++;
1109  li->l.sample_count_in += frame->nb_samples;
1110  filter_unblock(link->dst);
1111  ret = ff_framequeue_add(&li->fifo, frame);
1112  if (ret < 0) {
1113  av_frame_free(&frame);
1114  return ret;
1115  }
1116  ff_filter_set_ready(link->dst, 300);
1117  return 0;
1118 
1119 error:
1120  av_frame_free(&frame);
1121  return AVERROR_PATCHWELCOME;
1122 }
1123 
1125 {
1126  return ff_framequeue_queued_frames(&link->fifo) &&
1127  (ff_framequeue_queued_samples(&link->fifo) >= min ||
1128  link->status_in);
1129 }
1130 
1131 static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max,
1132  AVFrame **rframe)
1133 {
1134  FilterLink *l = &li->l;
1135  AVFilterLink *link = &l->pub;
1136  AVFrame *frame0, *frame, *buf;
1137  unsigned nb_samples, nb_frames, i, p;
1138  int ret;
1139 
1140  /* Note: this function relies on no format changes and must only be
1141  called with enough samples. */
1143  frame0 = frame = ff_framequeue_peek(&li->fifo, 0);
1144  if (!li->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1145  *rframe = ff_framequeue_take(&li->fifo);
1146  return 0;
1147  }
1148  nb_frames = 0;
1149  nb_samples = 0;
1150  while (1) {
1151  if (nb_samples + frame->nb_samples > max) {
1152  if (nb_samples < min)
1153  nb_samples = max;
1154  break;
1155  }
1156  nb_samples += frame->nb_samples;
1157  nb_frames++;
1158  if (nb_frames == ff_framequeue_queued_frames(&li->fifo))
1159  break;
1160  frame = ff_framequeue_peek(&li->fifo, nb_frames);
1161  }
1162 
1163  buf = ff_get_audio_buffer(link, nb_samples);
1164  if (!buf)
1165  return AVERROR(ENOMEM);
1166  ret = av_frame_copy_props(buf, frame0);
1167  if (ret < 0) {
1168  av_frame_free(&buf);
1169  return ret;
1170  }
1171 
1172  p = 0;
1173  for (i = 0; i < nb_frames; i++) {
1174  frame = ff_framequeue_take(&li->fifo);
1175  av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1176  frame->nb_samples, link->ch_layout.nb_channels, link->format);
1177  p += frame->nb_samples;
1178  av_frame_free(&frame);
1179  }
1180  if (p < nb_samples) {
1181  unsigned n = nb_samples - p;
1182  frame = ff_framequeue_peek(&li->fifo, 0);
1183  av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1186  }
1187 
1188  *rframe = buf;
1189  return 0;
1190 }
1191 
1193 {
1195  AVFrame *frame = NULL;
1196  AVFilterContext *dst = link->dst;
1197  int ret;
1198 
1200  ret = li->l.min_samples ?
1203  av_assert1(ret);
1204  if (ret < 0) {
1205  av_assert1(!frame);
1206  return ret;
1207  }
1208  /* The filter will soon have received a new frame, that may allow it to
1209  produce one or more: unblock its outputs. */
1211  /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1212  before the frame; filter_frame_framed() will re-increment it. */
1213  li->l.frame_count_out--;
1215  if (ret < 0 && ret != li->status_out) {
1217  } else {
1218  /* Run once again, to see if several frames were available, or if
1219  the input status has also changed, or any other reason. */
1220  ff_filter_set_ready(dst, 300);
1221  }
1222  return ret;
1223 }
1224 
1226 {
1227  AVFilterLink *in = &li_in->l.pub;
1228  unsigned out = 0, progress = 0;
1229  int ret;
1230 
1231  av_assert0(!li_in->status_out);
1232  if (!filter->nb_outputs) {
1233  /* not necessary with the current API and sinks */
1234  return 0;
1235  }
1236  while (!li_in->status_out) {
1237  FilterLinkInternal *li_out = ff_link_internal(filter->outputs[out]);
1238 
1239  if (!li_out->status_in) {
1240  progress++;
1241  ret = request_frame_to_filter(filter->outputs[out]);
1242  if (ret < 0)
1243  return ret;
1244  }
1245  if (++out == filter->nb_outputs) {
1246  if (!progress) {
1247  /* Every output already closed: input no longer interesting
1248  (example: overlay in shortest mode, other input closed). */
1249  link_set_out_status(in, li_in->status_in, li_in->status_in_pts);
1250  return 0;
1251  }
1252  progress = 0;
1253  out = 0;
1254  }
1255  }
1257  return 0;
1258 }
1259 
1261 {
1262  unsigned i;
1263  int nb_eofs = 0;
1264 
1265  for (i = 0; i < filter->nb_outputs; i++)
1266  nb_eofs += ff_outlink_get_status(filter->outputs[i]) == AVERROR_EOF;
1267  if (filter->nb_outputs && nb_eofs == filter->nb_outputs) {
1268  for (int j = 0; j < filter->nb_inputs; j++)
1270  return 0;
1271  }
1272 
1273  for (i = 0; i < filter->nb_inputs; i++) {
1274  FilterLinkInternal *li = ff_link_internal(filter->inputs[i]);
1275  if (samples_ready(li, li->l.min_samples)) {
1276  return filter_frame_to_filter(filter->inputs[i]);
1277  }
1278  }
1279  for (i = 0; i < filter->nb_inputs; i++) {
1280  FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]);
1281  if (li->status_in && !li->status_out) {
1283  return forward_status_change(filter, li);
1284  }
1285  }
1286  for (i = 0; i < filter->nb_outputs; i++) {
1287  FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1288  if (li->frame_wanted_out &&
1289  !li->frame_blocked_in) {
1290  return request_frame_to_filter(filter->outputs[i]);
1291  }
1292  }
1293  for (i = 0; i < filter->nb_outputs; i++) {
1294  FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1295  if (li->frame_wanted_out)
1296  return request_frame_to_filter(filter->outputs[i]);
1297  }
1298  if (!filter->nb_outputs) {
1299  ff_inlink_request_frame(filter->inputs[0]);
1300  return 0;
1301  }
1302  return FFERROR_NOT_READY;
1303 }
1304 
1305 /*
1306  Filter scheduling and activation
1307 
1308  When a filter is activated, it must:
1309  - if possible, output a frame;
1310  - else, if relevant, forward the input status change;
1311  - else, check outputs for wanted frames and forward the requests.
1312 
1313  The following AVFilterLink fields are used for activation:
1314 
1315  - frame_wanted_out:
1316 
1317  This field indicates if a frame is needed on this input of the
1318  destination filter. A positive value indicates that a frame is needed
1319  to process queued frames or internal data or to satisfy the
1320  application; a zero value indicates that a frame is not especially
1321  needed but could be processed anyway; a negative value indicates that a
1322  frame would just be queued.
1323 
1324  It is set by filters using ff_request_frame() or ff_request_no_frame(),
1325  when requested by the application through a specific API or when it is
1326  set on one of the outputs.
1327 
1328  It is cleared when a frame is sent from the source using
1329  ff_filter_frame().
1330 
1331  It is also cleared when a status change is sent from the source using
1332  ff_avfilter_link_set_in_status().
1333 
1334  - frame_blocked_in:
1335 
1336  This field means that the source filter can not generate a frame as is.
1337  Its goal is to avoid repeatedly calling the request_frame() method on
1338  the same link.
1339 
1340  It is set by the framework on all outputs of a filter before activating it.
1341 
1342  It is automatically cleared by ff_filter_frame().
1343 
1344  It is also automatically cleared by ff_avfilter_link_set_in_status().
1345 
1346  It is also cleared on all outputs (using filter_unblock()) when
1347  something happens on an input: processing a frame or changing the
1348  status.
1349 
1350  - fifo:
1351 
1352  Contains the frames queued on a filter input. If it contains frames and
1353  frame_wanted_out is not set, then the filter can be activated. If that
1354  result in the filter not able to use these frames, the filter must set
1355  frame_wanted_out to ask for more frames.
1356 
1357  - status_in and status_in_pts:
1358 
1359  Status (EOF or error code) of the link and timestamp of the status
1360  change (in link time base, same as frames) as seen from the input of
1361  the link. The status change is considered happening after the frames
1362  queued in fifo.
1363 
1364  It is set by the source filter using ff_avfilter_link_set_in_status().
1365 
1366  - status_out:
1367 
1368  Status of the link as seen from the output of the link. The status
1369  change is considered having already happened.
1370 
1371  It is set by the destination filter using
1372  link_set_out_status().
1373 
1374  Filters are activated according to the ready field, set using the
1375  ff_filter_set_ready(). Eventually, a priority queue will be used.
1376  ff_filter_set_ready() is called whenever anything could cause progress to
1377  be possible. Marking a filter ready when it is not is not a problem,
1378  except for the small overhead it causes.
1379 
1380  Conditions that cause a filter to be marked ready are:
1381 
1382  - frames added on an input link;
1383 
1384  - changes in the input or output status of an input link;
1385 
1386  - requests for a frame on an output link;
1387 
1388  - after any actual processing using the legacy methods (filter_frame(),
1389  and request_frame() to acknowledge status changes), to run once more
1390  and check if enough input was present for several frames.
1391 
1392  Examples of scenarios to consider:
1393 
1394  - buffersrc: activate if frame_wanted_out to notify the application;
1395  activate when the application adds a frame to push it immediately.
1396 
1397  - testsrc: activate only if frame_wanted_out to produce and push a frame.
1398 
1399  - concat (not at stitch points): can process a frame on any output.
1400  Activate if frame_wanted_out on output to forward on the corresponding
1401  input. Activate when a frame is present on input to process it
1402  immediately.
1403 
1404  - framesync: needs at least one frame on each input; extra frames on the
1405  wrong input will accumulate. When a frame is first added on one input,
1406  set frame_wanted_out<0 on it to avoid getting more (would trigger
1407  testsrc) and frame_wanted_out>0 on the other to allow processing it.
1408 
1409  Activation of old filters:
1410 
1411  In order to activate a filter implementing the legacy filter_frame() and
1412  request_frame() methods, perform the first possible of the following
1413  actions:
1414 
1415  - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1416  frame and call filter_frame().
1417 
1418  Rationale: filter frames as soon as possible instead of leaving them
1419  queued; frame_wanted_out < 0 is not possible since the old API does not
1420  set it nor provides any similar feedback; frame_wanted_out > 0 happens
1421  when min_samples > 0 and there are not enough samples queued.
1422 
1423  - If an input has status_in set but not status_out, try to call
1424  request_frame() on one of the outputs in the hope that it will trigger
1425  request_frame() on the input with status_in and acknowledge it. This is
1426  awkward and fragile, filters with several inputs or outputs should be
1427  updated to direct activation as soon as possible.
1428 
1429  - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1430  request_frame().
1431 
1432  Rationale: checking frame_blocked_in is necessary to avoid requesting
1433  repeatedly on a blocked input if another is not blocked (example:
1434  [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1435 
1436  - If an output has frame_wanted_out > 0 call request_frame().
1437 
1438  Rationale: even if all inputs are blocked an activate callback should
1439  request a frame on some if its inputs if a frame is requested on any of
1440  its output.
1441 
1442  - Request a frame on the input for sinks.
1443 
1444  Rationale: sinks using the old api have no way to request a frame on their
1445  input, so we need to do it for them.
1446  */
1447 
1449 {
1451  const FFFilter *const fi = fffilter(filter->filter);
1452  int ret;
1453 
1454  /* Generic timeline support is not yet implemented but should be easy */
1456  fi->activate));
1457  ctxi->ready = 0;
1459  if (ret == FFERROR_NOT_READY)
1460  ret = 0;
1461  return ret;
1462 }
1463 
1465 {
1467  *rpts = li->l.current_pts;
1469  return *rstatus = 0;
1470  if (li->status_out)
1471  return *rstatus = li->status_out;
1472  if (!li->status_in)
1473  return *rstatus = 0;
1474  *rstatus = li->status_out = li->status_in;
1476  *rpts = li->l.current_pts;
1477  return 1;
1478 }
1479 
1481 {
1483  return ff_framequeue_queued_frames(&li->fifo);
1484 }
1485 
1487 {
1489  return ff_framequeue_queued_frames(&li->fifo) > 0;
1490 }
1491 
1493 {
1495  return ff_framequeue_queued_samples(&li->fifo);
1496 }
1497 
1499 {
1501  uint64_t samples = ff_framequeue_queued_samples(&li->fifo);
1502  av_assert1(min);
1503  return samples >= min || (li->status_in && samples);
1504 }
1505 
1507 {
1508  AVFilterLink *const link = &li->l.pub;
1509  update_link_current_pts(li, frame->pts);
1511  if (link == link->dst->inputs[0])
1512  link->dst->is_disabled = !evaluate_timeline_at_frame(link, frame);
1513  li->l.frame_count_out++;
1514  li->l.sample_count_out += frame->nb_samples;
1515 }
1516 
1518 {
1520  AVFrame *frame;
1521 
1522  *rframe = NULL;
1524  return 0;
1525 
1526  if (li->fifo.samples_skipped) {
1527  frame = ff_framequeue_peek(&li->fifo, 0);
1528  return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1529  }
1530 
1531  frame = ff_framequeue_take(&li->fifo);
1532  consume_update(li, frame);
1533  *rframe = frame;
1534  return 1;
1535 }
1536 
1538  AVFrame **rframe)
1539 {
1541  AVFrame *frame;
1542  int ret;
1543 
1544  av_assert1(min);
1545  *rframe = NULL;
1547  return 0;
1548  if (li->status_in)
1550  ret = take_samples(li, min, max, &frame);
1551  if (ret < 0)
1552  return ret;
1553  consume_update(li, frame);
1554  *rframe = frame;
1555  return 1;
1556 }
1557 
1559 {
1561  return ff_framequeue_peek(&li->fifo, idx);
1562 }
1563 
1565 {
1566  AVFrame *frame = *rframe;
1567  AVFrame *out;
1568  int ret;
1569 
1571  return 0;
1572  av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1573 
1574  switch (link->type) {
1575  case AVMEDIA_TYPE_VIDEO:
1576  out = ff_get_video_buffer(link, link->w, link->h);
1577  break;
1578  case AVMEDIA_TYPE_AUDIO:
1579  out = ff_get_audio_buffer(link, frame->nb_samples);
1580  break;
1581  default:
1582  return AVERROR(EINVAL);
1583  }
1584  if (!out)
1585  return AVERROR(ENOMEM);
1586 
1588  if (ret < 0) {
1589  av_frame_free(&out);
1590  return ret;
1591  }
1592 
1593  ret = av_frame_copy(out, frame);
1594  if (ret < 0) {
1595  av_frame_free(&out);
1596  return ret;
1597  }
1598 
1599  av_frame_free(&frame);
1600  *rframe = out;
1601  return 0;
1602 }
1603 
1605 {
1606  FFFilterContext *ctxi = fffilterctx(link->dst);
1607  AVFilterCommand *cmd = ctxi->command_queue;
1608 
1609  while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1610  av_log(link->dst, AV_LOG_DEBUG,
1611  "Processing command time:%f command:%s arg:%s\n",
1612  cmd->time, cmd->command, cmd->arg);
1613  avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1614  command_queue_pop(link->dst);
1615  cmd = ctxi->command_queue;
1616  }
1617  return 0;
1618 }
1619 
1621 {
1623  av_assert1(!li->status_in);
1624  av_assert1(!li->status_out);
1625  li->frame_wanted_out = 1;
1626  ff_filter_set_ready(link->src, 100);
1627 }
1628 
1630 {
1632  if (li->status_out)
1633  return;
1634  li->frame_wanted_out = 0;
1635  li->frame_blocked_in = 0;
1637  while (ff_framequeue_queued_frames(&li->fifo)) {
1639  av_frame_free(&frame);
1640  }
1641  if (!li->status_in)
1642  li->status_in = status;
1643 }
1644 
1646 {
1648  return li->status_in;
1649 }
1650 
1652 {
1653  FilterLinkInternal * const li_in = ff_link_internal(inlink);
1654  return ff_outlink_frame_wanted(outlink) ||
1656  li_in->status_out;
1657 }
1658 
1659 
1661 {
1662  return &avfilter_class;
1663 }
1664 
1666  int default_pool_size)
1667 {
1670 
1671  // Must already be set by caller.
1673 
1675 
1676  if (frames->initial_pool_size == 0) {
1677  // Dynamic allocation is necessarily supported.
1678  } else if (avctx->extra_hw_frames >= 0) {
1679  frames->initial_pool_size += avctx->extra_hw_frames;
1680  } else {
1681  frames->initial_pool_size = default_pool_size;
1682  }
1683 
1684  return 0;
1685 }
1686 
1688 {
1690  return li->frame_wanted_out;
1691 }
1692 
1694  void *arg, int *ret, int nb_jobs)
1695 {
1696  return fffilterctx(ctx)->execute(ctx, func, arg, ret, nb_jobs);
1697 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:605
flags
const SwsFlags flags[]
Definition: swscale.c:61
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:117
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:98
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
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:631
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:1678
ff_link_internal
static FilterLinkInternal * ff_link_internal(AVFilterLink *link)
Definition: avfilter_internal.h:90
r
const char * r
Definition: vf_curves.c:127
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:650
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:987
FFFilterContext::enable
struct AVExpr * enable
parsed expression
Definition: avfilter_internal.h:114
FFFilter::process_command
int(* process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags)
Make the filter instance process a command.
Definition: filters.h:446
out
FILE * out
Definition: movenc.c:55
evaluate_timeline_at_frame
static int 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:1017
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
update_link_current_pts
static void update_link_current_pts(FilterLinkInternal *li, int64_t pts)
Definition: avfilter.c:216
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1067
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:852
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:572
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3447
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
FFFilter::uninit
void(* uninit)(AVFilterContext *ctx)
Filter uninitialization function.
Definition: filters.h:336
AVFrame::nb_side_data
int nb_side_data
Definition: frame.h:625
rational.h
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:263
int64_t
long long int64_t
Definition: coverity.c:34
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:64
AVFilterContext::is_disabled
int is_disabled
MUST NOT be accessed from outside avfilter.
Definition: avfilter.h:343
ff_filter_activate
int ff_filter_activate(AVFilterContext *filter)
Definition: avfilter.c:1448
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:689
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
pixdesc.h
free_link
static void free_link(AVFilterLink *link)
Definition: avfilter.c:774
link_free
static void link_free(AVFilterLink **link)
Definition: avfilter.c:198
command_queue_pop
static void command_queue_pop(AVFilterContext *filter)
Definition: avfilter.c:81
AVOption
AVOption.
Definition: opt.h:429
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:1997
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:483
FilterLinkInternal::l
FilterLink l
Definition: avfilter_internal.h:35
FFFilter::priv_size
int priv_size
size of private data to allocate for the filter
Definition: filters.h:430
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
FFFilter::init
int(* init)(AVFilterContext *ctx)
Filter initialization function.
Definition: filters.h:324
max
#define max(a, b)
Definition: cuda_runtime.h:33
AVDictionary
Definition: dict.c:32
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:50
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
av_frame_side_data_clone
int av_frame_side_data_clone(AVFrameSideData ***sd, int *nb_sd, const AVFrameSideData *src, unsigned int flags)
Add a new side data entry to an array based on existing side data, taking a reference towards the con...
Definition: side_data.c:248
default_filter_name
static const char * default_filter_name(void *filter_ctx)
Definition: avfilter.c:636
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
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:701
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:599
ff_inoutlink_check_flow
int ff_inoutlink_check_flow(AVFilterLink *inlink, AVFilterLink *outlink)
Check for flow control between input and output.
Definition: avfilter.c:1651
fffilter
static const FFFilter * fffilter(const AVFilter *f)
Definition: filters.h:463
AVFILTERPAD_FLAG_FREE_NAME
#define AVFILTERPAD_FLAG_FREE_NAME
The pad's name is allocated and should be freed generically.
Definition: filters.h:63
FilterLinkInternal
Definition: avfilter_internal.h:34
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:655
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:710
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
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:1517
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:133
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:127
set_enable_expr
static int set_enable_expr(FFFilterContext *ctxi, const char *expr)
Definition: avfilter.c:569
fail
#define fail()
Definition: checkasm.h:200
AVOption::offset
int offset
Native access only.
Definition: opt.h:444
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:1875
AVFilterContext::enable_str
char * enable_str
enable expression string
Definition: avfilter.h:326
AVFilterCommand::flags
int flags
Definition: avfilter_internal.h:130
frames
if it could not because there are no more frames
Definition: filter_design.txt:267
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:282
av_filter_iterate
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:633
samplefmt.h
take_samples
static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max, AVFrame **rframe)
Definition: avfilter.c:1131
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:380
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1949
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:52
request_frame_to_filter
static int request_frame_to_filter(AVFilterLink *link)
Definition: avfilter.c:532
AVFrame::alpha_mode
enum AVAlphaMode alpha_mode
Indicates how the alpha channel of the video is to be handled.
Definition: frame.h:782
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:770
FFFilterContext::p
AVFilterContext p
The public AVFilterContext.
Definition: avfilter_internal.h:99
pts
static int64_t pts
Definition: transcode_aac.c:644
AVFILTER_THREAD_SLICE
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
Definition: avfilter.h:271
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:835
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:358
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:39
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:724
AV_DICT_DONT_STRDUP_VAL
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:79
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:328
FFFrameQueue::samples_skipped
int samples_skipped
Indicate that samples are skipped.
Definition: framequeue.h:118
avassert.h
ff_outlink_frame_wanted
int ff_outlink_frame_wanted(AVFilterLink *link)
Test if a frame is wanted on an output link.
Definition: avfilter.c:1687
FFFilterGraph::thread_execute
avfilter_execute_func * thread_execute
Definition: avfilter_internal.h:146
filter_activate_default
static int filter_activate_default(AVFilterContext *filter)
Definition: avfilter.c:1260
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
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:1498
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:642
FFFilter
Definition: filters.h:266
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:653
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1620
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1415
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:610
AVDictionaryEntry::key
char * key
Definition: dict.h:91
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
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:41
filters.h
VAR_W
@ VAR_W
Definition: avfilter.c:564
AVFilter::flags
int flags
A combination of AVFILTER_FLAG_*.
Definition: avfilter.h:260
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
ctx
AVFormatContext * ctx
Definition: movenc.c:49
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:792
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:158
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
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
FFFilter::preinit
int(* preinit)(AVFilterContext *ctx)
Filter pre-initialization function.
Definition: filters.h:301
ff_framequeue_take
AVFrame * ff_framequeue_take(FFFrameQueue *fq)
Take the first frame in the queue.
Definition: framequeue.c:104
ff_inlink_make_frame_writable
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
Definition: avfilter.c:1564
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:780
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:1558
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:1539
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
FFFilter::activate
int(* activate)(AVFilterContext *ctx)
Filter activation function.
Definition: filters.h:460
filter_unblock
static void filter_unblock(AVFilterContext *filter)
Clear frame_blocked_in on all outputs.
Definition: avfilter.c:239
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
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:1537
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:599
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:1506
ff_framequeue_add
int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
Add a frame.
Definition: framequeue.c:67
ff_framequeue_free
void ff_framequeue_free(FFFrameQueue *fq)
Free the queue and all queued frames.
Definition: framequeue.c:57
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:132
avfilter_link_get_hw_frames_ctx
AVBufferRef * avfilter_link_get_hw_frames_ctx(AVFilterLink *link)
Get the hardware frames context of a filter link.
Definition: avfilter.c:997
fffiltergraph
static FFFilterGraph * fffiltergraph(AVFilterGraph *graph)
Definition: avfilter_internal.h:150
options
Definition: swscale.c:43
AV_CLASS_STATE_INITIALIZED
@ AV_CLASS_STATE_INITIALIZED
Object initialization has finished and it is now in the 'runtime' stage.
Definition: log.h:56
avfilter_internal.h
filter_frame
static int filter_frame(DBEDecodeContext *s, AVFrame *frame)
Definition: dolby_e.c:1059
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
avfilter_class
static const AVClass avfilter_class
Definition: avfilter.c:677
ff_channel_layouts_unref
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition: formats.c:756
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:1464
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:1480
tlog_ref
static void tlog_ref(void *ctx, AVFrame *ref, int end)
Definition: avfilter.c:47
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:198
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:68
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: filters.h:207
FFFilterContext::command_queue
struct AVFilterCommand * command_queue
Definition: avfilter_internal.h:118
ff_frame_pool_uninit
void ff_frame_pool_uninit(FFFramePool **pool)
Deallocate the frame pool.
Definition: framepool.c:283
eval.h
AVFILTERPAD_FLAG_NEEDS_WRITABLE
#define AVFILTERPAD_FLAG_NEEDS_WRITABLE
The filter expects writable frames from its input link, duplicating data buffers if needed.
Definition: filters.h:58
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:381
f
f
Definition: af_crystalizer.c:122
FFFilter::nb_outputs
uint8_t nb_outputs
The number of entries in the list of outputs.
Definition: filters.h:280
default_execute
static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: avfilter.c:688
AVMediaType
AVMediaType
Definition: avutil.h:198
guess_status_pts
static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
Definition: avfilter.c:510
ff_inlink_set_status
void ff_inlink_set_status(AVFilterLink *link, int status)
Set the status on an input link.
Definition: avfilter.c:1629
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:1486
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
FilterLinkInternal::age_index
int age_index
Index in the age array.
Definition: avfilter_internal.h:80
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:711
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:122
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:590
avfilter_link
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
Definition: avfilter.c:149
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:247
FFFilterGraph::frame_queues
FFFrameQueueGlobal frame_queues
Definition: avfilter_internal.h:147
AVFrame::time_base
AVRational time_base
Time base for the timestamps in this frame.
Definition: frame.h:544
OFFSET
#define OFFSET(x)
Definition: avfilter.c:661
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:535
VAR_N
@ VAR_N
Definition: avfilter.c:563
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:514
AVOption::name
const char * name
Definition: opt.h:430
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:905
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:233
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:809
VAR_T
@ VAR_T
Definition: avfilter.c:562
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
avfilter_init_str
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:959
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:197
ff_framequeue_peek
AVFrame * ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
Access a frame in the queue, without removing it.
Definition: framequeue.c:122
FilterLinkInternal::frame_blocked_in
int frame_blocked_in
If set, the source filter can not generate a frame as is.
Definition: avfilter_internal.h:49
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
ff_tlog_link
#define ff_tlog_link(ctx, link, end)
Definition: avfilter_internal.h:210
FFFilterContext::state_flags
unsigned state_flags
Definition: avfilter_internal.h:104
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:744
avfilter_options
static const AVOption avfilter_options[]
Definition: avfilter.c:664
bprint.h
append_pad
static int append_pad(unsigned *count, AVFilterPad **pads, AVFilterLink ***links, AVFilterPad *newpad)
Append a new pad.
Definition: avfilter.c:100
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_frame_side_data_free
void av_frame_side_data_free(AVFrameSideData ***sd, int *nb_sd)
Free all side data entries and their contents, then zeroes out the values which the pointers are poin...
Definition: side_data.c:133
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:269
filter_child_next
static void * filter_child_next(void *obj, void *prev)
Definition: avfilter.c:642
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:250
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:1962
internal.h
fffilterctx
static FFFilterContext * fffilterctx(AVFilterContext *ctx)
Definition: avfilter_internal.h:121
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:488
AVFilterCommand
Definition: avfilter_internal.h:126
FilterLinkInternal::status_in
int status_in
Link input status.
Definition: avfilter_internal.h:56
FFFilter::nb_inputs
uint8_t nb_inputs
The number of entries in the list of inputs.
Definition: filters.h:275
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:845
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
ff_framequeue_queued_samples
static uint64_t ff_framequeue_queued_samples(const FFFrameQueue *fq)
Get the number of queued samples.
Definition: framequeue.h:166
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
FilterLinkInternal::frame_wanted_out
int frame_wanted_out
True if a frame is currently wanted on the output of this filter.
Definition: avfilter_internal.h:75
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FF_TPRINTF_START
#define FF_TPRINTF_START(ctx, func)
Definition: avfilter_internal.h:205
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:256
AVFilterPad::flags
int flags
A combination of AVFILTERPAD_FLAG_* flags.
Definition: filters.h:68
VAR_H
@ VAR_H
Definition: avfilter.c:565
AVFrame::side_data
AVFrameSideData ** side_data
Definition: frame.h:624
filt
static const int8_t filt[NUMTAPS *2]
Definition: af_earwax.c:40
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:45
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:693
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1492
forward_status_change
static int forward_status_change(AVFilterContext *filter, FilterLinkInternal *li_in)
Definition: avfilter.c:1225
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:650
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AVFilter
Filter definition.
Definition: avfilter.h:216
VAR_VARS_NB
@ VAR_VARS_NB
Definition: avfilter.c:566
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:118
FFFilterContext::ready
unsigned ready
Ready status of the filter.
Definition: avfilter_internal.h:111
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: filters.h:50
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:81
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
framepool.h
FFFilter::flags_internal
int flags_internal
Additional flags for avfilter internal use only.
Definition: filters.h:432
AVOption::type
enum AVOptionType type
Definition: opt.h:445
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:524
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: af_aecho.c:272
ff_framequeue_queued_frames
static size_t ff_framequeue_queued_frames(const FFFrameQueue *fq)
Get the number of queued frames.
Definition: framequeue.h:158
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:992
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
ff_filter_graph_remove_filter
void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
Remove a filter from a graph;.
Definition: avfiltergraph.c:101
status
ov_status_e status
Definition: dnn_backend_openvino.c:100
channel_layout.h
FFFilterContext::execute
avfilter_execute_func * execute
Definition: avfilter_internal.h:101
ff_filter_execute
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: avfilter.c:1693
AVClass::option
const struct AVOption * option
An array of options for the structure or NULL.
Definition: log.h:96
avfilter_init_dict
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
Initialize a filter with the supplied dictionary of options.
Definition: avfilter.c:918
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:377
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
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:442
AVFilterCommand::command
char * command
command
Definition: avfilter_internal.h:128
FFFilterContext
Definition: avfilter_internal.h:95
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
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:129
FFFilterContext::var_values
double * var_values
variable values for the enable expression
Definition: avfilter_internal.h:116
filter_frame_framed
static int filter_frame_framed(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:1035
ff_outlink_get_status
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
Definition: avfilter.c:1645
AVFilterContext
An instance of a filter.
Definition: avfilter.h:274
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:167
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:270
FilterLinkInternal::init_state
enum FilterLinkInternal::@347 init_state
stage of the initialization of the link properties (dimensions, etc)
mem.h
audio.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
TFLAGS
#define TFLAGS
Definition: avfilter.c:663
avfilter_free
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:799
ff_append_outpad
int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:138
FLAGS
#define FLAGS
Definition: avfilter.c:662
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:90
default_filter_frame
static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:1006
ff_tlog
#define ff_tlog(a,...)
Definition: tableprint_vlc.h:29
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:1604
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:210
ff_append_outpad_free_name
int ff_append_outpad_free_name(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:143
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:86
var_names
static const char *const var_names[]
Definition: avfilter.c:553
samples_ready
static int samples_ready(FilterLinkInternal *link, unsigned min)
Definition: avfilter.c:1124
FilterLinkInternal::frame_pool
struct FFFramePool * frame_pool
Definition: avfilter_internal.h:37
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
hwcontext.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FilterLinkInternal::fifo
FFFrameQueue fifo
Queue of frames waiting to be filtered.
Definition: avfilter_internal.h:42
ff_channel_layouts_changeref
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref, AVFilterChannelLayouts **newref)
Definition: formats.c:774
avstring.h
AVFilterContext::filter
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:277
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
avfilter_get_class
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:1660
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
FilterLinkInternal::status_in_pts
int64_t status_in_pts
Timestamp of the input status change.
Definition: avfilter_internal.h:61
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:42
src
#define src
Definition: vp8dsp.c:248
AV_DICT_DONT_STRDUP_KEY
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function.
Definition: dict.h:77
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:311
filter_frame_to_filter
static int filter_frame_to_filter(AVFilterLink *link)
Definition: avfilter.c:1192
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:3367
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:229
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:1665
AVFilterCommand::time
double time
time expressed in seconds
Definition: avfilter_internal.h:127
min
float min
Definition: vorbis_enc_data.h:429