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"
26 #include "libavutil/common.h"
27 #include "libavutil/eval.h"
28 #include "libavutil/imgutils.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 #include "libavutil/rational.h"
33 #include "libavutil/samplefmt.h"
34 
35 #include "audio.h"
36 #include "avfilter.h"
37 #include "formats.h"
38 #include "internal.h"
39 
41 
42 void ff_tlog_ref(void *ctx, AVFrame *ref, int end)
43 {
44  av_unused char buf[16];
45  ff_tlog(ctx,
46  "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
47  ref, ref->buf, ref->data[0],
48  ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
49  ref->pts, av_frame_get_pkt_pos(ref));
50 
51  if (ref->width) {
52  ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
54  ref->width, ref->height,
55  !ref->interlaced_frame ? 'P' : /* Progressive */
56  ref->top_field_first ? 'T' : 'B', /* Top / Bottom */
57  ref->key_frame,
59  }
60  if (ref->nb_samples) {
61  ff_tlog(ctx, " cl:%"PRId64"d n:%d r:%d",
62  ref->channel_layout,
63  ref->nb_samples,
64  ref->sample_rate);
65  }
66 
67  ff_tlog(ctx, "]%s", end ? "\n" : "");
68 }
69 
70 unsigned avfilter_version(void)
71 {
74 }
75 
76 const char *avfilter_configuration(void)
77 {
78  return FFMPEG_CONFIGURATION;
79 }
80 
81 const char *avfilter_license(void)
82 {
83 #define LICENSE_PREFIX "libavfilter license: "
84  return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
85 }
86 
88 {
90  av_freep(&c->arg);
91  av_freep(&c->command);
92  filter->command_queue= c->next;
93  av_free(c);
94 }
95 
96 int ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
97  AVFilterPad **pads, AVFilterLink ***links,
98  AVFilterPad *newpad)
99 {
100  AVFilterLink **newlinks;
101  AVFilterPad *newpads;
102  unsigned i;
103 
104  idx = FFMIN(idx, *count);
105 
106  newpads = av_realloc_array(*pads, *count + 1, sizeof(AVFilterPad));
107  newlinks = av_realloc_array(*links, *count + 1, sizeof(AVFilterLink*));
108  if (newpads)
109  *pads = newpads;
110  if (newlinks)
111  *links = newlinks;
112  if (!newpads || !newlinks)
113  return AVERROR(ENOMEM);
114 
115  memmove(*pads + idx + 1, *pads + idx, sizeof(AVFilterPad) * (*count - idx));
116  memmove(*links + idx + 1, *links + idx, sizeof(AVFilterLink*) * (*count - idx));
117  memcpy(*pads + idx, newpad, sizeof(AVFilterPad));
118  (*links)[idx] = NULL;
119 
120  (*count)++;
121  for (i = idx + 1; i < *count; i++)
122  if ((*links)[i])
123  (*(unsigned *)((uint8_t *) (*links)[i] + padidx_off))++;
124 
125  return 0;
126 }
127 
128 int avfilter_link(AVFilterContext *src, unsigned srcpad,
129  AVFilterContext *dst, unsigned dstpad)
130 {
131  AVFilterLink *link;
132 
133  if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
134  src->outputs[srcpad] || dst->inputs[dstpad])
135  return -1;
136 
137  if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
138  av_log(src, AV_LOG_ERROR,
139  "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
140  src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),
141  dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));
142  return AVERROR(EINVAL);
143  }
144 
145  link = av_mallocz(sizeof(*link));
146  if (!link)
147  return AVERROR(ENOMEM);
148 
149  src->outputs[srcpad] = dst->inputs[dstpad] = link;
150 
151  link->src = src;
152  link->dst = dst;
153  link->srcpad = &src->output_pads[srcpad];
154  link->dstpad = &dst->input_pads[dstpad];
155  link->type = src->output_pads[srcpad].type;
157  link->format = -1;
158 
159  return 0;
160 }
161 
163 {
164  if (!*link)
165  return;
166 
167  av_frame_free(&(*link)->partial_buf);
168 
169  av_freep(link);
170 }
171 
173 {
174  return link->channels;
175 }
176 
177 void avfilter_link_set_closed(AVFilterLink *link, int closed)
178 {
179  link->closed = closed;
180 }
181 
183  unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
184 {
185  int ret;
186  unsigned dstpad_idx = link->dstpad - link->dst->input_pads;
187 
188  av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "
189  "between the filter '%s' and the filter '%s'\n",
190  filt->name, link->src->name, link->dst->name);
191 
192  link->dst->inputs[dstpad_idx] = NULL;
193  if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {
194  /* failed to link output filter to new filter */
195  link->dst->inputs[dstpad_idx] = link;
196  return ret;
197  }
198 
199  /* re-hookup the link to the new destination filter we inserted */
200  link->dst = filt;
201  link->dstpad = &filt->input_pads[filt_srcpad_idx];
202  filt->inputs[filt_srcpad_idx] = link;
203 
204  /* if any information on supported media formats already exists on the
205  * link, we need to preserve that */
206  if (link->out_formats)
208  &filt->outputs[filt_dstpad_idx]->out_formats);
209  if (link->out_samplerates)
211  &filt->outputs[filt_dstpad_idx]->out_samplerates);
212  if (link->out_channel_layouts)
214  &filt->outputs[filt_dstpad_idx]->out_channel_layouts);
215 
216  return 0;
217 }
218 
220 {
221  int (*config_link)(AVFilterLink *);
222  unsigned i;
223  int ret;
224 
225  for (i = 0; i < filter->nb_inputs; i ++) {
226  AVFilterLink *link = filter->inputs[i];
227  AVFilterLink *inlink;
228 
229  if (!link) continue;
230 
231  inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
232  link->current_pts = AV_NOPTS_VALUE;
233 
234  switch (link->init_state) {
235  case AVLINK_INIT:
236  continue;
237  case AVLINK_STARTINIT:
238  av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");
239  return 0;
240  case AVLINK_UNINIT:
241  link->init_state = AVLINK_STARTINIT;
242 
243  if ((ret = avfilter_config_links(link->src)) < 0)
244  return ret;
245 
246  if (!(config_link = link->srcpad->config_props)) {
247  if (link->src->nb_inputs != 1) {
248  av_log(link->src, AV_LOG_ERROR, "Source filters and filters "
249  "with more than one input "
250  "must set config_props() "
251  "callbacks on all outputs\n");
252  return AVERROR(EINVAL);
253  }
254  } else if ((ret = config_link(link)) < 0) {
255  av_log(link->src, AV_LOG_ERROR,
256  "Failed to configure output pad on %s\n",
257  link->src->name);
258  return ret;
259  }
260 
261  switch (link->type) {
262  case AVMEDIA_TYPE_VIDEO:
263  if (!link->time_base.num && !link->time_base.den)
264  link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
265 
266  if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
267  link->sample_aspect_ratio = inlink ?
268  inlink->sample_aspect_ratio : (AVRational){1,1};
269 
270  if (inlink && !link->frame_rate.num && !link->frame_rate.den)
271  link->frame_rate = inlink->frame_rate;
272 
273  if (inlink) {
274  if (!link->w)
275  link->w = inlink->w;
276  if (!link->h)
277  link->h = inlink->h;
278  } else if (!link->w || !link->h) {
279  av_log(link->src, AV_LOG_ERROR,
280  "Video source filters must set their output link's "
281  "width and height\n");
282  return AVERROR(EINVAL);
283  }
284  break;
285 
286  case AVMEDIA_TYPE_AUDIO:
287  if (inlink) {
288  if (!link->time_base.num && !link->time_base.den)
289  link->time_base = inlink->time_base;
290  }
291 
292  if (!link->time_base.num && !link->time_base.den)
293  link->time_base = (AVRational) {1, link->sample_rate};
294  }
295 
296  if ((config_link = link->dstpad->config_props))
297  if ((ret = config_link(link)) < 0) {
298  av_log(link->dst, AV_LOG_ERROR,
299  "Failed to configure input pad on %s\n",
300  link->dst->name);
301  return ret;
302  }
303 
304  link->init_state = AVLINK_INIT;
305  }
306  }
307 
308  return 0;
309 }
310 
311 void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
312 {
313  if (link->type == AVMEDIA_TYPE_VIDEO) {
314  ff_tlog(ctx,
315  "link[%p s:%dx%d fmt:%s %s->%s]%s",
316  link, link->w, link->h,
318  link->src ? link->src->filter->name : "",
319  link->dst ? link->dst->filter->name : "",
320  end ? "\n" : "");
321  } else {
322  char buf[128];
323  av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);
324 
325  ff_tlog(ctx,
326  "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
327  link, (int)link->sample_rate, buf,
329  link->src ? link->src->filter->name : "",
330  link->dst ? link->dst->filter->name : "",
331  end ? "\n" : "");
332  }
333 }
334 
336 {
337  int ret = -1;
338  FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1);
339 
340  if (link->closed)
341  return AVERROR_EOF;
342  av_assert0(!link->frame_requested);
343  link->frame_requested = 1;
344  while (link->frame_requested) {
345  if (link->srcpad->request_frame)
346  ret = link->srcpad->request_frame(link);
347  else if (link->src->inputs[0])
348  ret = ff_request_frame(link->src->inputs[0]);
349  if (ret == AVERROR_EOF && link->partial_buf) {
350  AVFrame *pbuf = link->partial_buf;
351  link->partial_buf = NULL;
352  ret = ff_filter_frame_framed(link, pbuf);
353  }
354  if (ret < 0) {
355  link->frame_requested = 0;
356  if (ret == AVERROR_EOF)
357  link->closed = 1;
358  } else {
359  av_assert0(!link->frame_requested ||
361  }
362  }
363  return ret;
364 }
365 
367 {
368  int i, min = INT_MAX;
369 
370  if (link->srcpad->poll_frame)
371  return link->srcpad->poll_frame(link);
372 
373  for (i = 0; i < link->src->nb_inputs; i++) {
374  int val;
375  if (!link->src->inputs[i])
376  return -1;
377  val = ff_poll_frame(link->src->inputs[i]);
378  min = FFMIN(min, val);
379  }
380 
381  return min;
382 }
383 
384 static const char *const var_names[] = { "t", "n", "pos", NULL };
386 
387 static int set_enable_expr(AVFilterContext *ctx, const char *expr)
388 {
389  int ret;
390  char *expr_dup;
391  AVExpr *old = ctx->enable;
392 
394  av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
395  "with filter '%s'\n", ctx->filter->name);
396  return AVERROR_PATCHWELCOME;
397  }
398 
399  expr_dup = av_strdup(expr);
400  if (!expr_dup)
401  return AVERROR(ENOMEM);
402 
403  if (!ctx->var_values) {
404  ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values));
405  if (!ctx->var_values) {
406  av_free(expr_dup);
407  return AVERROR(ENOMEM);
408  }
409  }
410 
411  ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names,
412  NULL, NULL, NULL, NULL, 0, ctx->priv);
413  if (ret < 0) {
414  av_log(ctx->priv, AV_LOG_ERROR,
415  "Error when evaluating the expression '%s' for enable\n",
416  expr_dup);
417  av_free(expr_dup);
418  return ret;
419  }
420 
421  av_expr_free(old);
422  av_free(ctx->enable_str);
423  ctx->enable_str = expr_dup;
424  return 0;
425 }
426 
427 void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)
428 {
429  if (pts == AV_NOPTS_VALUE)
430  return;
431  link->current_pts = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
432  /* TODO use duration */
433  if (link->graph && link->age_index >= 0)
435 }
436 
437 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
438 {
439  if(!strcmp(cmd, "ping")){
440  char local_res[256] = {0};
441 
442  if (!res) {
443  res = local_res;
444  res_len = sizeof(local_res);
445  }
446  av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
447  if (res == local_res)
448  av_log(filter, AV_LOG_INFO, "%s", res);
449  return 0;
450  }else if(!strcmp(cmd, "enable")) {
451  return set_enable_expr(filter, arg);
452  }else if(filter->filter->process_command) {
453  return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);
454  }
455  return AVERROR(ENOSYS);
456 }
457 
460 
461 #if !FF_API_NOCONST_GET_NAME
462 const
463 #endif
465 {
466  const AVFilter *f = NULL;
467 
468  if (!name)
469  return NULL;
470 
471  while ((f = avfilter_next(f)))
472  if (!strcmp(f->name, name))
473  return (AVFilter *)f;
474 
475  return NULL;
476 }
477 
479 {
480  AVFilter **f = last_filter;
481  int i;
482 
483  /* the filter must select generic or internal exclusively */
485 
486  for(i=0; filter->inputs && filter->inputs[i].name; i++) {
487  const AVFilterPad *input = &filter->inputs[i];
488  av_assert0( !input->filter_frame
489  || (!input->start_frame && !input->end_frame));
490  }
491 
492  filter->next = NULL;
493 
494  while(*f || avpriv_atomic_ptr_cas((void * volatile *)f, NULL, filter))
495  f = &(*f)->next;
496  last_filter = &filter->next;
497 
498  return 0;
499 }
500 
501 const AVFilter *avfilter_next(const AVFilter *prev)
502 {
503  return prev ? prev->next : first_filter;
504 }
505 
506 #if FF_API_OLD_FILTER_REGISTER
507 AVFilter **av_filter_next(AVFilter **filter)
508 {
509  return filter ? &(*filter)->next : &first_filter;
510 }
511 
512 void avfilter_uninit(void)
513 {
514 }
515 #endif
516 
518 {
519  int count;
520 
521  if (!pads)
522  return 0;
523 
524  for (count = 0; pads->name; count++)
525  pads++;
526  return count;
527 }
528 
529 static const char *default_filter_name(void *filter_ctx)
530 {
532  return ctx->name ? ctx->name : ctx->filter->name;
533 }
534 
535 static void *filter_child_next(void *obj, void *prev)
536 {
537  AVFilterContext *ctx = obj;
538  if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)
539  return ctx->priv;
540  return NULL;
541 }
542 
543 static const AVClass *filter_child_class_next(const AVClass *prev)
544 {
545  const AVFilter *f = NULL;
546 
547  /* find the filter that corresponds to prev */
548  while (prev && (f = avfilter_next(f)))
549  if (f->priv_class == prev)
550  break;
551 
552  /* could not find filter corresponding to prev */
553  if (prev && !f)
554  return NULL;
555 
556  /* find next filter with specific options */
557  while ((f = avfilter_next(f)))
558  if (f->priv_class)
559  return f->priv_class;
560 
561  return NULL;
562 }
563 
564 #define OFFSET(x) offsetof(AVFilterContext, x)
565 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
566 static const AVOption avfilter_options[] = {
567  { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
568  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
569  { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .unit = "thread_type" },
570  { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
571  { NULL },
572 };
573 
574 static const AVClass avfilter_class = {
575  .class_name = "AVFilter",
576  .item_name = default_filter_name,
577  .version = LIBAVUTIL_VERSION_INT,
578  .category = AV_CLASS_CATEGORY_FILTER,
579  .child_next = filter_child_next,
580  .child_class_next = filter_child_class_next,
582 };
583 
585  int *ret, int nb_jobs)
586 {
587  int i;
588 
589  for (i = 0; i < nb_jobs; i++) {
590  int r = func(ctx, arg, i, nb_jobs);
591  if (ret)
592  ret[i] = r;
593  }
594  return 0;
595 }
596 
597 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
598 {
600 
601  if (!filter)
602  return NULL;
603 
604  ret = av_mallocz(sizeof(AVFilterContext));
605  if (!ret)
606  return NULL;
607 
608  ret->av_class = &avfilter_class;
609  ret->filter = filter;
610  ret->name = inst_name ? av_strdup(inst_name) : NULL;
611  if (filter->priv_size) {
612  ret->priv = av_mallocz(filter->priv_size);
613  if (!ret->priv)
614  goto err;
615  }
616 
617  av_opt_set_defaults(ret);
618  if (filter->priv_class) {
619  *(const AVClass**)ret->priv = filter->priv_class;
621  }
622 
623  ret->internal = av_mallocz(sizeof(*ret->internal));
624  if (!ret->internal)
625  goto err;
627 
628  ret->nb_inputs = avfilter_pad_count(filter->inputs);
629  if (ret->nb_inputs ) {
630  ret->input_pads = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad));
631  if (!ret->input_pads)
632  goto err;
633  memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
634  ret->inputs = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*));
635  if (!ret->inputs)
636  goto err;
637  }
638 
639  ret->nb_outputs = avfilter_pad_count(filter->outputs);
640  if (ret->nb_outputs) {
641  ret->output_pads = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad));
642  if (!ret->output_pads)
643  goto err;
644  memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
645  ret->outputs = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*));
646  if (!ret->outputs)
647  goto err;
648  }
649 #if FF_API_FOO_COUNT
651  ret->output_count = ret->nb_outputs;
652  ret->input_count = ret->nb_inputs;
654 #endif
655 
656  return ret;
657 
658 err:
659  av_freep(&ret->inputs);
660  av_freep(&ret->input_pads);
661  ret->nb_inputs = 0;
662  av_freep(&ret->outputs);
663  av_freep(&ret->output_pads);
664  ret->nb_outputs = 0;
665  av_freep(&ret->priv);
666  av_freep(&ret->internal);
667  av_free(ret);
668  return NULL;
669 }
670 
671 #if FF_API_AVFILTER_OPEN
672 int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
673 {
674  *filter_ctx = ff_filter_alloc(filter, inst_name);
675  return *filter_ctx ? 0 : AVERROR(ENOMEM);
676 }
677 #endif
678 
679 static void free_link(AVFilterLink *link)
680 {
681  if (!link)
682  return;
683 
684  if (link->src)
685  link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
686  if (link->dst)
687  link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
688 
695  avfilter_link_free(&link);
696 }
697 
699 {
700  int i;
701 
702  if (!filter)
703  return;
704 
705  if (filter->graph)
706  ff_filter_graph_remove_filter(filter->graph, filter);
707 
708  if (filter->filter->uninit)
709  filter->filter->uninit(filter);
710 
711  for (i = 0; i < filter->nb_inputs; i++) {
712  free_link(filter->inputs[i]);
713  }
714  for (i = 0; i < filter->nb_outputs; i++) {
715  free_link(filter->outputs[i]);
716  }
717 
718  if (filter->filter->priv_class)
719  av_opt_free(filter->priv);
720 
721  av_freep(&filter->name);
722  av_freep(&filter->input_pads);
723  av_freep(&filter->output_pads);
724  av_freep(&filter->inputs);
725  av_freep(&filter->outputs);
726  av_freep(&filter->priv);
727  while(filter->command_queue){
728  ff_command_queue_pop(filter);
729  }
730  av_opt_free(filter);
731  av_expr_free(filter->enable);
732  filter->enable = NULL;
733  av_freep(&filter->var_values);
734  av_freep(&filter->internal);
735  av_free(filter);
736 }
737 
739  const char *args)
740 {
741  const AVOption *o = NULL;
742  int ret, count = 0;
743  char *av_uninit(parsed_key), *av_uninit(value);
744  const char *key;
745  int offset= -1;
746 
747  if (!args)
748  return 0;
749 
750  while (*args) {
751  const char *shorthand = NULL;
752 
753  o = av_opt_next(ctx->priv, o);
754  if (o) {
755  if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
756  continue;
757  offset = o->offset;
758  shorthand = o->name;
759  }
760 
761  ret = av_opt_get_key_value(&args, "=", ":",
762  shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
763  &parsed_key, &value);
764  if (ret < 0) {
765  if (ret == AVERROR(EINVAL))
766  av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
767  else
768  av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
769  av_err2str(ret));
770  return ret;
771  }
772  if (*args)
773  args++;
774  if (parsed_key) {
775  key = parsed_key;
776  while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */
777  } else {
778  key = shorthand;
779  }
780 
781  av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
782 
783  if (av_opt_find(ctx, key, NULL, 0, 0)) {
784  ret = av_opt_set(ctx, key, value, 0);
785  if (ret < 0) {
786  av_free(value);
787  av_free(parsed_key);
788  return ret;
789  }
790  } else {
791  av_dict_set(options, key, value, 0);
792  if ((ret = av_opt_set(ctx->priv, key, value, 0)) < 0) {
793  if (!av_opt_find(ctx->priv, key, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) {
794  if (ret == AVERROR_OPTION_NOT_FOUND)
795  av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
796  av_free(value);
797  av_free(parsed_key);
798  return ret;
799  }
800  }
801  }
802 
803  av_free(value);
804  av_free(parsed_key);
805  count++;
806  }
807 
808  if (ctx->enable_str) {
809  ret = set_enable_expr(ctx, ctx->enable_str);
810  if (ret < 0)
811  return ret;
812  }
813  return count;
814 }
815 
816 #if FF_API_AVFILTER_INIT_FILTER
817 int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque)
818 {
819  return avfilter_init_str(filter, args);
820 }
821 #endif
822 
824 {
825  int ret = 0;
826 
827  ret = av_opt_set_dict(ctx, options);
828  if (ret < 0) {
829  av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
830  return ret;
831  }
832 
835  ctx->graph->internal->thread_execute) {
838  } else {
839  ctx->thread_type = 0;
840  }
841 
842  if (ctx->filter->priv_class) {
843  ret = av_opt_set_dict(ctx->priv, options);
844  if (ret < 0) {
845  av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
846  return ret;
847  }
848  }
849 
850  if (ctx->filter->init_opaque)
851  ret = ctx->filter->init_opaque(ctx, NULL);
852  else if (ctx->filter->init)
853  ret = ctx->filter->init(ctx);
854  else if (ctx->filter->init_dict)
855  ret = ctx->filter->init_dict(ctx, options);
856 
857  return ret;
858 }
859 
861 {
862  AVDictionary *options = NULL;
864  int ret = 0;
865 
866  if (args && *args) {
867  if (!filter->filter->priv_class) {
868  av_log(filter, AV_LOG_ERROR, "This filter does not take any "
869  "options, but options were provided: %s.\n", args);
870  return AVERROR(EINVAL);
871  }
872 
873 #if FF_API_OLD_FILTER_OPTS
874  if ( !strcmp(filter->filter->name, "format") ||
875  !strcmp(filter->filter->name, "noformat") ||
876  !strcmp(filter->filter->name, "frei0r") ||
877  !strcmp(filter->filter->name, "frei0r_src") ||
878  !strcmp(filter->filter->name, "ocv") ||
879  !strcmp(filter->filter->name, "pan") ||
880  !strcmp(filter->filter->name, "pp") ||
881  !strcmp(filter->filter->name, "aevalsrc")) {
882  /* a hack for compatibility with the old syntax
883  * replace colons with |s */
884  char *copy = av_strdup(args);
885  char *p = copy;
886  int nb_leading = 0; // number of leading colons to skip
887  int deprecated = 0;
888 
889  if (!copy) {
890  ret = AVERROR(ENOMEM);
891  goto fail;
892  }
893 
894  if (!strcmp(filter->filter->name, "frei0r") ||
895  !strcmp(filter->filter->name, "ocv"))
896  nb_leading = 1;
897  else if (!strcmp(filter->filter->name, "frei0r_src"))
898  nb_leading = 3;
899 
900  while (nb_leading--) {
901  p = strchr(p, ':');
902  if (!p) {
903  p = copy + strlen(copy);
904  break;
905  }
906  p++;
907  }
908 
909  deprecated = strchr(p, ':') != NULL;
910 
911  if (!strcmp(filter->filter->name, "aevalsrc")) {
912  deprecated = 0;
913  while ((p = strchr(p, ':')) && p[1] != ':') {
914  const char *epos = strchr(p + 1, '=');
915  const char *spos = strchr(p + 1, ':');
916  const int next_token_is_opt = epos && (!spos || epos < spos);
917  if (next_token_is_opt) {
918  p++;
919  break;
920  }
921  /* next token does not contain a '=', assume a channel expression */
922  deprecated = 1;
923  *p++ = '|';
924  }
925  if (p && *p == ':') { // double sep '::' found
926  deprecated = 1;
927  memmove(p, p + 1, strlen(p));
928  }
929  } else
930  while ((p = strchr(p, ':')))
931  *p++ = '|';
932 
933  if (deprecated)
934  av_log(filter, AV_LOG_WARNING, "This syntax is deprecated. Use "
935  "'|' to separate the list items.\n");
936 
937  av_log(filter, AV_LOG_DEBUG, "compat: called with args=[%s]\n", copy);
938  ret = process_options(filter, &options, copy);
939  av_freep(&copy);
940 
941  if (ret < 0)
942  goto fail;
943 #endif
944  } else {
945 #if CONFIG_MP_FILTER
946  if (!strcmp(filter->filter->name, "mp")) {
947  char *escaped;
948 
949  if (!strncmp(args, "filter=", 7))
950  args += 7;
951  ret = av_escape(&escaped, args, ":=", AV_ESCAPE_MODE_BACKSLASH, 0);
952  if (ret < 0) {
953  av_log(filter, AV_LOG_ERROR, "Unable to escape MPlayer filters arg '%s'\n", args);
954  goto fail;
955  }
956  ret = process_options(filter, &options, escaped);
957  av_free(escaped);
958  } else
959 #endif
960  ret = process_options(filter, &options, args);
961  if (ret < 0)
962  goto fail;
963  }
964  }
965 
966  ret = avfilter_init_dict(filter, &options);
967  if (ret < 0)
968  goto fail;
969 
970  if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
971  av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);
973  goto fail;
974  }
975 
976 fail:
977  av_dict_free(&options);
978 
979  return ret;
980 }
981 
982 const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
983 {
984  return pads[pad_idx].name;
985 }
986 
987 enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
988 {
989  return pads[pad_idx].type;
990 }
991 
993 {
994  return ff_filter_frame(link->dst->outputs[0], frame);
995 }
996 
998 {
999  int (*filter_frame)(AVFilterLink *, AVFrame *);
1000  AVFilterContext *dstctx = link->dst;
1001  AVFilterPad *dst = link->dstpad;
1002  AVFrame *out = NULL;
1003  int ret;
1004  AVFilterCommand *cmd= link->dst->command_queue;
1005  int64_t pts;
1006 
1007  if (link->closed) {
1008  av_frame_free(&frame);
1009  return AVERROR_EOF;
1010  }
1011 
1012  if (!(filter_frame = dst->filter_frame))
1014 
1015  /* copy the frame if needed */
1016  if (dst->needs_writable && !av_frame_is_writable(frame)) {
1017  av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
1018 
1019  /* Maybe use ff_copy_buffer_ref instead? */
1020  switch (link->type) {
1021  case AVMEDIA_TYPE_VIDEO:
1022  out = ff_get_video_buffer(link, link->w, link->h);
1023  break;
1024  case AVMEDIA_TYPE_AUDIO:
1025  out = ff_get_audio_buffer(link, frame->nb_samples);
1026  break;
1027  default:
1028  ret = AVERROR(EINVAL);
1029  goto fail;
1030  }
1031  if (!out) {
1032  ret = AVERROR(ENOMEM);
1033  goto fail;
1034  }
1035 
1036  ret = av_frame_copy_props(out, frame);
1037  if (ret < 0)
1038  goto fail;
1039 
1040  switch (link->type) {
1041  case AVMEDIA_TYPE_VIDEO:
1042  av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
1043  frame->format, frame->width, frame->height);
1044  break;
1045  case AVMEDIA_TYPE_AUDIO:
1047  0, 0, frame->nb_samples,
1049  frame->format);
1050  break;
1051  default:
1052  ret = AVERROR(EINVAL);
1053  goto fail;
1054  }
1055 
1056  av_frame_free(&frame);
1057  } else
1058  out = frame;
1059 
1060  while(cmd && cmd->time <= out->pts * av_q2d(link->time_base)){
1061  av_log(link->dst, AV_LOG_DEBUG,
1062  "Processing command time:%f command:%s arg:%s\n",
1063  cmd->time, cmd->command, cmd->arg);
1064  avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
1065  ff_command_queue_pop(link->dst);
1066  cmd= link->dst->command_queue;
1067  }
1068 
1069  pts = out->pts;
1070  if (dstctx->enable_str) {
1071  int64_t pos = av_frame_get_pkt_pos(out);
1072  dstctx->var_values[VAR_N] = link->frame_count;
1073  dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
1074  dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
1075 
1076  dstctx->is_disabled = fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) < 0.5;
1077  if (dstctx->is_disabled &&
1080  }
1081  ret = filter_frame(link, out);
1082  link->frame_count++;
1083  link->frame_requested = 0;
1084  ff_update_link_current_pts(link, pts);
1085  return ret;
1086 
1087 fail:
1088  av_frame_free(&out);
1089  av_frame_free(&frame);
1090  return ret;
1091 }
1092 
1094 {
1095  int insamples = frame->nb_samples, inpos = 0, nb_samples;
1096  AVFrame *pbuf = link->partial_buf;
1097  int nb_channels = av_frame_get_channels(frame);
1098  int ret = 0;
1099 
1101  /* Handle framing (min_samples, max_samples) */
1102  while (insamples) {
1103  if (!pbuf) {
1104  AVRational samples_tb = { 1, link->sample_rate };
1105  pbuf = ff_get_audio_buffer(link, link->partial_buf_size);
1106  if (!pbuf) {
1107  av_log(link->dst, AV_LOG_WARNING,
1108  "Samples dropped due to memory allocation failure.\n");
1109  return 0;
1110  }
1111  av_frame_copy_props(pbuf, frame);
1112  pbuf->pts = frame->pts;
1113  if (pbuf->pts != AV_NOPTS_VALUE)
1114  pbuf->pts += av_rescale_q(inpos, samples_tb, link->time_base);
1115  pbuf->nb_samples = 0;
1116  }
1117  nb_samples = FFMIN(insamples,
1118  link->partial_buf_size - pbuf->nb_samples);
1120  pbuf->nb_samples, inpos,
1121  nb_samples, nb_channels, link->format);
1122  inpos += nb_samples;
1123  insamples -= nb_samples;
1124  pbuf->nb_samples += nb_samples;
1125  if (pbuf->nb_samples >= link->min_samples) {
1126  ret = ff_filter_frame_framed(link, pbuf);
1127  pbuf = NULL;
1128  }
1129  }
1130  av_frame_free(&frame);
1131  link->partial_buf = pbuf;
1132  return ret;
1133 }
1134 
1136 {
1137  FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);
1138 
1139  /* Consistency checks */
1140  if (link->type == AVMEDIA_TYPE_VIDEO) {
1141  if (strcmp(link->dst->filter->name, "scale")) {
1142  av_assert1(frame->format == link->format);
1143  av_assert1(frame->width == link->w);
1144  av_assert1(frame->height == link->h);
1145  }
1146  } else {
1147  av_assert1(frame->format == link->format);
1148  av_assert1(av_frame_get_channels(frame) == link->channels);
1149  av_assert1(frame->channel_layout == link->channel_layout);
1150  av_assert1(frame->sample_rate == link->sample_rate);
1151  }
1152 
1153  /* Go directly to actual filtering if possible */
1154  if (link->type == AVMEDIA_TYPE_AUDIO &&
1155  link->min_samples &&
1156  (link->partial_buf ||
1157  frame->nb_samples < link->min_samples ||
1158  frame->nb_samples > link->max_samples)) {
1159  return ff_filter_frame_needs_framing(link, frame);
1160  } else {
1161  return ff_filter_frame_framed(link, frame);
1162  }
1163 }
1164 
1166 {
1167  return &avfilter_class;
1168 }