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