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