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 
579 {
580  int count;
581 
582  if (!pads)
583  return 0;
584 
585  for (count = 0; pads->name; count++)
586  pads++;
587  return count;
588 }
589 
590 static const char *default_filter_name(void *filter_ctx)
591 {
593  return ctx->name ? ctx->name : ctx->filter->name;
594 }
595 
596 static void *filter_child_next(void *obj, void *prev)
597 {
598  AVFilterContext *ctx = obj;
599  if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
600  return ctx->priv;
601  return NULL;
602 }
603 
604 static const AVClass *filter_child_class_next(const AVClass *prev)
605 {
606  void *opaque = NULL;
607  const AVFilter *f = NULL;
608 
609  /* find the filter that corresponds to prev */
610  while (prev && (f = av_filter_iterate(&opaque)))
611  if (f->priv_class == prev)
612  break;
613 
614  /* could not find filter corresponding to prev */
615  if (prev && !f)
616  return NULL;
617 
618  /* find next filter with specific options */
619  while ((f = av_filter_iterate(&opaque)))
620  if (f->priv_class)
621  return f->priv_class;
622 
623  return NULL;
624 }
625 
626 #define OFFSET(x) offsetof(AVFilterContext, x)
627 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
628 static const AVOption avfilter_options[] = {
629  { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
630  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
631  { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
632  { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
633  { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
634  { .i64 = 0 }, 0, INT_MAX, FLAGS },
635  { "extra_hw_frames", "Number of extra hardware frames to allocate for the user",
636  OFFSET(extra_hw_frames), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
637  { NULL },
638 };
639 
640 static const AVClass avfilter_class = {
641  .class_name = "AVFilter",
642  .item_name = default_filter_name,
643  .version = LIBAVUTIL_VERSION_INT,
644  .category = AV_CLASS_CATEGORY_FILTER,
645  .child_next = filter_child_next,
646  .child_class_next = filter_child_class_next,
648 };
649 
651  int *ret, int nb_jobs)
652 {
653  int i;
654 
655  for (i = 0; i < nb_jobs; i++) {
656  int r = func(ctx, arg, i, nb_jobs);
657  if (ret)
658  ret[i] = r;
659  }
660  return 0;
661 }
662 
663 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
664 {
665  AVFilterContext *ret;
666  int preinited = 0;
667 
668  if (!filter)
669  return NULL;
670 
671  ret = av_mallocz(sizeof(AVFilterContext));
672  if (!ret)
673  return NULL;
674 
675  ret->av_class = &avfilter_class;
676  ret->filter = filter;
677  ret->name = inst_name ? av_strdup(inst_name) : NULL;
678  if (filter->priv_size) {
679  ret->priv = av_mallocz(filter->priv_size);
680  if (!ret->priv)
681  goto err;
682  }
683  if (filter->preinit) {
684  if (filter->preinit(ret) < 0)
685  goto err;
686  preinited = 1;
687  }
688 
689  av_opt_set_defaults(ret);
690  if (filter->priv_class) {
691  *(const AVClass**)ret->priv = filter->priv_class;
693  }
694 
695  ret->internal = av_mallocz(sizeof(*ret->internal));
696  if (!ret->internal)
697  goto err;
699 
700  ret->nb_inputs = avfilter_pad_count(filter->inputs);
701  if (ret->nb_inputs ) {
702  ret->input_pads = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad));
703  if (!ret->input_pads)
704  goto err;
705  memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
706  ret->inputs = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*));
707  if (!ret->inputs)
708  goto err;
709  }
710 
711  ret->nb_outputs = avfilter_pad_count(filter->outputs);
712  if (ret->nb_outputs) {
713  ret->output_pads = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad));
714  if (!ret->output_pads)
715  goto err;
716  memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
717  ret->outputs = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*));
718  if (!ret->outputs)
719  goto err;
720  }
721 
722  return ret;
723 
724 err:
725  if (preinited)
726  filter->uninit(ret);
727  av_freep(&ret->inputs);
728  av_freep(&ret->input_pads);
729  ret->nb_inputs = 0;
730  av_freep(&ret->outputs);
731  av_freep(&ret->output_pads);
732  ret->nb_outputs = 0;
733  av_freep(&ret->priv);
734  av_freep(&ret->internal);
735  av_free(ret);
736  return NULL;
737 }
738 
739 static void free_link(AVFilterLink *link)
740 {
741  if (!link)
742  return;
743 
744  if (link->src)
745  link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
746  if (link->dst)
747  link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
748 
750 
757  avfilter_link_free(&link);
758 }
759 
761 {
762  int i;
763 
764  if (!filter)
765  return;
766 
767  if (filter->graph)
768  ff_filter_graph_remove_filter(filter->graph, filter);
769 
770  if (filter->filter->uninit)
771  filter->filter->uninit(filter);
772 
773  for (i = 0; i < filter->nb_inputs; i++) {
774  free_link(filter->inputs[i]);
775  }
776  for (i = 0; i < filter->nb_outputs; i++) {
777  free_link(filter->outputs[i]);
778  }
779 
780  if (filter->filter->priv_class)
781  av_opt_free(filter->priv);
782 
783  av_buffer_unref(&filter->hw_device_ctx);
784 
785  av_freep(&filter->name);
786  av_freep(&filter->input_pads);
787  av_freep(&filter->output_pads);
788  av_freep(&filter->inputs);
789  av_freep(&filter->outputs);
790  av_freep(&filter->priv);
791  while(filter->command_queue){
792  ff_command_queue_pop(filter);
793  }
794  av_opt_free(filter);
795  av_expr_free(filter->enable);
796  filter->enable = NULL;
797  av_freep(&filter->var_values);
798  av_freep(&filter->internal);
799  av_free(filter);
800 }
801 
803 {
804  if (ctx->nb_threads > 0)
805  return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
806  return ctx->graph->nb_threads;
807 }
808 
810  const char *args)
811 {
812  const AVOption *o = NULL;
813  int ret, count = 0;
814  char *av_uninit(parsed_key), *av_uninit(value);
815  const char *key;
816  int offset= -1;
817 
818  if (!args)
819  return 0;
820 
821  while (*args) {
822  const char *shorthand = NULL;
823 
824  o = av_opt_next(ctx->priv, o);
825  if (o) {
826  if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
827  continue;
828  offset = o->offset;
829  shorthand = o->name;
830  }
831 
832  ret = av_opt_get_key_value(&args, "=", ":",
833  shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
834  &parsed_key, &value);
835  if (ret < 0) {
836  if (ret == AVERROR(EINVAL))
837  av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
838  else
839  av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
840  av_err2str(ret));
841  return ret;
842  }
843  if (*args)
844  args++;
845  if (parsed_key) {
846  key = parsed_key;
847  while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */
848  } else {
849  key = shorthand;
850  }
851 
852  av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
853 
854  if (av_opt_find(ctx, key, NULL, 0, 0)) {
855  ret = av_opt_set(ctx, key, value, 0);
856  if (ret < 0) {
857  av_free(value);
858  av_free(parsed_key);
859  return ret;
860  }
861  } else {
862  av_dict_set(options, key, value, 0);
863  if ((ret = av_opt_set(ctx->priv, key, value, AV_OPT_SEARCH_CHILDREN)) < 0) {
865  if (ret == AVERROR_OPTION_NOT_FOUND)
866  av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
867  av_free(value);
868  av_free(parsed_key);
869  return ret;
870  }
871  }
872  }
873 
874  av_free(value);
875  av_free(parsed_key);
876  count++;
877  }
878 
879  if (ctx->enable_str) {
880  ret = set_enable_expr(ctx, ctx->enable_str);
881  if (ret < 0)
882  return ret;
883  }
884  return count;
885 }
886 
888 {
889  int ret = 0;
890 
891  ret = av_opt_set_dict(ctx, options);
892  if (ret < 0) {
893  av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
894  return ret;
895  }
896 
899  ctx->graph->internal->thread_execute) {
902  } else {
903  ctx->thread_type = 0;
904  }
905 
906  if (ctx->filter->priv_class) {
907  ret = av_opt_set_dict2(ctx->priv, options, AV_OPT_SEARCH_CHILDREN);
908  if (ret < 0) {
909  av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
910  return ret;
911  }
912  }
913 
914  if (ctx->filter->init_opaque)
915  ret = ctx->filter->init_opaque(ctx, NULL);
916  else if (ctx->filter->init)
917  ret = ctx->filter->init(ctx);
918  else if (ctx->filter->init_dict)
919  ret = ctx->filter->init_dict(ctx, options);
920 
921  return ret;
922 }
923 
925 {
928  int ret = 0;
929 
930  if (args && *args) {
931  if (!filter->filter->priv_class) {
932  av_log(filter, AV_LOG_ERROR, "This filter does not take any "
933  "options, but options were provided: %s.\n", args);
934  return AVERROR(EINVAL);
935  }
936 
937 #if FF_API_OLD_FILTER_OPTS_ERROR
938  if ( !strcmp(filter->filter->name, "format") ||
939  !strcmp(filter->filter->name, "noformat") ||
940  !strcmp(filter->filter->name, "frei0r") ||
941  !strcmp(filter->filter->name, "frei0r_src") ||
942  !strcmp(filter->filter->name, "ocv") ||
943  !strcmp(filter->filter->name, "pan") ||
944  !strcmp(filter->filter->name, "pp") ||
945  !strcmp(filter->filter->name, "aevalsrc")) {
946  /* a hack for compatibility with the old syntax
947  * replace colons with |s */
948  char *copy = av_strdup(args);
949  char *p = copy;
950  int nb_leading = 0; // number of leading colons to skip
951  int deprecated = 0;
952 
953  if (!copy) {
954  ret = AVERROR(ENOMEM);
955  goto fail;
956  }
957 
958  if (!strcmp(filter->filter->name, "frei0r") ||
959  !strcmp(filter->filter->name, "ocv"))
960  nb_leading = 1;
961  else if (!strcmp(filter->filter->name, "frei0r_src"))
962  nb_leading = 3;
963 
964  while (nb_leading--) {
965  p = strchr(p, ':');
966  if (!p) {
967  p = copy + strlen(copy);
968  break;
969  }
970  p++;
971  }
972 
973  deprecated = strchr(p, ':') != NULL;
974 
975  if (!strcmp(filter->filter->name, "aevalsrc")) {
976  deprecated = 0;
977  while ((p = strchr(p, ':')) && p[1] != ':') {
978  const char *epos = strchr(p + 1, '=');
979  const char *spos = strchr(p + 1, ':');
980  const int next_token_is_opt = epos && (!spos || epos < spos);
981  if (next_token_is_opt) {
982  p++;
983  break;
984  }
985  /* next token does not contain a '=', assume a channel expression */
986  deprecated = 1;
987  *p++ = '|';
988  }
989  if (p && *p == ':') { // double sep '::' found
990  deprecated = 1;
991  memmove(p, p + 1, strlen(p));
992  }
993  } else
994  while ((p = strchr(p, ':')))
995  *p++ = '|';
996 
997  if (deprecated) {
998  av_log(filter, AV_LOG_ERROR, "This syntax is deprecated. Use "
999  "'|' to separate the list items ('%s' instead of '%s')\n",
1000  copy, args);
1001  ret = AVERROR(EINVAL);
1002  } else {
1003  ret = process_options(filter, &options, copy);
1004  }
1005  av_freep(&copy);
1006 
1007  if (ret < 0)
1008  goto fail;
1009  } else
1010 #endif
1011  {
1012  ret = process_options(filter, &options, args);
1013  if (ret < 0)
1014  goto fail;
1015  }
1016  }
1017 
1018  ret = avfilter_init_dict(filter, &options);
1019  if (ret < 0)
1020  goto fail;
1021 
1022  if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1023  av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
1025  goto fail;
1026  }
1027 
1028 fail:
1029  av_dict_free(&options);
1030 
1031  return ret;
1032 }
1033 
1034 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
1035 {
1036  return pads[pad_idx].name;
1037 }
1038 
1039 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
1040 {
1041  return pads[pad_idx].type;
1042 }
1043 
1045 {
1046  return ff_filter_frame(link->dst->outputs[0], frame);
1047 }
1048 
1050 {
1052  AVFilterContext *dstctx = link->dst;
1053  AVFilterPad *dst = link->dstpad;
1054  int ret;
1055 
1056  if (!(filter_frame = dst->filter_frame))
1058 
1059  if (dst->needs_writable) {
1060  ret = ff_inlink_make_frame_writable(link, &frame);
1061  if (ret < 0)
1062  goto fail;
1063  }
1064 
1065  ff_inlink_process_commands(link, frame);
1066  dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1067 
1068  if (dstctx->is_disabled &&
1071  ret = filter_frame(link, frame);
1072  link->frame_count_out++;
1073  return ret;
1074 
1075 fail:
1076  av_frame_free(&frame);
1077  return ret;
1078 }
1079 
1081 {
1082  int ret;
1084 
1085  /* Consistency checks */
1086  if (link->type == AVMEDIA_TYPE_VIDEO) {
1087  if (strcmp(link->dst->filter->name, "buffersink") &&
1088  strcmp(link->dst->filter->name, "format") &&
1089  strcmp(link->dst->filter->name, "idet") &&
1090  strcmp(link->dst->filter->name, "null") &&
1091  strcmp(link->dst->filter->name, "scale")) {
1092  av_assert1(frame->format == link->format);
1093  av_assert1(frame->width == link->w);
1094  av_assert1(frame->height == link->h);
1095  }
1096  } else {
1097  if (frame->format != link->format) {
1098  av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1099  goto error;
1100  }
1101  if (frame->channels != link->channels) {
1102  av_log(link->dst, AV_LOG_ERROR, "Channel count change is not supported\n");
1103  goto error;
1104  }
1105  if (frame->channel_layout != link->channel_layout) {
1106  av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1107  goto error;
1108  }
1109  if (frame->sample_rate != link->sample_rate) {
1110  av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1111  goto error;
1112  }
1113  }
1114 
1115  link->frame_blocked_in = link->frame_wanted_out = 0;
1116  link->frame_count_in++;
1117  filter_unblock(link->dst);
1118  ret = ff_framequeue_add(&link->fifo, frame);
1119  if (ret < 0) {
1120  av_frame_free(&frame);
1121  return ret;
1122  }
1123  ff_filter_set_ready(link->dst, 300);
1124  return 0;
1125 
1126 error:
1127  av_frame_free(&frame);
1128  return AVERROR_PATCHWELCOME;
1129 }
1130 
1131 static int samples_ready(AVFilterLink *link, unsigned min)
1132 {
1133  return ff_framequeue_queued_frames(&link->fifo) &&
1134  (ff_framequeue_queued_samples(&link->fifo) >= min ||
1135  link->status_in);
1136 }
1137 
1138 static int take_samples(AVFilterLink *link, unsigned min, unsigned max,
1139  AVFrame **rframe)
1140 {
1141  AVFrame *frame0, *frame, *buf;
1142  unsigned nb_samples, nb_frames, i, p;
1143  int ret;
1144 
1145  /* Note: this function relies on no format changes and must only be
1146  called with enough samples. */
1147  av_assert1(samples_ready(link, link->min_samples));
1148  frame0 = frame = ff_framequeue_peek(&link->fifo, 0);
1149  if (!link->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
1150  *rframe = ff_framequeue_take(&link->fifo);
1151  return 0;
1152  }
1153  nb_frames = 0;
1154  nb_samples = 0;
1155  while (1) {
1156  if (nb_samples + frame->nb_samples > max) {
1157  if (nb_samples < min)
1158  nb_samples = max;
1159  break;
1160  }
1161  nb_samples += frame->nb_samples;
1162  nb_frames++;
1163  if (nb_frames == ff_framequeue_queued_frames(&link->fifo))
1164  break;
1165  frame = ff_framequeue_peek(&link->fifo, nb_frames);
1166  }
1167 
1168  buf = ff_get_audio_buffer(link, nb_samples);
1169  if (!buf)
1170  return AVERROR(ENOMEM);
1171  ret = av_frame_copy_props(buf, frame0);
1172  if (ret < 0) {
1173  av_frame_free(&buf);
1174  return ret;
1175  }
1176  buf->pts = frame0->pts;
1177 
1178  p = 0;
1179  for (i = 0; i < nb_frames; i++) {
1180  frame = ff_framequeue_take(&link->fifo);
1181  av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1182  frame->nb_samples, link->channels, link->format);
1183  p += frame->nb_samples;
1184  av_frame_free(&frame);
1185  }
1186  if (p < nb_samples) {
1187  unsigned n = nb_samples - p;
1188  frame = ff_framequeue_peek(&link->fifo, 0);
1189  av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1190  link->channels, link->format);
1191  ff_framequeue_skip_samples(&link->fifo, n, link->time_base);
1192  }
1193 
1194  *rframe = buf;
1195  return 0;
1196 }
1197 
1199 {
1200  AVFrame *frame = NULL;
1201  AVFilterContext *dst = link->dst;
1202  int ret;
1203 
1205  ret = link->min_samples ?
1206  ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1207  ff_inlink_consume_frame(link, &frame);
1208  av_assert1(ret);
1209  if (ret < 0) {
1210  av_assert1(!frame);
1211  return ret;
1212  }
1213  /* The filter will soon have received a new frame, that may allow it to
1214  produce one or more: unblock its outputs. */
1215  filter_unblock(dst);
1216  /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1217  before the frame; ff_filter_frame_framed() will re-increment it. */
1218  link->frame_count_out--;
1219  ret = ff_filter_frame_framed(link, frame);
1220  if (ret < 0 && ret != link->status_out) {
1222  } else {
1223  /* Run once again, to see if several frames were available, or if
1224  the input status has also changed, or any other reason. */
1225  ff_filter_set_ready(dst, 300);
1226  }
1227  return ret;
1228 }
1229 
1231 {
1232  unsigned out = 0, progress = 0;
1233  int ret;
1234 
1235  av_assert0(!in->status_out);
1236  if (!filter->nb_outputs) {
1237  /* not necessary with the current API and sinks */
1238  return 0;
1239  }
1240  while (!in->status_out) {
1241  if (!filter->outputs[out]->status_in) {
1242  progress++;
1243  ret = ff_request_frame_to_filter(filter->outputs[out]);
1244  if (ret < 0)
1245  return ret;
1246  }
1247  if (++out == filter->nb_outputs) {
1248  if (!progress) {
1249  /* Every output already closed: input no longer interesting
1250  (example: overlay in shortest mode, other input closed). */
1251  ff_avfilter_link_set_out_status(in, in->status_in, in->status_in_pts);
1252  return 0;
1253  }
1254  progress = 0;
1255  out = 0;
1256  }
1257  }
1258  ff_filter_set_ready(filter, 200);
1259  return 0;
1260 }
1261 
1263 {
1264  unsigned i;
1265 
1266  for (i = 0; i < filter->nb_inputs; i++) {
1267  if (samples_ready(filter->inputs[i], filter->inputs[i]->min_samples)) {
1268  return ff_filter_frame_to_filter(filter->inputs[i]);
1269  }
1270  }
1271  for (i = 0; i < filter->nb_inputs; i++) {
1272  if (filter->inputs[i]->status_in && !filter->inputs[i]->status_out) {
1273  av_assert1(!ff_framequeue_queued_frames(&filter->inputs[i]->fifo));
1274  return forward_status_change(filter, filter->inputs[i]);
1275  }
1276  }
1277  for (i = 0; i < filter->nb_outputs; i++) {
1278  if (filter->outputs[i]->frame_wanted_out &&
1279  !filter->outputs[i]->frame_blocked_in) {
1280  return ff_request_frame_to_filter(filter->outputs[i]);
1281  }
1282  }
1283  return FFERROR_NOT_READY;
1284 }
1285 
1286 /*
1287  Filter scheduling and activation
1288 
1289  When a filter is activated, it must:
1290  - if possible, output a frame;
1291  - else, if relevant, forward the input status change;
1292  - else, check outputs for wanted frames and forward the requests.
1293 
1294  The following AVFilterLink fields are used for activation:
1295 
1296  - frame_wanted_out:
1297 
1298  This field indicates if a frame is needed on this input of the
1299  destination filter. A positive value indicates that a frame is needed
1300  to process queued frames or internal data or to satisfy the
1301  application; a zero value indicates that a frame is not especially
1302  needed but could be processed anyway; a negative value indicates that a
1303  frame would just be queued.
1304 
1305  It is set by filters using ff_request_frame() or ff_request_no_frame(),
1306  when requested by the application through a specific API or when it is
1307  set on one of the outputs.
1308 
1309  It is cleared when a frame is sent from the source using
1310  ff_filter_frame().
1311 
1312  It is also cleared when a status change is sent from the source using
1313  ff_avfilter_link_set_in_status().
1314 
1315  - frame_blocked_in:
1316 
1317  This field means that the source filter can not generate a frame as is.
1318  Its goal is to avoid repeatedly calling the request_frame() method on
1319  the same link.
1320 
1321  It is set by the framework on all outputs of a filter before activating it.
1322 
1323  It is automatically cleared by ff_filter_frame().
1324 
1325  It is also automatically cleared by ff_avfilter_link_set_in_status().
1326 
1327  It is also cleared on all outputs (using filter_unblock()) when
1328  something happens on an input: processing a frame or changing the
1329  status.
1330 
1331  - fifo:
1332 
1333  Contains the frames queued on a filter input. If it contains frames and
1334  frame_wanted_out is not set, then the filter can be activated. If that
1335  result in the filter not able to use these frames, the filter must set
1336  frame_wanted_out to ask for more frames.
1337 
1338  - status_in and status_in_pts:
1339 
1340  Status (EOF or error code) of the link and timestamp of the status
1341  change (in link time base, same as frames) as seen from the input of
1342  the link. The status change is considered happening after the frames
1343  queued in fifo.
1344 
1345  It is set by the source filter using ff_avfilter_link_set_in_status().
1346 
1347  - status_out:
1348 
1349  Status of the link as seen from the output of the link. The status
1350  change is considered having already happened.
1351 
1352  It is set by the destination filter using
1353  ff_avfilter_link_set_out_status().
1354 
1355  Filters are activated according to the ready field, set using the
1356  ff_filter_set_ready(). Eventually, a priority queue will be used.
1357  ff_filter_set_ready() is called whenever anything could cause progress to
1358  be possible. Marking a filter ready when it is not is not a problem,
1359  except for the small overhead it causes.
1360 
1361  Conditions that cause a filter to be marked ready are:
1362 
1363  - frames added on an input link;
1364 
1365  - changes in the input or output status of an input link;
1366 
1367  - requests for a frame on an output link;
1368 
1369  - after any actual processing using the legacy methods (filter_frame(),
1370  and request_frame() to acknowledge status changes), to run once more
1371  and check if enough input was present for several frames.
1372 
1373  Exemples of scenarios to consider:
1374 
1375  - buffersrc: activate if frame_wanted_out to notify the application;
1376  activate when the application adds a frame to push it immediately.
1377 
1378  - testsrc: activate only if frame_wanted_out to produce and push a frame.
1379 
1380  - concat (not at stitch points): can process a frame on any output.
1381  Activate if frame_wanted_out on output to forward on the corresponding
1382  input. Activate when a frame is present on input to process it
1383  immediately.
1384 
1385  - framesync: needs at least one frame on each input; extra frames on the
1386  wrong input will accumulate. When a frame is first added on one input,
1387  set frame_wanted_out<0 on it to avoid getting more (would trigger
1388  testsrc) and frame_wanted_out>0 on the other to allow processing it.
1389 
1390  Activation of old filters:
1391 
1392  In order to activate a filter implementing the legacy filter_frame() and
1393  request_frame() methods, perform the first possible of the following
1394  actions:
1395 
1396  - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1397  frame and call filter_frame().
1398 
1399  Ratinale: filter frames as soon as possible instead of leaving them
1400  queued; frame_wanted_out < 0 is not possible since the old API does not
1401  set it nor provides any similar feedback; frame_wanted_out > 0 happens
1402  when min_samples > 0 and there are not enough samples queued.
1403 
1404  - If an input has status_in set but not status_out, try to call
1405  request_frame() on one of the outputs in the hope that it will trigger
1406  request_frame() on the input with status_in and acknowledge it. This is
1407  awkward and fragile, filters with several inputs or outputs should be
1408  updated to direct activation as soon as possible.
1409 
1410  - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1411  request_frame().
1412 
1413  Rationale: checking frame_blocked_in is necessary to avoid requesting
1414  repeatedly on a blocked input if another is not blocked (example:
1415  [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1416 
1417  TODO: respect needs_fifo and remove auto-inserted fifos.
1418 
1419  */
1420 
1422 {
1423  int ret;
1424 
1425  /* Generic timeline support is not yet implemented but should be easy */
1427  filter->filter->activate));
1428  filter->ready = 0;
1429  ret = filter->filter->activate ? filter->filter->activate(filter) :
1431  if (ret == FFERROR_NOT_READY)
1432  ret = 0;
1433  return ret;
1434 }
1435 
1436 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1437 {
1438  *rpts = link->current_pts;
1439  if (ff_framequeue_queued_frames(&link->fifo))
1440  return *rstatus = 0;
1441  if (link->status_out)
1442  return *rstatus = link->status_out;
1443  if (!link->status_in)
1444  return *rstatus = 0;
1445  *rstatus = link->status_out = link->status_in;
1446  ff_update_link_current_pts(link, link->status_in_pts);
1447  *rpts = link->current_pts;
1448  return 1;
1449 }
1450 
1452 {
1453  return ff_framequeue_queued_frames(&link->fifo) > 0;
1454 }
1455 
1457 {
1458  uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
1459  av_assert1(min);
1460  return samples >= min || (link->status_in && samples);
1461 }
1462 
1463 static void consume_update(AVFilterLink *link, const AVFrame *frame)
1464 {
1465  ff_update_link_current_pts(link, frame->pts);
1466  ff_inlink_process_commands(link, frame);
1467  link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1468  link->frame_count_out++;
1469 }
1470 
1472 {
1473  AVFrame *frame;
1474 
1475  *rframe = NULL;
1477  return 0;
1478 
1479  if (link->fifo.samples_skipped) {
1480  frame = ff_framequeue_peek(&link->fifo, 0);
1481  return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
1482  }
1483 
1484  frame = ff_framequeue_take(&link->fifo);
1485  consume_update(link, frame);
1486  *rframe = frame;
1487  return 1;
1488 }
1489 
1490 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1491  AVFrame **rframe)
1492 {
1493  AVFrame *frame;
1494  int ret;
1495 
1496  av_assert1(min);
1497  *rframe = NULL;
1498  if (!ff_inlink_check_available_samples(link, min))
1499  return 0;
1500  if (link->status_in)
1501  min = FFMIN(min, ff_framequeue_queued_samples(&link->fifo));
1502  ret = take_samples(link, min, max, &frame);
1503  if (ret < 0)
1504  return ret;
1505  consume_update(link, frame);
1506  *rframe = frame;
1507  return 1;
1508 }
1509 
1511 {
1512  AVFrame *frame = *rframe;
1513  AVFrame *out;
1514  int ret;
1515 
1516  if (av_frame_is_writable(frame))
1517  return 0;
1518  av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1519 
1520  switch (link->type) {
1521  case AVMEDIA_TYPE_VIDEO:
1522  out = ff_get_video_buffer(link, link->w, link->h);
1523  break;
1524  case AVMEDIA_TYPE_AUDIO:
1525  out = ff_get_audio_buffer(link, frame->nb_samples);
1526  break;
1527  default:
1528  return AVERROR(EINVAL);
1529  }
1530  if (!out)
1531  return AVERROR(ENOMEM);
1532 
1533  ret = av_frame_copy_props(out, frame);
1534  if (ret < 0) {
1535  av_frame_free(&out);
1536  return ret;
1537  }
1538 
1539  switch (link->type) {
1540  case AVMEDIA_TYPE_VIDEO:
1541  av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
1542  frame->format, frame->width, frame->height);
1543  break;
1544  case AVMEDIA_TYPE_AUDIO:
1546  0, 0, frame->nb_samples,
1547  frame->channels,
1548  frame->format);
1549  break;
1550  default:
1551  av_assert0(!"reached");
1552  }
1553 
1554  av_frame_free(&frame);
1555  *rframe = out;
1556  return 0;
1557 }
1558 
1560 {
1561  AVFilterCommand *cmd = link->dst->command_queue;
1562 
1563  while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1564  av_log(link->dst, AV_LOG_DEBUG,
1565  "Processing command time:%f command:%s arg:%s\n",
1566  cmd->time, cmd->command, cmd->arg);
1567  avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1568  ff_command_queue_pop(link->dst);
1569  cmd= link->dst->command_queue;
1570  }
1571  return 0;
1572 }
1573 
1575 {
1576  AVFilterContext *dstctx = link->dst;
1577  int64_t pts = frame->pts;
1578  int64_t pos = frame->pkt_pos;
1579 
1580  if (!dstctx->enable_str)
1581  return 1;
1582 
1583  dstctx->var_values[VAR_N] = link->frame_count_out;
1584  dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1585  dstctx->var_values[VAR_W] = link->w;
1586  dstctx->var_values[VAR_H] = link->h;
1587  dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1588 
1589  return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
1590 }
1591 
1593 {
1594  av_assert1(!link->status_in);
1595  av_assert1(!link->status_out);
1596  link->frame_wanted_out = 1;
1597  ff_filter_set_ready(link->src, 100);
1598 }
1599 
1600 void ff_inlink_set_status(AVFilterLink *link, int status)
1601 {
1602  if (link->status_out)
1603  return;
1604  link->frame_wanted_out = 0;
1605  link->frame_blocked_in = 0;
1607  while (ff_framequeue_queued_frames(&link->fifo)) {
1608  AVFrame *frame = ff_framequeue_take(&link->fifo);
1609  av_frame_free(&frame);
1610  }
1611  if (!link->status_in)
1612  link->status_in = status;
1613 }
1614 
1616 {
1617  return link->status_in;
1618 }
1619 
1621 {
1622  return &avfilter_class;
1623 }
1624 
1626  int default_pool_size)
1627 {
1629 
1630  // Must already be set by caller.
1631  av_assert0(link->hw_frames_ctx);
1632 
1633  frames = (AVHWFramesContext*)link->hw_frames_ctx->data;
1634 
1635  if (frames->initial_pool_size == 0) {
1636  // Dynamic allocation is necessarily supported.
1637  } else if (avctx->extra_hw_frames >= 0) {
1638  frames->initial_pool_size += avctx->extra_hw_frames;
1639  } else {
1640  frames->initial_pool_size = default_pool_size;
1641  }
1642 
1643  return 0;
1644 }
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:1471
#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:663
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
int thread_type
Type of multithreading allowed for filters in this graph.
Definition: avfilter.h:862
static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:1044
AVOption.
Definition: opt.h:246
static int ff_filter_activate_default(AVFilterContext *filter)
Definition: avfilter.c:1262
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:760
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:490
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:410
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:1298
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:1039
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
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:1456
#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:1592
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
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:1080
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:153
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.
#define f(width, name)
Definition: cbs_vp9.c:255
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:311
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:869
int avfilter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
Definition: avfilter.c:277
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
#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:365
void(* uninit)(AVFilterContext *ctx)
Filter uninitialization function.
Definition: avfilter.h:258
static void free_link(AVFilterLink *link)
Definition: avfilter.c:739
#define flags(name, subs,...)
Definition: cbs_h2645.c:263
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,...)
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
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:1574
static const AVClass avfilter_class
Definition: avfilter.c:640
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:1436
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:345
static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
Definition: avfilter.c:1230
static void consume_update(AVFilterLink *link, const AVFrame *frame)
Definition: avfilter.c:1463
int width
Definition: frame.h:276
#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
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
static const char * default_filter_name(void *filter_ctx)
Definition: avfilter.c:590
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
Accept to parse a value without a key; the key will then be returned as NULL.
Definition: opt.h:529
#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:202
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
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:117
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
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:396
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:1601
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:596
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:198
void avfilter_link_set_closed(AVFilterLink *link, int closed)
Set the closed field of a link.
Definition: avfilter.c:235
int channels
number of audio channels, only used for audio.
Definition: frame.h:523
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:301
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:802
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:556
struct AVFilterCommand * next
Definition: internal.h:43
static const AVOption avfilter_options[]
Definition: avfilter.c:628
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:1198
int(* init_opaque)(AVFilterContext *ctx, void *opaque)
Filter initialization function, alternative to the init() callback.
Definition: avfilter.h:313
int frames
Definition: movenc.c:65
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
Definition: avfilter.c:1510
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:1571
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:924
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:1620
#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:291
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:874
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:592
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1596
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:249
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:1490
uint8_t * data
The data buffer.
Definition: buffer.h:89
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:306
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:1559
Describe the class of an AVClass context structure.
Definition: log.h:67
int sample_rate
Sample rate of the audio data.
Definition: frame.h:391
Filter definition.
Definition: avfilter.h:144
static int take_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Definition: avfilter.c:1138
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:1615
Rational number (pair of numerator and denominator).
Definition: rational.h:58
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
Definition: allfilters.c:446
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:123
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:1600
int ff_inlink_check_available_frame(AVFilterLink *link)
Test if a frame is available on the link.
Definition: avfilter.c:1451
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:1034
#define FLAGS
Definition: avfilter.c:627
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:626
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:650
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:232
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
Initialize a filter with the supplied dictionary of options.
Definition: avfilter.c:887
int
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1551
const OptionDef options[]
Definition: ffmpeg_opt.c:3322
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
if(ret< 0)
Definition: vf_mcdeint.c:279
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
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:1625
#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:565
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:1131
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 top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:370
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:1477
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:734
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:1049
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:296
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:578
int height
Definition: frame.h:276
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:2322
static const AVClass * filter_child_class_next(const AVClass *prev)
Definition: avfilter.c:604
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:1421
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:265
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:284
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:652
#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:809
simple arithmetic expression evaluator
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
char * arg
optional argument for the command
Definition: internal.h:41
#define LIBAVFILTER_VERSION_MICRO
Definition: version.h:34