FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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",
61  ref->width, ref->height,
62  !ref->interlaced_frame ? 'P' : /* Progressive */
63  ref->top_field_first ? 'T' : 'B', /* Top / Bottom */
64  ref->key_frame,
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 {
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 {
138  AVFilterLink *link;
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) {
149  av_log(src, AV_LOG_ERROR,
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
187 int avfilter_link_get_channels(AVFilterLink *link)
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 
211 void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
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 
224 void ff_avfilter_link_set_out_status(AVFilterLink *link, int status, int64_t pts)
225 {
227  av_assert0(!link->status_out);
228  link->status_out = status;
229  if (pts != AV_NOPTS_VALUE)
230  ff_update_link_current_pts(link, pts);
231  filter_unblock(link->dst);
232  ff_filter_set_ready(link->src, 200);
233 }
234 
235 void avfilter_link_set_closed(AVFilterLink *link, int closed)
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)
266  &filt->outputs[filt_dstpad_idx]->out_formats);
267  if (link->out_samplerates)
269  &filt->outputs[filt_dstpad_idx]->out_samplerates);
270  if (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];
285  AVFilterLink *inlink;
286 
287  if (!link) continue;
288  if (!link->src || !link->dst) {
289  av_log(filter, AV_LOG_ERROR,
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 =
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 
330  if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
331  link->sample_aspect_ratio = inlink ?
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 &&
361  av_assert0(!link->hw_frames_ctx &&
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 
383 void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
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)) {
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)
463  ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base));
464  if (ret == AVERROR_EOF)
465  ret = 0;
466  }
467  return ret;
468 }
469 
471 {
472  int i, min = INT_MAX;
473 
474  if (link->srcpad->poll_frame)
475  return link->srcpad->poll_frame(link);
476 
477  for (i = 0; i < link->src->nb_inputs; i++) {
478  int val;
479  if (!link->src->inputs[i])
480  return AVERROR(EINVAL);
481  val = ff_poll_frame(link->src->inputs[i]);
482  min = FFMIN(min, val);
483  }
484 
485  return min;
486 }
487 
488 static const char *const var_names[] = {
489  "t",
490  "n",
491  "pos",
492  "w",
493  "h",
494  NULL
495 };
496 
497 enum {
504 };
505 
506 static int set_enable_expr(AVFilterContext *ctx, const char *expr)
507 {
508  int ret;
509  char *expr_dup;
510  AVExpr *old = ctx->enable;
511 
513  av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
514  "with filter '%s'\n", ctx->filter->name);
515  return AVERROR_PATCHWELCOME;
516  }
517 
518  expr_dup = av_strdup(expr);
519  if (!expr_dup)
520  return AVERROR(ENOMEM);
521 
522  if (!ctx->var_values) {
523  ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values));
524  if (!ctx->var_values) {
525  av_free(expr_dup);
526  return AVERROR(ENOMEM);
527  }
528  }
529 
530  ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names,
531  NULL, NULL, NULL, NULL, 0, ctx->priv);
532  if (ret < 0) {
533  av_log(ctx->priv, AV_LOG_ERROR,
534  "Error when evaluating the expression '%s' for enable\n",
535  expr_dup);
536  av_free(expr_dup);
537  return ret;
538  }
539 
540  av_expr_free(old);
541  av_free(ctx->enable_str);
542  ctx->enable_str = expr_dup;
543  return 0;
544 }
545 
547 {
548  if (pts == AV_NOPTS_VALUE)
549  return;
550  link->current_pts = pts;
552  /* TODO use duration */
553  if (link->graph && link->age_index >= 0)
555 }
556 
557 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
558 {
559  if(!strcmp(cmd, "ping")){
560  char local_res[256] = {0};
561 
562  if (!res) {
563  res = local_res;
564  res_len = sizeof(local_res);
565  }
566  av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
567  if (res == local_res)
568  av_log(filter, AV_LOG_INFO, "%s", res);
569  return 0;
570  }else if(!strcmp(cmd, "enable")) {
571  return set_enable_expr(filter, arg);
572  }else if(filter->filter->process_command) {
573  return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);
574  }
575  return AVERROR(ENOSYS);
576 }
577 
580 
581 const AVFilter *avfilter_get_by_name(const char *name)
582 {
583  const AVFilter *f = NULL;
584 
585  if (!name)
586  return NULL;
587 
588  while ((f = avfilter_next(f)))
589  if (!strcmp(f->name, name))
590  return (AVFilter *)f;
591 
592  return NULL;
593 }
594 
596 
598 {
599  AVFilter **f;
600 
601  /* the filter must select generic or internal exclusively */
603 
605  f = last_filter;
606 
607  while (*f)
608  f = &(*f)->next;
609  *f = filter;
610  filter->next = NULL;
611  last_filter = &filter->next;
612 
614 
615  return 0;
616 }
617 
618 const AVFilter *avfilter_next(const AVFilter *prev)
619 {
620  return prev ? prev->next : first_filter;
621 }
622 
624 {
625  int count;
626 
627  if (!pads)
628  return 0;
629 
630  for (count = 0; pads->name; count++)
631  pads++;
632  return count;
633 }
634 
635 static const char *default_filter_name(void *filter_ctx)
636 {
638  return ctx->name ? ctx->name : ctx->filter->name;
639 }
640 
641 static void *filter_child_next(void *obj, void *prev)
642 {
643  AVFilterContext *ctx = obj;
644  if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
645  return ctx->priv;
646  return NULL;
647 }
648 
649 static const AVClass *filter_child_class_next(const AVClass *prev)
650 {
651  const AVFilter *f = NULL;
652 
653  /* find the filter that corresponds to prev */
654  while (prev && (f = avfilter_next(f)))
655  if (f->priv_class == prev)
656  break;
657 
658  /* could not find filter corresponding to prev */
659  if (prev && !f)
660  return NULL;
661 
662  /* find next filter with specific options */
663  while ((f = avfilter_next(f)))
664  if (f->priv_class)
665  return f->priv_class;
666 
667  return NULL;
668 }
669 
670 #define OFFSET(x) offsetof(AVFilterContext, x)
671 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
672 static const AVOption avfilter_options[] = {
673  { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
674  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
675  { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .unit = "thread_type" },
676  { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
677  { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
678  { .i64 = 0 }, 0, INT_MAX, FLAGS },
679  { NULL },
680 };
681 
682 static const AVClass avfilter_class = {
683  .class_name = "AVFilter",
684  .item_name = default_filter_name,
685  .version = LIBAVUTIL_VERSION_INT,
686  .category = AV_CLASS_CATEGORY_FILTER,
687  .child_next = filter_child_next,
688  .child_class_next = filter_child_class_next,
690 };
691 
693  int *ret, int nb_jobs)
694 {
695  int i;
696 
697  for (i = 0; i < nb_jobs; i++) {
698  int r = func(ctx, arg, i, nb_jobs);
699  if (ret)
700  ret[i] = r;
701  }
702  return 0;
703 }
704 
705 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
706 {
707  AVFilterContext *ret;
708  int preinited = 0;
709 
710  if (!filter)
711  return NULL;
712 
713  ret = av_mallocz(sizeof(AVFilterContext));
714  if (!ret)
715  return NULL;
716 
717  ret->av_class = &avfilter_class;
718  ret->filter = filter;
719  ret->name = inst_name ? av_strdup(inst_name) : NULL;
720  if (filter->priv_size) {
721  ret->priv = av_mallocz(filter->priv_size);
722  if (!ret->priv)
723  goto err;
724  }
725  if (filter->preinit) {
726  if (filter->preinit(ret) < 0)
727  goto err;
728  preinited = 1;
729  }
730 
731  av_opt_set_defaults(ret);
732  if (filter->priv_class) {
733  *(const AVClass**)ret->priv = filter->priv_class;
735  }
736 
737  ret->internal = av_mallocz(sizeof(*ret->internal));
738  if (!ret->internal)
739  goto err;
741 
742  ret->nb_inputs = avfilter_pad_count(filter->inputs);
743  if (ret->nb_inputs ) {
744  ret->input_pads = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad));
745  if (!ret->input_pads)
746  goto err;
747  memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
748  ret->inputs = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*));
749  if (!ret->inputs)
750  goto err;
751  }
752 
753  ret->nb_outputs = avfilter_pad_count(filter->outputs);
754  if (ret->nb_outputs) {
755  ret->output_pads = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad));
756  if (!ret->output_pads)
757  goto err;
758  memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
759  ret->outputs = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*));
760  if (!ret->outputs)
761  goto err;
762  }
763 
764  return ret;
765 
766 err:
767  if (preinited)
768  filter->uninit(ret);
769  av_freep(&ret->inputs);
770  av_freep(&ret->input_pads);
771  ret->nb_inputs = 0;
772  av_freep(&ret->outputs);
773  av_freep(&ret->output_pads);
774  ret->nb_outputs = 0;
775  av_freep(&ret->priv);
776  av_freep(&ret->internal);
777  av_free(ret);
778  return NULL;
779 }
780 
781 static void free_link(AVFilterLink *link)
782 {
783  if (!link)
784  return;
785 
786  if (link->src)
787  link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
788  if (link->dst)
789  link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
790 
792 
799  avfilter_link_free(&link);
800 }
801 
803 {
804  int i;
805 
806  if (!filter)
807  return;
808 
809  if (filter->graph)
810  ff_filter_graph_remove_filter(filter->graph, filter);
811 
812  if (filter->filter->uninit)
813  filter->filter->uninit(filter);
814 
815  for (i = 0; i < filter->nb_inputs; i++) {
816  free_link(filter->inputs[i]);
817  }
818  for (i = 0; i < filter->nb_outputs; i++) {
819  free_link(filter->outputs[i]);
820  }
821 
822  if (filter->filter->priv_class)
823  av_opt_free(filter->priv);
824 
825  av_buffer_unref(&filter->hw_device_ctx);
826 
827  av_freep(&filter->name);
828  av_freep(&filter->input_pads);
829  av_freep(&filter->output_pads);
830  av_freep(&filter->inputs);
831  av_freep(&filter->outputs);
832  av_freep(&filter->priv);
833  while(filter->command_queue){
834  ff_command_queue_pop(filter);
835  }
836  av_opt_free(filter);
837  av_expr_free(filter->enable);
838  filter->enable = NULL;
839  av_freep(&filter->var_values);
840  av_freep(&filter->internal);
841  av_free(filter);
842 }
843 
845 {
846  if (ctx->nb_threads > 0)
847  return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
848  return ctx->graph->nb_threads;
849 }
850 
852  const char *args)
853 {
854  const AVOption *o = NULL;
855  int ret, count = 0;
856  char *av_uninit(parsed_key), *av_uninit(value);
857  const char *key;
858  int offset= -1;
859 
860  if (!args)
861  return 0;
862 
863  while (*args) {
864  const char *shorthand = NULL;
865 
866  o = av_opt_next(ctx->priv, o);
867  if (o) {
868  if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
869  continue;
870  offset = o->offset;
871  shorthand = o->name;
872  }
873 
874  ret = av_opt_get_key_value(&args, "=", ":",
875  shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
876  &parsed_key, &value);
877  if (ret < 0) {
878  if (ret == AVERROR(EINVAL))
879  av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
880  else
881  av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
882  av_err2str(ret));
883  return ret;
884  }
885  if (*args)
886  args++;
887  if (parsed_key) {
888  key = parsed_key;
889  while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */
890  } else {
891  key = shorthand;
892  }
893 
894  av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
895 
896  if (av_opt_find(ctx, key, NULL, 0, 0)) {
897  ret = av_opt_set(ctx, key, value, 0);
898  if (ret < 0) {
899  av_free(value);
900  av_free(parsed_key);
901  return ret;
902  }
903  } else {
904  av_dict_set(options, key, value, 0);
905  if ((ret = av_opt_set(ctx->priv, key, value, AV_OPT_SEARCH_CHILDREN)) < 0) {
907  if (ret == AVERROR_OPTION_NOT_FOUND)
908  av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
909  av_free(value);
910  av_free(parsed_key);
911  return ret;
912  }
913  }
914  }
915 
916  av_free(value);
917  av_free(parsed_key);
918  count++;
919  }
920 
921  if (ctx->enable_str) {
922  ret = set_enable_expr(ctx, ctx->enable_str);
923  if (ret < 0)
924  return ret;
925  }
926  return count;
927 }
928 
930 {
931  int ret = 0;
932 
933  ret = av_opt_set_dict(ctx, options);
934  if (ret < 0) {
935  av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
936  return ret;
937  }
938 
941  ctx->graph->internal->thread_execute) {
944  } else {
945  ctx->thread_type = 0;
946  }
947 
948  if (ctx->filter->priv_class) {
949  ret = av_opt_set_dict2(ctx->priv, options, AV_OPT_SEARCH_CHILDREN);
950  if (ret < 0) {
951  av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
952  return ret;
953  }
954  }
955 
956  if (ctx->filter->init_opaque)
957  ret = ctx->filter->init_opaque(ctx, NULL);
958  else if (ctx->filter->init)
959  ret = ctx->filter->init(ctx);
960  else if (ctx->filter->init_dict)
961  ret = ctx->filter->init_dict(ctx, options);
962 
963  return ret;
964 }
965 
967 {
970  int ret = 0;
971 
972  if (args && *args) {
973  if (!filter->filter->priv_class) {
974  av_log(filter, AV_LOG_ERROR, "This filter does not take any "
975  "options, but options were provided: %s.\n", args);
976  return AVERROR(EINVAL);
977  }
978 
979 #if FF_API_OLD_FILTER_OPTS_ERROR
980  if ( !strcmp(filter->filter->name, "format") ||
981  !strcmp(filter->filter->name, "noformat") ||
982  !strcmp(filter->filter->name, "frei0r") ||
983  !strcmp(filter->filter->name, "frei0r_src") ||
984  !strcmp(filter->filter->name, "ocv") ||
985  !strcmp(filter->filter->name, "pan") ||
986  !strcmp(filter->filter->name, "pp") ||
987  !strcmp(filter->filter->name, "aevalsrc")) {
988  /* a hack for compatibility with the old syntax
989  * replace colons with |s */
990  char *copy = av_strdup(args);
991  char *p = copy;
992  int nb_leading = 0; // number of leading colons to skip
993  int deprecated = 0;
994 
995  if (!copy) {
996  ret = AVERROR(ENOMEM);
997  goto fail;
998  }
999 
1000  if (!strcmp(filter->filter->name, "frei0r") ||
1001  !strcmp(filter->filter->name, "ocv"))
1002  nb_leading = 1;
1003  else if (!strcmp(filter->filter->name, "frei0r_src"))
1004  nb_leading = 3;
1005 
1006  while (nb_leading--) {
1007  p = strchr(p, ':');
1008  if (!p) {
1009  p = copy + strlen(copy);
1010  break;
1011  }
1012  p++;
1013  }
1014 
1015  deprecated = strchr(p, ':') != NULL;
1016 
1017  if (!strcmp(filter->filter->name, "aevalsrc")) {
1018  deprecated = 0;
1019  while ((p = strchr(p, ':')) && p[1] != ':') {
1020  const char *epos = strchr(p + 1, '=');
1021  const char *spos = strchr(p + 1, ':');
1022  const int next_token_is_opt = epos && (!spos || epos < spos);
1023  if (next_token_is_opt) {
1024  p++;
1025  break;
1026  }
1027  /* next token does not contain a '=', assume a channel expression */
1028  deprecated = 1;
1029  *p++ = '|';
1030  }
1031  if (p && *p == ':') { // double sep '::' found
1032  deprecated = 1;
1033  memmove(p, p + 1, strlen(p));
1034  }
1035  } else
1036  while ((p = strchr(p, ':')))
1037  *p++ = '|';
1038 
1039  if (deprecated) {
1040  av_log(filter, AV_LOG_ERROR, "This syntax is deprecated. Use "
1041  "'|' to separate the list items ('%s' instead of '%s')\n",
1042  copy, args);
1043  ret = AVERROR(EINVAL);
1044  } else {
1045  ret = process_options(filter, &options, copy);
1046  }
1047  av_freep(&copy);
1048 
1049  if (ret < 0)
1050  goto fail;
1051  } else
1052 #endif
1053  {
1054  ret = process_options(filter, &options, args);
1055  if (ret < 0)
1056  goto fail;
1057  }
1058  }
1059 
1060  ret = avfilter_init_dict(filter, &options);
1061  if (ret < 0)
1062  goto fail;
1063 
1064  if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1065  av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
1067  goto fail;
1068  }
1069 
1070 fail:
1071  av_dict_free(&options);
1072 
1073  return ret;
1074 }
1075 
1076 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
1077 {
1078  return pads[pad_idx].name;
1079 }
1080 
1081 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
1082 {
1083  return pads[pad_idx].type;
1084 }
1085 
1087 {
1088  return ff_filter_frame(link->dst->outputs[0], frame);
1089 }
1090 
1092 {
1094  AVFilterContext *dstctx = link->dst;
1095  AVFilterPad *dst = link->dstpad;
1096  int ret;
1097 
1098  if (!(filter_frame = dst->filter_frame))
1100 
1101  if (dst->needs_writable) {
1102  ret = ff_inlink_make_frame_writable(link, &frame);
1103  if (ret < 0)
1104  goto fail;
1105  }
1106 
1107  ff_inlink_process_commands(link, frame);
1108  dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1109 
1110  if (dstctx->is_disabled &&
1113  ret = filter_frame(link, frame);
1114  link->frame_count_out++;
1115  return ret;
1116 
1117 fail:
1118  av_frame_free(&frame);
1119  return ret;
1120 }
1121 
1123 {
1124  int ret;
1126 
1127  /* Consistency checks */
1128  if (link->type == AVMEDIA_TYPE_VIDEO) {
1129  if (strcmp(link->dst->filter->name, "buffersink") &&
1130  strcmp(link->dst->filter->name, "format") &&
1131  strcmp(link->dst->filter->name, "idet") &&
1132  strcmp(link->dst->filter->name, "null") &&
1133  strcmp(link->dst->filter->name, "scale")) {
1134  av_assert1(frame->format == link->format);
1135  av_assert1(frame->width == link->w);
1136  av_assert1(frame->height == link->h);
1137  }
1138  } else {
1139  if (frame->format != link->format) {
1140  av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1141  goto error;
1142  }
1143  if (frame->channels != link->channels) {
1144  av_log(link->dst, AV_LOG_ERROR, "Channel count change is not supported\n");
1145  goto error;
1146  }
1147  if (frame->channel_layout != link->channel_layout) {
1148  av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1149  goto error;
1150  }
1151  if (frame->sample_rate != link->sample_rate) {
1152  av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1153  goto error;
1154  }
1155  }
1156 
1157  link->frame_blocked_in = link->frame_wanted_out = 0;
1158  link->frame_count_in++;
1159  filter_unblock(link->dst);
1160  ret = ff_framequeue_add(&link->fifo, frame);
1161  if (ret < 0) {
1162  av_frame_free(&frame);
1163  return ret;
1164  }
1165  ff_filter_set_ready(link->dst, 300);
1166  return 0;
1167 
1168 error:
1169  av_frame_free(&frame);
1170  return AVERROR_PATCHWELCOME;
1171 }
1172 
1173 static int samples_ready(AVFilterLink *link, unsigned min)
1174 {
1175  return ff_framequeue_queued_frames(&link->fifo) &&
1176  (ff_framequeue_queued_samples(&link->fifo) >= min ||
1177  link->status_in);
1178 }
1179 
1180 static int take_samples(AVFilterLink *link, unsigned min, unsigned max,
1181  AVFrame **rframe)
1182 {
1183  AVFrame *frame0, *frame, *buf;
1184  unsigned nb_samples, nb_frames, i, p;
1185  int ret;
1186 
1187  /* Note: this function relies on no format changes and must only be
1188  called with enough samples. */
1189  av_assert1(samples_ready(link, link->min_samples));
1190  frame0 = frame = ff_framequeue_peek(&link->fifo, 0);
1191  if (!link->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1192  *rframe = ff_framequeue_take(&link->fifo);
1193  return 0;
1194  }
1195  nb_frames = 0;
1196  nb_samples = 0;
1197  while (1) {
1198  if (nb_samples + frame->nb_samples > max) {
1199  if (nb_samples < min)
1200  nb_samples = max;
1201  break;
1202  }
1203  nb_samples += frame->nb_samples;
1204  nb_frames++;
1205  if (nb_frames == ff_framequeue_queued_frames(&link->fifo))
1206  break;
1207  frame = ff_framequeue_peek(&link->fifo, nb_frames);
1208  }
1209 
1210  buf = ff_get_audio_buffer(link, nb_samples);
1211  if (!buf)
1212  return AVERROR(ENOMEM);
1213  ret = av_frame_copy_props(buf, frame0);
1214  if (ret < 0) {
1215  av_frame_free(&buf);
1216  return ret;
1217  }
1218  buf->pts = frame0->pts;
1219 
1220  p = 0;
1221  for (i = 0; i < nb_frames; i++) {
1222  frame = ff_framequeue_take(&link->fifo);
1223  av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1224  frame->nb_samples, link->channels, link->format);
1225  p += frame->nb_samples;
1226  av_frame_free(&frame);
1227  }
1228  if (p < nb_samples) {
1229  unsigned n = nb_samples - p;
1230  frame = ff_framequeue_peek(&link->fifo, 0);
1231  av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1232  link->channels, link->format);
1233  ff_framequeue_skip_samples(&link->fifo, n, link->time_base);
1234  }
1235 
1236  *rframe = buf;
1237  return 0;
1238 }
1239 
1241 {
1242  AVFrame *frame = NULL;
1243  AVFilterContext *dst = link->dst;
1244  int ret;
1245 
1247  ret = link->min_samples ?
1248  ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1249  ff_inlink_consume_frame(link, &frame);
1250  av_assert1(ret);
1251  if (ret < 0) {
1252  av_assert1(!frame);
1253  return ret;
1254  }
1255  /* The filter will soon have received a new frame, that may allow it to
1256  produce one or more: unblock its outputs. */
1257  filter_unblock(dst);
1258  /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1259  before the frame; ff_filter_frame_framed() will re-increment it. */
1260  link->frame_count_out--;
1261  ret = ff_filter_frame_framed(link, frame);
1262  if (ret < 0 && ret != link->status_out) {
1264  } else {
1265  /* Run once again, to see if several frames were available, or if
1266  the input status has also changed, or any other reason. */
1267  ff_filter_set_ready(dst, 300);
1268  }
1269  return ret;
1270 }
1271 
1273 {
1274  unsigned out = 0, progress = 0;
1275  int ret;
1276 
1277  av_assert0(!in->status_out);
1278  if (!filter->nb_outputs) {
1279  /* not necessary with the current API and sinks */
1280  return 0;
1281  }
1282  while (!in->status_out) {
1283  if (!filter->outputs[out]->status_in) {
1284  progress++;
1285  ret = ff_request_frame_to_filter(filter->outputs[out]);
1286  if (ret < 0)
1287  return ret;
1288  }
1289  if (++out == filter->nb_outputs) {
1290  if (!progress) {
1291  /* Every output already closed: input no longer interesting
1292  (example: overlay in shortest mode, other input closed). */
1293  ff_avfilter_link_set_out_status(in, in->status_in, in->status_in_pts);
1294  return 0;
1295  }
1296  progress = 0;
1297  out = 0;
1298  }
1299  }
1300  ff_filter_set_ready(filter, 200);
1301  return 0;
1302 }
1303 
1305 {
1306  unsigned i;
1307 
1308  for (i = 0; i < filter->nb_inputs; i++) {
1309  if (samples_ready(filter->inputs[i], filter->inputs[i]->min_samples)) {
1310  return ff_filter_frame_to_filter(filter->inputs[i]);
1311  }
1312  }
1313  for (i = 0; i < filter->nb_inputs; i++) {
1314  if (filter->inputs[i]->status_in && !filter->inputs[i]->status_out) {
1315  av_assert1(!ff_framequeue_queued_frames(&filter->inputs[i]->fifo));
1316  return forward_status_change(filter, filter->inputs[i]);
1317  }
1318  }
1319  for (i = 0; i < filter->nb_outputs; i++) {
1320  if (filter->outputs[i]->frame_wanted_out &&
1321  !filter->outputs[i]->frame_blocked_in) {
1322  return ff_request_frame_to_filter(filter->outputs[i]);
1323  }
1324  }
1325  return FFERROR_NOT_READY;
1326 }
1327 
1328 /*
1329  Filter scheduling and activation
1330 
1331  When a filter is activated, it must:
1332  - if possible, output a frame;
1333  - else, if relevant, forward the input status change;
1334  - else, check outputs for wanted frames and forward the requests.
1335 
1336  The following AVFilterLink fields are used for activation:
1337 
1338  - frame_wanted_out:
1339 
1340  This field indicates if a frame is needed on this input of the
1341  destination filter. A positive value indicates that a frame is needed
1342  to process queued frames or internal data or to satisfy the
1343  application; a zero value indicates that a frame is not especially
1344  needed but could be processed anyway; a negative value indicates that a
1345  frame would just be queued.
1346 
1347  It is set by filters using ff_request_frame() or ff_request_no_frame(),
1348  when requested by the application through a specific API or when it is
1349  set on one of the outputs.
1350 
1351  It is cleared when a frame is sent from the source using
1352  ff_filter_frame().
1353 
1354  It is also cleared when a status change is sent from the source using
1355  ff_avfilter_link_set_in_status().
1356 
1357  - frame_blocked_in:
1358 
1359  This field means that the source filter can not generate a frame as is.
1360  Its goal is to avoid repeatedly calling the request_frame() method on
1361  the same link.
1362 
1363  It is set by the framework on all outputs of a filter before activating it.
1364 
1365  It is automatically cleared by ff_filter_frame().
1366 
1367  It is also automatically cleared by ff_avfilter_link_set_in_status().
1368 
1369  It is also cleared on all outputs (using filter_unblock()) when
1370  something happens on an input: processing a frame or changing the
1371  status.
1372 
1373  - fifo:
1374 
1375  Contains the frames queued on a filter input. If it contains frames and
1376  frame_wanted_out is not set, then the filter can be activated. If that
1377  result in the filter not able to use these frames, the filter must set
1378  frame_wanted_out to ask for more frames.
1379 
1380  - status_in and status_in_pts:
1381 
1382  Status (EOF or error code) of the link and timestamp of the status
1383  change (in link time base, same as frames) as seen from the input of
1384  the link. The status change is considered happening after the frames
1385  queued in fifo.
1386 
1387  It is set by the source filter using ff_avfilter_link_set_in_status().
1388 
1389  - status_out:
1390 
1391  Status of the link as seen from the output of the link. The status
1392  change is considered having already happened.
1393 
1394  It is set by the destination filter using
1395  ff_avfilter_link_set_out_status().
1396 
1397  Filters are activated according to the ready field, set using the
1398  ff_filter_set_ready(). Eventually, a priority queue will be used.
1399  ff_filter_set_ready() is called whenever anything could cause progress to
1400  be possible. Marking a filter ready when it is not is not a problem,
1401  except for the small overhead it causes.
1402 
1403  Conditions that cause a filter to be marked ready are:
1404 
1405  - frames added on an input link;
1406 
1407  - changes in the input or output status of an input link;
1408 
1409  - requests for a frame on an output link;
1410 
1411  - after any actual processing using the legacy methods (filter_frame(),
1412  and request_frame() to acknowledge status changes), to run once more
1413  and check if enough input was present for several frames.
1414 
1415  Exemples of scenarios to consider:
1416 
1417  - buffersrc: activate if frame_wanted_out to notify the application;
1418  activate when the application adds a frame to push it immediately.
1419 
1420  - testsrc: activate only if frame_wanted_out to produce and push a frame.
1421 
1422  - concat (not at stitch points): can process a frame on any output.
1423  Activate if frame_wanted_out on output to forward on the corresponding
1424  input. Activate when a frame is present on input to process it
1425  immediately.
1426 
1427  - framesync: needs at least one frame on each input; extra frames on the
1428  wrong input will accumulate. When a frame is first added on one input,
1429  set frame_wanted_out<0 on it to avoid getting more (would trigger
1430  testsrc) and frame_wanted_out>0 on the other to allow processing it.
1431 
1432  Activation of old filters:
1433 
1434  In order to activate a filter implementing the legacy filter_frame() and
1435  request_frame() methods, perform the first possible of the following
1436  actions:
1437 
1438  - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1439  frame and call filter_frame().
1440 
1441  Ratinale: filter frames as soon as possible instead of leaving them
1442  queued; frame_wanted_out < 0 is not possible since the old API does not
1443  set it nor provides any similar feedback; frame_wanted_out > 0 happens
1444  when min_samples > 0 and there are not enough samples queued.
1445 
1446  - If an input has status_in set but not status_out, try to call
1447  request_frame() on one of the outputs in the hope that it will trigger
1448  request_frame() on the input with status_in and acknowledge it. This is
1449  awkward and fragile, filters with several inputs or outputs should be
1450  updated to direct activation as soon as possible.
1451 
1452  - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1453  request_frame().
1454 
1455  Rationale: checking frame_blocked_in is necessary to avoid requesting
1456  repeatedly on a blocked input if another is not blocked (example:
1457  [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1458 
1459  TODO: respect needs_fifo and remove auto-inserted fifos.
1460 
1461  */
1462 
1464 {
1465  int ret;
1466 
1467  /* Generic timeline support is not yet implemented but should be easy */
1469  filter->filter->activate));
1470  filter->ready = 0;
1471  ret = filter->filter->activate ? filter->filter->activate(filter) :
1473  if (ret == FFERROR_NOT_READY)
1474  ret = 0;
1475  return ret;
1476 }
1477 
1478 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1479 {
1480  *rpts = link->current_pts;
1481  if (ff_framequeue_queued_frames(&link->fifo))
1482  return *rstatus = 0;
1483  if (link->status_out)
1484  return *rstatus = link->status_out;
1485  if (!link->status_in)
1486  return *rstatus = 0;
1487  *rstatus = link->status_out = link->status_in;
1488  ff_update_link_current_pts(link, link->status_in_pts);
1489  *rpts = link->current_pts;
1490  return 1;
1491 }
1492 
1494 {
1495  return ff_framequeue_queued_frames(&link->fifo) > 0;
1496 }
1497 
1499 {
1500  uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
1501  av_assert1(min);
1502  return samples >= min || (link->status_in && samples);
1503 }
1504 
1505 static void consume_update(AVFilterLink *link, const AVFrame *frame)
1506 {
1507  ff_update_link_current_pts(link, frame->pts);
1508  ff_inlink_process_commands(link, frame);
1509  link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1510  link->frame_count_out++;
1511 }
1512 
1514 {
1515  AVFrame *frame;
1516 
1517  *rframe = NULL;
1519  return 0;
1520 
1521  if (link->fifo.samples_skipped) {
1522  frame = ff_framequeue_peek(&link->fifo, 0);
1523  return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1524  }
1525 
1526  frame = ff_framequeue_take(&link->fifo);
1527  consume_update(link, frame);
1528  *rframe = frame;
1529  return 1;
1530 }
1531 
1532 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1533  AVFrame **rframe)
1534 {
1535  AVFrame *frame;
1536  int ret;
1537 
1538  av_assert1(min);
1539  *rframe = NULL;
1540  if (!ff_inlink_check_available_samples(link, min))
1541  return 0;
1542  if (link->status_in)
1543  min = FFMIN(min, ff_framequeue_queued_samples(&link->fifo));
1544  ret = take_samples(link, min, max, &frame);
1545  if (ret < 0)
1546  return ret;
1547  consume_update(link, frame);
1548  *rframe = frame;
1549  return 1;
1550 }
1551 
1553 {
1554  AVFrame *frame = *rframe;
1555  AVFrame *out;
1556  int ret;
1557 
1558  if (av_frame_is_writable(frame))
1559  return 0;
1560  av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1561 
1562  switch (link->type) {
1563  case AVMEDIA_TYPE_VIDEO:
1564  out = ff_get_video_buffer(link, link->w, link->h);
1565  break;
1566  case AVMEDIA_TYPE_AUDIO:
1567  out = ff_get_audio_buffer(link, frame->nb_samples);
1568  break;
1569  default:
1570  return AVERROR(EINVAL);
1571  }
1572  if (!out)
1573  return AVERROR(ENOMEM);
1574 
1575  ret = av_frame_copy_props(out, frame);
1576  if (ret < 0) {
1577  av_frame_free(&out);
1578  return ret;
1579  }
1580 
1581  switch (link->type) {
1582  case AVMEDIA_TYPE_VIDEO:
1583  av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
1584  frame->format, frame->width, frame->height);
1585  break;
1586  case AVMEDIA_TYPE_AUDIO:
1588  0, 0, frame->nb_samples,
1589  frame->channels,
1590  frame->format);
1591  break;
1592  default:
1593  av_assert0(!"reached");
1594  }
1595 
1596  av_frame_free(&frame);
1597  *rframe = out;
1598  return 0;
1599 }
1600 
1602 {
1603  AVFilterCommand *cmd = link->dst->command_queue;
1604 
1605  while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1606  av_log(link->dst, AV_LOG_DEBUG,
1607  "Processing command time:%f command:%s arg:%s\n",
1608  cmd->time, cmd->command, cmd->arg);
1609  avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1610  ff_command_queue_pop(link->dst);
1611  cmd= link->dst->command_queue;
1612  }
1613  return 0;
1614 }
1615 
1617 {
1618  AVFilterContext *dstctx = link->dst;
1619  int64_t pts = frame->pts;
1620  int64_t pos = frame->pkt_pos;
1621 
1622  if (!dstctx->enable_str)
1623  return 1;
1624 
1625  dstctx->var_values[VAR_N] = link->frame_count_out;
1626  dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1627  dstctx->var_values[VAR_W] = link->w;
1628  dstctx->var_values[VAR_H] = link->h;
1629  dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1630 
1631  return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
1632 }
1633 
1635 {
1636  av_assert1(!link->status_in);
1637  av_assert1(!link->status_out);
1638  link->frame_wanted_out = 1;
1639  ff_filter_set_ready(link->src, 100);
1640 }
1641 
1642 void ff_inlink_set_status(AVFilterLink *link, int status)
1643 {
1644  if (link->status_out)
1645  return;
1646  link->frame_wanted_out = 0;
1647  link->frame_blocked_in = 0;
1649  while (ff_framequeue_queued_frames(&link->fifo)) {
1650  AVFrame *frame = ff_framequeue_take(&link->fifo);
1651  av_frame_free(&frame);
1652  }
1653  if (!link->status_in)
1654  link->status_in = status;
1655 }
1656 
1658 {
1659  return link->status_in;
1660 }
1661 
1663 {
1664  return &avfilter_class;
1665 }
int(* poll_frame)(AVFilterLink *link)
Frame poll callback.
Definition: internal.h:104
double * var_values
variable values for the enable expression
Definition: avfilter.h:384
#define ff_tlog(ctx,...)
Definition: internal.h:75
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:1513
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
#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:385
void ff_tlog_ref(void *ctx, AVFrame *ref, int end)
Definition: avfilter.c:49
static void copy(const float *p1, float *p2, const int length)
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
AVFilterContext * ff_filter_alloc(const AVFilter *filter, const char *inst_name)
Allocate a new filter context and return it.
Definition: avfilter.c:705
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
int thread_type
Type of multithreading allowed for filters in this graph.
Definition: avfilter.h:829
static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:1086
AVOption.
Definition: opt.h:246
static int ff_filter_activate_default(AVFilterContext *filter)
Definition: avfilter.c:1304
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:802
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:473
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Main libavfilter public API header.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:393
int(* init)(AVFilterContext *ctx)
Filter initialization function.
Definition: avfilter.h:233
int(* preinit)(AVFilterContext *ctx)
Filter pre-initialization function.
Definition: avfilter.h:210
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref, AVFilterChannelLayouts **newref)
Definition: formats.c:499
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1291
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:1081
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
int num
Numerator.
Definition: rational.h:59
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:155
AVBufferRef * hw_device_ctx
For filters which will create hardware frames, sets the device the filter should create them in...
Definition: avfilter.h:394
#define FFERROR_NOT_READY
Filters implementation helper functions.
Definition: filters.h:34
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
#define LIBAVFILTER_VERSION_INT
Definition: version.h:36
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
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:679
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
int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
Test if enough samples are available on the link.
Definition: avfilter.c:1498
#define src
Definition: vp8dsp.c:254
int thread_type
Type of multithreading being allowed/used.
Definition: avfilter.h:373
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:385
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1634
int nb_threads
Max number of threads allowed in this filter instance.
Definition: avfilter.h:401
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
Definition: avfilter.h:333
struct AVFilterGraph * graph
filtergraph this filter belongs to
Definition: avfilter.h:355
#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
const char * name
Pad name.
Definition: internal.h:60
int priv_size
size of private data to allocate for the filter
Definition: avfilter.h:284
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
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
char * name
name of this filter instance
Definition: avfilter.h:343
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static AVFilter ** last_filter
Definition: avfilter.c:579
const char * name
Definition: opt.h:247
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1122
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
Definition: avfilter.c:135
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:349
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
Definition: cfhd.c:97
void ff_frame_pool_uninit(FFFramePool **pool)
Deallocate the frame pool.
Definition: framepool.c:284
const char * avfilter_license(void)
Return the libavfilter license.
Definition: avfilter.c:88
unsigned ready
Ready status of the filter.
Definition: avfilter.h:408
uint8_t
int(* request_frame)(AVFilterLink *link)
Frame request callback.
Definition: internal.h:113
AVOptions.
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
const struct AVOption * option
a pointer to the first option specified in the class if any or NULL
Definition: log.h:85
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:294
Definition: eval.c:157
int flags
A combination of AVFILTER_FLAG_*.
Definition: avfilter.h:187
void ff_command_queue_pop(AVFilterContext *filter)
Definition: avfilter.c:94
static void filter_unblock(AVFilterContext *filter)
Clear frame_blocked_in on all outputs.
Definition: avfilter.c:202
static AVFrame * frame
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
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
int nb_threads
Maximum number of threads used by filters in this graph.
Definition: avfilter.h:836
int avfilter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
Definition: avfilter.c:277
static int flags
Definition: log.c:55
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
const AVFilter * avfilter_next(const AVFilter *prev)
Iterate over all registered filters.
Definition: avfilter.c:618
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:348
void(* uninit)(AVFilterContext *ctx)
Filter uninitialization function.
Definition: avfilter.h:258
static void free_link(AVFilterLink *link)
Definition: avfilter.c:781
int(* process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags)
Make the filter instance process a command.
Definition: avfilter.h:306
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
Add a frame.
Definition: framequeue.c:63
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)
Definition: avfilter.c:546
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
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
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:1616
static const AVClass avfilter_class
Definition: avfilter.c:682
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:1478
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:345
static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
Definition: avfilter.c:1272
static void consume_update(AVFilterLink *link, const AVFrame *frame)
Definition: avfilter.c:1505
int width
Definition: frame.h:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
Before After |formats |<------—.
Definition: formats.c:505
#define AVMutex
Definition: thread.h:151
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:790
static const char * default_filter_name(void *filter_ctx)
Definition: avfilter.c:635
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
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
unsigned nb_outputs
number of output pads
Definition: avfilter.h:351
unsigned avfilter_version(void)
Return the LIBAVFILTER_VERSION_INT constant.
Definition: avfilter.c:77
const char * r
Definition: vf_curves.c:111
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:116
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int(* filter_frame)(AVFilterLink *link, AVFrame *frame)
Filtering callback.
Definition: internal.h:93
char * enable_str
enable expression string
Definition: avfilter.h:382
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
const char * arg
Definition: jacosubdec.c:66
int(* init_dict)(AVFilterContext *ctx, AVDictionary **options)
Should be set instead of init by the filters that want to pass a dictionary of AVOptions to nested co...
Definition: avfilter.h:246
simple assert() macros that are a bit more flexible than ISO C assert().
#define FF_TPRINTF_START(ctx, func)
Definition: internal.h:250
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
static FilteringContext * filter_ctx
Definition: transcoding.c:45
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
Accept to parse a value without a key; the key will then be returned as NULL.
Definition: opt.h:527
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
GLsizei count
Definition: opengl_enc.c:109
#define FFMAX(a, b)
Definition: common.h:94
Frame pool.
Definition: framepool.c:30
#define fail()
Definition: checkasm.h:113
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:386
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:156
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:379
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: avfilter.c:581
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:1594
void ff_framequeue_free(FFFrameQueue *fq)
Free the queue and all queued frames.
Definition: framequeue.c:53
common internal API header
static void * filter_child_next(void *obj, void *prev)
Definition: avfilter.c:641
void avfilter_link_set_closed(AVFilterLink *link, int closed)
Set the closed field of a link.
Definition: avfilter.c:235
#define AV_MUTEX_INITIALIZER
Definition: thread.h:152
int channels
number of audio channels, only used for audio.
Definition: frame.h:506
audio channel layout utility functions
static int request_frame(AVFilterLink *outlink)
Definition: aeval.c:274
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:284
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:844
unsigned nb_inputs
number of input pads
Definition: avfilter.h:347
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define NAN
Definition: mathematics.h:64
#define FFMIN(a, b)
Definition: common.h:96
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:554
static AVFilter * first_filter
Definition: avfilter.c:578
struct AVFilterCommand * next
Definition: internal.h:43
static const AVOption avfilter_options[]
Definition: avfilter.c:672
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
AVFrame * ff_framequeue_take(FFFrameQueue *fq)
Take the first frame in the queue.
Definition: framequeue.c:98
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
AVFormatContext * ctx
Definition: movenc.c:48
static int ff_request_frame_to_filter(AVFilterLink *link)
Definition: avfilter.c:450
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
int needs_writable
The filter expects writable frames from its input link, duplicating data buffers if needed...
Definition: internal.h:145
int flags_internal
Additional flags for avfilter internal use only.
Definition: avfilter.h:286
int n
Definition: avisynth_c.h:684
static int ff_filter_frame_to_filter(AVFilterLink *link)
Definition: avfilter.c:1240
int(* init_opaque)(AVFilterContext *ctx, void *opaque)
Filter initialization function, alternative to the init() callback.
Definition: avfilter.h:313
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
Definition: avfilter.c:1552
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:1564
static void error(const char *err)
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:966
const AVFilterPad * inputs
List of inputs, terminated by a zeroed element.
Definition: avfilter.h:164
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.
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:1662
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
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
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:274
const AVClass * priv_class
A class for the private data, used to declare filter private AVOptions.
Definition: avfilter.h:182
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
int offset
The offset relative to the context structure where the option value is stored.
Definition: opt.h:259
void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
Definition: avfilter.c:383
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:334
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVFilterGraphInternal * internal
Opaque object for libavfilter internal use.
Definition: avfilter.h:841
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:549
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1589
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:232
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:1532
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:289
void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
Update the position of a link in the age heap.
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition: formats.c:481
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
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:557
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
void * buf
Definition: avisynth_c.h:690
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
const char av_filter_ffversion[]
Definition: avfilter.c:47
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:1601
Describe the class of an AVClass context structure.
Definition: log.h:67
int sample_rate
Sample rate of the audio data.
Definition: frame.h:374
Filter definition.
Definition: avfilter.h:144
static int take_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Definition: avfilter.c:1180
static const char *const var_names[]
Definition: avfilter.c:488
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
Definition: avfilter.c:1657
Rational number (pair of numerator and denominator).
Definition: rational.h:58
struct AVFilter * next
Used by the filter registration system.
Definition: avfilter.h:292
static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
Definition: avfilter.c:432
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:67
void ff_inlink_set_status(AVFilterLink *link, int status)
Set the status on an input link.
Definition: avfilter.c:1642
int ff_inlink_check_available_frame(AVFilterLink *link)
Test if a frame is available on the link.
Definition: avfilter.c:1493
AVMediaType
Definition: avutil.h:199
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
refcounted data buffer API
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:476
const char * name
Filter name.
Definition: avfilter.h:148
const char * avfilter_configuration(void)
Return the libavfilter build-time configuration.
Definition: avfilter.c:83
static uint64_t ff_framequeue_queued_samples(const FFFrameQueue *fq)
Get the number of queued samples.
Definition: framequeue.h:154
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
Definition: avfilter.c:1076
#define FLAGS
Definition: avfilter.c:671
AVFrame * ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
Access a frame in the queue, without removing it.
Definition: framequeue.c:115
#define LICENSE_PREFIX
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
#define OFFSET(x)
Definition: avfilter.c:670
static int64_t pts
static const int8_t filt[NUMTAPS]
Definition: af_earwax.c:39
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
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:378
static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: avfilter.c:692
static int filter_frame(DBEContext *s, AVFrame *frame)
Definition: dolby_e.c:565
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
Initialize a filter with the supplied dictionary of options.
Definition: avfilter.c:929
int
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1544
const OptionDef options[]
Definition: ffmpeg_opt.c:3291
static int set_enable_expr(AVFilterContext *ctx, const char *expr)
Definition: avfilter.c:506
static size_t ff_framequeue_queued_frames(const FFFrameQueue *fq)
Get the number of queued frames.
Definition: framequeue.h:146
common internal and external API header
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
Utilties for rational number calculation.
#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
static double c[64]
struct AVFilterCommand * command_queue
Definition: avfilter.h:380
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
Definition: avfilter.c:193
#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:563
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
avfilter_execute_func * execute
Definition: internal.h:155
static int samples_ready(AVFilterLink *link, unsigned min)
Definition: avfilter.c:1173
void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
Remove a filter from a graph;.
avfilter_execute_func * thread_execute
Definition: internal.h:150
#define av_free(p)
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:61
int avfilter_register(AVFilter *filter)
Register a filter.
Definition: avfilter.c:597
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:353
enum AVOptionType type
Definition: opt.h:260
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:1470
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:734
static AVMutex filter_register_mutex
Definition: avfilter.c:595
void * enable
parsed expression (AVExpr*)
Definition: avfilter.h:383
const AVClass * av_class
needed for av_log() and filters common options
Definition: avfilter.h:339
static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:1091
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:279
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
An instance of a filter.
Definition: avfilter.h:338
#define av_uninit(x)
Definition: attributes.h:148
int avfilter_pad_count(const AVFilterPad *pads)
Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
Definition: avfilter.c:623
int height
Definition: frame.h:259
FILE * out
Definition: movenc.c:54
const AVFilterPad * outputs
List of outputs, terminated by a zeroed element.
Definition: avfilter.h:172
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
#define av_freep(p)
int(* config_props)(AVFilterLink *link)
Link configuration callback.
Definition: internal.h:129
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
FFFrameQueueGlobal frame_queues
Definition: internal.h:151
#define av_malloc_array(a, b)
double time
time expressed in seconds
Definition: internal.h:39
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:407
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:2279
static const AVClass * filter_child_class_next(const AVClass *prev)
Definition: avfilter.c:649
internal API functions
void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg)
Init a frame queue and attach it to a global structure.
Definition: framequeue.c:47
int ff_filter_activate(AVFilterContext *filter)
Definition: avfilter.c:1463
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:248
int(* activate)(AVFilterContext *ctx)
Filter activation function.
Definition: avfilter.h:327
int ff_poll_frame(AVFilterLink *link)
Poll a frame from the filter chain.
Definition: avfilter.c:470
float min
void avfilter_link_free(AVFilterLink **link)
Free the link in *link, and set its pointer to NULL.
Definition: avfilter.c:174
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:449
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:267
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:341
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:609
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
char * command
command
Definition: internal.h:40
#define av_unused
Definition: attributes.h:125
static int process_options(AVFilterContext *ctx, AVDictionary **options, const char *args)
Definition: avfilter.c:851
simple arithmetic expression evaluator
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
const char * name
Definition: opengl_enc.c:103
char * arg
optional argument for the command
Definition: internal.h:41
#define LIBAVFILTER_VERSION_MICRO
Definition: version.h:34