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