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.
81493 Commits
32 Branches
283MB
Tree: 449339084f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '449339084f'
${ noResults }
FFmpeg/libavfilter/avfilter.c

1236 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 ((config_link = link->dstpad->config_props))

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

  321.                     av_log(link->dst, AV_LOG_ERROR,

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

  323.                            link->dst->name);

  324.                     return ret;

  325.                 }

  326. 

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

  328.                 !link->hw_frames_ctx) {

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

  330. 

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

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

  333.                     if (!link->hw_frames_ctx)

  334.                         return AVERROR(ENOMEM);

  335.                 }

  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. static int process_options(AVFilterContext *ctx, AVDictionary **options,

  787.                            const char *args)

  788. {

  789.     const AVOption *o = NULL;

  790.     int ret, count = 0;

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

  792.     const char *key;

  793.     int offset= -1;

  794. 

  795.     if (!args)

  796.         return 0;

  797. 

  798.     while (*args) {

  799.         const char *shorthand = NULL;

  800. 

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

  802.         if (o) {

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

  804.                 continue;

  805.             offset = o->offset;

  806.             shorthand = o->name;

  807.         }

  808. 

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

  810.                                    shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,

  811.                                    &parsed_key, &value);

  812.         if (ret < 0) {

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

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

  815.             else

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

  817.                        av_err2str(ret));

  818.             return ret;

  819.         }

  820.         if (*args)

  821.             args++;

  822.         if (parsed_key) {

  823.             key = parsed_key;

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

  825.         } else {

  826.             key = shorthand;

  827.         }

  828. 

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

  830. 

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

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

  833.             if (ret < 0) {

  834.                 av_free(value);

  835.                 av_free(parsed_key);

  836.                 return ret;

  837.             }

  838.         } else {

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

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

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

  842.             if (ret == AVERROR_OPTION_NOT_FOUND)

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

  844.             av_free(value);

  845.             av_free(parsed_key);

  846.             return ret;

  847.             }

  848.         }

  849.         }

  850. 

  851.         av_free(value);

  852.         av_free(parsed_key);

  853.         count++;

  854.     }

  855. 

  856.     if (ctx->enable_str) {

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

  858.         if (ret < 0)

  859.             return ret;

  860.     }

  861.     return count;

  862. }

  863. 

  864. #if FF_API_AVFILTER_INIT_FILTER

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

  866. {

  867.     return avfilter_init_str(filter, args);

  868. }

  869. #endif

  870. 

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

  872. {

  873.     int ret = 0;

  874. 

  875.     ret = av_opt_set_dict(ctx, options);

  876.     if (ret < 0) {

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

  878.         return ret;

  879.     }

  880. 

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

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

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

  884.         ctx->thread_type       = AVFILTER_THREAD_SLICE;

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

  886.     } else {

  887.         ctx->thread_type = 0;

  888.     }

  889. 

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

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

  892.         if (ret < 0) {

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

  894.             return ret;

  895.         }

  896.     }

  897. 

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

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

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

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

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

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

  904. 

  905.     return ret;

  906. }

  907. 

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

  909. {

  910.     AVDictionary *options = NULL;

  911.     AVDictionaryEntry *e;

  912.     int ret = 0;

  913. 

  914.     if (args && *args) {

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

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

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

  918.             return AVERROR(EINVAL);

  919.         }

  920. 

  921. #if FF_API_OLD_FILTER_OPTS || FF_API_OLD_FILTER_OPTS_ERROR

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

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

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

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

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

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

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

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

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

  931.              * replace colons with |s */

  932.             char *copy = av_strdup(args);

  933.             char *p    = copy;

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

  935.             int deprecated = 0;

  936. 

  937.             if (!copy) {

  938.                 ret = AVERROR(ENOMEM);

  939.                 goto fail;

  940.             }

  941. 

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

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

  944.                 nb_leading = 1;

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

  946.                 nb_leading = 3;

  947. 

  948.             while (nb_leading--) {

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

  950.                 if (!p) {

  951.                     p = copy + strlen(copy);

  952.                     break;

  953.                 }

  954.                 p++;

  955.             }

  956. 

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

  958. 

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

  960.                 deprecated = 0;

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

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

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

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

  965.                     if (next_token_is_opt) {

  966.                         p++;

  967.                         break;

  968.                     }

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

  970.                     deprecated = 1;

  971.                     *p++ = '|';

  972.                 }

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

  974.                     deprecated = 1;

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

  976.                 }

  977.             } else

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

  979.                 *p++ = '|';

  980. 

  981. #if FF_API_OLD_FILTER_OPTS

  982.             if (deprecated)

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

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

  985. 

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

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

  988. #else

  989.             if (deprecated) {

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

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

  992.                        copy, args);

  993.                 ret = AVERROR(EINVAL);

  994.             } else {

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

  996.             }

  997. #endif

  998.             av_freep(&copy);

  999. 

  1000.             if (ret < 0)

  1001.                 goto fail;

  1002.         } else

  1003. #endif

  1004.         {

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

  1006.             if (ret < 0)

  1007.                 goto fail;

  1008.         }

  1009.     }

  1010. 

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

  1012.     if (ret < 0)

  1013.         goto fail;

  1014. 

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

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

  1017.         ret = AVERROR_OPTION_NOT_FOUND;

  1018.         goto fail;

  1019.     }

  1020. 

  1021. fail:

  1022.     av_dict_free(&options);

  1023. 

  1024.     return ret;

  1025. }

  1026. 

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

  1028. {

  1029.     return pads[pad_idx].name;

  1030. }

  1031. 

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

  1033. {

  1034.     return pads[pad_idx].type;

  1035. }

  1036. 

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

  1038. {

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

  1040. }

  1041. 

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

  1043. {

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

  1045.     AVFilterContext *dstctx = link->dst;

  1046.     AVFilterPad *dst = link->dstpad;

  1047.     AVFrame *out = NULL;

  1048.     int ret;

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

  1050.     int64_t pts;

  1051. 

  1052.     if (link->status) {

  1053.         av_frame_free(&frame);

  1054.         return link->status;

  1055.     }

  1056. 

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

  1058.         filter_frame = default_filter_frame;

  1059. 

  1060.     /* copy the frame if needed */

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

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

  1063. 

  1064.         switch (link->type) {

  1065.         case AVMEDIA_TYPE_VIDEO:

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

  1067.             break;

  1068.         case AVMEDIA_TYPE_AUDIO:

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

  1070.             break;

  1071.         default:

  1072.             ret = AVERROR(EINVAL);

  1073.             goto fail;

  1074.         }

  1075.         if (!out) {

  1076.             ret = AVERROR(ENOMEM);

  1077.             goto fail;

  1078.         }

  1079. 

  1080.         ret = av_frame_copy_props(out, frame);

  1081.         if (ret < 0)

  1082.             goto fail;

  1083. 

  1084.         switch (link->type) {

  1085.         case AVMEDIA_TYPE_VIDEO:

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

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

  1088.             break;

  1089.         case AVMEDIA_TYPE_AUDIO:

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

  1091.                             0, 0, frame->nb_samples,

  1092.                             av_get_channel_layout_nb_channels(frame->channel_layout),

  1093.                             frame->format);

  1094.             break;

  1095.         default:

  1096.             ret = AVERROR(EINVAL);

  1097.             goto fail;

  1098.         }

  1099. 

  1100.         av_frame_free(&frame);

  1101.     } else

  1102.         out = frame;

  1103. 

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

  1105.         av_log(link->dst, AV_LOG_DEBUG,

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

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

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

  1109.         ff_command_queue_pop(link->dst);

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

  1111.     }

  1112. 

  1113.     pts = out->pts;

  1114.     if (dstctx->enable_str) {

  1115.         int64_t pos = av_frame_get_pkt_pos(out);

  1116.         dstctx->var_values[VAR_N] = link->frame_count;

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

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

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

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

  1121. 

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

  1123.         if (dstctx->is_disabled &&

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

  1125.             filter_frame = default_filter_frame;

  1126.     }

  1127.     ret = filter_frame(link, out);

  1128.     link->frame_count++;

  1129.     ff_update_link_current_pts(link, pts);

  1130.     return ret;

  1131. 

  1132. fail:

  1133.     av_frame_free(&out);

  1134.     av_frame_free(&frame);

  1135.     return ret;

  1136. }

  1137. 

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

  1139. {

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

  1141.     AVFrame *pbuf = link->partial_buf;

  1142.     int nb_channels = av_frame_get_channels(frame);

  1143.     int ret = 0;

  1144. 

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

  1146.     while (insamples) {

  1147.         if (!pbuf) {

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

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

  1150.             if (!pbuf) {

  1151.                 av_log(link->dst, AV_LOG_WARNING,

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

  1153.                 return 0;

  1154.             }

  1155.             av_frame_copy_props(pbuf, frame);

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

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

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

  1159.             pbuf->nb_samples = 0;

  1160.         }

  1161.         nb_samples = FFMIN(insamples,

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

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

  1164.                         pbuf->nb_samples, inpos,

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

  1166.         inpos                   += nb_samples;

  1167.         insamples               -= nb_samples;

  1168.         pbuf->nb_samples += nb_samples;

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

  1170.             ret = ff_filter_frame_framed(link, pbuf);

  1171.             pbuf = NULL;

  1172.         } else {

  1173.             if (link->frame_wanted_out)

  1174.                 link->frame_wanted_in = 1;

  1175.         }

  1176.     }

  1177.     av_frame_free(&frame);

  1178.     link->partial_buf = pbuf;

  1179.     return ret;

  1180. }

  1181. 

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

  1183. {

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

  1185. 

  1186.     /* Consistency checks */

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

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

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

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

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

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

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

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

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

  1196.         }

  1197.     } else {

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

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

  1200.             goto error;

  1201.         }

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

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

  1204.             goto error;

  1205.         }

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

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

  1208.             goto error;

  1209.         }

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

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

  1212.             goto error;

  1213.         }

  1214.     }

  1215. 

  1216.     link->frame_wanted_out = 0;

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

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

  1219.         link->min_samples &&

  1220.         (link->partial_buf ||

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

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

  1223.         return ff_filter_frame_needs_framing(link, frame);

  1224.     } else {

  1225.         return ff_filter_frame_framed(link, frame);

  1226.     }

  1227. error:

  1228.     av_frame_free(&frame);

  1229.     return AVERROR_PATCHWELCOME;

  1230. }

  1231. 

  1232. const AVClass *avfilter_get_class(void)

  1233. {

  1234.     return &avfilter_class;

  1235. }