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