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, av_frame_get_pkt_pos(ref));
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 &&
358  !link->hw_frames_ctx) {
359  AVHWFramesContext *input_ctx = (AVHWFramesContext*)link->src->inputs[0]->hw_frames_ctx->data;
360 
361  if (input_ctx->format == link->format) {
362  link->hw_frames_ctx = av_buffer_ref(link->src->inputs[0]->hw_frames_ctx);
363  if (!link->hw_frames_ctx)
364  return AVERROR(ENOMEM);
365  }
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 
433 {
434  int ret = -1;
435 
436  FF_TPRINTF_START(NULL, request_frame_to_filter); ff_tlog_link(NULL, link, 1);
437  /* Assume the filter is blocked, let the method clear it if not */
438  link->frame_blocked_in = 1;
439  if (link->srcpad->request_frame)
440  ret = link->srcpad->request_frame(link);
441  else if (link->src->inputs[0])
442  ret = ff_request_frame(link->src->inputs[0]);
443  if (ret < 0) {
444  if (ret != AVERROR(EAGAIN) && ret != link->status_in)
446  if (ret == AVERROR_EOF)
447  ret = 0;
448  }
449  return ret;
450 }
451 
453 {
454  int i, min = INT_MAX;
455 
456  if (link->srcpad->poll_frame)
457  return link->srcpad->poll_frame(link);
458 
459  for (i = 0; i < link->src->nb_inputs; i++) {
460  int val;
461  if (!link->src->inputs[i])
462  return AVERROR(EINVAL);
463  val = ff_poll_frame(link->src->inputs[i]);
464  min = FFMIN(min, val);
465  }
466 
467  return min;
468 }
469 
470 static const char *const var_names[] = {
471  "t",
472  "n",
473  "pos",
474  "w",
475  "h",
476  NULL
477 };
478 
479 enum {
486 };
487 
488 static int set_enable_expr(AVFilterContext *ctx, const char *expr)
489 {
490  int ret;
491  char *expr_dup;
492  AVExpr *old = ctx->enable;
493 
495  av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
496  "with filter '%s'\n", ctx->filter->name);
497  return AVERROR_PATCHWELCOME;
498  }
499 
500  expr_dup = av_strdup(expr);
501  if (!expr_dup)
502  return AVERROR(ENOMEM);
503 
504  if (!ctx->var_values) {
505  ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values));
506  if (!ctx->var_values) {
507  av_free(expr_dup);
508  return AVERROR(ENOMEM);
509  }
510  }
511 
512  ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names,
513  NULL, NULL, NULL, NULL, 0, ctx->priv);
514  if (ret < 0) {
515  av_log(ctx->priv, AV_LOG_ERROR,
516  "Error when evaluating the expression '%s' for enable\n",
517  expr_dup);
518  av_free(expr_dup);
519  return ret;
520  }
521 
522  av_expr_free(old);
523  av_free(ctx->enable_str);
524  ctx->enable_str = expr_dup;
525  return 0;
526 }
527 
529 {
530  if (pts == AV_NOPTS_VALUE)
531  return;
532  link->current_pts = pts;
534  /* TODO use duration */
535  if (link->graph && link->age_index >= 0)
537 }
538 
539 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
540 {
541  if(!strcmp(cmd, "ping")){
542  char local_res[256] = {0};
543 
544  if (!res) {
545  res = local_res;
546  res_len = sizeof(local_res);
547  }
548  av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
549  if (res == local_res)
550  av_log(filter, AV_LOG_INFO, "%s", res);
551  return 0;
552  }else if(!strcmp(cmd, "enable")) {
553  return set_enable_expr(filter, arg);
554  }else if(filter->filter->process_command) {
555  return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);
556  }
557  return AVERROR(ENOSYS);
558 }
559 
562 
563 #if !FF_API_NOCONST_GET_NAME
564 const
565 #endif
567 {
568  const AVFilter *f = NULL;
569 
570  if (!name)
571  return NULL;
572 
573  while ((f = avfilter_next(f)))
574  if (!strcmp(f->name, name))
575  return (AVFilter *)f;
576 
577  return NULL;
578 }
579 
581 {
582  AVFilter **f = last_filter;
583 
584  /* the filter must select generic or internal exclusively */
586 
587  filter->next = NULL;
588 
589  while(*f || avpriv_atomic_ptr_cas((void * volatile *)f, NULL, filter))
590  f = &(*f)->next;
591  last_filter = &filter->next;
592 
593  return 0;
594 }
595 
596 const AVFilter *avfilter_next(const AVFilter *prev)
597 {
598  return prev ? prev->next : first_filter;
599 }
600 
601 #if FF_API_OLD_FILTER_REGISTER
602 AVFilter **av_filter_next(AVFilter **filter)
603 {
604  return filter ? &(*filter)->next : &first_filter;
605 }
606 
607 void avfilter_uninit(void)
608 {
609 }
610 #endif
611 
613 {
614  int count;
615 
616  if (!pads)
617  return 0;
618 
619  for (count = 0; pads->name; count++)
620  pads++;
621  return count;
622 }
623 
624 static const char *default_filter_name(void *filter_ctx)
625 {
627  return ctx->name ? ctx->name : ctx->filter->name;
628 }
629 
630 static void *filter_child_next(void *obj, void *prev)
631 {
632  AVFilterContext *ctx = obj;
633  if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
634  return ctx->priv;
635  return NULL;
636 }
637 
638 static const AVClass *filter_child_class_next(const AVClass *prev)
639 {
640  const AVFilter *f = NULL;
641 
642  /* find the filter that corresponds to prev */
643  while (prev && (f = avfilter_next(f)))
644  if (f->priv_class == prev)
645  break;
646 
647  /* could not find filter corresponding to prev */
648  if (prev && !f)
649  return NULL;
650 
651  /* find next filter with specific options */
652  while ((f = avfilter_next(f)))
653  if (f->priv_class)
654  return f->priv_class;
655 
656  return NULL;
657 }
658 
659 #define OFFSET(x) offsetof(AVFilterContext, x)
660 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
661 static const AVOption avfilter_options[] = {
662  { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
663  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
664  { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .unit = "thread_type" },
665  { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
666  { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
667  { .i64 = 0 }, 0, INT_MAX, FLAGS },
668  { NULL },
669 };
670 
671 static const AVClass avfilter_class = {
672  .class_name = "AVFilter",
673  .item_name = default_filter_name,
674  .version = LIBAVUTIL_VERSION_INT,
675  .category = AV_CLASS_CATEGORY_FILTER,
676  .child_next = filter_child_next,
677  .child_class_next = filter_child_class_next,
679 };
680 
682  int *ret, int nb_jobs)
683 {
684  int i;
685 
686  for (i = 0; i < nb_jobs; i++) {
687  int r = func(ctx, arg, i, nb_jobs);
688  if (ret)
689  ret[i] = r;
690  }
691  return 0;
692 }
693 
694 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
695 {
696  AVFilterContext *ret;
697 
698  if (!filter)
699  return NULL;
700 
701  ret = av_mallocz(sizeof(AVFilterContext));
702  if (!ret)
703  return NULL;
704 
705  ret->av_class = &avfilter_class;
706  ret->filter = filter;
707  ret->name = inst_name ? av_strdup(inst_name) : NULL;
708  if (filter->priv_size) {
709  ret->priv = av_mallocz(filter->priv_size);
710  if (!ret->priv)
711  goto err;
712  }
713 
714  av_opt_set_defaults(ret);
715  if (filter->priv_class) {
716  *(const AVClass**)ret->priv = filter->priv_class;
718  }
719 
720  ret->internal = av_mallocz(sizeof(*ret->internal));
721  if (!ret->internal)
722  goto err;
724 
725  ret->nb_inputs = avfilter_pad_count(filter->inputs);
726  if (ret->nb_inputs ) {
727  ret->input_pads = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad));
728  if (!ret->input_pads)
729  goto err;
730  memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
731  ret->inputs = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*));
732  if (!ret->inputs)
733  goto err;
734  }
735 
736  ret->nb_outputs = avfilter_pad_count(filter->outputs);
737  if (ret->nb_outputs) {
738  ret->output_pads = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad));
739  if (!ret->output_pads)
740  goto err;
741  memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
742  ret->outputs = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*));
743  if (!ret->outputs)
744  goto err;
745  }
746 
747  return ret;
748 
749 err:
750  av_freep(&ret->inputs);
751  av_freep(&ret->input_pads);
752  ret->nb_inputs = 0;
753  av_freep(&ret->outputs);
754  av_freep(&ret->output_pads);
755  ret->nb_outputs = 0;
756  av_freep(&ret->priv);
757  av_freep(&ret->internal);
758  av_free(ret);
759  return NULL;
760 }
761 
762 #if FF_API_AVFILTER_OPEN
763 int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
764 {
765  *filter_ctx = ff_filter_alloc(filter, inst_name);
766  return *filter_ctx ? 0 : AVERROR(ENOMEM);
767 }
768 #endif
769 
770 static void free_link(AVFilterLink *link)
771 {
772  if (!link)
773  return;
774 
775  if (link->src)
776  link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
777  if (link->dst)
778  link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
779 
781 
788  avfilter_link_free(&link);
789 }
790 
792 {
793  int i;
794 
795  if (!filter)
796  return;
797 
798  if (filter->graph)
799  ff_filter_graph_remove_filter(filter->graph, filter);
800 
801  if (filter->filter->uninit)
802  filter->filter->uninit(filter);
803 
804  for (i = 0; i < filter->nb_inputs; i++) {
805  free_link(filter->inputs[i]);
806  }
807  for (i = 0; i < filter->nb_outputs; i++) {
808  free_link(filter->outputs[i]);
809  }
810 
811  if (filter->filter->priv_class)
812  av_opt_free(filter->priv);
813 
814  av_buffer_unref(&filter->hw_device_ctx);
815 
816  av_freep(&filter->name);
817  av_freep(&filter->input_pads);
818  av_freep(&filter->output_pads);
819  av_freep(&filter->inputs);
820  av_freep(&filter->outputs);
821  av_freep(&filter->priv);
822  while(filter->command_queue){
823  ff_command_queue_pop(filter);
824  }
825  av_opt_free(filter);
826  av_expr_free(filter->enable);
827  filter->enable = NULL;
828  av_freep(&filter->var_values);
829  av_freep(&filter->internal);
830  av_free(filter);
831 }
832 
834 {
835  if (ctx->nb_threads > 0)
836  return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);
837  return ctx->graph->nb_threads;
838 }
839 
841  const char *args)
842 {
843  const AVOption *o = NULL;
844  int ret, count = 0;
845  char *av_uninit(parsed_key), *av_uninit(value);
846  const char *key;
847  int offset= -1;
848 
849  if (!args)
850  return 0;
851 
852  while (*args) {
853  const char *shorthand = NULL;
854 
855  o = av_opt_next(ctx->priv, o);
856  if (o) {
857  if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
858  continue;
859  offset = o->offset;
860  shorthand = o->name;
861  }
862 
863  ret = av_opt_get_key_value(&args, "=", ":",
864  shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
865  &parsed_key, &value);
866  if (ret < 0) {
867  if (ret == AVERROR(EINVAL))
868  av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
869  else
870  av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
871  av_err2str(ret));
872  return ret;
873  }
874  if (*args)
875  args++;
876  if (parsed_key) {
877  key = parsed_key;
878  while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */
879  } else {
880  key = shorthand;
881  }
882 
883  av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
884 
885  if (av_opt_find(ctx, key, NULL, 0, 0)) {
886  ret = av_opt_set(ctx, key, value, 0);
887  if (ret < 0) {
888  av_free(value);
889  av_free(parsed_key);
890  return ret;
891  }
892  } else {
893  av_dict_set(options, key, value, 0);
894  if ((ret = av_opt_set(ctx->priv, key, value, 0)) < 0) {
896  if (ret == AVERROR_OPTION_NOT_FOUND)
897  av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
898  av_free(value);
899  av_free(parsed_key);
900  return ret;
901  }
902  }
903  }
904 
905  av_free(value);
906  av_free(parsed_key);
907  count++;
908  }
909 
910  if (ctx->enable_str) {
911  ret = set_enable_expr(ctx, ctx->enable_str);
912  if (ret < 0)
913  return ret;
914  }
915  return count;
916 }
917 
918 #if FF_API_AVFILTER_INIT_FILTER
919 int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque)
920 {
921  return avfilter_init_str(filter, args);
922 }
923 #endif
924 
926 {
927  int ret = 0;
928 
929  ret = av_opt_set_dict(ctx, options);
930  if (ret < 0) {
931  av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
932  return ret;
933  }
934 
937  ctx->graph->internal->thread_execute) {
940  } else {
941  ctx->thread_type = 0;
942  }
943 
944  if (ctx->filter->priv_class) {
945  ret = av_opt_set_dict(ctx->priv, options);
946  if (ret < 0) {
947  av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
948  return ret;
949  }
950  }
951 
952  if (ctx->filter->init_opaque)
953  ret = ctx->filter->init_opaque(ctx, NULL);
954  else if (ctx->filter->init)
955  ret = ctx->filter->init(ctx);
956  else if (ctx->filter->init_dict)
957  ret = ctx->filter->init_dict(ctx, options);
958 
959  return ret;
960 }
961 
963 {
966  int ret = 0;
967 
968  if (args && *args) {
969  if (!filter->filter->priv_class) {
970  av_log(filter, AV_LOG_ERROR, "This filter does not take any "
971  "options, but options were provided: %s.\n", args);
972  return AVERROR(EINVAL);
973  }
974 
975 #if FF_API_OLD_FILTER_OPTS || FF_API_OLD_FILTER_OPTS_ERROR
976  if ( !strcmp(filter->filter->name, "format") ||
977  !strcmp(filter->filter->name, "noformat") ||
978  !strcmp(filter->filter->name, "frei0r") ||
979  !strcmp(filter->filter->name, "frei0r_src") ||
980  !strcmp(filter->filter->name, "ocv") ||
981  !strcmp(filter->filter->name, "pan") ||
982  !strcmp(filter->filter->name, "pp") ||
983  !strcmp(filter->filter->name, "aevalsrc")) {
984  /* a hack for compatibility with the old syntax
985  * replace colons with |s */
986  char *copy = av_strdup(args);
987  char *p = copy;
988  int nb_leading = 0; // number of leading colons to skip
989  int deprecated = 0;
990 
991  if (!copy) {
992  ret = AVERROR(ENOMEM);
993  goto fail;
994  }
995 
996  if (!strcmp(filter->filter->name, "frei0r") ||
997  !strcmp(filter->filter->name, "ocv"))
998  nb_leading = 1;
999  else if (!strcmp(filter->filter->name, "frei0r_src"))
1000  nb_leading = 3;
1001 
1002  while (nb_leading--) {
1003  p = strchr(p, ':');
1004  if (!p) {
1005  p = copy + strlen(copy);
1006  break;
1007  }
1008  p++;
1009  }
1010 
1011  deprecated = strchr(p, ':') != NULL;
1012 
1013  if (!strcmp(filter->filter->name, "aevalsrc")) {
1014  deprecated = 0;
1015  while ((p = strchr(p, ':')) && p[1] != ':') {
1016  const char *epos = strchr(p + 1, '=');
1017  const char *spos = strchr(p + 1, ':');
1018  const int next_token_is_opt = epos && (!spos || epos < spos);
1019  if (next_token_is_opt) {
1020  p++;
1021  break;
1022  }
1023  /* next token does not contain a '=', assume a channel expression */
1024  deprecated = 1;
1025  *p++ = '|';
1026  }
1027  if (p && *p == ':') { // double sep '::' found
1028  deprecated = 1;
1029  memmove(p, p + 1, strlen(p));
1030  }
1031  } else
1032  while ((p = strchr(p, ':')))
1033  *p++ = '|';
1034 
1035 #if FF_API_OLD_FILTER_OPTS
1036  if (deprecated)
1037  av_log(filter, AV_LOG_WARNING, "This syntax is deprecated. Use "
1038  "'|' to separate the list items.\n");
1039 
1040  av_log(filter, AV_LOG_DEBUG, "compat: called with args=[%s]\n", copy);
1041  ret = process_options(filter, &options, copy);
1042 #else
1043  if (deprecated) {
1044  av_log(filter, AV_LOG_ERROR, "This syntax is deprecated. Use "
1045  "'|' to separate the list items ('%s' instead of '%s')\n",
1046  copy, args);
1047  ret = AVERROR(EINVAL);
1048  } else {
1049  ret = process_options(filter, &options, copy);
1050  }
1051 #endif
1052  av_freep(&copy);
1053 
1054  if (ret < 0)
1055  goto fail;
1056  } else
1057 #endif
1058  {
1059  ret = process_options(filter, &options, args);
1060  if (ret < 0)
1061  goto fail;
1062  }
1063  }
1064 
1065  ret = avfilter_init_dict(filter, &options);
1066  if (ret < 0)
1067  goto fail;
1068 
1069  if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1070  av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
1072  goto fail;
1073  }
1074 
1075 fail:
1076  av_dict_free(&options);
1077 
1078  return ret;
1079 }
1080 
1081 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
1082 {
1083  return pads[pad_idx].name;
1084 }
1085 
1086 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
1087 {
1088  return pads[pad_idx].type;
1089 }
1090 
1092 {
1093  return ff_filter_frame(link->dst->outputs[0], frame);
1094 }
1095 
1097 {
1099  AVFilterContext *dstctx = link->dst;
1100  AVFilterPad *dst = link->dstpad;
1101  int ret;
1102 
1103  if (!(filter_frame = dst->filter_frame))
1105 
1106  if (dst->needs_writable) {
1107  ret = ff_inlink_make_frame_writable(link, &frame);
1108  if (ret < 0)
1109  goto fail;
1110  }
1111 
1112  ff_inlink_process_commands(link, frame);
1113  dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1114 
1115  if (dstctx->is_disabled &&
1118  ret = filter_frame(link, frame);
1119  link->frame_count_out++;
1120  return ret;
1121 
1122 fail:
1123  av_frame_free(&frame);
1124  return ret;
1125 }
1126 
1128 {
1129  int ret;
1131 
1132  /* Consistency checks */
1133  if (link->type == AVMEDIA_TYPE_VIDEO) {
1134  if (strcmp(link->dst->filter->name, "buffersink") &&
1135  strcmp(link->dst->filter->name, "format") &&
1136  strcmp(link->dst->filter->name, "idet") &&
1137  strcmp(link->dst->filter->name, "null") &&
1138  strcmp(link->dst->filter->name, "scale")) {
1139  av_assert1(frame->format == link->format);
1140  av_assert1(frame->width == link->w);
1141  av_assert1(frame->height == link->h);
1142  }
1143  } else {
1144  if (frame->format != link->format) {
1145  av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
1146  goto error;
1147  }
1148  if (av_frame_get_channels(frame) != link->channels) {
1149  av_log(link->dst, AV_LOG_ERROR, "Channel count change is not supported\n");
1150  goto error;
1151  }
1152  if (frame->channel_layout != link->channel_layout) {
1153  av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");
1154  goto error;
1155  }
1156  if (frame->sample_rate != link->sample_rate) {
1157  av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");
1158  goto error;
1159  }
1160  }
1161 
1162  link->frame_blocked_in = link->frame_wanted_out = 0;
1163  link->frame_count_in++;
1164  filter_unblock(link->dst);
1165  ret = ff_framequeue_add(&link->fifo, frame);
1166  if (ret < 0) {
1167  av_frame_free(&frame);
1168  return ret;
1169  }
1170  ff_filter_set_ready(link->dst, 300);
1171  return 0;
1172 
1173 error:
1174  av_frame_free(&frame);
1175  return AVERROR_PATCHWELCOME;
1176 }
1177 
1178 static int samples_ready(AVFilterLink *link, unsigned min)
1179 {
1180  return ff_framequeue_queued_frames(&link->fifo) &&
1181  (ff_framequeue_queued_samples(&link->fifo) >= min ||
1182  link->status_in);
1183 }
1184 
1185 static int take_samples(AVFilterLink *link, unsigned min, unsigned max,
1186  AVFrame **rframe)
1187 {
1188  AVFrame *frame0, *frame, *buf;
1189  unsigned nb_samples, nb_frames, i, p;
1190  int ret;
1191 
1192  /* Note: this function relies on no format changes and must only be
1193  called with enough samples. */
1194  av_assert1(samples_ready(link, link->min_samples));
1195  frame0 = frame = ff_framequeue_peek(&link->fifo, 0);
1196  if (frame->nb_samples >= min && frame->nb_samples < max) {
1197  *rframe = ff_framequeue_take(&link->fifo);
1198  return 0;
1199  }
1200  nb_frames = 0;
1201  nb_samples = 0;
1202  while (1) {
1203  if (nb_samples + frame->nb_samples > max) {
1204  if (nb_samples < min)
1205  nb_samples = max;
1206  break;
1207  }
1208  nb_samples += frame->nb_samples;
1209  nb_frames++;
1210  if (nb_frames == ff_framequeue_queued_frames(&link->fifo))
1211  break;
1212  frame = ff_framequeue_peek(&link->fifo, nb_frames);
1213  }
1214 
1215  buf = ff_get_audio_buffer(link, nb_samples);
1216  if (!buf)
1217  return AVERROR(ENOMEM);
1218  ret = av_frame_copy_props(buf, frame0);
1219  if (ret < 0) {
1220  av_frame_free(&buf);
1221  return ret;
1222  }
1223  buf->pts = frame0->pts;
1224 
1225  p = 0;
1226  for (i = 0; i < nb_frames; i++) {
1227  frame = ff_framequeue_take(&link->fifo);
1228  av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
1229  frame->nb_samples, link->channels, link->format);
1230  p += frame->nb_samples;
1231  av_frame_free(&frame);
1232  }
1233  if (p < nb_samples) {
1234  unsigned n = nb_samples - p;
1235  frame = ff_framequeue_peek(&link->fifo, 0);
1236  av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
1237  link->channels, link->format);
1238  frame->nb_samples -= n;
1239  av_samples_copy(frame->extended_data, frame->extended_data, 0, n,
1240  frame->nb_samples, link->channels, link->format);
1241  if (frame->pts != AV_NOPTS_VALUE)
1242  frame->pts += av_rescale_q(n, av_make_q(1, link->sample_rate), link->time_base);
1243  ff_framequeue_update_peeked(&link->fifo, 0);
1244  ff_framequeue_skip_samples(&link->fifo, n);
1245  }
1246 
1247  *rframe = buf;
1248  return 0;
1249 }
1250 
1252 {
1253  AVFrame *frame = NULL;
1254  AVFilterContext *dst = link->dst;
1255  int ret;
1256 
1258  ret = link->min_samples ?
1259  ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
1260  ff_inlink_consume_frame(link, &frame);
1261  av_assert1(ret);
1262  if (ret < 0) {
1263  av_assert1(!frame);
1264  return ret;
1265  }
1266  /* The filter will soon have received a new frame, that may allow it to
1267  produce one or more: unblock its outputs. */
1268  filter_unblock(dst);
1269  /* AVFilterPad.filter_frame() expect frame_count_out to have the value
1270  before the frame; ff_filter_frame_framed() will re-increment it. */
1271  link->frame_count_out--;
1272  ret = ff_filter_frame_framed(link, frame);
1273  if (ret < 0 && ret != link->status_out) {
1275  } else {
1276  /* Run once again, to see if several frames were available, or if
1277  the input status has also changed, or any other reason. */
1278  ff_filter_set_ready(dst, 300);
1279  }
1280  return ret;
1281 }
1282 
1284 {
1285  unsigned out = 0, progress = 0;
1286  int ret;
1287 
1288  av_assert0(!in->status_out);
1289  if (!filter->nb_outputs) {
1290  /* not necessary with the current API and sinks */
1291  return 0;
1292  }
1293  while (!in->status_out) {
1294  if (!filter->outputs[out]->status_in) {
1295  progress++;
1296  ret = ff_request_frame_to_filter(filter->outputs[out]);
1297  if (ret < 0)
1298  return ret;
1299  }
1300  if (++out == filter->nb_outputs) {
1301  if (!progress) {
1302  /* Every output already closed: input no longer interesting
1303  (example: overlay in shortest mode, other input closed). */
1304  ff_avfilter_link_set_out_status(in, in->status_in, in->status_in_pts);
1305  return 0;
1306  }
1307  progress = 0;
1308  out = 0;
1309  }
1310  }
1311  ff_filter_set_ready(filter, 200);
1312  return 0;
1313 }
1314 
1315 #define FFERROR_NOT_READY FFERRTAG('N','R','D','Y')
1316 
1318 {
1319  unsigned i;
1320 
1321  for (i = 0; i < filter->nb_inputs; i++) {
1322  if (samples_ready(filter->inputs[i], filter->inputs[i]->min_samples)) {
1323  return ff_filter_frame_to_filter(filter->inputs[i]);
1324  }
1325  }
1326  for (i = 0; i < filter->nb_inputs; i++) {
1327  if (filter->inputs[i]->status_in && !filter->inputs[i]->status_out) {
1328  av_assert1(!ff_framequeue_queued_frames(&filter->inputs[i]->fifo));
1329  return forward_status_change(filter, filter->inputs[i]);
1330  }
1331  }
1332  for (i = 0; i < filter->nb_outputs; i++) {
1333  if (filter->outputs[i]->frame_wanted_out &&
1334  !filter->outputs[i]->frame_blocked_in) {
1335  return ff_request_frame_to_filter(filter->outputs[i]);
1336  }
1337  }
1338  return FFERROR_NOT_READY;
1339 }
1340 
1341 /*
1342  Filter scheduling and activation
1343 
1344  When a filter is activated, it must:
1345  - if possible, output a frame;
1346  - else, if relevant, forward the input status change;
1347  - else, check outputs for wanted frames and forward the requests.
1348 
1349  The following AVFilterLink fields are used for activation:
1350 
1351  - frame_wanted_out:
1352 
1353  This field indicates if a frame is needed on this input of the
1354  destination filter. A positive value indicates that a frame is needed
1355  to process queued frames or internal data or to satisfy the
1356  application; a zero value indicates that a frame is not especially
1357  needed but could be processed anyway; a negative value indicates that a
1358  frame would just be queued.
1359 
1360  It is set by filters using ff_request_frame() or ff_request_no_frame(),
1361  when requested by the application through a specific API or when it is
1362  set on one of the outputs.
1363 
1364  It is cleared when a frame is sent from the source using
1365  ff_filter_frame().
1366 
1367  It is also cleared when a status change is sent from the source using
1368  ff_avfilter_link_set_in_status().
1369 
1370  - frame_blocked_in:
1371 
1372  This field means that the source filter can not generate a frame as is.
1373  Its goal is to avoid repeatedly calling the request_frame() method on
1374  the same link.
1375 
1376  It is set by the framework on all outputs of a filter before activating it.
1377 
1378  It is automatically cleared by ff_filter_frame().
1379 
1380  It is also automatically cleared by ff_avfilter_link_set_in_status().
1381 
1382  It is also cleared on all outputs (using filter_unblock()) when
1383  something happens on an input: processing a frame or changing the
1384  status.
1385 
1386  - fifo:
1387 
1388  Contains the frames queued on a filter input. If it contains frames and
1389  frame_wanted_out is not set, then the filter can be activated. If that
1390  result in the filter not able to use these frames, the filter must set
1391  frame_wanted_out to ask for more frames.
1392 
1393  - status_in and status_in_pts:
1394 
1395  Status (EOF or error code) of the link and timestamp of the status
1396  change (in link time base, same as frames) as seen from the input of
1397  the link. The status change is considered happening after the frames
1398  queued in fifo.
1399 
1400  It is set by the source filter using ff_avfilter_link_set_in_status().
1401 
1402  - status_out:
1403 
1404  Status of the link as seen from the output of the link. The status
1405  change is considered having already happened.
1406 
1407  It is set by the destination filter using
1408  ff_avfilter_link_set_out_status().
1409 
1410  Filters are activated according to the ready field, set using the
1411  ff_filter_set_ready(). Eventually, a priority queue will be used.
1412  ff_filter_set_ready() is called whenever anything could cause progress to
1413  be possible. Marking a filter ready when it is not is not a problem,
1414  except for the small overhead it causes.
1415 
1416  Conditions that cause a filter to be marked ready are:
1417 
1418  - frames added on an input link;
1419 
1420  - changes in the input or output status of an input link;
1421 
1422  - requests for a frame on an output link;
1423 
1424  - after any actual processing using the legacy methods (filter_frame(),
1425  and request_frame() to acknowledge status changes), to run once more
1426  and check if enough input was present for several frames.
1427 
1428  Exemples of scenarios to consider:
1429 
1430  - buffersrc: activate if frame_wanted_out to notify the application;
1431  activate when the application adds a frame to push it immediately.
1432 
1433  - testsrc: activate only if frame_wanted_out to produce and push a frame.
1434 
1435  - concat (not at stitch points): can process a frame on any output.
1436  Activate if frame_wanted_out on output to forward on the corresponding
1437  input. Activate when a frame is present on input to process it
1438  immediately.
1439 
1440  - framesync: needs at least one frame on each input; extra frames on the
1441  wrong input will accumulate. When a frame is first added on one input,
1442  set frame_wanted_out<0 on it to avoid getting more (would trigger
1443  testsrc) and frame_wanted_out>0 on the other to allow processing it.
1444 
1445  Activation of old filters:
1446 
1447  In order to activate a filter implementing the legacy filter_frame() and
1448  request_frame() methods, perform the first possible of the following
1449  actions:
1450 
1451  - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
1452  frame and call filter_frame().
1453 
1454  Ratinale: filter frames as soon as possible instead of leaving them
1455  queued; frame_wanted_out < 0 is not possible since the old API does not
1456  set it nor provides any similar feedback; frame_wanted_out > 0 happens
1457  when min_samples > 0 and there are not enough samples queued.
1458 
1459  - If an input has status_in set but not status_out, try to call
1460  request_frame() on one of the outputs in the hope that it will trigger
1461  request_frame() on the input with status_in and acknowledge it. This is
1462  awkward and fragile, filters with several inputs or outputs should be
1463  updated to direct activation as soon as possible.
1464 
1465  - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
1466  request_frame().
1467 
1468  Rationale: checking frame_blocked_in is necessary to avoid requesting
1469  repeatedly on a blocked input if another is not blocked (example:
1470  [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
1471 
1472  TODO: respect needs_fifo and remove auto-inserted fifos.
1473 
1474  */
1475 
1477 {
1478  int ret;
1479 
1480  /* Generic timeline support is not yet implemented but should be easy */
1482  filter->filter->activate));
1483  filter->ready = 0;
1484  ret = filter->filter->activate ? filter->filter->activate(filter) :
1486  if (ret == FFERROR_NOT_READY)
1487  ret = 0;
1488  return ret;
1489 }
1490 
1491 int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
1492 {
1493  *rpts = link->current_pts;
1494  if (ff_framequeue_queued_frames(&link->fifo))
1495  return *rstatus = 0;
1496  if (link->status_out)
1497  return *rstatus = link->status_out;
1498  if (!link->status_in)
1499  return *rstatus = 0;
1500  *rstatus = link->status_out = link->status_in;
1501  ff_update_link_current_pts(link, link->status_in_pts);
1502  *rpts = link->current_pts;
1503  return 1;
1504 }
1505 
1507 {
1508  return ff_framequeue_queued_frames(&link->fifo) > 0;
1509 }
1510 
1512 {
1513  uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
1514  av_assert1(min);
1515  return samples >= min || (link->status_in && samples);
1516 }
1517 
1518 static void consume_update(AVFilterLink *link, const AVFrame *frame)
1519 {
1520  ff_update_link_current_pts(link, frame->pts);
1521  ff_inlink_process_commands(link, frame);
1522  link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
1523  link->frame_count_out++;
1524 }
1525 
1527 {
1528  AVFrame *frame;
1529 
1530  *rframe = NULL;
1532  return 0;
1533  frame = ff_framequeue_take(&link->fifo);
1534  consume_update(link, frame);
1535  *rframe = frame;
1536  return 1;
1537 }
1538 
1539 int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
1540  AVFrame **rframe)
1541 {
1542  AVFrame *frame;
1543  int ret;
1544 
1545  av_assert1(min);
1546  *rframe = NULL;
1547  if (!ff_inlink_check_available_samples(link, min))
1548  return 0;
1549  if (link->status_in)
1550  min = FFMIN(min, ff_framequeue_queued_samples(&link->fifo));
1551  ret = take_samples(link, min, link->max_samples, &frame);
1552  if (ret < 0)
1553  return ret;
1554  consume_update(link, frame);
1555  *rframe = frame;
1556  return 1;
1557 }
1558 
1560 {
1561  AVFrame *frame = *rframe;
1562  AVFrame *out;
1563  int ret;
1564 
1565  if (av_frame_is_writable(frame))
1566  return 0;
1567  av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1568 
1569  switch (link->type) {
1570  case AVMEDIA_TYPE_VIDEO:
1571  out = ff_get_video_buffer(link, link->w, link->h);
1572  break;
1573  case AVMEDIA_TYPE_AUDIO:
1574  out = ff_get_audio_buffer(link, frame->nb_samples);
1575  break;
1576  default:
1577  return AVERROR(EINVAL);
1578  }
1579  if (!out)
1580  return AVERROR(ENOMEM);
1581 
1582  ret = av_frame_copy_props(out, frame);
1583  if (ret < 0) {
1584  av_frame_free(&out);
1585  return ret;
1586  }
1587 
1588  switch (link->type) {
1589  case AVMEDIA_TYPE_VIDEO:
1590  av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
1591  frame->format, frame->width, frame->height);
1592  break;
1593  case AVMEDIA_TYPE_AUDIO:
1595  0, 0, frame->nb_samples,
1596  av_frame_get_channels(frame),
1597  frame->format);
1598  break;
1599  default:
1600  av_assert0(!"reached");
1601  }
1602 
1603  av_frame_free(&frame);
1604  *rframe = out;
1605  return 0;
1606 }
1607 
1609 {
1610  AVFilterCommand *cmd = link->dst->command_queue;
1611 
1612  while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
1613  av_log(link->dst, AV_LOG_DEBUG,
1614  "Processing command time:%f command:%s arg:%s\n",
1615  cmd->time, cmd->command, cmd->arg);
1616  avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1617  ff_command_queue_pop(link->dst);
1618  cmd= link->dst->command_queue;
1619  }
1620  return 0;
1621 }
1622 
1624 {
1625  AVFilterContext *dstctx = link->dst;
1626  int64_t pts = frame->pts;
1627  int64_t pos = av_frame_get_pkt_pos(frame);
1628 
1629  if (!dstctx->enable_str)
1630  return 1;
1631 
1632  dstctx->var_values[VAR_N] = link->frame_count_out;
1633  dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1634  dstctx->var_values[VAR_W] = link->w;
1635  dstctx->var_values[VAR_H] = link->h;
1636  dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1637 
1638  return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
1639 }
1640 
1642 {
1643  av_assert1(!link->status_in);
1644  av_assert1(!link->status_out);
1645  link->frame_wanted_out = 1;
1646  ff_filter_set_ready(link->src, 100);
1647 }
1648 
1650 {
1651  return &avfilter_class;
1652 }
int(* poll_frame)(AVFilterLink *link)
Frame poll callback.
Definition: internal.h:104
double * var_values
variable values for the enable expression
Definition: avfilter.h:367
#define ff_tlog(ctx,...)
Definition: internal.h:65
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:1526
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
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:124
AVFilterContext * ff_filter_alloc(const AVFilter *filter, const char *inst_name)
Allocate a new filter context and return it.
Definition: avfilter.c:694
This structure describes decoded (raw) audio or video data.
Definition: frame.h:190
int thread_type
Type of multithreading allowed for filters in this graph.
Definition: avfilter.h:858
static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:1091
AVOption.
Definition: opt.h:246
static int ff_filter_activate_default(AVFilterContext *filter)
Definition: avfilter.c:1317
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:791
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:373
int(* init)(AVFilterContext *ctx)
Filter initialization function.
Definition: avfilter.h:218
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:1293
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:1086
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:377
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:202
static void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t n)
Update the sample count in the queue.
Definition: framequeue.h:169
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:252
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:659
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:76
int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
Test if enough samples are available on the link.
Definition: avfilter.c:1511
#define src
Definition: vp8dsp.c:254
int thread_type
Type of multithreading being allowed/used.
Definition: avfilter.h:356
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:368
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1641
int nb_threads
Max number of threads allowed in this filter instance.
Definition: avfilter.h:384
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:260
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
Definition: avfilter.h:316
struct AVFilterGraph * graph
filtergraph this filter belongs to
Definition: avfilter.h:338
#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:269
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:329
char * name
name of this filter instance
Definition: avfilter.h:326
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static AVFilter ** last_filter
Definition: avfilter.c:561
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:1127
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:332
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:391
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:274
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:865
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:596
#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:328
void(* uninit)(AVFilterContext *ctx)
Filter uninitialization function.
Definition: avfilter.h:243
static void free_link(AVFilterLink *link)
Definition: avfilter.c:770
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:289
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:208
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:528
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:1623
static const AVClass avfilter_class
Definition: avfilter.c:671
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:1491
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:328
static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
Definition: avfilter.c:1283
static void consume_update(AVFilterLink *link, const AVFrame *frame)
Definition: avfilter.c:1518
int width
width and height of the video frame
Definition: frame.h:242
#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:60
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:821
static const char * default_filter_name(void *filter_ctx)
Definition: avfilter.c:624
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:158
unsigned nb_outputs
number of output pads
Definition: avfilter.h:334
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:336
#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:365
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:231
simple assert() macros that are a bit more flexible than ISO C assert().
#define FF_TPRINTF_START(ctx, func)
Definition: internal.h:258
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 error(const char *err)
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:226
Frame pool.
Definition: framepool.c:30
#define fail()
Definition: checkasm.h:84
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:321
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:359
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: avfilter.c:566
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:1596
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:630
void avfilter_link_set_closed(AVFilterLink *link, int closed)
Set the closed field of a link.
Definition: avfilter.c:233
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:264
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:833
unsigned nb_inputs
number of input pads
Definition: avfilter.h:330
#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:560
struct AVFilterCommand * next
Definition: internal.h:43
static const AVOption avfilter_options[]
Definition: avfilter.c:661
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
Accept to parse a value without a key; the key will then be returned as NULL.
Definition: opt.h:530
AVFrame * ff_framequeue_take(FFFrameQueue *fq)
Take the first frame in the queue.
Definition: framequeue.c:98
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: aeval.c:413
#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:432
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 n
Definition: avisynth_c.h:684
static int ff_filter_frame_to_filter(AVFilterLink *link)
Definition: avfilter.c:1251
int(* init_opaque)(AVFilterContext *ctx, void *opaque)
Filter initialization function, alternative to the init() callback.
Definition: avfilter.h:296
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
Definition: avfilter.c:1559
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:962
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:1649
#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:254
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:267
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:319
#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:870
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:531
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1591
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:221
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
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:1539
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:269
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:539
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:1608
Describe the class of an AVClass context structure.
Definition: log.h:67
int sample_rate
Sample rate of the audio data.
Definition: frame.h:354
int av_frame_get_channels(const AVFrame *frame)
Filter definition.
Definition: avfilter.h:144
static int take_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Definition: avfilter.c:1185
static const char *const var_names[]
Definition: avfilter.c:470
Rational number (pair of numerator and denominator).
Definition: rational.h:58
struct AVFilter * next
Used by the filter registration system.
Definition: avfilter.h:275
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:117
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:67
int ff_inlink_check_available_frame(AVFilterLink *link)
Test if a frame is available on the link.
Definition: avfilter.c:1506
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:149
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
Definition: avfilter.c:1081
#define FLAGS
Definition: avfilter.c:660
AVFrame * ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
Access a frame in the queue, without removing it.
Definition: framequeue.c:114
#define LICENSE_PREFIX
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:333
#define OFFSET(x)
Definition: avfilter.c:659
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:361
static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: avfilter.c:681
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:204
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
Initialize a filter with the supplied dictionary of options.
Definition: avfilter.c:925
#define FFERROR_NOT_READY
Definition: avfilter.c:1315
int
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1546
static int set_enable_expr(AVFilterContext *ctx, const char *expr)
Definition: avfilter.c:488
static size_t ff_framequeue_queued_frames(const FFFrameQueue *fq)
Get the number of queued frames.
Definition: framequeue.h:141
common internal and external API header
if(ret< 0)
Definition: vf_mcdeint.c:282
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
struct AVFilterCommand * command_queue
Definition: avfilter.h:363
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:92
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Filters implementation helper functions.
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:1178
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:580
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:333
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:1472
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:714
int64_t av_frame_get_pkt_pos(const AVFrame *frame)
void * enable
parsed expression (AVExpr*)
Definition: avfilter.h:366
const AVClass * av_class
needed for av_log() and filters common options
Definition: avfilter.h:322
static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
Definition: avfilter.c:1096
static void ff_framequeue_update_peeked(FFFrameQueue *fq, size_t idx)
Update the statistics after a frame accessed using ff_framequeue_peek() was modified.
Definition: framequeue.h:159
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:259
static AVCodec * c
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:321
#define av_uninit(x)
Definition: attributes.h:149
int avfilter_pad_count(const AVFilterPad *pads)
Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
Definition: avfilter.c:612
int height
Definition: frame.h:242
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:2248
static const AVClass * filter_child_class_next(const AVClass *prev)
Definition: avfilter.c:638
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:1476
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:237
int(* activate)(AVFilterContext *ctx)
Filter activation function.
Definition: avfilter.h:310
int ff_poll_frame(AVFilterLink *link)
Poll a frame from the filter chain.
Definition: avfilter.c:452
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:451
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:247
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:324
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:591
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
char * command
command
Definition: internal.h:40
#define av_unused
Definition: attributes.h:126
static int process_options(AVFilterContext *ctx, AVDictionary **options, const char *args)
Definition: avfilter.c:840
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