falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
82667 Commits
32 Branches
283MB
Tree: afb84857bf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'afb84857bf'
${ noResults }
FFmpeg/libavfilter/avfilter.c

1244 lines
38KB
Raw Blame History 

  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"

  26. #include "libavutil/channel_layout.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. #include "audio.h"

  38. #include "avfilter.h"

  39. #include "formats.h"

  40. #include "internal.h"

  41. 

  42. #include "libavutil/ffversion.h"

  43. const char av_filter_ffversion[] = "FFmpeg version " FFMPEG_VERSION;

  44. 

  45. static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame);

  46. 

  47. void ff_tlog_ref(void *ctx, AVFrame *ref, int end)

  48. {

  49.     av_unused char buf[16];

  50.     ff_tlog(ctx,

  51.             "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,

  52.             ref, ref->buf, ref->data[0],

  53.             ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],

  54.             ref->pts, av_frame_get_pkt_pos(ref));

  55. 

  56.     if (ref->width) {

  57.         ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",

  58.                 ref->sample_aspect_ratio.num, ref->sample_aspect_ratio.den,

  59.                 ref->width, ref->height,

  60.                 !ref->interlaced_frame     ? 'P' :         /* Progressive  */

  61.                 ref->top_field_first ? 'T' : 'B',    /* Top / Bottom */

  62.                 ref->key_frame,

  63.                 av_get_picture_type_char(ref->pict_type));

  64.     }

  65.     if (ref->nb_samples) {

  66.         ff_tlog(ctx, " cl:%"PRId64"d n:%d r:%d",

  67.                 ref->channel_layout,

  68.                 ref->nb_samples,

  69.                 ref->sample_rate);

  70.     }

  71. 

  72.     ff_tlog(ctx, "]%s", end ? "\n" : "");

  73. }

  74. 

  75. unsigned avfilter_version(void)

  76. {

  77.     av_assert0(LIBAVFILTER_VERSION_MICRO >= 100);

  78.     return LIBAVFILTER_VERSION_INT;

  79. }

  80. 

  81. const char *avfilter_configuration(void)

  82. {

  83.     return FFMPEG_CONFIGURATION;

  84. }

  85. 

  86. const char *avfilter_license(void)

  87. {

  88. #define LICENSE_PREFIX "libavfilter license: "

  89.     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;

  90. }

  91. 

  92. void ff_command_queue_pop(AVFilterContext *filter)

  93. {

  94.     AVFilterCommand *c= filter->command_queue;

  95.     av_freep(&c->arg);

  96.     av_freep(&c->command);

  97.     filter->command_queue= c->next;

  98.     av_free(c);

  99. }

  100. 

  101. int ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,

  102.                    AVFilterPad **pads, AVFilterLink ***links,

  103.                    AVFilterPad *newpad)

  104. {

  105.     AVFilterLink **newlinks;

  106.     AVFilterPad *newpads;

  107.     unsigned i;

  108. 

  109.     idx = FFMIN(idx, *count);

  110. 

  111.     newpads  = av_realloc_array(*pads,  *count + 1, sizeof(AVFilterPad));

  112.     newlinks = av_realloc_array(*links, *count + 1, sizeof(AVFilterLink*));

  113.     if (newpads)

  114.         *pads  = newpads;

  115.     if (newlinks)

  116.         *links = newlinks;

  117.     if (!newpads || !newlinks)

  118.         return AVERROR(ENOMEM);

  119. 

  120.     memmove(*pads  + idx + 1, *pads  + idx, sizeof(AVFilterPad)   * (*count - idx));

  121.     memmove(*links + idx + 1, *links + idx, sizeof(AVFilterLink*) * (*count - idx));

  122.     memcpy(*pads + idx, newpad, sizeof(AVFilterPad));

  123.     (*links)[idx] = NULL;

  124. 

  125.     (*count)++;

  126.     for (i = idx + 1; i < *count; i++)

  127.         if ((*links)[i])

  128.             (*(unsigned *)((uint8_t *) (*links)[i] + padidx_off))++;

  129. 

  130.     return 0;

  131. }

  132. 

  133. int avfilter_link(AVFilterContext *src, unsigned srcpad,

  134.                   AVFilterContext *dst, unsigned dstpad)

  135. {

  136.     AVFilterLink *link;

  137. 

  138.     if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||

  139.         src->outputs[srcpad]      || dst->inputs[dstpad])

  140.         return AVERROR(EINVAL);

  141. 

  142.     if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {

  143.         av_log(src, AV_LOG_ERROR,

  144.                "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",

  145.                src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),

  146.                dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));

  147.         return AVERROR(EINVAL);

  148.     }

  149. 

  150.     link = av_mallocz(sizeof(*link));

  151.     if (!link)

  152.         return AVERROR(ENOMEM);

  153. 

  154.     src->outputs[srcpad] = dst->inputs[dstpad] = link;

  155. 

  156.     link->src     = src;

  157.     link->dst     = dst;

  158.     link->srcpad  = &src->output_pads[srcpad];

  159.     link->dstpad  = &dst->input_pads[dstpad];

  160.     link->type    = src->output_pads[srcpad].type;

  161.     av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);

  162.     link->format  = -1;

  163. 

  164.     return 0;

  165. }

  166. 

  167. void avfilter_link_free(AVFilterLink **link)

  168. {

  169.     if (!*link)

  170.         return;

  171. 

  172.     av_frame_free(&(*link)->partial_buf);

  173.     ff_video_frame_pool_uninit((FFVideoFramePool**)&(*link)->video_frame_pool);

  174. 

  175.     av_freep(link);

  176. }

  177. 

  178. int avfilter_link_get_channels(AVFilterLink *link)

  179. {

  180.     return link->channels;

  181. }

  182. 

  183. void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)

  184. {

  185.     ff_avfilter_link_set_out_status(link, status, pts);

  186. }

  187. 

  188. void ff_avfilter_link_set_out_status(AVFilterLink *link, int status, int64_t pts)

  189. {

  190.     link->status = status;

  191.     link->frame_wanted_in = link->frame_wanted_out = 0;

  192.     ff_update_link_current_pts(link, pts);

  193. }

  194. 

  195. void avfilter_link_set_closed(AVFilterLink *link, int closed)

  196. {

  197.     ff_avfilter_link_set_out_status(link, closed ? AVERROR_EOF : 0, AV_NOPTS_VALUE);

  198. }

  199. 

  200. int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,

  201.                            unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)

  202. {

  203.     int ret;

  204.     unsigned dstpad_idx = link->dstpad - link->dst->input_pads;

  205. 

  206.     av_log(link->dst, AV_LOG_VERBOSE, "auto-inserting filter '%s' "

  207.            "between the filter '%s' and the filter '%s'\n",

  208.            filt->name, link->src->name, link->dst->name);

  209. 

  210.     link->dst->inputs[dstpad_idx] = NULL;

  211.     if ((ret = avfilter_link(filt, filt_dstpad_idx, link->dst, dstpad_idx)) < 0) {

  212.         /* failed to link output filter to new filter */

  213.         link->dst->inputs[dstpad_idx] = link;

  214.         return ret;

  215.     }

  216. 

  217.     /* re-hookup the link to the new destination filter we inserted */

  218.     link->dst                     = filt;

  219.     link->dstpad                  = &filt->input_pads[filt_srcpad_idx];

  220.     filt->inputs[filt_srcpad_idx] = link;

  221. 

  222.     /* if any information on supported media formats already exists on the

  223.      * link, we need to preserve that */

  224.     if (link->out_formats)

  225.         ff_formats_changeref(&link->out_formats,

  226.                              &filt->outputs[filt_dstpad_idx]->out_formats);

  227.     if (link->out_samplerates)

  228.         ff_formats_changeref(&link->out_samplerates,

  229.                              &filt->outputs[filt_dstpad_idx]->out_samplerates);

  230.     if (link->out_channel_layouts)

  231.         ff_channel_layouts_changeref(&link->out_channel_layouts,

  232.                                      &filt->outputs[filt_dstpad_idx]->out_channel_layouts);

  233. 

  234.     return 0;

  235. }

  236. 

  237. int avfilter_config_links(AVFilterContext *filter)

  238. {

  239.     int (*config_link)(AVFilterLink *);

  240.     unsigned i;

  241.     int ret;

  242. 

  243.     for (i = 0; i < filter->nb_inputs; i ++) {

  244.         AVFilterLink *link = filter->inputs[i];

  245.         AVFilterLink *inlink;

  246. 

  247.         if (!link) continue;

  248.         if (!link->src || !link->dst) {

  249.             av_log(filter, AV_LOG_ERROR,

  250.                    "Not all input and output are properly linked (%d).\n", i);

  251.             return AVERROR(EINVAL);

  252.         }

  253. 

  254.         inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;

  255.         link->current_pts =

  256.         link->current_pts_us = AV_NOPTS_VALUE;

  257. 

  258.         switch (link->init_state) {

  259.         case AVLINK_INIT:

  260.             continue;

  261.         case AVLINK_STARTINIT:

  262.             av_log(filter, AV_LOG_INFO, "circular filter chain detected\n");

  263.             return 0;

  264.         case AVLINK_UNINIT:

  265.             link->init_state = AVLINK_STARTINIT;

  266. 

  267.             if ((ret = avfilter_config_links(link->src)) < 0)

  268.                 return ret;

  269. 

  270.             if (!(config_link = link->srcpad->config_props)) {

  271.                 if (link->src->nb_inputs != 1) {

  272.                     av_log(link->src, AV_LOG_ERROR, "Source filters and filters "

  273.                                                     "with more than one input "

  274.                                                     "must set config_props() "

  275.                                                     "callbacks on all outputs\n");

  276.                     return AVERROR(EINVAL);

  277.                 }

  278.             } else if ((ret = config_link(link)) < 0) {

  279.                 av_log(link->src, AV_LOG_ERROR,

  280.                        "Failed to configure output pad on %s\n",

  281.                        link->src->name);

  282.                 return ret;

  283.             }

  284. 

  285.             switch (link->type) {

  286.             case AVMEDIA_TYPE_VIDEO:

  287.                 if (!link->time_base.num && !link->time_base.den)

  288.                     link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;

  289. 

  290.                 if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)

  291.                     link->sample_aspect_ratio = inlink ?

  292.                         inlink->sample_aspect_ratio : (AVRational){1,1};

  293. 

  294.                 if (inlink) {

  295.                     if (!link->frame_rate.num && !link->frame_rate.den)

  296.                         link->frame_rate = inlink->frame_rate;

  297.                     if (!link->w)

  298.                         link->w = inlink->w;

  299.                     if (!link->h)

  300.                         link->h = inlink->h;

  301.                 } else if (!link->w || !link->h) {

  302.                     av_log(link->src, AV_LOG_ERROR,

  303.                            "Video source filters must set their output link's "

  304.                            "width and height\n");

  305.                     return AVERROR(EINVAL);

  306.                 }

  307.                 break;

  308. 

  309.             case AVMEDIA_TYPE_AUDIO:

  310.                 if (inlink) {

  311.                     if (!link->time_base.num && !link->time_base.den)

  312.                         link->time_base = inlink->time_base;

  313.                 }

  314. 

  315.                 if (!link->time_base.num && !link->time_base.den)

  316.                     link->time_base = (AVRational) {1, link->sample_rate};

  317.             }

  318. 

  319.             if (link->src->nb_inputs && link->src->inputs[0]->hw_frames_ctx &&

  320.                 !link->hw_frames_ctx) {

  321.                 AVHWFramesContext *input_ctx = (AVHWFramesContext*)link->src->inputs[0]->hw_frames_ctx->data;

  322. 

  323.                 if (input_ctx->format == link->format) {

  324.                     link->hw_frames_ctx = av_buffer_ref(link->src->inputs[0]->hw_frames_ctx);

  325.                     if (!link->hw_frames_ctx)

  326.                         return AVERROR(ENOMEM);

  327.                 }

  328.             }

  329. 

  330.             if ((config_link = link->dstpad->config_props))

  331.                 if ((ret = config_link(link)) < 0) {

  332.                     av_log(link->dst, AV_LOG_ERROR,

  333.                            "Failed to configure input pad on %s\n",

  334.                            link->dst->name);

  335.                     return ret;

  336.                 }

  337. 

  338.             link->init_state = AVLINK_INIT;

  339.         }

  340.     }

  341. 

  342.     return 0;

  343. }

  344. 

  345. void ff_tlog_link(void *ctx, AVFilterLink *link, int end)

  346. {

  347.     if (link->type == AVMEDIA_TYPE_VIDEO) {

  348.         ff_tlog(ctx,

  349.                 "link[%p s:%dx%d fmt:%s %s->%s]%s",

  350.                 link, link->w, link->h,

  351.                 av_get_pix_fmt_name(link->format),

  352.                 link->src ? link->src->filter->name : "",

  353.                 link->dst ? link->dst->filter->name : "",

  354.                 end ? "\n" : "");

  355.     } else {

  356.         char buf[128];

  357.         av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);

  358. 

  359.         ff_tlog(ctx,

  360.                 "link[%p r:%d cl:%s fmt:%s %s->%s]%s",

  361.                 link, (int)link->sample_rate, buf,

  362.                 av_get_sample_fmt_name(link->format),

  363.                 link->src ? link->src->filter->name : "",

  364.                 link->dst ? link->dst->filter->name : "",

  365.                 end ? "\n" : "");

  366.     }

  367. }

  368. 

  369. int ff_request_frame(AVFilterLink *link)

  370. {

  371.     FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1);

  372. 

  373.     if (link->status)

  374.         return link->status;

  375.     link->frame_wanted_in = 1;

  376.     link->frame_wanted_out = 1;

  377.     return 0;

  378. }

  379. 

  380. int ff_request_frame_to_filter(AVFilterLink *link)

  381. {

  382.     int ret = -1;

  383. 

  384.     FF_TPRINTF_START(NULL, request_frame_to_filter); ff_tlog_link(NULL, link, 1);

  385.     link->frame_wanted_in = 0;

  386.     if (link->srcpad->request_frame)

  387.         ret = link->srcpad->request_frame(link);

  388.     else if (link->src->inputs[0])

  389.         ret = ff_request_frame(link->src->inputs[0]);

  390.     if (ret == AVERROR_EOF && link->partial_buf) {

  391.         AVFrame *pbuf = link->partial_buf;

  392.         link->partial_buf = NULL;

  393.         ret = ff_filter_frame_framed(link, pbuf);

  394.         ff_avfilter_link_set_in_status(link, AVERROR_EOF, AV_NOPTS_VALUE);

  395.         link->frame_wanted_out = 0;

  396.         return ret;

  397.     }

  398.     if (ret < 0) {

  399.         if (ret != AVERROR(EAGAIN) && ret != link->status)

  400.             ff_avfilter_link_set_in_status(link, ret, AV_NOPTS_VALUE);

  401.     }

  402.     return ret;

  403. }

  404. 

  405. int ff_poll_frame(AVFilterLink *link)

  406. {

  407.     int i, min = INT_MAX;

  408. 

  409.     if (link->srcpad->poll_frame)

  410.         return link->srcpad->poll_frame(link);

  411. 

  412.     for (i = 0; i < link->src->nb_inputs; i++) {

  413.         int val;

  414.         if (!link->src->inputs[i])

  415.             return AVERROR(EINVAL);

  416.         val = ff_poll_frame(link->src->inputs[i]);

  417.         min = FFMIN(min, val);

  418.     }

  419. 

  420.     return min;

  421. }

  422. 

  423. static const char *const var_names[] = {

  424.     "t",

  425.     "n",

  426.     "pos",

  427.     "w",

  428.     "h",

  429.     NULL

  430. };

  431. 

  432. enum {

  433.     VAR_T,

  434.     VAR_N,

  435.     VAR_POS,

  436.     VAR_W,

  437.     VAR_H,

  438.     VAR_VARS_NB

  439. };

  440. 

  441. static int set_enable_expr(AVFilterContext *ctx, const char *expr)

  442. {

  443.     int ret;

  444.     char *expr_dup;

  445.     AVExpr *old = ctx->enable;

  446. 

  447.     if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) {

  448.         av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "

  449.                "with filter '%s'\n", ctx->filter->name);

  450.         return AVERROR_PATCHWELCOME;

  451.     }

  452. 

  453.     expr_dup = av_strdup(expr);

  454.     if (!expr_dup)

  455.         return AVERROR(ENOMEM);

  456. 

  457.     if (!ctx->var_values) {

  458.         ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values));

  459.         if (!ctx->var_values) {

  460.             av_free(expr_dup);

  461.             return AVERROR(ENOMEM);

  462.         }

  463.     }

  464. 

  465.     ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names,

  466.                         NULL, NULL, NULL, NULL, 0, ctx->priv);

  467.     if (ret < 0) {

  468.         av_log(ctx->priv, AV_LOG_ERROR,

  469.                "Error when evaluating the expression '%s' for enable\n",

  470.                expr_dup);

  471.         av_free(expr_dup);

  472.         return ret;

  473.     }

  474. 

  475.     av_expr_free(old);

  476.     av_free(ctx->enable_str);

  477.     ctx->enable_str = expr_dup;

  478.     return 0;

  479. }

  480. 

  481. void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)

  482. {

  483.     if (pts == AV_NOPTS_VALUE)

  484.         return;

  485.     link->current_pts = pts;

  486.     link->current_pts_us = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);

  487.     /* TODO use duration */

  488.     if (link->graph && link->age_index >= 0)

  489.         ff_avfilter_graph_update_heap(link->graph, link);

  490. }

  491. 

  492. int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)

  493. {

  494.     if(!strcmp(cmd, "ping")){

  495.         char local_res[256] = {0};

  496. 

  497.         if (!res) {

  498.             res = local_res;

  499.             res_len = sizeof(local_res);

  500.         }

  501.         av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);

  502.         if (res == local_res)

  503.             av_log(filter, AV_LOG_INFO, "%s", res);

  504.         return 0;

  505.     }else if(!strcmp(cmd, "enable")) {

  506.         return set_enable_expr(filter, arg);

  507.     }else if(filter->filter->process_command) {

  508.         return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);

  509.     }

  510.     return AVERROR(ENOSYS);

  511. }

  512. 

  513. static AVFilter *first_filter;

  514. static AVFilter **last_filter = &first_filter;

  515. 

  516. #if !FF_API_NOCONST_GET_NAME

  517. const

  518. #endif

  519. AVFilter *avfilter_get_by_name(const char *name)

  520. {

  521.     const AVFilter *f = NULL;

  522. 

  523.     if (!name)

  524.         return NULL;

  525. 

  526.     while ((f = avfilter_next(f)))

  527.         if (!strcmp(f->name, name))

  528.             return (AVFilter *)f;

  529. 

  530.     return NULL;

  531. }

  532. 

  533. int avfilter_register(AVFilter *filter)

  534. {

  535.     AVFilter **f = last_filter;

  536. 

  537.     /* the filter must select generic or internal exclusively */

  538.     av_assert0((filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE) != AVFILTER_FLAG_SUPPORT_TIMELINE);

  539. 

  540.     filter->next = NULL;

  541. 

  542.     while(*f || avpriv_atomic_ptr_cas((void * volatile *)f, NULL, filter))

  543.         f = &(*f)->next;

  544.     last_filter = &filter->next;

  545. 

  546.     return 0;

  547. }

  548. 

  549. const AVFilter *avfilter_next(const AVFilter *prev)

  550. {

  551.     return prev ? prev->next : first_filter;

  552. }

  553. 

  554. #if FF_API_OLD_FILTER_REGISTER

  555. AVFilter **av_filter_next(AVFilter **filter)

  556. {

  557.     return filter ? &(*filter)->next : &first_filter;

  558. }

  559. 

  560. void avfilter_uninit(void)

  561. {

  562. }

  563. #endif

  564. 

  565. int avfilter_pad_count(const AVFilterPad *pads)

  566. {

  567.     int count;

  568. 

  569.     if (!pads)

  570.         return 0;

  571. 

  572.     for (count = 0; pads->name; count++)

  573.         pads++;

  574.     return count;

  575. }

  576. 

  577. static const char *default_filter_name(void *filter_ctx)

  578. {

  579.     AVFilterContext *ctx = filter_ctx;

  580.     return ctx->name ? ctx->name : ctx->filter->name;

  581. }

  582. 

  583. static void *filter_child_next(void *obj, void *prev)

  584. {

  585.     AVFilterContext *ctx = obj;

  586.     if (!prev && ctx->filter && ctx->filter->priv_class && ctx->priv)

  587.         return ctx->priv;

  588.     return NULL;

  589. }

  590. 

  591. static const AVClass *filter_child_class_next(const AVClass *prev)

  592. {

  593.     const AVFilter *f = NULL;

  594. 

  595.     /* find the filter that corresponds to prev */

  596.     while (prev && (f = avfilter_next(f)))

  597.         if (f->priv_class == prev)

  598.             break;

  599. 

  600.     /* could not find filter corresponding to prev */

  601.     if (prev && !f)

  602.         return NULL;

  603. 

  604.     /* find next filter with specific options */

  605.     while ((f = avfilter_next(f)))

  606.         if (f->priv_class)

  607.             return f->priv_class;

  608. 

  609.     return NULL;

  610. }

  611. 

  612. #define OFFSET(x) offsetof(AVFilterContext, x)

  613. #define FLAGS AV_OPT_FLAG_FILTERING_PARAM

  614. static const AVOption avfilter_options[] = {

  615.     { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,

  616.         { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },

  617.         { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .unit = "thread_type" },

  618.     { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },

  619.     { "threads", "Allowed number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,

  620.         { .i64 = 0 }, 0, INT_MAX, FLAGS },

  621.     { NULL },

  622. };

  623. 

  624. static const AVClass avfilter_class = {

  625.     .class_name = "AVFilter",

  626.     .item_name  = default_filter_name,

  627.     .version    = LIBAVUTIL_VERSION_INT,

  628.     .category   = AV_CLASS_CATEGORY_FILTER,

  629.     .child_next = filter_child_next,

  630.     .child_class_next = filter_child_class_next,

  631.     .option           = avfilter_options,

  632. };

  633. 

  634. static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg,

  635.                            int *ret, int nb_jobs)

  636. {

  637.     int i;

  638. 

  639.     for (i = 0; i < nb_jobs; i++) {

  640.         int r = func(ctx, arg, i, nb_jobs);

  641.         if (ret)

  642.             ret[i] = r;

  643.     }

  644.     return 0;

  645. }

  646. 

  647. AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)

  648. {

  649.     AVFilterContext *ret;

  650. 

  651.     if (!filter)

  652.         return NULL;

  653. 

  654.     ret = av_mallocz(sizeof(AVFilterContext));

  655.     if (!ret)

  656.         return NULL;

  657. 

  658.     ret->av_class = &avfilter_class;

  659.     ret->filter   = filter;

  660.     ret->name     = inst_name ? av_strdup(inst_name) : NULL;

  661.     if (filter->priv_size) {

  662.         ret->priv     = av_mallocz(filter->priv_size);

  663.         if (!ret->priv)

  664.             goto err;

  665.     }

  666. 

  667.     av_opt_set_defaults(ret);

  668.     if (filter->priv_class) {

  669.         *(const AVClass**)ret->priv = filter->priv_class;

  670.         av_opt_set_defaults(ret->priv);

  671.     }

  672. 

  673.     ret->internal = av_mallocz(sizeof(*ret->internal));

  674.     if (!ret->internal)

  675.         goto err;

  676.     ret->internal->execute = default_execute;

  677. 

  678.     ret->nb_inputs = avfilter_pad_count(filter->inputs);

  679.     if (ret->nb_inputs ) {

  680.         ret->input_pads   = av_malloc_array(ret->nb_inputs, sizeof(AVFilterPad));

  681.         if (!ret->input_pads)

  682.             goto err;

  683.         memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);

  684.         ret->inputs       = av_mallocz_array(ret->nb_inputs, sizeof(AVFilterLink*));

  685.         if (!ret->inputs)

  686.             goto err;

  687.     }

  688. 

  689.     ret->nb_outputs = avfilter_pad_count(filter->outputs);

  690.     if (ret->nb_outputs) {

  691.         ret->output_pads  = av_malloc_array(ret->nb_outputs, sizeof(AVFilterPad));

  692.         if (!ret->output_pads)

  693.             goto err;

  694.         memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);

  695.         ret->outputs      = av_mallocz_array(ret->nb_outputs, sizeof(AVFilterLink*));

  696.         if (!ret->outputs)

  697.             goto err;

  698.     }

  699. 

  700.     return ret;

  701. 

  702. err:

  703.     av_freep(&ret->inputs);

  704.     av_freep(&ret->input_pads);

  705.     ret->nb_inputs = 0;

  706.     av_freep(&ret->outputs);

  707.     av_freep(&ret->output_pads);

  708.     ret->nb_outputs = 0;

  709.     av_freep(&ret->priv);

  710.     av_freep(&ret->internal);

  711.     av_free(ret);

  712.     return NULL;

  713. }

  714. 

  715. #if FF_API_AVFILTER_OPEN

  716. int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)

  717. {

  718.     *filter_ctx = ff_filter_alloc(filter, inst_name);

  719.     return *filter_ctx ? 0 : AVERROR(ENOMEM);

  720. }

  721. #endif

  722. 

  723. static void free_link(AVFilterLink *link)

  724. {

  725.     if (!link)

  726.         return;

  727. 

  728.     if (link->src)

  729.         link->src->outputs[link->srcpad - link->src->output_pads] = NULL;

  730.     if (link->dst)

  731.         link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;

  732. 

  733.     av_buffer_unref(&link->hw_frames_ctx);

  734. 

  735.     ff_formats_unref(&link->in_formats);

  736.     ff_formats_unref(&link->out_formats);

  737.     ff_formats_unref(&link->in_samplerates);

  738.     ff_formats_unref(&link->out_samplerates);

  739.     ff_channel_layouts_unref(&link->in_channel_layouts);

  740.     ff_channel_layouts_unref(&link->out_channel_layouts);

  741.     avfilter_link_free(&link);

  742. }

  743. 

  744. void avfilter_free(AVFilterContext *filter)

  745. {

  746.     int i;

  747. 

  748.     if (!filter)

  749.         return;

  750. 

  751.     if (filter->graph)

  752.         ff_filter_graph_remove_filter(filter->graph, filter);

  753. 

  754.     if (filter->filter->uninit)

  755.         filter->filter->uninit(filter);

  756. 

  757.     for (i = 0; i < filter->nb_inputs; i++) {

  758.         free_link(filter->inputs[i]);

  759.     }

  760.     for (i = 0; i < filter->nb_outputs; i++) {

  761.         free_link(filter->outputs[i]);

  762.     }

  763. 

  764.     if (filter->filter->priv_class)

  765.         av_opt_free(filter->priv);

  766. 

  767.     av_buffer_unref(&filter->hw_device_ctx);

  768. 

  769.     av_freep(&filter->name);

  770.     av_freep(&filter->input_pads);

  771.     av_freep(&filter->output_pads);

  772.     av_freep(&filter->inputs);

  773.     av_freep(&filter->outputs);

  774.     av_freep(&filter->priv);

  775.     while(filter->command_queue){

  776.         ff_command_queue_pop(filter);

  777.     }

  778.     av_opt_free(filter);

  779.     av_expr_free(filter->enable);

  780.     filter->enable = NULL;

  781.     av_freep(&filter->var_values);

  782.     av_freep(&filter->internal);

  783.     av_free(filter);

  784. }

  785. 

  786. int ff_filter_get_nb_threads(AVFilterContext *ctx)

  787. {

  788.      if (ctx->nb_threads > 0)

  789.          return FFMIN(ctx->nb_threads, ctx->graph->nb_threads);

  790.      return ctx->graph->nb_threads;

  791. }

  792. 

  793. static int process_options(AVFilterContext *ctx, AVDictionary **options,

  794.                            const char *args)

  795. {

  796.     const AVOption *o = NULL;

  797.     int ret, count = 0;

  798.     char *av_uninit(parsed_key), *av_uninit(value);

  799.     const char *key;

  800.     int offset= -1;

  801. 

  802.     if (!args)

  803.         return 0;

  804. 

  805.     while (*args) {

  806.         const char *shorthand = NULL;

  807. 

  808.         o = av_opt_next(ctx->priv, o);

  809.         if (o) {

  810.             if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)

  811.                 continue;

  812.             offset = o->offset;

  813.             shorthand = o->name;

  814.         }

  815. 

  816.         ret = av_opt_get_key_value(&args, "=", ":",

  817.                                    shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,

  818.                                    &parsed_key, &value);

  819.         if (ret < 0) {

  820.             if (ret == AVERROR(EINVAL))

  821.                 av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args);

  822.             else

  823.                 av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,

  824.                        av_err2str(ret));

  825.             return ret;

  826.         }

  827.         if (*args)

  828.             args++;

  829.         if (parsed_key) {

  830.             key = parsed_key;

  831.             while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */

  832.         } else {

  833.             key = shorthand;

  834.         }

  835. 

  836.         av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);

  837. 

  838.         if (av_opt_find(ctx, key, NULL, 0, 0)) {

  839.             ret = av_opt_set(ctx, key, value, 0);

  840.             if (ret < 0) {

  841.                 av_free(value);

  842.                 av_free(parsed_key);

  843.                 return ret;

  844.             }

  845.         } else {

  846.         av_dict_set(options, key, value, 0);

  847.         if ((ret = av_opt_set(ctx->priv, key, value, 0)) < 0) {

  848.             if (!av_opt_find(ctx->priv, key, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) {

  849.             if (ret == AVERROR_OPTION_NOT_FOUND)

  850.                 av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);

  851.             av_free(value);

  852.             av_free(parsed_key);

  853.             return ret;

  854.             }

  855.         }

  856.         }

  857. 

  858.         av_free(value);

  859.         av_free(parsed_key);

  860.         count++;

  861.     }

  862. 

  863.     if (ctx->enable_str) {

  864.         ret = set_enable_expr(ctx, ctx->enable_str);

  865.         if (ret < 0)

  866.             return ret;

  867.     }

  868.     return count;

  869. }

  870. 

  871. #if FF_API_AVFILTER_INIT_FILTER

  872. int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque)

  873. {

  874.     return avfilter_init_str(filter, args);

  875. }

  876. #endif

  877. 

  878. int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)

  879. {

  880.     int ret = 0;

  881. 

  882.     ret = av_opt_set_dict(ctx, options);

  883.     if (ret < 0) {

  884.         av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");

  885.         return ret;

  886.     }

  887. 

  888.     if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&

  889.         ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&

  890.         ctx->graph->internal->thread_execute) {

  891.         ctx->thread_type       = AVFILTER_THREAD_SLICE;

  892.         ctx->internal->execute = ctx->graph->internal->thread_execute;

  893.     } else {

  894.         ctx->thread_type = 0;

  895.     }

  896. 

  897.     if (ctx->filter->priv_class) {

  898.         ret = av_opt_set_dict(ctx->priv, options);

  899.         if (ret < 0) {

  900.             av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");

  901.             return ret;

  902.         }

  903.     }

  904. 

  905.     if (ctx->filter->init_opaque)

  906.         ret = ctx->filter->init_opaque(ctx, NULL);

  907.     else if (ctx->filter->init)

  908.         ret = ctx->filter->init(ctx);

  909.     else if (ctx->filter->init_dict)

  910.         ret = ctx->filter->init_dict(ctx, options);

  911. 

  912.     return ret;

  913. }

  914. 

  915. int avfilter_init_str(AVFilterContext *filter, const char *args)

  916. {

  917.     AVDictionary *options = NULL;

  918.     AVDictionaryEntry *e;

  919.     int ret = 0;

  920. 

  921.     if (args && *args) {

  922.         if (!filter->filter->priv_class) {

  923.             av_log(filter, AV_LOG_ERROR, "This filter does not take any "

  924.                    "options, but options were provided: %s.\n", args);

  925.             return AVERROR(EINVAL);

  926.         }

  927. 

  928. #if FF_API_OLD_FILTER_OPTS || FF_API_OLD_FILTER_OPTS_ERROR

  929.             if (   !strcmp(filter->filter->name, "format")     ||

  930.                    !strcmp(filter->filter->name, "noformat")   ||

  931.                    !strcmp(filter->filter->name, "frei0r")     ||

  932.                    !strcmp(filter->filter->name, "frei0r_src") ||

  933.                    !strcmp(filter->filter->name, "ocv")        ||

  934.                    !strcmp(filter->filter->name, "pan")        ||

  935.                    !strcmp(filter->filter->name, "pp")         ||

  936.                    !strcmp(filter->filter->name, "aevalsrc")) {

  937.             /* a hack for compatibility with the old syntax

  938.              * replace colons with |s */

  939.             char *copy = av_strdup(args);

  940.             char *p    = copy;

  941.             int nb_leading = 0; // number of leading colons to skip

  942.             int deprecated = 0;

  943. 

  944.             if (!copy) {

  945.                 ret = AVERROR(ENOMEM);

  946.                 goto fail;

  947.             }

  948. 

  949.             if (!strcmp(filter->filter->name, "frei0r") ||

  950.                 !strcmp(filter->filter->name, "ocv"))

  951.                 nb_leading = 1;

  952.             else if (!strcmp(filter->filter->name, "frei0r_src"))

  953.                 nb_leading = 3;

  954. 

  955.             while (nb_leading--) {

  956.                 p = strchr(p, ':');

  957.                 if (!p) {

  958.                     p = copy + strlen(copy);

  959.                     break;

  960.                 }

  961.                 p++;

  962.             }

  963. 

  964.             deprecated = strchr(p, ':') != NULL;

  965. 

  966.             if (!strcmp(filter->filter->name, "aevalsrc")) {

  967.                 deprecated = 0;

  968.                 while ((p = strchr(p, ':')) && p[1] != ':') {

  969.                     const char *epos = strchr(p + 1, '=');

  970.                     const char *spos = strchr(p + 1, ':');

  971.                     const int next_token_is_opt = epos && (!spos || epos < spos);

  972.                     if (next_token_is_opt) {

  973.                         p++;

  974.                         break;

  975.                     }

  976.                     /* next token does not contain a '=', assume a channel expression */

  977.                     deprecated = 1;

  978.                     *p++ = '|';

  979.                 }

  980.                 if (p && *p == ':') { // double sep '::' found

  981.                     deprecated = 1;

  982.                     memmove(p, p + 1, strlen(p));

  983.                 }

  984.             } else

  985.             while ((p = strchr(p, ':')))

  986.                 *p++ = '|';

  987. 

  988. #if FF_API_OLD_FILTER_OPTS

  989.             if (deprecated)

  990.                 av_log(filter, AV_LOG_WARNING, "This syntax is deprecated. Use "

  991.                        "'|' to separate the list items.\n");

  992. 

  993.             av_log(filter, AV_LOG_DEBUG, "compat: called with args=[%s]\n", copy);

  994.             ret = process_options(filter, &options, copy);

  995. #else

  996.             if (deprecated) {

  997.                 av_log(filter, AV_LOG_ERROR, "This syntax is deprecated. Use "

  998.                        "'|' to separate the list items ('%s' instead of '%s')\n",

  999.                        copy, args);

  1000.                 ret = AVERROR(EINVAL);

  1001.             } else {

  1002.                 ret = process_options(filter, &options, copy);

  1003.             }

  1004. #endif

  1005.             av_freep(&copy);

  1006. 

  1007.             if (ret < 0)

  1008.                 goto fail;

  1009.         } else

  1010. #endif

  1011.         {

  1012.             ret = process_options(filter, &options, args);

  1013.             if (ret < 0)

  1014.                 goto fail;

  1015.         }

  1016.     }

  1017. 

  1018.     ret = avfilter_init_dict(filter, &options);

  1019.     if (ret < 0)

  1020.         goto fail;

  1021. 

  1022.     if ((e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX))) {

  1023.         av_log(filter, AV_LOG_ERROR, "No such option: %s.\n", e->key);

  1024.         ret = AVERROR_OPTION_NOT_FOUND;

  1025.         goto fail;

  1026.     }

  1027. 

  1028. fail:

  1029.     av_dict_free(&options);

  1030. 

  1031.     return ret;

  1032. }

  1033. 

  1034. const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)

  1035. {

  1036.     return pads[pad_idx].name;

  1037. }

  1038. 

  1039. enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)

  1040. {

  1041.     return pads[pad_idx].type;

  1042. }

  1043. 

  1044. static int default_filter_frame(AVFilterLink *link, AVFrame *frame)

  1045. {

  1046.     return ff_filter_frame(link->dst->outputs[0], frame);

  1047. }

  1048. 

  1049. static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)

  1050. {

  1051.     int (*filter_frame)(AVFilterLink *, AVFrame *);

  1052.     AVFilterContext *dstctx = link->dst;

  1053.     AVFilterPad *dst = link->dstpad;

  1054.     AVFrame *out = NULL;

  1055.     int ret;

  1056.     AVFilterCommand *cmd= link->dst->command_queue;

  1057.     int64_t pts;

  1058. 

  1059.     if (link->status) {

  1060.         av_frame_free(&frame);

  1061.         return link->status;

  1062.     }

  1063. 

  1064.     if (!(filter_frame = dst->filter_frame))

  1065.         filter_frame = default_filter_frame;

  1066. 

  1067.     /* copy the frame if needed */

  1068.     if (dst->needs_writable && !av_frame_is_writable(frame)) {

  1069.         av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");

  1070. 

  1071.         switch (link->type) {

  1072.         case AVMEDIA_TYPE_VIDEO:

  1073.             out = ff_get_video_buffer(link, link->w, link->h);

  1074.             break;

  1075.         case AVMEDIA_TYPE_AUDIO:

  1076.             out = ff_get_audio_buffer(link, frame->nb_samples);

  1077.             break;

  1078.         default:

  1079.             ret = AVERROR(EINVAL);

  1080.             goto fail;

  1081.         }

  1082.         if (!out) {

  1083.             ret = AVERROR(ENOMEM);

  1084.             goto fail;

  1085.         }

  1086. 

  1087.         ret = av_frame_copy_props(out, frame);

  1088.         if (ret < 0)

  1089.             goto fail;

  1090. 

  1091.         switch (link->type) {

  1092.         case AVMEDIA_TYPE_VIDEO:

  1093.             av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,

  1094.                           frame->format, frame->width, frame->height);

  1095.             break;

  1096.         case AVMEDIA_TYPE_AUDIO:

  1097.             av_samples_copy(out->extended_data, frame->extended_data,

  1098.                             0, 0, frame->nb_samples,

  1099.                             av_get_channel_layout_nb_channels(frame->channel_layout),

  1100.                             frame->format);

  1101.             break;

  1102.         default:

  1103.             ret = AVERROR(EINVAL);

  1104.             goto fail;

  1105.         }

  1106. 

  1107.         av_frame_free(&frame);

  1108.     } else

  1109.         out = frame;

  1110. 

  1111.     while(cmd && cmd->time <= out->pts * av_q2d(link->time_base)){

  1112.         av_log(link->dst, AV_LOG_DEBUG,

  1113.                "Processing command time:%f command:%s arg:%s\n",

  1114.                cmd->time, cmd->command, cmd->arg);

  1115.         avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);

  1116.         ff_command_queue_pop(link->dst);

  1117.         cmd= link->dst->command_queue;

  1118.     }

  1119. 

  1120.     pts = out->pts;

  1121.     if (dstctx->enable_str) {

  1122.         int64_t pos = av_frame_get_pkt_pos(out);

  1123.         dstctx->var_values[VAR_N] = link->frame_count_out;

  1124.         dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);

  1125.         dstctx->var_values[VAR_W] = link->w;

  1126.         dstctx->var_values[VAR_H] = link->h;

  1127.         dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;

  1128. 

  1129.         dstctx->is_disabled = fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) < 0.5;

  1130.         if (dstctx->is_disabled &&

  1131.             (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))

  1132.             filter_frame = default_filter_frame;

  1133.     }

  1134.     ret = filter_frame(link, out);

  1135.     link->frame_count_out++;

  1136.     ff_update_link_current_pts(link, pts);

  1137.     return ret;

  1138. 

  1139. fail:

  1140.     av_frame_free(&out);

  1141.     av_frame_free(&frame);

  1142.     return ret;

  1143. }

  1144. 

  1145. static int ff_filter_frame_needs_framing(AVFilterLink *link, AVFrame *frame)

  1146. {

  1147.     int insamples = frame->nb_samples, inpos = 0, nb_samples;

  1148.     AVFrame *pbuf = link->partial_buf;

  1149.     int nb_channels = av_frame_get_channels(frame);

  1150.     int ret = 0;

  1151. 

  1152.     /* Handle framing (min_samples, max_samples) */

  1153.     while (insamples) {

  1154.         if (!pbuf) {

  1155.             AVRational samples_tb = { 1, link->sample_rate };

  1156.             pbuf = ff_get_audio_buffer(link, link->partial_buf_size);

  1157.             if (!pbuf) {

  1158.                 av_log(link->dst, AV_LOG_WARNING,

  1159.                        "Samples dropped due to memory allocation failure.\n");

  1160.                 return 0;

  1161.             }

  1162.             av_frame_copy_props(pbuf, frame);

  1163.             pbuf->pts = frame->pts;

  1164.             if (pbuf->pts != AV_NOPTS_VALUE)

  1165.                 pbuf->pts += av_rescale_q(inpos, samples_tb, link->time_base);

  1166.             pbuf->nb_samples = 0;

  1167.         }

  1168.         nb_samples = FFMIN(insamples,

  1169.                            link->partial_buf_size - pbuf->nb_samples);

  1170.         av_samples_copy(pbuf->extended_data, frame->extended_data,

  1171.                         pbuf->nb_samples, inpos,

  1172.                         nb_samples, nb_channels, link->format);

  1173.         inpos                   += nb_samples;

  1174.         insamples               -= nb_samples;

  1175.         pbuf->nb_samples += nb_samples;

  1176.         if (pbuf->nb_samples >= link->min_samples) {

  1177.             ret = ff_filter_frame_framed(link, pbuf);

  1178.             pbuf = NULL;

  1179.         } else {

  1180.             if (link->frame_wanted_out)

  1181.                 link->frame_wanted_in = 1;

  1182.         }

  1183.     }

  1184.     av_frame_free(&frame);

  1185.     link->partial_buf = pbuf;

  1186.     return ret;

  1187. }

  1188. 

  1189. int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

  1190. {

  1191.     FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);

  1192. 

  1193.     /* Consistency checks */

  1194.     if (link->type == AVMEDIA_TYPE_VIDEO) {

  1195.         if (strcmp(link->dst->filter->name, "buffersink") &&

  1196.             strcmp(link->dst->filter->name, "format") &&

  1197.             strcmp(link->dst->filter->name, "idet") &&

  1198.             strcmp(link->dst->filter->name, "null") &&

  1199.             strcmp(link->dst->filter->name, "scale")) {

  1200.             av_assert1(frame->format                 == link->format);

  1201.             av_assert1(frame->width               == link->w);

  1202.             av_assert1(frame->height               == link->h);

  1203.         }

  1204.     } else {

  1205.         if (frame->format != link->format) {

  1206.             av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");

  1207.             goto error;

  1208.         }

  1209.         if (av_frame_get_channels(frame) != link->channels) {

  1210.             av_log(link->dst, AV_LOG_ERROR, "Channel count change is not supported\n");

  1211.             goto error;

  1212.         }

  1213.         if (frame->channel_layout != link->channel_layout) {

  1214.             av_log(link->dst, AV_LOG_ERROR, "Channel layout change is not supported\n");

  1215.             goto error;

  1216.         }

  1217.         if (frame->sample_rate != link->sample_rate) {

  1218.             av_log(link->dst, AV_LOG_ERROR, "Sample rate change is not supported\n");

  1219.             goto error;

  1220.         }

  1221.     }

  1222. 

  1223.     link->frame_wanted_out = 0;

  1224.     link->frame_count_in++;

  1225.     /* Go directly to actual filtering if possible */

  1226.     if (link->type == AVMEDIA_TYPE_AUDIO &&

  1227.         link->min_samples &&

  1228.         (link->partial_buf ||

  1229.          frame->nb_samples < link->min_samples ||

  1230.          frame->nb_samples > link->max_samples)) {

  1231.         return ff_filter_frame_needs_framing(link, frame);

  1232.     } else {

  1233.         return ff_filter_frame_framed(link, frame);

  1234.     }

  1235. error:

  1236.     av_frame_free(&frame);

  1237.     return AVERROR_PATCHWELCOME;

  1238. }

  1239. 

  1240. const AVClass *avfilter_get_class(void)

  1241. {

  1242.     return &avfilter_class;

  1243. }