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