# public sherpya /FFmpeg forked from FFmpeg/FFmpeg

### Subversion checkout URL

You can clone with HTTPS or Subversion.

Fetching contributors…

Cannot retrieve contributors at this time

file 270 lines (239 sloc) 10.554 kb
 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 /* * Filter graphs * copyright (c) 2007 Bobby Bingham * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */#ifndef AVFILTER_AVFILTERGRAPH_H#define AVFILTER_AVFILTERGRAPH_H#include "avfilter.h"#include "libavutil/log.h"typedef struct AVFilterGraph {    const AVClass *av_class;    unsigned filter_count;    AVFilterContext **filters;    char *scale_sws_opts; ///< sws options to use for the auto-inserted scale filters    /** * Private fields * * The following fields are for internal use only. * Their type, offset, number and semantic can change without notice. */    AVFilterLink **sink_links;    int sink_links_count;    unsigned disable_auto_convert;} AVFilterGraph;/** * Allocate a filter graph. */AVFilterGraph *avfilter_graph_alloc(void);/** * Get a filter instance with name name from graph. * * @return the pointer to the found filter instance or NULL if it * cannot be found. */AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, char *name);/** * Add an existing filter instance to a filter graph. * * @param graphctx the filter graph * @param filter the filter to be added */int avfilter_graph_add_filter(AVFilterGraph *graphctx, AVFilterContext *filter);/** * Create and add a filter instance into an existing graph. * The filter instance is created from the filter filt and inited * with the parameters args and opaque. * * In case of success put in *filt_ctx the pointer to the created * filter instance, otherwise set *filt_ctx to NULL. * * @param name the instance name to give to the created filter instance * @param graph_ctx the filter graph * @return a negative AVERROR error code in case of failure, a non * negative value otherwise */int avfilter_graph_create_filter(AVFilterContext **filt_ctx, AVFilter *filt,                                 const char *name, const char *args, void *opaque,                                 AVFilterGraph *graph_ctx);/** * Enable or disable automatic format conversion inside the graph. * * Note that format conversion can still happen inside explicitly inserted * scale and aconvert filters. * * @param flags any of the AVFILTER_AUTO_CONVERT_* constants */void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags);enum {    AVFILTER_AUTO_CONVERT_ALL = 0, /**< all automatic conversions enabled */    AVFILTER_AUTO_CONVERT_NONE = -1, /**< all automatic conversions disabled */};/** * Check validity and configure all the links and formats in the graph. * * @param graphctx the filter graph * @param log_ctx context used for logging * @return 0 in case of success, a negative AVERROR code otherwise */int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx);/** * Free a graph, destroy its links, and set *graph to NULL. * If *graph is NULL, do nothing. */void avfilter_graph_free(AVFilterGraph **graph);/** * A linked-list of the inputs/outputs of the filter chain. * * This is mainly useful for avfilter_graph_parse() / avfilter_graph_parse2(), * where it is used to communicate open (unlinked) inputs and outputs from and * to the caller. * This struct specifies, per each not connected pad contained in the graph, the * filter context and the pad index required for establishing a link. */typedef struct AVFilterInOut {    /** unique name for this input/output in the list */    char *name;    /** filter context associated to this input/output */    AVFilterContext *filter_ctx;    /** index of the filt_ctx pad to use for linking */    int pad_idx;    /** next input/input in the list, NULL if this is the last */    struct AVFilterInOut *next;} AVFilterInOut;/** * Allocate a single AVFilterInOut entry. * Must be freed with avfilter_inout_free(). * @return allocated AVFilterInOut on success, NULL on failure. */AVFilterInOut *avfilter_inout_alloc(void);/** * Free the supplied list of AVFilterInOut and set *inout to NULL. * If *inout is NULL, do nothing. */void avfilter_inout_free(AVFilterInOut **inout);/** * Add a graph described by a string to a graph. * * @param graph the filter graph where to link the parsed graph context * @param filters string to be parsed * @param inputs pointer to a linked list to the inputs of the graph, may be NULL. * If non-NULL, *inputs is updated to contain the list of open inputs * after the parsing, should be freed with avfilter_inout_free(). * @param outputs pointer to a linked list to the outputs of the graph, may be NULL. * If non-NULL, *outputs is updated to contain the list of open outputs * after the parsing, should be freed with avfilter_inout_free(). * @return non negative on success, a negative AVERROR code on error */int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,                         AVFilterInOut **inputs, AVFilterInOut **outputs,                         void *log_ctx);/** * Add a graph described by a string to a graph. * * @param[in] graph the filter graph where to link the parsed graph context * @param[in] filters string to be parsed * @param[out] inputs a linked list of all free (unlinked) inputs of the * parsed graph will be returned here. It is to be freed * by the caller using avfilter_inout_free(). * @param[out] outputs a linked list of all free (unlinked) outputs of the * parsed graph will be returned here. It is to be freed by the * caller using avfilter_inout_free(). * @return zero on success, a negative AVERROR code on error * * @note the difference between avfilter_graph_parse2() and * avfilter_graph_parse() is that in avfilter_graph_parse(), the caller provides * the lists of inputs and outputs, which therefore must be known before calling * the function. On the other hand, avfilter_graph_parse2() \em returns the * inputs and outputs that are left unlinked after parsing the graph and the * caller then deals with them. Another difference is that in * avfilter_graph_parse(), the inputs parameter describes inputs of the * already existing part of the graph; i.e. from the point of view of * the newly created part, they are outputs. Similarly the outputs parameter * describes outputs of the already existing filters, which are provided as * inputs to the parsed filters. * avfilter_graph_parse2() takes the opposite approach -- it makes no reference * whatsoever to already existing parts of the graph and the inputs parameter * will on return contain inputs of the newly parsed part of the graph. * Analogously the outputs parameter will contain outputs of the newly created * filters. */int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters,                          AVFilterInOut **inputs,                          AVFilterInOut **outputs);/** * Send a command to one or more filter instances. * * @param graph the filter graph * @param target the filter(s) to which the command should be sent * "all" sends to all filters * otherwise it can be a filter or filter instance name * which will send the command to all matching filters. * @param cmd the command to sent, for handling simplicity all commands must be alphanumeric only * @param arg the argument for the command * @param res a buffer with size res_size where the filter(s) can return a response. * * @returns >=0 on success otherwise an error code. * AVERROR(ENOSYS) on unsupported commands */int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags);/** * Queue a command for one or more filter instances. * * @param graph the filter graph * @param target the filter(s) to which the command should be sent * "all" sends to all filters * otherwise it can be a filter or filter instance name * which will send the command to all matching filters. * @param cmd the command to sent, for handling simplicity all commands must be alphanummeric only * @param arg the argument for the command * @param ts time at which the command should be sent to the filter * * @note As this executes commands after this function returns, no return code * from the filter is provided, also AVFILTER_CMD_FLAG_ONE is not supported. */int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, int flags, double ts);/** * Dump a graph into a human-readable string representation. * * @param graph the graph to dump * @param options formatting options; currently ignored * @return a string, or NULL in case of memory allocation failure; * the string must be freed using av_free */char *avfilter_graph_dump(AVFilterGraph *graph, const char *options);/** * Request a frame on the oldest sink link. * * If the request returns AVERROR_EOF, try the next. * * Note that this function is not meant to be the sole scheduling mechanism * of a filtergraph, only a convenience function to help drain a filtergraph * in a balanced way under normal circumstances. * * Also note that AVERROR_EOF does not mean that frames did not arrive on * some of the sinks during the process. * When there are multiple sink links, in case the requested link * returns an EOF, this may cause a filter to flush pending frames * which are sent to another sink link, although unrequested. * * @return the return value of ff_request_frame(), * or AVERROR_EOF if all links returned AVERROR_EOF */int avfilter_graph_request_oldest(AVFilterGraph *graph);#endif /* AVFILTER_AVFILTERGRAPH_H */
Something went wrong with that request. Please try again.