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 #if FF_API_FILTER_GET_SET
188 {
189  return link->channels;
190 }
191 #endif
192 
193 void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
194 {
195  filter->ready = FFMAX(filter->ready, priority);
196 }
197 
198 /**
199  * Clear frame_blocked_in on all outputs.
200  * This is necessary whenever something changes on input.
201  */
203 {
204  unsigned i;
205 
206  for (i = 0; i < filter->nb_outputs; i++)
207  filter->outputs[i]->frame_blocked_in = 0;
208 }
209 
210 
212 {
213  if (link->status_in == status)
214  return;
215  av_assert0(!link->status_in);
216  link->status_in = status;
217  link->status_in_pts = pts;
218  link->frame_wanted_out = 0;
219  link->frame_blocked_in = 0;
220  filter_unblock(link->dst);
221  ff_filter_set_ready(link->dst, 200);
222 }
223 
225 {
226  av_assert0(!link->frame_wanted_out);
227  av_assert0(!link->status_out);
228  link->status_out = status;
229  if (pts != AV_NOPTS_VALUE)
231  filter_unblock(link->dst);
232  ff_filter_set_ready(link->src, 200);
233 }
234 
236 {
238 }
239 
241  unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
242 {
243  int ret;
244  unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
245 
246  av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
247  "between the filter '%s' and the filter '%s'\n",
248  filt->name, link->src->name, link->dst->name);
249 
250  link->dst->inputs[dstpad_idx] = NULL;
251  if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {
252  /* failed to link output filter to new filter */
253  link->dst->inputs[dstpad_idx] = link;
254  return ret;
255  }
256 
257  /* re-hookup the link to the new destination filter we inserted */
258  link->dst = filt;
259  link->dstpad = &filt->input_pads[filt_srcpad_idx];
260  filt->inputs[filt_srcpad_idx] = link;
261 
262  /* if any information on supported media formats already exists on the
263  * link, we need to preserve that */
264  if (link->out_formats)
265  ff_formats_changeref(&link->out_formats,
266  &filt->outputs[filt_dstpad_idx]->out_formats);
267  if (link->out_samplerates)
268  ff_formats_changeref(&link->out_samplerates,
269  &filt->outputs[filt_dstpad_idx]->out_samplerates);
270  if (link->out_channel_layouts)
271  ff_channel_layouts_changeref(&link->out_channel_layouts,
272  &filt->outputs[filt_dstpad_idx]->out_channel_layouts);
273 
274  return 0;
275 }
276 
278 {
279  int (*config_link)(AVFilterLink *);
280  unsigned i;
281  int ret;
282 
283  for (i = 0; i < filter->nb_inputs; i ++) {
284  AVFilterLink *link = filter->inputs[i];
286 
287  if (!link) continue;
288  if (!link->src || !link->dst) {
290  "Not all input and output are properly linked (%d).\n", i);
291  return AVERROR(EINVAL);
292  }
293 
294  inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
295  link->current_pts =
296  link->current_pts_us = AV_NOPTS_VALUE;
297 
298  switch (link->init_state) {
299  case AVLINK_INIT:
300  continue;
301  case AVLINK_STARTINIT:
302  av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
303  return 0;
304  case AVLINK_UNINIT:
305  link->init_state = AVLINK_STARTINIT;
306 
307  if ((ret = avfilter_config_links(link->src)) < 0)
308  return ret;
309 
310  if (!(config_link = link->srcpad->config_props)) {
311  if (link->src->nb_inputs != 1) {
312  av_log(link->src, AV_LOG_ERROR, "Source filters and filters "
313  "with more than one input "
314  "must set config_props() "
315  "callbacks on all outputs\n");
316  return AVERROR(EINVAL);
317  }
318  } else if ((ret = config_link(link)) < 0) {
319  av_log(link->src, AV_LOG_ERROR,
320  "Failed to configure output pad on %s\n",
321  link->src->name);
322  return ret;
323  }
324 
325  switch (link->type) {
326  case AVMEDIA_TYPE_VIDEO:
327  if (!link->time_base.num && !link->time_base.den)
328  link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
329 
332  inlink->sample_aspect_ratio : (AVRational){1,1};
333 
334  if (inlink) {
335  if (!link->frame_rate.num && !link->frame_rate.den)
336  link->frame_rate = inlink->frame_rate;
337  if (!link->w)
338  link->w = inlink->w;
339  if (!link->h)
340  link->h = inlink->h;
341  } else if (!link->w || !link->h) {
342  av_log(link->src, AV_LOG_ERROR,
343  "Video source filters must set their output link's "
344  "width and height\n");
345  return AVERROR(EINVAL);
346  }
347  break;
348 
349  case AVMEDIA_TYPE_AUDIO:
350  if (inlink) {
351  if (!link->time_base.num && !link->time_base.den)
352  link->time_base = inlink->time_base;
353  }
354 
355  if (!link->time_base.num && !link->time_base.den)
356  link->time_base = (AVRational) {1, link->sample_rate};
357  }
358 
359  if (link->src->nb_inputs && link->src->inputs[0]->hw_frames_ctx &&
360  !(link->src->filter->flags_internal & FF_FILTER_FLAG_HWFRAME_AWARE)) {
362  "should not be set by non-hwframe-aware filter");
363  link->hw_frames_ctx = av_buffer_ref(link->src->inputs[0]->hw_frames_ctx);
364  if (!link->hw_frames_ctx)
365  return AVERROR(ENOMEM);
366  }
367 
368  if ((config_link = link->dstpad->config_props))
369  if ((ret = config_link(link)) < 0) {
370  av_log(link->dst, AV_LOG_ERROR,
371  "Failed to configure input pad on %s\n",
372  link->dst->name);
373  return ret;
374  }
375 
376  link->init_state = AVLINK_INIT;
377  }
378  }
379 
380  return 0;
381 }
382 
384 {
385  if (link->type == AVMEDIA_TYPE_VIDEO) {
386  ff_tlog(ctx,
387  "link[%p s:%dx%d fmt:%s %s->%s]%s",
388  link, link->w, link->h,
390  link->src ? link->src->filter->name : "",
391  link->dst ? link->dst->filter->name : "",
392  end ? "\n" : "");
393  } else {
394  char buf[128];
395  av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);
396 
397  ff_tlog(ctx,
398  "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
399  link, (int)link->sample_rate, buf,
401  link->src ? link->src->filter->name : "",
402  link->dst ? link->dst->filter->name : "",
403  end ? "\n" : "");
404  }
405 }
406 
408 {
410 
411  av_assert1(!link->dst->filter->activate);
412  if (link->status_out)
413  return link->status_out;
414  if (link->status_in) {
415  if (ff_framequeue_queued_frames(&link->fifo)) {
416  av_assert1(!link->frame_wanted_out);
417  av_assert1(link->dst->ready >= 300);
418  return 0;
419  } else {
420  /* Acknowledge status change. Filters using ff_request_frame() will
421  handle the change automatically. Filters can also check the
422  status directly but none do yet. */
423  ff_avfilter_link_set_out_status(link, link->status_in, link->status_in_pts);
424  return link->status_out;
425  }
426  }
427  link->frame_wanted_out = 1;
428  ff_filter_set_ready(link->src, 100);
429  return 0;
430 }
431 
432 static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
433 {
434  unsigned i;
435  int64_t r = INT64_MAX;
436 
437  for (i = 0; i < ctx->nb_inputs; i++)
438  if (ctx->inputs[i]->status_out == status)
439  r = FFMIN(r, av_rescale_q(ctx->inputs[i]->current_pts, ctx->inputs[i]->time_base, link_time_base));
440  if (r < INT64_MAX)
441  return r;
442  av_log(ctx, AV_LOG_WARNING, "EOF timestamp not reliable\n");
443  for (i = 0; i < ctx->nb_inputs; i++)
444  r = FFMIN(r, av_rescale_q(ctx->inputs[i]->status_in_pts, ctx->inputs[i]->time_base, link_time_base));
445  if (r < INT64_MAX)
446  return r;
447  return AV_NOPTS_VALUE;
448 }
449 
451 {
452  int ret = -1;
453 
454  FF_TPRINTF_START(NULL, request_frame_to_filter); ff_tlog_link(NULL, link, 1);
455  /* Assume the filter is blocked, let the method clear it if not */
456  link->frame_blocked_in = 1;
457  if (link->srcpad->request_frame)
458  ret = link->srcpad->request_frame(link);
459  else if (link->src->inputs[0])
460  ret = ff_request_frame(link->src->inputs[0]);
461  if (ret < 0) {
462  if (ret != AVERROR(EAGAIN) && ret != link->status_in)
464  if (ret == AVERROR_EOF)
465  ret = 0;
466  }
467  return ret;
468 }
469 
470 static const char *const var_names[] = {
471  "t",
472  "n",
473  "pos",
474  "w",
475  "h",
476  NULL
477 };
478 
479 enum {
486 };
487 
488 static int set_enable_expr(AVFilterContext *ctx, const char *expr)
489 {
490  int ret;
491  char *expr_dup;
492  AVExpr *old = ctx->enable;
493 
494  if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) {
495  av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
496  "with filter '%s'\n", ctx->filter->name);
497  return AVERROR_PATCHWELCOME;
498  }
499 
500  expr_dup = av_strdup(expr);
501  if (!expr_dup)
502  return AVERROR(ENOMEM);
503 
504  if (!ctx->var_values) {
505  ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values));
506  if (!ctx->var_values) {
507  av_free(expr_dup);
508  return AVERROR(ENOMEM);
509  }
510  }
511 
512  ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names,
513  NULL, NULL, NULL, NULL, 0, ctx->priv);
514  if (ret < 0) {
515  av_log(ctx->priv, AV_LOG_ERROR,
516  "Error when evaluating the expression '%s' for enable\n",
517  expr_dup);
518  av_free(expr_dup);
519  return ret;
520  }
521 
522  av_expr_free(old);
523  av_free(ctx->enable_str);
524  ctx->enable_str = expr_dup;
525  return 0;
526 }
527 
529 {
530  if (pts == AV_NOPTS_VALUE)
531  return;
532  link->current_pts = pts;
533  link->current_pts_us = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
534  /* TODO use duration */
535  if (link->graph && link->age_index >= 0)
537 }
538 
539 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
540 {
541  if(!strcmp(cmd, "ping")){
542  char local_res[256] = {0};
543 
544  if (!res) {
545  res = local_res;
546  res_len = sizeof(local_res);
547  }
548  av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
549  if (res == local_res)
550  av_log(filter, AV_LOG_INFO, "%s", res);
551  return 0;
552  }else if(!strcmp(cmd, "enable")) {
553  return set_enable_expr(filter, arg);
554  }else if(filter->filter->process_command) {
555  return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);
556  }
557  return AVERROR(ENOSYS);
558 }
559 
561 {
562  int count;
563 
564  if (!pads)
565  return 0;
566 
567  for (count = 0; pads->name; count++)
568  pads++;
569  return count;
570 }
571 
572 static const char *default_filter_name(void *filter_ctx)
573 {
575  return ctx->name ? ctx->name : ctx->filter->name;
576 }
577 
578 static void *filter_child_next(void *obj, void *prev)
579 {
580  AVFilterContext *ctx = obj;
581  if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
582  return ctx->priv;
583  return NULL;
584 }
585 
586 static const AVClass *filter_child_class_next(const AVClass *prev)
587 {
588  void *opaque = NULL;
589  const AVFilter *f = NULL;
590 
591  /* find the filter that corresponds to prev */
592  while (prev && (f = av_filter_iterate(&opaque)))
593  if (f->priv_class == prev)
594  break;
595 
596  /* could not find filter corresponding to prev */
597  if (prev && !f)
598  return NULL;
599 
600  /* find next filter with specific options */
601  while ((f = av_filter_iterate(&opaque)))
602  if (f->priv_class)
603  return f->priv_class;
604 
605  return NULL;
606 }
607 
608 #define OFFSET(x) offsetof(AVFilterContext, x)
609 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
610 static const AVOption avfilter_options[] = {
611  { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
612  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
613  { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
614  { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
615  { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
616  { .i64 = 0 }, 0, INT_MAX, FLAGS },
617  { "extra_hw_frames", "Number of extra hardware frames to allocate for the user",
618  OFFSET(extra_hw_frames), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
619  { NULL },
620 };
621 
622 static const AVClass avfilter_class = {
623  .class_name = "AVFilter",
624  .item_name = default_filter_name,
625  .version = LIBAVUTIL_VERSION_INT,
626  .category = AV_CLASS_CATEGORY_FILTER,
627  .child_next = filter_child_next,
628  .child_class_next = filter_child_class_next,
630 };
631 
633  int *ret, int nb_jobs)
634 {
635  int i;
636 
637  for (i = 0; i < nb_jobs; i++) {
638  int r = func(ctx, arg, i, nb_jobs);
639  if (ret)
640  ret[i] = r;
641  }
642  return 0;
643 }
644 
645 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
646 {
648  int preinited = 0;
649 
650  if (!filter)
651  return NULL;
652 
653  ret = av_mallocz(sizeof(AVFilterContext));
654  if (!ret)
655  return NULL;
656 
657  ret->av_class = &avfilter_class;
658  ret->filter = filter;
659  ret->name = inst_name ? av_strdup(inst_name) : NULL;
660  if (filter->priv_size) {
661  ret->priv = av_mallocz(filter->priv_size);
662  if (!ret->priv)
663  goto err;
664  }
665  if (filter->preinit) {
666  if (filter->preinit(ret) < 0)
667  goto err;
668  preinited = 1;
669  }
670 
672  if (filter->priv_class) {
673  *(const AVClass**)ret->priv = filter->priv_class;
674  av_opt_set_defaults(ret->priv);
675  }
676 
677  ret->internal = av_mallocz(sizeof(*ret->internal));
678  if (!ret->internal)
679  goto err;
680  ret->internal->execute = default_execute;
681 
682  ret->nb_inputs = avfilter_pad_count(filter->inputs);
683  if (ret->nb_inputs ) {
684  ret->input_pads = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad));
685  if (!ret->input_pads)
686  goto err;
687  memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
688  ret->inputs = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*));
689  if (!ret->inputs)
690  goto err;
691  }
692 
693  ret->nb_outputs = avfilter_pad_count(filter->outputs);
694  if (ret->nb_outputs) {
695  ret->output_pads = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad));
696  if (!ret->output_pads)
697  goto err;
698  memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
699  ret->outputs = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*));
700  if (!ret->outputs)
701  goto err;
702  }
703 
704  return ret;
705 
706 err:
707  if (preinited)
708  filter->uninit(ret);
709  av_freep(&ret->inputs);
710  av_freep(&ret->input_pads);
711  ret->nb_inputs = 0;
712  av_freep(&ret->outputs);
713  av_freep(&ret->output_pads);
714  ret->nb_outputs = 0;
715  av_freep(&ret->priv);
716  av_freep(&ret->internal);
717  av_free(ret);
718  return NULL;
719 }
720 
722 {
723  if (!link)
724  return;
725 
726  if (link->src)
727  link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
728  if (link->dst)
729  link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
730 
732 
733  ff_formats_unref(&link->in_formats);
734  ff_formats_unref(&link->out_formats);
735  ff_formats_unref(&link->in_samplerates);
736  ff_formats_unref(&link->out_samplerates);
737  ff_channel_layouts_unref(&link->in_channel_layouts);
738  ff_channel_layouts_unref(&link->out_channel_layouts);
740 }
741 
743 {
744  int i;
745 
746  if (!filter)
747  return;
748 
749  if (filter->graph)
751 
752  if (filter->filter->uninit)
753  filter->filter->uninit(filter);
754 
755  for (i = 0; i < filter->nb_inputs; i++) {
756  free_link(filter->inputs[i]);
757  }
758  for (i = 0; i < filter->nb_outputs; i++) {
759  free_link(filter->outputs[i]);
760  }
761 
762  if (filter->filter->priv_class)
763  av_opt_free(filter->priv);
764 
765  av_buffer_unref(&filter->hw_device_ctx);
766 
767  av_freep(&filter->name);
768  av_freep(&filter->input_pads);
769  av_freep(&filter->output_pads);
770  av_freep(&filter->inputs);
771  av_freep(&filter->outputs);
772  av_freep(&filter->priv);
773  while(filter->command_queue){
775  }
777  av_expr_free(filter->enable);
778  filter->enable = NULL;
779  av_freep(&filter->var_values);
780  av_freep(&filter->internal);
781  av_free(filter);
782 }
783 
785 {
786  if (ctx->nb_threads > 0)
787  return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
788  return ctx->graph->nb_threads;
789 }
790 
792  const char *args)
793 {
794  const AVOption *o = NULL;
795  int ret, count = 0;
796  char *av_uninit(parsed_key), *av_uninit(value);
797  const char *key;
798  int offset= -1;
799 
800  if (!args)
801  return 0;
802 
803  while (*args) {
804  const char *shorthand = NULL;
805 
806  o = av_opt_next(ctx->priv, o);
807  if (o) {
808  if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
809  continue;
810  offset = o->offset;
811  shorthand = o->name;
812  }
813 
814  ret = av_opt_get_key_value(&args, "=", ":",
815  shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
816  &parsed_key, &value);
817  if (ret < 0) {
818  if (ret == AVERROR(EINVAL))
819  av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
820  else
821  av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
822  av_err2str(ret));
823  return ret;
824  }
825  if (*args)
826  args++;
827  if (parsed_key) {
828  key = parsed_key;
829  while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */
830  } else {
831  key = shorthand;
832  }
833 
834  av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
835 
836  if (av_opt_find(ctx, key, NULL, 0, 0)) {
837  ret = av_opt_set(ctx, key, value, 0);
838  if (ret < 0) {
839  av_free(value);
840  av_free(parsed_key);
841  return ret;
842  }
843  } else {
845  if ((ret = av_opt_set(ctx->priv, key, value, AV_OPT_SEARCH_CHILDREN)) < 0) {
848  av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
849  av_free(value);
850  av_free(parsed_key);
851  return ret;
852  }
853  }
854  }
855 
856  av_free(value);
857  av_free(parsed_key);
858  count++;
859  }
860 
861  if (ctx->enable_str) {
862  ret = set_enable_expr(ctx, ctx->enable_str);
863  if (ret < 0)
864  return ret;
865  }
866  return count;
867 }
868 
870  const char *arg, char *res, int res_len, int flags)
871 {
872  const AVOption *o;
873 
874  if (!ctx->filter->priv_class)
875  return 0;
877  if (!o)
878  return AVERROR(ENOSYS);
879  return av_opt_set(ctx->priv, cmd, arg, 0);
880 }
881 
883 {
884  int ret = 0;
885 
887  if (ret < 0) {
888  av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
889  return ret;
890  }
891 
892  if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
893  ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
894  ctx->graph->internal->thread_execute) {
895  ctx->thread_type = AVFILTER_THREAD_SLICE;
896  ctx->internal->execute = ctx->graph->internal->thread_execute;
897  } else {
898  ctx->thread_type = 0;
899  }
900 
901  if (ctx->filter->priv_class) {
903  if (ret < 0) {
904  av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
905  return ret;
906  }
907  }
908 
909  if (ctx->filter->init_opaque)
910  ret = ctx->filter->init_opaque(ctx, NULL);
911  else if (ctx->filter->init)
912  ret = ctx->filter->init(ctx);
913  else if (ctx->filter->init_dict)
914  ret = ctx->filter->init_dict(ctx, options);
915 
916  return ret;
917 }
918 
919 int avfilter_init_str(AVFilterContext *filter, const char *args)
920 {
923  int ret = 0;
924 
925  if (args && *args) {
926  if (!filter->filter->priv_class) {
927  av_log(filter, AV_LOG_ERROR, "This filter does not take any "
928  "options, but options were provided: %s.\n", args);
929  return AVERROR(EINVAL);
930  }
931 
932 #if FF_API_OLD_FILTER_OPTS_ERROR
933  if ( !strcmp(filter->filter->name, "format") ||
934  !strcmp(filter->filter->name, "noformat") ||
935  !strcmp(filter->filter->name, "frei0r") ||
936  !strcmp(filter->filter->name, "frei0r_src") ||
937  !strcmp(filter->filter->name, "ocv") ||
938  !strcmp(filter->filter->name, "pan") ||
939  !strcmp(filter->filter->name, "pp") ||
940  !strcmp(filter->filter->name, "aevalsrc")) {
941  /* a hack for compatibility with the old syntax
942  * replace colons with |s */
943  char *copy = av_strdup(args);
944  char *p = copy;
945  int nb_leading = 0; // number of leading colons to skip
946  int deprecated = 0;
947 
948  if (!copy) {
949  ret = AVERROR(ENOMEM);
950  goto fail;
951  }
952 
953  if (!strcmp(filter->filter->name, "frei0r") ||
954  !strcmp(filter->filter->name, "ocv"))
955  nb_leading = 1;
956  else if (!strcmp(filter->filter->name, "frei0r_src"))
957  nb_leading = 3;
958 
959  while (nb_leading--) {
960  p = strchr(p, ':');
961  if (!p) {
962  p = copy + strlen(copy);
963  break;
964  }
965  p++;
966  }
967 
968  deprecated = strchr(p, ':') != NULL;
969 
970  if (!strcmp(filter->filter->name, "aevalsrc")) {
971  deprecated = 0;
972  while ((p = strchr(p, ':')) && p[1] != ':') {
973  const char *epos = strchr(p + 1, '=');
974  const char *spos = strchr(p + 1, ':');
975  const int next_token_is_opt = epos && (!spos || epos < spos);
976  if (next_token_is_opt) {
977  p++;
978  break;
979  }
980  /* next token does not contain a '=', assume a channel expression */
981  deprecated = 1;
982  *p++ = '|';
983  }
984  if (p && *p == ':') { // double sep '::' found
985  deprecated = 1;
986  memmove(p, p + 1, strlen(p));
987  }
988  } else
989  while ((p = strchr(p, ':')))
990  *p++ = '|';
991 
992  if (deprecated) {
993  av_log(filter, AV_LOG_ERROR, "This syntax is deprecated. Use "
994  "'|' to separate the list items ('%s' instead of '%s')\n",
995  copy, args);
996  ret = AVERROR(EINVAL);
997  } else {
999  }
1000  av_freep(&copy);
1001 
1002  if (ret < 0)
1003  goto fail;
1004  } else
1005 #endif
1006  {
1007  ret = process_options(filter, &options, args);
1008  if (ret < 0)
1009  goto fail;
1010  }
1011  }
1012 
1014  if (ret < 0)
1015  goto fail;
1016 
1017  if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1018  av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
1020  goto fail;
1021  }
1022 
1023 fail:
1025 
1026  return ret;
1027 }
1028 
1029 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
1030 {
1031  return pads[pad_idx].name;
1032 }
1033 
1034 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
1035 {
1036  return pads[pad_idx].type;
1037 }
1038 
1040 {
1041  return ff_filter_frame(link->dst->outputs[0], frame);
1042 }
1043 
1045 {
1047  AVFilterContext *dstctx = link->dst;
1048  AVFilterPad *dst = link->dstpad;
1049  int ret;
1050 
1051  if (!(filter_frame = dst->filter_frame))
1053 
1054  if (dst->needs_writable) {
1056  if (ret < 0)
1057  goto fail;
1058  }
1059 
1062 
1063  if (dstctx->is_disabled &&
1066  ret = filter_frame(link, frame);
1067  link->frame_count_out++;
1068  return ret;
1069 
1070 fail:
1071  av_frame_free(&frame);
1072  return ret;
1073 }
1074 
1076 {
1077  int ret;
1079 
1080  /* Consistency checks */
1081  if (link->type == AVMEDIA_TYPE_VIDEO) {
1082  if (strcmp(link->dst->filter->name, "buffersink") &&
1083  strcmp(link->dst->filter->name, "format") &&
1084  strcmp(link->dst->filter->name, "idet") &&
1085  strcmp(link->dst->filter->name, "null") &&
1086  strcmp(link->dst->filter->name, "scale")) {
1087  av_assert1(frame->format == link->format);
1088  av_assert1(frame->width == link->w);
1089  av_assert1(frame->height == link->h);
1090  }
1091  } else {
1092  if (frame->format != link->format) {
1093  av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1094  goto error;
1095  }
1096  if (frame->channels != link->channels) {
1097  av_log(link->dst, AV_LOG_ERROR, "Channel count change is not supported\n");
1098  goto error;
1099  }
1100  if (frame->channel_layout != link->channel_layout) {
1101  av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1102  goto error;
1103  }
1104  if (frame->sample_rate != link->sample_rate) {
1105  av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1106  goto error;
1107  }
1108  }
1109 
1110  link->frame_blocked_in = link->frame_wanted_out = 0;
1111  link->frame_count_in++;
1112  filter_unblock(link->dst);
1113  ret = ff_framequeue_add(&link->fifo, frame);
1114  if (ret < 0) {
1115  av_frame_free(&frame);
1116  return ret;
1117  }
1118  ff_filter_set_ready(link->dst, 300);
1119  return 0;
1120 
1121 error:
1122  av_frame_free(&frame);
1123  return AVERROR_PATCHWELCOME;
1124 }
1125 
1126 static int samples_ready(AVFilterLink *link, unsigned min)
1127 {
1128  return ff_framequeue_queued_frames(&link->fifo) &&
1129  (ff_framequeue_queued_samples(&link->fifo) >= min ||
1130  link->status_in);
1131 }
1132 
1133 static int take_samples(AVFilterLink *link, unsigned min, unsigned max,
1134  AVFrame **rframe)
1135 {
1136  AVFrame *frame0, *frame, *buf;
1137  unsigned nb_samples, nb_frames, i, p;
1138  int ret;
1139 
1140  /* Note: this function relies on no format changes and must only be
1141  called with enough samples. */
1142  av_assert1(samples_ready(link, link->min_samples));
1143  frame0 = frame = ff_framequeue_peek(&link->fifo, 0);
1144  if (!link->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1145  *rframe = ff_framequeue_take(&link->fifo);
1146  return 0;
1147  }
1148  nb_frames = 0;
1149  nb_samples = 0;
1150  while (1) {
1151  if (nb_samples + frame->nb_samples > max) {
1152  if (nb_samples < min)
1153  nb_samples = max;
1154  break;
1155  }
1156  nb_samples += frame->nb_samples;
1157  nb_frames++;
1158  if (nb_frames == ff_framequeue_queued_frames(&link->fifo))
1159  break;
1160  frame = ff_framequeue_peek(&link->fifo, nb_frames);
1161  }
1162 
1163  buf = ff_get_audio_buffer(link, nb_samples);
1164  if (!buf)
1165  return AVERROR(ENOMEM);
1166  ret = av_frame_copy_props(buf, frame0);
1167  if (ret < 0) {
1168  av_frame_free(&buf);
1169  return ret;
1170  }
1171  buf->pts = frame0->pts;
1172 
1173  p = 0;
1174  for (i = 0; i < nb_frames; i++) {
1175  frame = ff_framequeue_take(&link->fifo);
1176  av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1177  frame->nb_samples, link->channels, link->format);
1178  p += frame->nb_samples;
1179  av_frame_free(&frame);
1180  }
1181  if (p < nb_samples) {
1182  unsigned n = nb_samples - p;
1183  frame = ff_framequeue_peek(&link->fifo, 0);
1184  av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1185  link->channels, link->format);
1186  ff_framequeue_skip_samples(&link->fifo, n, link->time_base);
1187  }
1188 
1189  *rframe = buf;
1190  return 0;
1191 }
1192 
1194 {
1195  AVFrame *frame = NULL;
1196  AVFilterContext *dst = link->dst;
1197  int ret;
1198 
1200  ret = link->min_samples ?
1201  ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1203  av_assert1(ret);
1204  if (ret < 0) {
1205  av_assert1(!frame);
1206  return ret;
1207  }
1208  /* The filter will soon have received a new frame, that may allow it to
1209  produce one or more: unblock its outputs. */
1210  filter_unblock(dst);
1211  /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1212  before the frame; ff_filter_frame_framed() will re-increment it. */
1213  link->frame_count_out--;
1215  if (ret < 0 && ret != link->status_out) {
1217  } else {
1218  /* Run once again, to see if several frames were available, or if
1219  the input status has also changed, or any other reason. */
1220  ff_filter_set_ready(dst, 300);
1221  }
1222  return ret;
1223 }
1224 
1226 {
1227  unsigned out = 0, progress = 0;
1228  int ret;
1229 
1230  av_assert0(!in->status_out);
1231  if (!filter->nb_outputs) {
1232  /* not necessary with the current API and sinks */
1233  return 0;
1234  }
1235  while (!in->status_out) {
1236  if (!filter->outputs[out]->status_in) {
1237  progress++;
1239  if (ret < 0)
1240  return ret;
1241  }
1242  if (++out == filter->nb_outputs) {
1243  if (!progress) {
1244  /* Every output already closed: input no longer interesting
1245  (example: overlay in shortest mode, other input closed). */
1246  ff_avfilter_link_set_out_status(in, in->status_in, in->status_in_pts);
1247  return 0;
1248  }
1249  progress = 0;
1250  out = 0;
1251  }
1252  }
1254  return 0;
1255 }
1256 
1258 {
1259  unsigned i;
1260 
1261  for (i = 0; i < filter->nb_inputs; i++) {
1262  if (samples_ready(filter->inputs[i], filter->inputs[i]->min_samples)) {
1263  return ff_filter_frame_to_filter(filter->inputs[i]);
1264  }
1265  }
1266  for (i = 0; i < filter->nb_inputs; i++) {
1267  if (filter->inputs[i]->status_in && !filter->inputs[i]->status_out) {
1268  av_assert1(!ff_framequeue_queued_frames(&filter->inputs[i]->fifo));
1269  return forward_status_change(filter, filter->inputs[i]);
1270  }
1271  }
1272  for (i = 0; i < filter->nb_outputs; i++) {
1273  if (filter->outputs[i]->frame_wanted_out &&
1274  !filter->outputs[i]->frame_blocked_in) {
1275  return ff_request_frame_to_filter(filter->outputs[i]);
1276  }
1277  }
1278  return FFERROR_NOT_READY;
1279 }
1280 
1281 /*
1282  Filter scheduling and activation
1283 
1284  When a filter is activated, it must:
1285  - if possible, output a frame;
1286  - else, if relevant, forward the input status change;
1287  - else, check outputs for wanted frames and forward the requests.
1288 
1289  The following AVFilterLink fields are used for activation:
1290 
1291  - frame_wanted_out:
1292 
1293  This field indicates if a frame is needed on this input of the
1294  destination filter. A positive value indicates that a frame is needed
1295  to process queued frames or internal data or to satisfy the
1296  application; a zero value indicates that a frame is not especially
1297  needed but could be processed anyway; a negative value indicates that a
1298  frame would just be queued.
1299 
1300  It is set by filters using ff_request_frame() or ff_request_no_frame(),
1301  when requested by the application through a specific API or when it is
1302  set on one of the outputs.
1303 
1304  It is cleared when a frame is sent from the source using
1305  ff_filter_frame().
1306 
1307  It is also cleared when a status change is sent from the source using
1308  ff_avfilter_link_set_in_status().
1309 
1310  - frame_blocked_in:
1311 
1312  This field means that the source filter can not generate a frame as is.
1313  Its goal is to avoid repeatedly calling the request_frame() method on
1314  the same link.
1315 
1316  It is set by the framework on all outputs of a filter before activating it.
1317 
1318  It is automatically cleared by ff_filter_frame().
1319 
1320  It is also automatically cleared by ff_avfilter_link_set_in_status().
1321 
1322  It is also cleared on all outputs (using filter_unblock()) when
1323  something happens on an input: processing a frame or changing the
1324  status.
1325 
1326  - fifo:
1327 
1328  Contains the frames queued on a filter input. If it contains frames and
1329  frame_wanted_out is not set, then the filter can be activated. If that
1330  result in the filter not able to use these frames, the filter must set
1331  frame_wanted_out to ask for more frames.
1332 
1333  - status_in and status_in_pts:
1334 
1335  Status (EOF or error code) of the link and timestamp of the status
1336  change (in link time base, same as frames) as seen from the input of
1337  the link. The status change is considered happening after the frames
1338  queued in fifo.
1339 
1340  It is set by the source filter using ff_avfilter_link_set_in_status().
1341 
1342  - status_out:
1343 
1344  Status of the link as seen from the output of the link. The status
1345  change is considered having already happened.
1346 
1347  It is set by the destination filter using
1348  ff_avfilter_link_set_out_status().
1349 
1350  Filters are activated according to the ready field, set using the
1351  ff_filter_set_ready(). Eventually, a priority queue will be used.
1352  ff_filter_set_ready() is called whenever anything could cause progress to
1353  be possible. Marking a filter ready when it is not is not a problem,
1354  except for the small overhead it causes.
1355 
1356  Conditions that cause a filter to be marked ready are:
1357 
1358  - frames added on an input link;
1359 
1360  - changes in the input or output status of an input link;
1361 
1362  - requests for a frame on an output link;
1363 
1364  - after any actual processing using the legacy methods (filter_frame(),
1365  and request_frame() to acknowledge status changes), to run once more
1366  and check if enough input was present for several frames.
1367 
1368  Examples of scenarios to consider:
1369 
1370  - buffersrc: activate if frame_wanted_out to notify the application;
1371  activate when the application adds a frame to push it immediately.
1372 
1373  - testsrc: activate only if frame_wanted_out to produce and push a frame.
1374 
1375  - concat (not at stitch points): can process a frame on any output.
1376  Activate if frame_wanted_out on output to forward on the corresponding
1377  input. Activate when a frame is present on input to process it
1378  immediately.
1379 
1380  - framesync: needs at least one frame on each input; extra frames on the
1381  wrong input will accumulate. When a frame is first added on one input,
1382  set frame_wanted_out<0 on it to avoid getting more (would trigger
1383  testsrc) and frame_wanted_out>0 on the other to allow processing it.
1384 
1385  Activation of old filters:
1386 
1387  In order to activate a filter implementing the legacy filter_frame() and
1388  request_frame() methods, perform the first possible of the following
1389  actions:
1390 
1391  - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1392  frame and call filter_frame().
1393 
1394  Rationale: filter frames as soon as possible instead of leaving them
1395  queued; frame_wanted_out < 0 is not possible since the old API does not
1396  set it nor provides any similar feedback; frame_wanted_out > 0 happens
1397  when min_samples > 0 and there are not enough samples queued.
1398 
1399  - If an input has status_in set but not status_out, try to call
1400  request_frame() on one of the outputs in the hope that it will trigger
1401  request_frame() on the input with status_in and acknowledge it. This is
1402  awkward and fragile, filters with several inputs or outputs should be
1403  updated to direct activation as soon as possible.
1404 
1405  - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1406  request_frame().
1407 
1408  Rationale: checking frame_blocked_in is necessary to avoid requesting
1409  repeatedly on a blocked input if another is not blocked (example:
1410  [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1411 
1412  TODO: respect needs_fifo and remove auto-inserted fifos.
1413 
1414  */
1415 
1417 {
1418  int ret;
1419 
1420  /* Generic timeline support is not yet implemented but should be easy */
1422  filter->filter->activate));
1423  filter->ready = 0;
1424  ret = filter->filter->activate ? filter->filter->activate(filter) :
1426  if (ret == FFERROR_NOT_READY)
1427  ret = 0;
1428  return ret;
1429 }
1430 
1431 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1432 {
1433  *rpts = link->current_pts;
1434  if (ff_framequeue_queued_frames(&link->fifo))
1435  return *rstatus = 0;
1436  if (link->status_out)
1437  return *rstatus = link->status_out;
1438  if (!link->status_in)
1439  return *rstatus = 0;
1440  *rstatus = link->status_out = link->status_in;
1441  ff_update_link_current_pts(link, link->status_in_pts);
1442  *rpts = link->current_pts;
1443  return 1;
1444 }
1445 
1447 {
1448  return ff_framequeue_queued_frames(&link->fifo);
1449 }
1450 
1452 {
1453  return ff_framequeue_queued_frames(&link->fifo) > 0;
1454 }
1455 
1457 {
1458  return ff_framequeue_queued_samples(&link->fifo);
1459 }
1460 
1462 {
1463  uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
1464  av_assert1(min);
1465  return samples >= min || (link->status_in && samples);
1466 }
1467 
1469 {
1472  link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1473  link->frame_count_out++;
1474 }
1475 
1477 {
1478  AVFrame *frame;
1479 
1480  *rframe = NULL;
1482  return 0;
1483 
1484  if (link->fifo.samples_skipped) {
1485  frame = ff_framequeue_peek(&link->fifo, 0);
1486  return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1487  }
1488 
1489  frame = ff_framequeue_take(&link->fifo);
1491  *rframe = frame;
1492  return 1;
1493 }
1494 
1496  AVFrame **rframe)
1497 {
1498  AVFrame *frame;
1499  int ret;
1500 
1501  av_assert1(min);
1502  *rframe = NULL;
1504  return 0;
1505  if (link->status_in)
1507  ret = take_samples(link, min, max, &frame);
1508  if (ret < 0)
1509  return ret;
1511  *rframe = frame;
1512  return 1;
1513 }
1514 
1516 {
1517  return ff_framequeue_peek(&link->fifo, idx);
1518 }
1519 
1521 {
1522  AVFrame *frame = *rframe;
1523  AVFrame *out;
1524  int ret;
1525 
1527  return 0;
1528  av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1529 
1530  switch (link->type) {
1531  case AVMEDIA_TYPE_VIDEO:
1532  out = ff_get_video_buffer(link, link->w, link->h);
1533  break;
1534  case AVMEDIA_TYPE_AUDIO:
1535  out = ff_get_audio_buffer(link, frame->nb_samples);
1536  break;
1537  default:
1538  return AVERROR(EINVAL);
1539  }
1540  if (!out)
1541  return AVERROR(ENOMEM);
1542 
1544  if (ret < 0) {
1545  av_frame_free(&out);
1546  return ret;
1547  }
1548 
1549  switch (link->type) {
1550  case AVMEDIA_TYPE_VIDEO:
1551  av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
1552  frame->format, frame->width, frame->height);
1553  break;
1554  case AVMEDIA_TYPE_AUDIO:
1555  av_samples_copy(out->extended_data, frame->extended_data,
1556  0, 0, frame->nb_samples,
1557  frame->channels,
1558  frame->format);
1559  break;
1560  default:
1561  av_assert0(!"reached");
1562  }
1563 
1564  av_frame_free(&frame);
1565  *rframe = out;
1566  return 0;
1567 }
1568 
1570 {
1571  AVFilterCommand *cmd = link->dst->command_queue;
1572 
1573  while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1574  av_log(link->dst, AV_LOG_DEBUG,
1575  "Processing command time:%f command:%s arg:%s\n",
1576  cmd->time, cmd->command, cmd->arg);
1577  avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1578  ff_command_queue_pop(link->dst);
1579  cmd= link->dst->command_queue;
1580  }
1581  return 0;
1582 }
1583 
1585 {
1586  AVFilterContext *dstctx = link->dst;
1587  int64_t pts = frame->pts;
1588  int64_t pos = frame->pkt_pos;
1589 
1590  if (!dstctx->enable_str)
1591  return 1;
1592 
1593  dstctx->var_values[VAR_N] = link->frame_count_out;
1594  dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1595  dstctx->var_values[VAR_W] = link->w;
1596  dstctx->var_values[VAR_H] = link->h;
1597  dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1598 
1599  return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
1600 }
1601 
1603 {
1604  av_assert1(!link->status_in);
1605  av_assert1(!link->status_out);
1606  link->frame_wanted_out = 1;
1607  ff_filter_set_ready(link->src, 100);
1608 }
1609 
1611 {
1612  if (link->status_out)
1613  return;
1614  link->frame_wanted_out = 0;
1615  link->frame_blocked_in = 0;
1617  while (ff_framequeue_queued_frames(&link->fifo)) {
1618  AVFrame *frame = ff_framequeue_take(&link->fifo);
1619  av_frame_free(&frame);
1620  }
1621  if (!link->status_in)
1622  link->status_in = status;
1623 }
1624 
1626 {
1627  return link->status_in;
1628 }
1629 
1631 {
1632  return &avfilter_class;
1633 }
1634 
1636  int default_pool_size)
1637 {
1639 
1640  // Must already be set by caller.
1642 
1644 
1645  if (frames->initial_pool_size == 0) {
1646  // Dynamic allocation is necessarily supported.
1647  } else if (avctx->extra_hw_frames >= 0) {
1648  frames->initial_pool_size += avctx->extra_hw_frames;
1649  } else {
1650  frames->initial_pool_size = default_pool_size;
1651  }
1652 
1653  return 0;
1654 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:29
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:67
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:182
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:114
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:45
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:1029
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:1357
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:365
VAR_VARS_NB
@ VAR_VARS_NB
Definition: avfilter.c:485
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1075
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:823
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:89
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:384
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
filter_child_class_next
static const AVClass * filter_child_class_next(const AVClass *prev)
Definition: avfilter.c:586
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFilterContext::is_disabled
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:385
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
ff_filter_activate
int ff_filter_activate(AVFilterContext *filter)
Definition: avfilter.c:1416
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:211
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
pixdesc.h
free_link
static void free_link(AVFilterLink *link)
Definition: avfilter.c:721
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:393
VAR_H
@ VAR_H
Definition: avfilter.c:484
ff_command_queue_pop
void ff_command_queue_pop(AVFilterContext *filter)
Definition: avfilter.c:94
AVOption
AVOption.
Definition: opt.h:246
process_options
static int process_options(AVFilterContext *ctx, AVDictionary **options, const char *args)
Definition: avfilter.c:791
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:407
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:291
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:190
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
max
#define max(a, b)
Definition: cuda_runtime.h:33
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:86
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:572
AVFormatContext::internal
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1788
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:292
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:645
forward_status_change
static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
Definition: avfilter.c:1225
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:1476
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:355
fail
#define fail()
Definition: checkasm.h:123
AVOption::offset
int offset
The offset relative to the context structure where the option value is stored.
Definition: opt.h:259
AVFilterContext::enable_str
char * enable_str
enable expression string
Definition: avfilter.h:382
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:240
av_filter_iterate
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:509
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:424
avfilter_config_links
int avfilter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
Definition: avfilter.c:277
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:647
AVFILTER_THREAD_SLICE
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
Definition: avfilter.h:333
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:345
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:1461
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:1655
ff_request_frame_to_filter
static int ff_request_frame_to_filter(AVFilterLink *link)
Definition: avfilter.c:450
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:224
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1602
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1466
AVFrame::channels
int channels
number of audio channels, only used for audio.
Definition: frame.h:606
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:539
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:560
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:187
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
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:1193
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:1520
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:1660
arg
const char * arg
Definition: jacosubdec.c:66
if
if(ret)
Definition: filter_design.txt:179
ff_formats_changeref
void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
Definition: formats.c:550
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:1515
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:202
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
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:1495
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:659
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:483
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:346
src
#define src
Definition: vp8dsp.c:254
AVFilterContext::name
char * name
name of this filter instance
Definition: avfilter.h:343
take_samples
static int take_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Definition: avfilter.c:1133
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:1610
avfilter_class
static const AVClass avfilter_class
Definition: avfilter.c:622
ff_channel_layouts_unref
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition: formats.c:526
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:1431
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:1446
consume_update
static void consume_update(AVFilterLink *link, const AVFrame *frame)
Definition: avfilter.c:1468
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:566
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:284
options
const OptionDef options[]
eval.h
AVFilterContext::nb_inputs
unsigned nb_inputs
number of input pads
Definition: avfilter.h:347
default_execute
static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: avfilter.c:632
AVMediaType
AVMediaType
Definition: avutil.h:199
guess_status_pts
static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
Definition: avfilter.c:432
ff_update_link_current_pts
void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)
Definition: avfilter.c:528
ff_inlink_set_status
void ff_inlink_set_status(AVFilterLink *link, int status)
Set the status on an input link.
Definition: avfilter.c:1610
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:1451
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:194
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:1584
FF_TPRINTF_START
#define FF_TPRINTF_START(ctx, func)
Definition: internal.h:239
avfilter_link_set_closed
void avfilter_link_set_closed(AVFilterLink *link, int closed)
Set the closed field of a link.
Definition: avfilter.c:235
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:472
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:94
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:488
OFFSET
#define OFFSET(x)
Definition: avfilter.c:608
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:595
filt
static const int8_t filt[NUMTAPS]
Definition: af_earwax.c:39
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:373
AVOption::name
const char * name
Definition: opt.h:247
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:869
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:558
AVFilterPad::needs_writable
int needs_writable
The filter expects writable frames from its input link, duplicating data buffers if needed.
Definition: internal.h:134
VAR_POS
@ VAR_POS
Definition: avfilter.c:482
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
AVFrame::channel_layout
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:477
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:1666
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:1630
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:187
internal.h
avfilter_init_str
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:919
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:125
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
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
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:521
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:610
ff_filter_frame_framed
static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:1044
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:578
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:211
internal.h
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:347
AVFilterCommand
Definition: internal.h:38
filter_frame
static int filter_frame(DBEContext *s, AVFrame *frame)
Definition: dolby_e.c:565
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:784
samples_ready
static int samples_ready(AVFilterLink *link, unsigned min)
Definition: avfilter.c:1126
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
uint8_t
uint8_t
Definition: audio_convert.c:194
VAR_T
@ VAR_T
Definition: avfilter.c:480
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:237
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:1456
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:144
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:1536
pos
unsigned int pos
Definition: spdifenc.c:412
AVOption::type
enum AVOptionType type
Definition: opt.h:260
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:388
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:1034
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:639
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:245
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:387
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:882
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:1391
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
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:383
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:383
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:1625
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
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:116
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
audio.h
avfilter_free
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:742
FLAGS
#define FLAGS
Definition: avfilter.c:609
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:1039
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:1569
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:138
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:470
ff_filter_activate_default
static int ff_filter_activate_default(AVFilterContext *filter)
Definition: avfilter.c:1257
avfilter_link_get_channels
int avfilter_link_get_channels(AVFilterLink *link)
Definition: avfilter.c:187
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:222
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
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:544
avstring.h
AVFilterContext::filter
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:341
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:227
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:531
int
int
Definition: ffmpeg_filter.c:192
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:1630
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
VAR_N
@ VAR_N
Definition: avfilter.c:481
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:2465
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:193
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:1635
AVFilterCommand::time
double time
time expressed in seconds
Definition: internal.h:39
min
float min
Definition: vorbis_enc_data.h:456