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 "internal.h"
46 #include "video.h"
47 
48 static void tlog_ref(void *ctx, AVFrame *ref, int end)
49 {
50 #ifdef TRACE
51  ff_tlog(ctx,
52  "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64,
53  ref, ref->buf, ref->data[0],
54  ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
55  ref->pts);
56 
57  if (ref->width) {
58  ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
59  ref->sample_aspect_ratio.num, ref->sample_aspect_ratio.den,
60  ref->width, ref->height,
61  !(ref->flags & AV_FRAME_FLAG_INTERLACED) ? 'P' : /* Progressive */
62  (ref->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 'T' : 'B', /* Top / Bottom */
63  !!(ref->flags & AV_FRAME_FLAG_KEY),
64  av_get_picture_type_char(ref->pict_type));
65  }
66  if (ref->nb_samples) {
67  AVBPrint bprint;
68 
70  av_channel_layout_describe_bprint(&ref->ch_layout, &bprint);
71  ff_tlog(ctx, " cl:%s n:%d r:%d",
72  bprint.str,
73  ref->nb_samples,
74  ref->sample_rate);
75  av_bprint_finalize(&bprint, NULL);
76  }
77 
78  ff_tlog(ctx, "]%s", end ? "\n" : "");
79 #endif
80 }
81 
83 {
84  AVFilterCommand *c= filter->command_queue;
85  av_freep(&c->arg);
86  av_freep(&c->command);
87  filter->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 
164  av_log(src, AV_LOG_ERROR, "Filters must be initialized before linking.\n");
165  return AVERROR(EINVAL);
166  }
167 
168  if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
170  "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
171  src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),
172  dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));
173  return AVERROR(EINVAL);
174  }
175 
176  li = av_mallocz(sizeof(*li));
177  if (!li)
178  return AVERROR(ENOMEM);
179  link = &li->l;
180 
181  src->outputs[srcpad] = dst->inputs[dstpad] = link;
182 
183  link->src = src;
184  link->dst = dst;
185  link->srcpad = &src->output_pads[srcpad];
186  link->dstpad = &dst->input_pads[dstpad];
187  link->type = src->output_pads[srcpad].type;
189  link->format = -1;
192 
193  return 0;
194 }
195 
197 {
198  FilterLinkInternal *li;
199 
200  if (!*link)
201  return;
202  li = ff_link_internal(*link);
203 
204  ff_framequeue_free(&li->fifo);
206  av_channel_layout_uninit(&(*link)->ch_layout);
207 
208  av_freep(link);
209 }
210 
211 #if FF_API_LINK_PUBLIC
212 void avfilter_link_free(AVFilterLink **link)
213 {
214  link_free(link);
215 }
216 int avfilter_config_links(AVFilterContext *filter)
217 {
219 }
220 #endif
221 
223 {
224  AVFilterLink *const link = &li->l;
225 
226  if (pts == AV_NOPTS_VALUE)
227  return;
228  link->current_pts = pts;
229  link->current_pts_us = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
230  /* TODO use duration */
231  if (link->graph && li->age_index >= 0)
233 }
234 
235 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
236 {
237  filter->ready = FFMAX(filter->ready, priority);
238 }
239 
240 /**
241  * Clear frame_blocked_in on all outputs.
242  * This is necessary whenever something changes on input.
243  */
245 {
246  unsigned i;
247 
248  for (i = 0; i < filter->nb_outputs; i++) {
249  FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
250  li->frame_blocked_in = 0;
251  }
252 }
253 
254 
256 {
258 
259  if (li->status_in == status)
260  return;
261  av_assert0(!li->status_in);
262  li->status_in = status;
263  li->status_in_pts = pts;
264  link->frame_wanted_out = 0;
265  li->frame_blocked_in = 0;
266  filter_unblock(link->dst);
267  ff_filter_set_ready(link->dst, 200);
268 }
269 
270 /**
271  * Set the status field of a link from the destination filter.
272  * The pts should probably be left unset (AV_NOPTS_VALUE).
273  */
274 static void link_set_out_status(AVFilterLink *link, int status, int64_t pts)
275 {
277 
278  av_assert0(!link->frame_wanted_out);
279  av_assert0(!li->status_out);
280  li->status_out = status;
281  if (pts != AV_NOPTS_VALUE)
283  filter_unblock(link->dst);
284  ff_filter_set_ready(link->src, 200);
285 }
286 
288  unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
289 {
290  int ret;
291  unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
292 
293  av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
294  "between the filter '%s' and the filter '%s'\n",
295  filt->name, link->src->name, link->dst->name);
296 
297  link->dst->inputs[dstpad_idx] = NULL;
298  if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {
299  /* failed to link output filter to new filter */
300  link->dst->inputs[dstpad_idx] = link;
301  return ret;
302  }
303 
304  /* re-hookup the link to the new destination filter we inserted */
305  link->dst = filt;
306  link->dstpad = &filt->input_pads[filt_srcpad_idx];
307  filt->inputs[filt_srcpad_idx] = link;
308 
309  /* if any information on supported media formats already exists on the
310  * link, we need to preserve that */
311  if (link->outcfg.formats)
312  ff_formats_changeref(&link->outcfg.formats,
313  &filt->outputs[filt_dstpad_idx]->outcfg.formats);
314  if (link->outcfg.color_spaces)
315  ff_formats_changeref(&link->outcfg.color_spaces,
316  &filt->outputs[filt_dstpad_idx]->outcfg.color_spaces);
317  if (link->outcfg.color_ranges)
318  ff_formats_changeref(&link->outcfg.color_ranges,
319  &filt->outputs[filt_dstpad_idx]->outcfg.color_ranges);
320  if (link->outcfg.samplerates)
321  ff_formats_changeref(&link->outcfg.samplerates,
322  &filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
323  if (link->outcfg.channel_layouts)
324  ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
325  &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
326 
327  return 0;
328 }
329 
331 {
332  int (*config_link)(AVFilterLink *);
333  unsigned i;
334  int ret;
335 
336  for (i = 0; i < filter->nb_inputs; i ++) {
337  AVFilterLink *link = filter->inputs[i];
340 
341  if (!link) continue;
342  if (!link->src || !link->dst) {
344  "Not all input and output are properly linked (%d).\n", i);
345  return AVERROR(EINVAL);
346  }
347 
348  inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
349  link->current_pts =
350  link->current_pts_us = AV_NOPTS_VALUE;
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  } else if ((ret = config_link(link)) < 0) {
373  av_log(link->src, AV_LOG_ERROR,
374  "Failed to configure output pad on %s\n",
375  link->src->name);
376  return ret;
377  }
378 
379  switch (link->type) {
380  case AVMEDIA_TYPE_VIDEO:
381  if (!link->time_base.num && !link->time_base.den)
382  link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
383 
386  inlink->sample_aspect_ratio : (AVRational){1,1};
387 
388  if (inlink) {
389  if (!link->frame_rate.num && !link->frame_rate.den)
390  link->frame_rate = inlink->frame_rate;
391  if (!link->w)
392  link->w = inlink->w;
393  if (!link->h)
394  link->h = inlink->h;
395  } else if (!link->w || !link->h) {
396  av_log(link->src, AV_LOG_ERROR,
397  "Video source filters must set their output link's "
398  "width and height\n");
399  return AVERROR(EINVAL);
400  }
401  break;
402 
403  case AVMEDIA_TYPE_AUDIO:
404  if (inlink) {
405  if (!link->time_base.num && !link->time_base.den)
406  link->time_base = inlink->time_base;
407  }
408 
409  if (!link->time_base.num && !link->time_base.den)
411  }
412 
413  if (link->src->nb_inputs && link->src->inputs[0]->hw_frames_ctx &&
414  !(link->src->filter->flags_internal & FF_FILTER_FLAG_HWFRAME_AWARE)) {
416  "should not be set by non-hwframe-aware filter");
417  link->hw_frames_ctx = av_buffer_ref(link->src->inputs[0]->hw_frames_ctx);
418  if (!link->hw_frames_ctx)
419  return AVERROR(ENOMEM);
420  }
421 
422  if ((config_link = link->dstpad->config_props))
423  if ((ret = config_link(link)) < 0) {
424  av_log(link->dst, AV_LOG_ERROR,
425  "Failed to configure input pad on %s\n",
426  link->dst->name);
427  return ret;
428  }
429 
430  li->init_state = AVLINK_INIT;
431  }
432  }
433 
434  return 0;
435 }
436 
437 #ifdef TRACE
438 void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
439 {
440  if (link->type == AVMEDIA_TYPE_VIDEO) {
441  ff_tlog(ctx,
442  "link[%p s:%dx%d fmt:%s %s->%s]%s",
443  link, link->w, link->h,
445  link->src ? link->src->filter->name : "",
446  link->dst ? link->dst->filter->name : "",
447  end ? "\n" : "");
448  } else {
449  char buf[128];
450  av_channel_layout_describe(&link->ch_layout, buf, sizeof(buf));
451 
452  ff_tlog(ctx,
453  "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
454  link, (int)link->sample_rate, buf,
456  link->src ? link->src->filter->name : "",
457  link->dst ? link->dst->filter->name : "",
458  end ? "\n" : "");
459  }
460 }
461 #endif
462 
464 {
466 
468 
469  av_assert1(!link->dst->filter->activate);
470  if (li->status_out)
471  return li->status_out;
472  if (li->status_in) {
473  if (ff_framequeue_queued_frames(&li->fifo)) {
474  av_assert1(!link->frame_wanted_out);
475  av_assert1(link->dst->ready >= 300);
476  return 0;
477  } else {
478  /* Acknowledge status change. Filters using ff_request_frame() will
479  handle the change automatically. Filters can also check the
480  status directly but none do yet. */
482  return li->status_out;
483  }
484  }
485  link->frame_wanted_out = 1;
486  ff_filter_set_ready(link->src, 100);
487  return 0;
488 }
489 
490 static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
491 {
492  unsigned i;
493  int64_t r = INT64_MAX;
494 
495  for (i = 0; i < ctx->nb_inputs; i++) {
496  FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
497  if (li->status_out == status)
498  r = FFMIN(r, av_rescale_q(ctx->inputs[i]->current_pts, ctx->inputs[i]->time_base, link_time_base));
499  }
500  if (r < INT64_MAX)
501  return r;
502  av_log(ctx, AV_LOG_WARNING, "EOF timestamp not reliable\n");
503  for (i = 0; i < ctx->nb_inputs; i++) {
504  FilterLinkInternal * const li = ff_link_internal(ctx->inputs[i]);
505  r = FFMIN(r, av_rescale_q(li->status_in_pts, ctx->inputs[i]->time_base, link_time_base));
506  }
507  if (r < INT64_MAX)
508  return r;
509  return AV_NOPTS_VALUE;
510 }
511 
513 {
515  int ret = -1;
516 
517  FF_TPRINTF_START(NULL, request_frame_to_filter); ff_tlog_link(NULL, link, 1);
518  /* Assume the filter is blocked, let the method clear it if not */
519  li->frame_blocked_in = 1;
520  if (link->srcpad->request_frame)
521  ret = link->srcpad->request_frame(link);
522  else if (link->src->inputs[0])
523  ret = ff_request_frame(link->src->inputs[0]);
524  if (ret < 0) {
525  if (ret != AVERROR(EAGAIN) && ret != li->status_in)
527  if (ret == AVERROR_EOF)
528  ret = 0;
529  }
530  return ret;
531 }
532 
533 static const char *const var_names[] = {
534  "t",
535  "n",
536 #if FF_API_FRAME_PKT
537  "pos",
538 #endif
539  "w",
540  "h",
541  NULL
542 };
543 
544 enum {
547 #if FF_API_FRAME_PKT
548  VAR_POS,
549 #endif
553 };
554 
555 static int set_enable_expr(AVFilterContext *ctx, const char *expr)
556 {
557  int ret;
558  char *expr_dup;
559  AVExpr *old = ctx->enable;
560 
561  if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) {
562  av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
563  "with filter '%s'\n", ctx->filter->name);
564  return AVERROR_PATCHWELCOME;
565  }
566 
567  expr_dup = av_strdup(expr);
568  if (!expr_dup)
569  return AVERROR(ENOMEM);
570 
571  if (!ctx->var_values) {
572  ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values));
573  if (!ctx->var_values) {
574  av_free(expr_dup);
575  return AVERROR(ENOMEM);
576  }
577  }
578 
579  ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names,
580  NULL, NULL, NULL, NULL, 0, ctx->priv);
581  if (ret < 0) {
582  av_log(ctx->priv, AV_LOG_ERROR,
583  "Error when evaluating the expression '%s' for enable\n",
584  expr_dup);
585  av_free(expr_dup);
586  return ret;
587  }
588 
589  av_expr_free(old);
590  av_free(ctx->enable_str);
591  ctx->enable_str = expr_dup;
592  return 0;
593 }
594 
595 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
596 {
597  if(!strcmp(cmd, "ping")){
598  char local_res[256] = {0};
599 
600  if (!res) {
601  res = local_res;
602  res_len = sizeof(local_res);
603  }
604  av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
605  if (res == local_res)
606  av_log(filter, AV_LOG_INFO, "%s", res);
607  return 0;
608  }else if(!strcmp(cmd, "enable")) {
609  return set_enable_expr(filter, arg);
610  }else if(filter->filter->process_command) {
611  return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);
612  }
613  return AVERROR(ENOSYS);
614 }
615 
616 unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output)
617 {
618  return is_output ? filter->nb_outputs : filter->nb_inputs;
619 }
620 
621 static const char *default_filter_name(void *filter_ctx)
622 {
624  return ctx->name ? ctx->name : ctx->filter->name;
625 }
626 
627 static void *filter_child_next(void *obj, void *prev)
628 {
629  AVFilterContext *ctx = obj;
630  if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
631  return ctx->priv;
632  return NULL;
633 }
634 
635 static const AVClass *filter_child_class_iterate(void **iter)
636 {
637  const AVFilter *f;
638 
639  while ((f = av_filter_iterate(iter)))
640  if (f->priv_class)
641  return f->priv_class;
642 
643  return NULL;
644 }
645 
646 #define OFFSET(x) offsetof(AVFilterContext, x)
647 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
648 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
649 static const AVOption avfilter_options[] = {
650  { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
651  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, .unit = "thread_type" },
652  { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
653  { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = TFLAGS },
654  { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
655  { .i64 = 0 }, 0, INT_MAX, FLAGS, .unit = "threads" },
656  {"auto", "autodetect a suitable number of threads to use", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, .flags = FLAGS, .unit = "threads"},
657  { "extra_hw_frames", "Number of extra hardware frames to allocate for the user",
658  OFFSET(extra_hw_frames), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
659  { NULL },
660 };
661 
662 static const AVClass avfilter_class = {
663  .class_name = "AVFilter",
664  .item_name = default_filter_name,
665  .version = LIBAVUTIL_VERSION_INT,
666  .category = AV_CLASS_CATEGORY_FILTER,
667  .child_next = filter_child_next,
668  .child_class_iterate = filter_child_class_iterate,
670 };
671 
673  int *ret, int nb_jobs)
674 {
675  int i;
676 
677  for (i = 0; i < nb_jobs; i++) {
678  int r = func(ctx, arg, i, nb_jobs);
679  if (ret)
680  ret[i] = r;
681  }
682  return 0;
683 }
684 
685 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
686 {
689  int preinited = 0;
690 
691  if (!filter)
692  return NULL;
693 
694  ctx = av_mallocz(sizeof(*ctx));
695  if (!ctx)
696  return NULL;
697  ret = &ctx->p;
698 
699  ret->av_class = &avfilter_class;
700  ret->filter = filter;
701  ret->name = inst_name ? av_strdup(inst_name) : NULL;
702  if (filter->priv_size) {
703  ret->priv = av_mallocz(filter->priv_size);
704  if (!ret->priv)
705  goto err;
706  }
707  if (filter->preinit) {
708  if (filter->preinit(ret) < 0)
709  goto err;
710  preinited = 1;
711  }
712 
714  if (filter->priv_class) {
715  *(const AVClass**)ret->priv = filter->priv_class;
716  av_opt_set_defaults(ret->priv);
717  }
718 
719  ctx->execute = default_execute;
720 
721  ret->nb_inputs = filter->nb_inputs;
722  if (ret->nb_inputs ) {
723  ret->input_pads = av_memdup(filter->inputs, ret->nb_inputs * sizeof(*filter->inputs));
724  if (!ret->input_pads)
725  goto err;
726  ret->inputs = av_calloc(ret->nb_inputs, sizeof(*ret->inputs));
727  if (!ret->inputs)
728  goto err;
729  }
730 
731  ret->nb_outputs = filter->nb_outputs;
732  if (ret->nb_outputs) {
733  ret->output_pads = av_memdup(filter->outputs, ret->nb_outputs * sizeof(*filter->outputs));
734  if (!ret->output_pads)
735  goto err;
736  ret->outputs = av_calloc(ret->nb_outputs, sizeof(*ret->outputs));
737  if (!ret->outputs)
738  goto err;
739  }
740 
741  return ret;
742 
743 err:
744  if (preinited)
745  filter->uninit(ret);
746  av_freep(&ret->inputs);
747  av_freep(&ret->input_pads);
748  ret->nb_inputs = 0;
749  av_freep(&ret->outputs);
750  av_freep(&ret->output_pads);
751  ret->nb_outputs = 0;
752  av_freep(&ret->priv);
753  av_free(ret);
754  return NULL;
755 }
756 
758 {
759  if (!link)
760  return;
761 
762  if (link->src)
763  link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
764  if (link->dst)
765  link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
766 
768 
769  ff_formats_unref(&link->incfg.formats);
770  ff_formats_unref(&link->outcfg.formats);
771  ff_formats_unref(&link->incfg.color_spaces);
772  ff_formats_unref(&link->outcfg.color_spaces);
773  ff_formats_unref(&link->incfg.color_ranges);
774  ff_formats_unref(&link->outcfg.color_ranges);
775  ff_formats_unref(&link->incfg.samplerates);
776  ff_formats_unref(&link->outcfg.samplerates);
777  ff_channel_layouts_unref(&link->incfg.channel_layouts);
778  ff_channel_layouts_unref(&link->outcfg.channel_layouts);
779  link_free(&link);
780 }
781 
783 {
784  int i;
785 
786  if (!filter)
787  return;
788 
789  if (filter->graph)
791 
792  if (filter->filter->uninit)
793  filter->filter->uninit(filter);
794 
795  for (i = 0; i < filter->nb_inputs; i++) {
796  free_link(filter->inputs[i]);
797  if (filter->input_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
798  av_freep(&filter->input_pads[i].name);
799  }
800  for (i = 0; i < filter->nb_outputs; i++) {
801  free_link(filter->outputs[i]);
802  if (filter->output_pads[i].flags & AVFILTERPAD_FLAG_FREE_NAME)
803  av_freep(&filter->output_pads[i].name);
804  }
805 
806  if (filter->filter->priv_class)
807  av_opt_free(filter->priv);
808 
809  av_buffer_unref(&filter->hw_device_ctx);
810 
811  av_freep(&filter->name);
812  av_freep(&filter->input_pads);
813  av_freep(&filter->output_pads);
814  av_freep(&filter->inputs);
815  av_freep(&filter->outputs);
816  av_freep(&filter->priv);
817  while(filter->command_queue){
819  }
821  av_expr_free(filter->enable);
822  filter->enable = NULL;
823  av_freep(&filter->var_values);
824  av_free(filter);
825 }
826 
828 {
829  if (ctx->nb_threads > 0)
830  return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
831  return ctx->graph->nb_threads;
832 }
833 
834 int ff_filter_opt_parse(void *logctx, const AVClass *priv_class,
835  AVDictionary **options, const char *args)
836 {
837  const AVOption *o = NULL;
838  int ret;
839  int offset= -1;
840 
841  if (!args)
842  return 0;
843 
844  while (*args) {
845  char *parsed_key, *value;
846  const char *key;
847  const char *shorthand = NULL;
848  int additional_flags = 0;
849 
850  if (priv_class && (o = av_opt_next(&priv_class, o))) {
851  if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
852  continue;
853  offset = o->offset;
854  shorthand = o->name;
855  }
856 
857  ret = av_opt_get_key_value(&args, "=", ":",
858  shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
859  &parsed_key, &value);
860  if (ret < 0) {
861  if (ret == AVERROR(EINVAL))
862  av_log(logctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
863  else
864  av_log(logctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
865  av_err2str(ret));
866  return ret;
867  }
868  if (*args)
869  args++;
870  if (parsed_key) {
871  key = parsed_key;
872  additional_flags = AV_DICT_DONT_STRDUP_KEY;
873  priv_class = NULL; /* reject all remaining shorthand */
874  } else {
875  key = shorthand;
876  }
877 
878  av_log(logctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
879 
881  additional_flags | AV_DICT_DONT_STRDUP_VAL | AV_DICT_MULTIKEY);
882  }
883 
884  return 0;
885 }
886 
888  const char *arg, char *res, int res_len, int flags)
889 {
890  const AVOption *o;
891 
892  if (!ctx->filter->priv_class)
893  return 0;
895  if (!o)
896  return AVERROR(ENOSYS);
897  return av_opt_set(ctx->priv, cmd, arg, 0);
898 }
899 
901 {
903  int ret = 0;
904 
905  if (ctxi->initialized) {
906  av_log(ctx, AV_LOG_ERROR, "Filter already initialized\n");
907  return AVERROR(EINVAL);
908  }
909 
911  if (ret < 0) {
912  av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
913  return ret;
914  }
915 
916  if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
917  ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
918  fffiltergraph(ctx->graph)->thread_execute) {
919  ctx->thread_type = AVFILTER_THREAD_SLICE;
920  ctxi->execute = fffiltergraph(ctx->graph)->thread_execute;
921  } else {
922  ctx->thread_type = 0;
923  }
924 
925  if (ctx->filter->init)
926  ret = ctx->filter->init(ctx);
927  if (ret < 0)
928  return ret;
929 
930  if (ctx->enable_str) {
931  ret = set_enable_expr(ctx, ctx->enable_str);
932  if (ret < 0)
933  return ret;
934  }
935 
936  ctxi->initialized = 1;
937 
938  return 0;
939 }
940 
941 int avfilter_init_str(AVFilterContext *filter, const char *args)
942 {
944  const AVDictionaryEntry *e;
945  int ret = 0;
946 
947  if (args && *args) {
948  ret = ff_filter_opt_parse(filter, filter->filter->priv_class, &options, args);
949  if (ret < 0)
950  goto fail;
951  }
952 
954  if (ret < 0)
955  goto fail;
956 
957  if ((e = av_dict_iterate(options, NULL))) {
958  av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
960  goto fail;
961  }
962 
963 fail:
965 
966  return ret;
967 }
968 
969 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
970 {
971  return pads[pad_idx].name;
972 }
973 
974 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
975 {
976  return pads[pad_idx].type;
977 }
978 
980 {
981  return ff_filter_frame(link->dst->outputs[0], frame);
982 }
983 
985 {
987  AVFilterContext *dstctx = link->dst;
988  AVFilterPad *dst = link->dstpad;
989  int ret;
990 
991  if (!(filter_frame = dst->filter_frame))
993 
996  if (ret < 0)
997  goto fail;
998  }
999 
1002 
1003  if (dstctx->is_disabled &&
1006  ret = filter_frame(link, frame);
1007  link->frame_count_out++;
1008  return ret;
1009 
1010 fail:
1011  av_frame_free(&frame);
1012  return ret;
1013 }
1014 
1016 {
1018  int ret;
1020 
1021  /* Consistency checks */
1022  if (link->type == AVMEDIA_TYPE_VIDEO) {
1023  if (strcmp(link->dst->filter->name, "buffersink") &&
1024  strcmp(link->dst->filter->name, "format") &&
1025  strcmp(link->dst->filter->name, "idet") &&
1026  strcmp(link->dst->filter->name, "null") &&
1027  strcmp(link->dst->filter->name, "scale")) {
1028  av_assert1(frame->format == link->format);
1029  av_assert1(frame->width == link->w);
1030  av_assert1(frame->height == link->h);
1031  }
1032 
1033  frame->sample_aspect_ratio = link->sample_aspect_ratio;
1034  } else {
1035  if (frame->format != link->format) {
1036  av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1037  goto error;
1038  }
1039  if (av_channel_layout_compare(&frame->ch_layout, &link->ch_layout)) {
1040  av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1041  goto error;
1042  }
1043  if (frame->sample_rate != link->sample_rate) {
1044  av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1045  goto error;
1046  }
1047 
1048  frame->duration = av_rescale_q(frame->nb_samples, (AVRational){ 1, frame->sample_rate },
1049  link->time_base);
1050  }
1051 
1052  li->frame_blocked_in = link->frame_wanted_out = 0;
1053  link->frame_count_in++;
1054  link->sample_count_in += frame->nb_samples;
1055  filter_unblock(link->dst);
1056  ret = ff_framequeue_add(&li->fifo, frame);
1057  if (ret < 0) {
1058  av_frame_free(&frame);
1059  return ret;
1060  }
1061  ff_filter_set_ready(link->dst, 300);
1062  return 0;
1063 
1064 error:
1065  av_frame_free(&frame);
1066  return AVERROR_PATCHWELCOME;
1067 }
1068 
1070 {
1071  return ff_framequeue_queued_frames(&link->fifo) &&
1072  (ff_framequeue_queued_samples(&link->fifo) >= min ||
1073  link->status_in);
1074 }
1075 
1076 static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max,
1077  AVFrame **rframe)
1078 {
1079  AVFilterLink *link = &li->l;
1080  AVFrame *frame0, *frame, *buf;
1081  unsigned nb_samples, nb_frames, i, p;
1082  int ret;
1083 
1084  /* Note: this function relies on no format changes and must only be
1085  called with enough samples. */
1086  av_assert1(samples_ready(li, link->min_samples));
1087  frame0 = frame = ff_framequeue_peek(&li->fifo, 0);
1088  if (!li->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1089  *rframe = ff_framequeue_take(&li->fifo);
1090  return 0;
1091  }
1092  nb_frames = 0;
1093  nb_samples = 0;
1094  while (1) {
1095  if (nb_samples + frame->nb_samples > max) {
1096  if (nb_samples < min)
1097  nb_samples = max;
1098  break;
1099  }
1100  nb_samples += frame->nb_samples;
1101  nb_frames++;
1102  if (nb_frames == ff_framequeue_queued_frames(&li->fifo))
1103  break;
1104  frame = ff_framequeue_peek(&li->fifo, nb_frames);
1105  }
1106 
1107  buf = ff_get_audio_buffer(link, nb_samples);
1108  if (!buf)
1109  return AVERROR(ENOMEM);
1110  ret = av_frame_copy_props(buf, frame0);
1111  if (ret < 0) {
1112  av_frame_free(&buf);
1113  return ret;
1114  }
1115 
1116  p = 0;
1117  for (i = 0; i < nb_frames; i++) {
1118  frame = ff_framequeue_take(&li->fifo);
1119  av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1120  frame->nb_samples, link->ch_layout.nb_channels, link->format);
1121  p += frame->nb_samples;
1122  av_frame_free(&frame);
1123  }
1124  if (p < nb_samples) {
1125  unsigned n = nb_samples - p;
1126  frame = ff_framequeue_peek(&li->fifo, 0);
1127  av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1130  }
1131 
1132  *rframe = buf;
1133  return 0;
1134 }
1135 
1137 {
1139  AVFrame *frame = NULL;
1140  AVFilterContext *dst = link->dst;
1141  int ret;
1142 
1144  ret = link->min_samples ?
1145  ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1147  av_assert1(ret);
1148  if (ret < 0) {
1149  av_assert1(!frame);
1150  return ret;
1151  }
1152  /* The filter will soon have received a new frame, that may allow it to
1153  produce one or more: unblock its outputs. */
1154  filter_unblock(dst);
1155  /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1156  before the frame; ff_filter_frame_framed() will re-increment it. */
1157  link->frame_count_out--;
1159  if (ret < 0 && ret != li->status_out) {
1161  } else {
1162  /* Run once again, to see if several frames were available, or if
1163  the input status has also changed, or any other reason. */
1164  ff_filter_set_ready(dst, 300);
1165  }
1166  return ret;
1167 }
1168 
1170 {
1171  AVFilterLink *in = &li_in->l;
1172  unsigned out = 0, progress = 0;
1173  int ret;
1174 
1175  av_assert0(!li_in->status_out);
1176  if (!filter->nb_outputs) {
1177  /* not necessary with the current API and sinks */
1178  return 0;
1179  }
1180  while (!li_in->status_out) {
1181  FilterLinkInternal *li_out = ff_link_internal(filter->outputs[out]);
1182 
1183  if (!li_out->status_in) {
1184  progress++;
1186  if (ret < 0)
1187  return ret;
1188  }
1189  if (++out == filter->nb_outputs) {
1190  if (!progress) {
1191  /* Every output already closed: input no longer interesting
1192  (example: overlay in shortest mode, other input closed). */
1193  link_set_out_status(in, li_in->status_in, li_in->status_in_pts);
1194  return 0;
1195  }
1196  progress = 0;
1197  out = 0;
1198  }
1199  }
1201  return 0;
1202 }
1203 
1205 {
1206  unsigned i;
1207 
1208  for (i = 0; i < filter->nb_outputs; i++) {
1209  FilterLinkInternal *li = ff_link_internal(filter->outputs[i]);
1210  int ret = li->status_in;
1211 
1212  if (ret) {
1213  for (int j = 0; j < filter->nb_inputs; j++)
1214  ff_inlink_set_status(filter->inputs[j], ret);
1215  return 0;
1216  }
1217  }
1218 
1219  for (i = 0; i < filter->nb_inputs; i++) {
1220  if (samples_ready(ff_link_internal(filter->inputs[i]),
1221  filter->inputs[i]->min_samples)) {
1222  return ff_filter_frame_to_filter(filter->inputs[i]);
1223  }
1224  }
1225  for (i = 0; i < filter->nb_inputs; i++) {
1226  FilterLinkInternal * const li = ff_link_internal(filter->inputs[i]);
1227  if (li->status_in && !li->status_out) {
1229  return forward_status_change(filter, li);
1230  }
1231  }
1232  for (i = 0; i < filter->nb_outputs; i++) {
1233  FilterLinkInternal * const li = ff_link_internal(filter->outputs[i]);
1234  if (filter->outputs[i]->frame_wanted_out &&
1235  !li->frame_blocked_in) {
1236  return ff_request_frame_to_filter(filter->outputs[i]);
1237  }
1238  }
1239  return FFERROR_NOT_READY;
1240 }
1241 
1242 /*
1243  Filter scheduling and activation
1244 
1245  When a filter is activated, it must:
1246  - if possible, output a frame;
1247  - else, if relevant, forward the input status change;
1248  - else, check outputs for wanted frames and forward the requests.
1249 
1250  The following AVFilterLink fields are used for activation:
1251 
1252  - frame_wanted_out:
1253 
1254  This field indicates if a frame is needed on this input of the
1255  destination filter. A positive value indicates that a frame is needed
1256  to process queued frames or internal data or to satisfy the
1257  application; a zero value indicates that a frame is not especially
1258  needed but could be processed anyway; a negative value indicates that a
1259  frame would just be queued.
1260 
1261  It is set by filters using ff_request_frame() or ff_request_no_frame(),
1262  when requested by the application through a specific API or when it is
1263  set on one of the outputs.
1264 
1265  It is cleared when a frame is sent from the source using
1266  ff_filter_frame().
1267 
1268  It is also cleared when a status change is sent from the source using
1269  ff_avfilter_link_set_in_status().
1270 
1271  - frame_blocked_in:
1272 
1273  This field means that the source filter can not generate a frame as is.
1274  Its goal is to avoid repeatedly calling the request_frame() method on
1275  the same link.
1276 
1277  It is set by the framework on all outputs of a filter before activating it.
1278 
1279  It is automatically cleared by ff_filter_frame().
1280 
1281  It is also automatically cleared by ff_avfilter_link_set_in_status().
1282 
1283  It is also cleared on all outputs (using filter_unblock()) when
1284  something happens on an input: processing a frame or changing the
1285  status.
1286 
1287  - fifo:
1288 
1289  Contains the frames queued on a filter input. If it contains frames and
1290  frame_wanted_out is not set, then the filter can be activated. If that
1291  result in the filter not able to use these frames, the filter must set
1292  frame_wanted_out to ask for more frames.
1293 
1294  - status_in and status_in_pts:
1295 
1296  Status (EOF or error code) of the link and timestamp of the status
1297  change (in link time base, same as frames) as seen from the input of
1298  the link. The status change is considered happening after the frames
1299  queued in fifo.
1300 
1301  It is set by the source filter using ff_avfilter_link_set_in_status().
1302 
1303  - status_out:
1304 
1305  Status of the link as seen from the output of the link. The status
1306  change is considered having already happened.
1307 
1308  It is set by the destination filter using
1309  link_set_out_status().
1310 
1311  Filters are activated according to the ready field, set using the
1312  ff_filter_set_ready(). Eventually, a priority queue will be used.
1313  ff_filter_set_ready() is called whenever anything could cause progress to
1314  be possible. Marking a filter ready when it is not is not a problem,
1315  except for the small overhead it causes.
1316 
1317  Conditions that cause a filter to be marked ready are:
1318 
1319  - frames added on an input link;
1320 
1321  - changes in the input or output status of an input link;
1322 
1323  - requests for a frame on an output link;
1324 
1325  - after any actual processing using the legacy methods (filter_frame(),
1326  and request_frame() to acknowledge status changes), to run once more
1327  and check if enough input was present for several frames.
1328 
1329  Examples of scenarios to consider:
1330 
1331  - buffersrc: activate if frame_wanted_out to notify the application;
1332  activate when the application adds a frame to push it immediately.
1333 
1334  - testsrc: activate only if frame_wanted_out to produce and push a frame.
1335 
1336  - concat (not at stitch points): can process a frame on any output.
1337  Activate if frame_wanted_out on output to forward on the corresponding
1338  input. Activate when a frame is present on input to process it
1339  immediately.
1340 
1341  - framesync: needs at least one frame on each input; extra frames on the
1342  wrong input will accumulate. When a frame is first added on one input,
1343  set frame_wanted_out<0 on it to avoid getting more (would trigger
1344  testsrc) and frame_wanted_out>0 on the other to allow processing it.
1345 
1346  Activation of old filters:
1347 
1348  In order to activate a filter implementing the legacy filter_frame() and
1349  request_frame() methods, perform the first possible of the following
1350  actions:
1351 
1352  - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1353  frame and call filter_frame().
1354 
1355  Rationale: filter frames as soon as possible instead of leaving them
1356  queued; frame_wanted_out < 0 is not possible since the old API does not
1357  set it nor provides any similar feedback; frame_wanted_out > 0 happens
1358  when min_samples > 0 and there are not enough samples queued.
1359 
1360  - If an input has status_in set but not status_out, try to call
1361  request_frame() on one of the outputs in the hope that it will trigger
1362  request_frame() on the input with status_in and acknowledge it. This is
1363  awkward and fragile, filters with several inputs or outputs should be
1364  updated to direct activation as soon as possible.
1365 
1366  - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1367  request_frame().
1368 
1369  Rationale: checking frame_blocked_in is necessary to avoid requesting
1370  repeatedly on a blocked input if another is not blocked (example:
1371  [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1372  */
1373 
1375 {
1376  int ret;
1377 
1378  /* Generic timeline support is not yet implemented but should be easy */
1380  filter->filter->activate));
1381  filter->ready = 0;
1382  ret = filter->filter->activate ? filter->filter->activate(filter) :
1384  if (ret == FFERROR_NOT_READY)
1385  ret = 0;
1386  return ret;
1387 }
1388 
1389 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1390 {
1392  *rpts = link->current_pts;
1394  return *rstatus = 0;
1395  if (li->status_out)
1396  return *rstatus = li->status_out;
1397  if (!li->status_in)
1398  return *rstatus = 0;
1399  *rstatus = li->status_out = li->status_in;
1401  *rpts = link->current_pts;
1402  return 1;
1403 }
1404 
1406 {
1408  return ff_framequeue_queued_frames(&li->fifo);
1409 }
1410 
1412 {
1414  return ff_framequeue_queued_frames(&li->fifo) > 0;
1415 }
1416 
1418 {
1420  return ff_framequeue_queued_samples(&li->fifo);
1421 }
1422 
1424 {
1426  uint64_t samples = ff_framequeue_queued_samples(&li->fifo);
1427  av_assert1(min);
1428  return samples >= min || (li->status_in && samples);
1429 }
1430 
1432 {
1433  AVFilterLink *const link = &li->l;
1434  update_link_current_pts(li, frame->pts);
1436  if (link == link->dst->inputs[0])
1437  link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1438  link->frame_count_out++;
1439  link->sample_count_out += frame->nb_samples;
1440 }
1441 
1443 {
1445  AVFrame *frame;
1446 
1447  *rframe = NULL;
1449  return 0;
1450 
1451  if (li->fifo.samples_skipped) {
1452  frame = ff_framequeue_peek(&li->fifo, 0);
1453  return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1454  }
1455 
1456  frame = ff_framequeue_take(&li->fifo);
1457  consume_update(li, frame);
1458  *rframe = frame;
1459  return 1;
1460 }
1461 
1463  AVFrame **rframe)
1464 {
1466  AVFrame *frame;
1467  int ret;
1468 
1469  av_assert1(min);
1470  *rframe = NULL;
1472  return 0;
1473  if (li->status_in)
1475  ret = take_samples(li, min, max, &frame);
1476  if (ret < 0)
1477  return ret;
1478  consume_update(li, frame);
1479  *rframe = frame;
1480  return 1;
1481 }
1482 
1484 {
1486  return ff_framequeue_peek(&li->fifo, idx);
1487 }
1488 
1490 {
1491  AVFrame *frame = *rframe;
1492  AVFrame *out;
1493  int ret;
1494 
1496  return 0;
1497  av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1498 
1499  switch (link->type) {
1500  case AVMEDIA_TYPE_VIDEO:
1501  out = ff_get_video_buffer(link, link->w, link->h);
1502  break;
1503  case AVMEDIA_TYPE_AUDIO:
1504  out = ff_get_audio_buffer(link, frame->nb_samples);
1505  break;
1506  default:
1507  return AVERROR(EINVAL);
1508  }
1509  if (!out)
1510  return AVERROR(ENOMEM);
1511 
1513  if (ret < 0) {
1514  av_frame_free(&out);
1515  return ret;
1516  }
1517 
1518  ret = av_frame_copy(out, frame);
1519  if (ret < 0) {
1520  av_frame_free(&out);
1521  return ret;
1522  }
1523 
1524  av_frame_free(&frame);
1525  *rframe = out;
1526  return 0;
1527 }
1528 
1530 {
1531  AVFilterCommand *cmd = link->dst->command_queue;
1532 
1533  while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1534  av_log(link->dst, AV_LOG_DEBUG,
1535  "Processing command time:%f command:%s arg:%s\n",
1536  cmd->time, cmd->command, cmd->arg);
1537  avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1538  command_queue_pop(link->dst);
1539  cmd= link->dst->command_queue;
1540  }
1541  return 0;
1542 }
1543 
1545 {
1546  AVFilterContext *dstctx = link->dst;
1547  int64_t pts = frame->pts;
1548 #if FF_API_FRAME_PKT
1550  int64_t pos = frame->pkt_pos;
1552 #endif
1553 
1554  if (!dstctx->enable_str)
1555  return 1;
1556 
1557  dstctx->var_values[VAR_N] = link->frame_count_out;
1558  dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1559  dstctx->var_values[VAR_W] = link->w;
1560  dstctx->var_values[VAR_H] = link->h;
1561 #if FF_API_FRAME_PKT
1562  dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1563 #endif
1564 
1565  return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
1566 }
1567 
1569 {
1571  av_assert1(!li->status_in);
1572  av_assert1(!li->status_out);
1573  link->frame_wanted_out = 1;
1574  ff_filter_set_ready(link->src, 100);
1575 }
1576 
1578 {
1580  if (li->status_out)
1581  return;
1582  link->frame_wanted_out = 0;
1583  li->frame_blocked_in = 0;
1585  while (ff_framequeue_queued_frames(&li->fifo)) {
1587  av_frame_free(&frame);
1588  }
1589  if (!li->status_in)
1590  li->status_in = status;
1591 }
1592 
1594 {
1596  return li->status_in;
1597 }
1598 
1600 {
1601  FilterLinkInternal * const li_in = ff_link_internal(inlink);
1602  return ff_outlink_frame_wanted(outlink) ||
1604  li_in->status_out;
1605 }
1606 
1607 
1609 {
1610  return &avfilter_class;
1611 }
1612 
1614  int default_pool_size)
1615 {
1617 
1618  // Must already be set by caller.
1620 
1622 
1623  if (frames->initial_pool_size == 0) {
1624  // Dynamic allocation is necessarily supported.
1625  } else if (avctx->extra_hw_frames >= 0) {
1626  frames->initial_pool_size += avctx->extra_hw_frames;
1627  } else {
1628  frames->initial_pool_size = default_pool_size;
1629  }
1630 
1631  return 0;
1632 }
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:533
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:616
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:1654
ff_link_internal
static FilterLinkInternal * ff_link_internal(AVFilterLink *link)
Definition: avfilter_internal.h:82
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:635
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:969
out
FILE * out
Definition: movenc.c:55
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:222
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1015
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:834
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
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
VAR_H
@ VAR_H
Definition: avfilter.c:551
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
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:1374
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:664
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
pixdesc.h
free_link
static void free_link(AVFilterLink *link)
Definition: avfilter.c:757
link_free
static void link_free(AVFilterLink **link)
Definition: avfilter.c:196
command_queue_pop
static void command_queue_pop(AVFilterContext *filter)
Definition: avfilter.c:82
AVOption
AVOption.
Definition: opt.h:357
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:1973
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:463
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:48
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:621
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:685
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:1599
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:638
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:1442
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:126
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
AVFilterContext::graph
struct AVFilterGraph * graph
filtergraph this filter belongs to
Definition: avfilter.h:424
fail
#define fail()
Definition: checkasm.h:182
AVOption::offset
int offset
Native access only.
Definition: opt.h:372
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:1851
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:287
av_filter_iterate
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:620
samplefmt.h
VAR_W
@ VAR_W
Definition: avfilter.c:550
take_samples
static int take_samples(FilterLinkInternal *li, unsigned min, unsigned max, AVFrame **rframe)
Definition: avfilter.c:1076
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:1925
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
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:775
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:404
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:747
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: internal.h:33
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:330
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:1423
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:625
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:512
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:1568
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: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:595
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: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
FilterLinkInternal::init_state
enum FilterLinkInternal::@270 init_state
stage of the initialization of the link properties (dimensions, etc)
ff_filter_frame_to_filter
static int ff_filter_frame_to_filter(AVFilterLink *link)
Definition: avfilter.c:1136
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
ff_framequeue_take
AVFrame * ff_framequeue_take(FFFrameQueue *fq)
Take the first frame in the queue.
Definition: framequeue.c:98
ff_inlink_make_frame_writable
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
Definition: avfilter.c:1489
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:754
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:1483
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:1365
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:244
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:1462
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:709
VAR_POS
@ VAR_POS
Definition: noise.c:56
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:1431
ff_framequeue_add
int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
Add a frame.
Definition: framequeue.c:64
ff_framequeue_free
void ff_framequeue_free(FFFrameQueue *fq)
Free the queue and all queued frames.
Definition: framequeue.c:54
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
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:662
ff_channel_layouts_unref
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition: formats.c:730
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:1389
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
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:646
ff_inlink_queued_frames
size_t ff_inlink_queued_frames(AVFilterLink *link)
Get the number of frames available on the link.
Definition: avfilter.c:1405
tlog_ref
static void tlog_ref(void *ctx, AVFrame *ref, int end)
Definition: avfilter.c:48
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:279
options
const OptionDef options[]
eval.h
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:309
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:672
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:490
ff_inlink_set_status
void ff_inlink_set_status(AVFilterLink *link, int status)
Set the status on an input link.
Definition: avfilter.c:1577
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:1411
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:1544
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:999
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:573
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: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:555
AVFrame::time_base
AVRational time_base
Time base for the timestamps in this frame.
Definition: frame.h:501
OFFSET
#define OFFSET(x)
Definition: avfilter.c:646
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:645
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:461
AVOption::name
const char * name
Definition: opt.h:358
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:887
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:941
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:115
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:718
avfilter_options
static const AVOption avfilter_options[]
Definition: avfilter.c:649
bprint.h
append_pad
static int append_pad(unsigned *count, AVFilterPad **pads, AVFilterLink ***links, AVFilterPad *newpad)
Append a new pad.
Definition: avfilter.c:100
ff_filter_frame_framed
static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:984
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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:274
filter_child_next
static void * filter_child_next(void *obj, void *prev)
Definition: avfilter.c:627
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:255
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:1938
internal.h
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:435
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:827
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
VAR_N
@ VAR_N
Definition: avfilter.c:546
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:256
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:1417
forward_status_change
static int forward_status_change(AVFilterContext *filter, FilterLinkInternal *li_in)
Definition: avfilter.c:1169
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:633
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AVFilter
Filter definition.
Definition: avfilter.h:166
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
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
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:264
framepool.h
pos
unsigned int pos
Definition: spdifenc.c:414
AVOption::type
enum AVOptionType type
Definition: opt.h:373
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:481
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: af_aecho.c:273
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:974
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:725
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:98
status
ov_status_e status
Definition: dnn_backend_openvino.c:101
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:900
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:305
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
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:433
AVFilterContext::enable
void * enable
parsed expression (AVExpr*)
Definition: avfilter.h:454
AVFilterCommand::command
char * command
command
Definition: avfilter_internal.h:89
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:1593
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
VAR_T
@ VAR_T
Definition: avfilter.c:545
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:272
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FilterLinkInternal::l
AVFilterLink l
Definition: avfilter_internal.h:34
mem.h
audio.h
TFLAGS
#define TFLAGS
Definition: avfilter.c:648
avfilter_free
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:782
ff_append_outpad
int ff_append_outpad(AVFilterContext *f, AVFilterPad *p)
Definition: avfilter.c:138
FLAGS
#define FLAGS
Definition: avfilter.c:647
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:141
default_filter_frame
static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:979
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:1529
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:143
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:533
ff_filter_activate_default
static int ff_filter_activate_default(AVFilterContext *filter)
Definition: avfilter.c:1204
samples_ready
static int samples_ready(FilterLinkInternal *link, unsigned min)
Definition: avfilter.c:1069
FilterLinkInternal::frame_pool
struct FFFramePool * frame_pool
Definition: avfilter_internal.h:36
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:244
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
hwcontext.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
VAR_VARS_NB
@ VAR_VARS_NB
Definition: avfilter.c:552
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:748
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:249
int
int
Definition: ffmpeg_filter.c:424
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:1608
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
FilterLinkInternal::status_in_pts
int64_t status_in_pts
Timestamp of the input status change.
Definition: avfilter_internal.h:60
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
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: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:2885
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:235
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:1613
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