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