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