| 1 | /* |
| 2 | * This file is part of FFmpeg. |
| 3 | * |
| 4 | * FFmpeg is free software; you can redistribute it and/or |
| 5 | * modify it under the terms of the GNU Lesser General Public |
| 6 | * License as published by the Free Software Foundation; either |
| 7 | * version 2.1 of the License, or (at your option) any later version. |
| 8 | * |
| 9 | * FFmpeg is distributed in the hope that it will be useful, |
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 12 | * Lesser General Public License for more details. |
| 13 | * |
| 14 | * You should have received a copy of the GNU Lesser General Public |
| 15 | * License along with FFmpeg; if not, write to the Free Software |
| 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| 17 | */ |
| 18 | |
| 19 | #ifndef AVFILTER_INTERNAL_H |
| 20 | #define AVFILTER_INTERNAL_H |
| 21 | |
| 22 | /** |
| 23 | * @file |
| 24 | * internal API functions |
| 25 | */ |
| 26 | |
| 27 | #include "libavutil/internal.h" |
| 28 | #include "avfilter.h" |
| 29 | #include "avfiltergraph.h" |
| 30 | #include "formats.h" |
| 31 | #include "thread.h" |
| 32 | #include "version.h" |
| 33 | #include "video.h" |
| 34 | |
| 35 | #define POOL_SIZE 32 |
| 36 | typedef struct AVFilterPool { |
| 37 | AVFilterBufferRef *pic[POOL_SIZE]; |
| 38 | int count; |
| 39 | int refcount; |
| 40 | int draining; |
| 41 | } AVFilterPool; |
| 42 | |
| 43 | typedef struct AVFilterCommand { |
| 44 | double time; ///< time expressed in seconds |
| 45 | char *command; ///< command |
| 46 | char *arg; ///< optional argument for the command |
| 47 | int flags; |
| 48 | struct AVFilterCommand *next; |
| 49 | } AVFilterCommand; |
| 50 | |
| 51 | /** |
| 52 | * Update the position of a link in the age heap. |
| 53 | */ |
| 54 | void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link); |
| 55 | |
| 56 | #if !FF_API_AVFILTERPAD_PUBLIC |
| 57 | /** |
| 58 | * A filter pad used for either input or output. |
| 59 | */ |
| 60 | struct AVFilterPad { |
| 61 | /** |
| 62 | * Pad name. The name is unique among inputs and among outputs, but an |
| 63 | * input may have the same name as an output. This may be NULL if this |
| 64 | * pad has no need to ever be referenced by name. |
| 65 | */ |
| 66 | const char *name; |
| 67 | |
| 68 | /** |
| 69 | * AVFilterPad type. |
| 70 | */ |
| 71 | enum AVMediaType type; |
| 72 | |
| 73 | /** |
| 74 | * Callback function to get a video buffer. If NULL, the filter system will |
| 75 | * use ff_default_get_video_buffer(). |
| 76 | * |
| 77 | * Input video pads only. |
| 78 | */ |
| 79 | AVFrame *(*get_video_buffer)(AVFilterLink *link, int w, int h); |
| 80 | |
| 81 | /** |
| 82 | * Callback function to get an audio buffer. If NULL, the filter system will |
| 83 | * use ff_default_get_audio_buffer(). |
| 84 | * |
| 85 | * Input audio pads only. |
| 86 | */ |
| 87 | AVFrame *(*get_audio_buffer)(AVFilterLink *link, int nb_samples); |
| 88 | |
| 89 | /** |
| 90 | * Filtering callback. This is where a filter receives a frame with |
| 91 | * audio/video data and should do its processing. |
| 92 | * |
| 93 | * Input pads only. |
| 94 | * |
| 95 | * @return >= 0 on success, a negative AVERROR on error. This function |
| 96 | * must ensure that samplesref is properly unreferenced on error if it |
| 97 | * hasn't been passed on to another filter. |
| 98 | */ |
| 99 | int (*filter_frame)(AVFilterLink *link, AVFrame *frame); |
| 100 | |
| 101 | /** |
| 102 | * Frame poll callback. This returns the number of immediately available |
| 103 | * samples. It should return a positive value if the next request_frame() |
| 104 | * is guaranteed to return one frame (with no delay). |
| 105 | * |
| 106 | * Defaults to just calling the source poll_frame() method. |
| 107 | * |
| 108 | * Output pads only. |
| 109 | */ |
| 110 | int (*poll_frame)(AVFilterLink *link); |
| 111 | |
| 112 | /** |
| 113 | * Frame request callback. A call to this should result in at least one |
| 114 | * frame being output over the given link. This should return zero on |
| 115 | * success, and another value on error. |
| 116 | * |
| 117 | * Output pads only. |
| 118 | */ |
| 119 | int (*request_frame)(AVFilterLink *link); |
| 120 | |
| 121 | /** |
| 122 | * Link configuration callback. |
| 123 | * |
| 124 | * For output pads, this should set the link properties such as |
| 125 | * width/height. This should NOT set the format property - that is |
| 126 | * negotiated between filters by the filter system using the |
| 127 | * query_formats() callback before this function is called. |
| 128 | * |
| 129 | * For input pads, this should check the properties of the link, and update |
| 130 | * the filter's internal state as necessary. |
| 131 | * |
| 132 | * For both input and output filters, this should return zero on success, |
| 133 | * and another value on error. |
| 134 | */ |
| 135 | int (*config_props)(AVFilterLink *link); |
| 136 | |
| 137 | /** |
| 138 | * The filter expects a fifo to be inserted on its input link, |
| 139 | * typically because it has a delay. |
| 140 | * |
| 141 | * input pads only. |
| 142 | */ |
| 143 | int needs_fifo; |
| 144 | |
| 145 | /** |
| 146 | * The filter expects writable frames from its input link, |
| 147 | * duplicating data buffers if needed. |
| 148 | * |
| 149 | * input pads only. |
| 150 | */ |
| 151 | int needs_writable; |
| 152 | }; |
| 153 | #endif |
| 154 | |
| 155 | struct AVFilterGraphInternal { |
| 156 | void *thread; |
| 157 | avfilter_execute_func *thread_execute; |
| 158 | }; |
| 159 | |
| 160 | struct AVFilterInternal { |
| 161 | avfilter_execute_func *execute; |
| 162 | }; |
| 163 | |
| 164 | #if FF_API_AVFILTERBUFFER |
| 165 | /** default handler for freeing audio/video buffer when there are no references left */ |
| 166 | void ff_avfilter_default_free_buffer(AVFilterBuffer *buf); |
| 167 | #endif |
| 168 | |
| 169 | /** Tell is a format is contained in the provided list terminated by -1. */ |
| 170 | int ff_fmt_is_in(int fmt, const int *fmts); |
| 171 | |
| 172 | /* Functions to parse audio format arguments */ |
| 173 | |
| 174 | /** |
| 175 | * Parse a pixel format. |
| 176 | * |
| 177 | * @param ret pixel format pointer to where the value should be written |
| 178 | * @param arg string to parse |
| 179 | * @param log_ctx log context |
| 180 | * @return >= 0 in case of success, a negative AVERROR code on error |
| 181 | */ |
| 182 | int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx); |
| 183 | |
| 184 | /** |
| 185 | * Parse a sample rate. |
| 186 | * |
| 187 | * @param ret unsigned integer pointer to where the value should be written |
| 188 | * @param arg string to parse |
| 189 | * @param log_ctx log context |
| 190 | * @return >= 0 in case of success, a negative AVERROR code on error |
| 191 | */ |
| 192 | int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx); |
| 193 | |
| 194 | /** |
| 195 | * Parse a time base. |
| 196 | * |
| 197 | * @param ret unsigned AVRational pointer to where the value should be written |
| 198 | * @param arg string to parse |
| 199 | * @param log_ctx log context |
| 200 | * @return >= 0 in case of success, a negative AVERROR code on error |
| 201 | */ |
| 202 | int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx); |
| 203 | |
| 204 | /** |
| 205 | * Parse a sample format name or a corresponding integer representation. |
| 206 | * |
| 207 | * @param ret integer pointer to where the value should be written |
| 208 | * @param arg string to parse |
| 209 | * @param log_ctx log context |
| 210 | * @return >= 0 in case of success, a negative AVERROR code on error |
| 211 | */ |
| 212 | int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx); |
| 213 | |
| 214 | /** |
| 215 | * Parse a channel layout or a corresponding integer representation. |
| 216 | * |
| 217 | * @param ret 64bit integer pointer to where the value should be written. |
| 218 | * @param nret integer pointer to the number of channels; |
| 219 | * if not NULL, then unknown channel layouts are accepted |
| 220 | * @param arg string to parse |
| 221 | * @param log_ctx log context |
| 222 | * @return >= 0 in case of success, a negative AVERROR code on error |
| 223 | */ |
| 224 | int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg, |
| 225 | void *log_ctx); |
| 226 | |
| 227 | void ff_update_link_current_pts(AVFilterLink *link, int64_t pts); |
| 228 | |
| 229 | void ff_command_queue_pop(AVFilterContext *filter); |
| 230 | |
| 231 | /* misc trace functions */ |
| 232 | |
| 233 | /* #define FF_AVFILTER_TRACE */ |
| 234 | |
| 235 | #ifdef FF_AVFILTER_TRACE |
| 236 | # define ff_tlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__) |
| 237 | #else |
| 238 | # define ff_tlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0) |
| 239 | #endif |
| 240 | |
| 241 | #define FF_TPRINTF_START(ctx, func) ff_tlog(NULL, "%-16s: ", #func) |
| 242 | |
| 243 | char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms); |
| 244 | |
| 245 | void ff_tlog_ref(void *ctx, AVFrame *ref, int end); |
| 246 | |
| 247 | void ff_tlog_link(void *ctx, AVFilterLink *link, int end); |
| 248 | |
| 249 | /** |
| 250 | * Insert a new pad. |
| 251 | * |
| 252 | * @param idx Insertion point. Pad is inserted at the end if this point |
| 253 | * is beyond the end of the list of pads. |
| 254 | * @param count Pointer to the number of pads in the list |
| 255 | * @param padidx_off Offset within an AVFilterLink structure to the element |
| 256 | * to increment when inserting a new pad causes link |
| 257 | * numbering to change |
| 258 | * @param pads Pointer to the pointer to the beginning of the list of pads |
| 259 | * @param links Pointer to the pointer to the beginning of the list of links |
| 260 | * @param newpad The new pad to add. A copy is made when adding. |
| 261 | * @return >= 0 in case of success, a negative AVERROR code on error |
| 262 | */ |
| 263 | int ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, |
| 264 | AVFilterPad **pads, AVFilterLink ***links, |
| 265 | AVFilterPad *newpad); |
| 266 | |
| 267 | /** Insert a new input pad for the filter. */ |
| 268 | static inline int ff_insert_inpad(AVFilterContext *f, unsigned index, |
| 269 | AVFilterPad *p) |
| 270 | { |
| 271 | int ret = ff_insert_pad(index, &f->nb_inputs, offsetof(AVFilterLink, dstpad), |
| 272 | &f->input_pads, &f->inputs, p); |
| 273 | #if FF_API_FOO_COUNT |
| 274 | FF_DISABLE_DEPRECATION_WARNINGS |
| 275 | f->input_count = f->nb_inputs; |
| 276 | FF_ENABLE_DEPRECATION_WARNINGS |
| 277 | #endif |
| 278 | return ret; |
| 279 | } |
| 280 | |
| 281 | /** Insert a new output pad for the filter. */ |
| 282 | static inline int ff_insert_outpad(AVFilterContext *f, unsigned index, |
| 283 | AVFilterPad *p) |
| 284 | { |
| 285 | int ret = ff_insert_pad(index, &f->nb_outputs, offsetof(AVFilterLink, srcpad), |
| 286 | &f->output_pads, &f->outputs, p); |
| 287 | #if FF_API_FOO_COUNT |
| 288 | FF_DISABLE_DEPRECATION_WARNINGS |
| 289 | f->output_count = f->nb_outputs; |
| 290 | FF_ENABLE_DEPRECATION_WARNINGS |
| 291 | #endif |
| 292 | return ret; |
| 293 | } |
| 294 | |
| 295 | /** |
| 296 | * Poll a frame from the filter chain. |
| 297 | * |
| 298 | * @param link the input link |
| 299 | * @return the number of immediately available frames, a negative |
| 300 | * number in case of error |
| 301 | */ |
| 302 | int ff_poll_frame(AVFilterLink *link); |
| 303 | |
| 304 | /** |
| 305 | * Request an input frame from the filter at the other end of the link. |
| 306 | * |
| 307 | * @param link the input link |
| 308 | * @return zero on success |
| 309 | */ |
| 310 | int ff_request_frame(AVFilterLink *link); |
| 311 | |
| 312 | #define AVFILTER_DEFINE_CLASS(fname) \ |
| 313 | static const AVClass fname##_class = { \ |
| 314 | .class_name = #fname, \ |
| 315 | .item_name = av_default_item_name, \ |
| 316 | .option = fname##_options, \ |
| 317 | .version = LIBAVUTIL_VERSION_INT, \ |
| 318 | .category = AV_CLASS_CATEGORY_FILTER, \ |
| 319 | } |
| 320 | |
| 321 | AVFilterBufferRef *ff_copy_buffer_ref(AVFilterLink *outlink, |
| 322 | AVFilterBufferRef *ref); |
| 323 | |
| 324 | /** |
| 325 | * Find the index of a link. |
| 326 | * |
| 327 | * I.e. find i such that link == ctx->(in|out)puts[i] |
| 328 | */ |
| 329 | #define FF_INLINK_IDX(link) ((int)((link)->dstpad - (link)->dst->input_pads)) |
| 330 | #define FF_OUTLINK_IDX(link) ((int)((link)->srcpad - (link)->src->output_pads)) |
| 331 | |
| 332 | int ff_buffersink_read_compat(AVFilterContext *ctx, AVFilterBufferRef **buf); |
| 333 | int ff_buffersink_read_samples_compat(AVFilterContext *ctx, AVFilterBufferRef **pbuf, |
| 334 | int nb_samples); |
| 335 | /** |
| 336 | * Send a frame of data to the next filter. |
| 337 | * |
| 338 | * @param link the output link over which the data is being sent |
| 339 | * @param frame a reference to the buffer of data being sent. The |
| 340 | * receiving filter will free this reference when it no longer |
| 341 | * needs it or pass it on to the next filter. |
| 342 | * |
| 343 | * @return >= 0 on success, a negative AVERROR on error. The receiving filter |
| 344 | * is responsible for unreferencing frame in case of error. |
| 345 | */ |
| 346 | int ff_filter_frame(AVFilterLink *link, AVFrame *frame); |
| 347 | |
| 348 | /** |
| 349 | * Flags for AVFilterLink.flags. |
| 350 | */ |
| 351 | enum { |
| 352 | |
| 353 | /** |
| 354 | * Frame requests may need to loop in order to be fulfilled. |
| 355 | * A filter must set this flags on an output link if it may return 0 in |
| 356 | * request_frame() without filtering a frame. |
| 357 | */ |
| 358 | FF_LINK_FLAG_REQUEST_LOOP = 1, |
| 359 | |
| 360 | }; |
| 361 | |
| 362 | /** |
| 363 | * Allocate a new filter context and return it. |
| 364 | * |
| 365 | * @param filter what filter to create an instance of |
| 366 | * @param inst_name name to give to the new filter context |
| 367 | * |
| 368 | * @return newly created filter context or NULL on failure |
| 369 | */ |
| 370 | AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name); |
| 371 | |
| 372 | /** |
| 373 | * Remove a filter from a graph; |
| 374 | */ |
| 375 | void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter); |
| 376 | |
| 377 | #endif /* AVFILTER_INTERNAL_H */ |