FFmpeg
buffersrc.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2008 Vitor Sessak
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * memory buffer source filter
24  */
25 
26 #include <float.h>
27 
28 #include "libavutil/avassert.h"
30 #include "libavutil/common.h"
31 #include "libavutil/frame.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/samplefmt.h"
36 #include "libavutil/timestamp.h"
37 #include "audio.h"
38 #include "avfilter.h"
39 #include "buffersrc.h"
40 #include "formats.h"
41 #include "internal.h"
42 #include "video.h"
43 
44 typedef struct BufferSourceContext {
45  const AVClass *class;
46  AVRational time_base; ///< time_base to set in the output link
47  AVRational frame_rate; ///< frame_rate to set in the output link
49 
50  /* video only */
51  int w, h;
54 #if FF_API_SWS_PARAM_OPTION
55  char *sws_param;
56 #endif
57 
59 
60  /* audio only */
63  int channels;
64  uint64_t channel_layout;
66 
67  int eof;
69 
70 #define CHECK_VIDEO_PARAM_CHANGE(s, c, width, height, format, pts)\
71  if (c->w != width || c->h != height || c->pix_fmt != format) {\
72  av_log(s, AV_LOG_INFO, "filter context - w: %d h: %d fmt: %d, incoming frame - w: %d h: %d fmt: %d pts_time: %s\n",\
73  c->w, c->h, c->pix_fmt, width, height, format, av_ts2timestr(pts, &s->outputs[0]->time_base));\
74  av_log(s, AV_LOG_WARNING, "Changing video frame properties on the fly is not supported by all filters.\n");\
75  }
76 
77 #define CHECK_AUDIO_PARAM_CHANGE(s, c, srate, ch_layout, ch_count, format, pts)\
78  if (c->sample_fmt != format || c->sample_rate != srate ||\
79  c->channel_layout != ch_layout || c->channels != ch_count) {\
80  av_log(s, AV_LOG_INFO, "filter context - fmt: %s r: %d layout: %"PRIX64" ch: %d, incoming frame - fmt: %s r: %d layout: %"PRIX64" ch: %d pts_time: %s\n",\
81  av_get_sample_fmt_name(c->sample_fmt), c->sample_rate, c->channel_layout, c->channels,\
82  av_get_sample_fmt_name(format), srate, ch_layout, ch_count, av_ts2timestr(pts, &s->outputs[0]->time_base));\
83  av_log(s, AV_LOG_ERROR, "Changing audio frame properties on the fly is not supported.\n");\
84  return AVERROR(EINVAL);\
85  }
86 
88 {
89  AVBufferSrcParameters *par = av_mallocz(sizeof(*par));
90  if (!par)
91  return NULL;
92 
93  par->format = -1;
94 
95  return par;
96 }
97 
99 {
100  BufferSourceContext *s = ctx->priv;
101 
102  if (param->time_base.num > 0 && param->time_base.den > 0)
103  s->time_base = param->time_base;
104 
105  switch (ctx->filter->outputs[0].type) {
106  case AVMEDIA_TYPE_VIDEO:
107  if (param->format != AV_PIX_FMT_NONE) {
108  s->pix_fmt = param->format;
109  }
110  if (param->width > 0)
111  s->w = param->width;
112  if (param->height > 0)
113  s->h = param->height;
114  if (param->sample_aspect_ratio.num > 0 && param->sample_aspect_ratio.den > 0)
115  s->pixel_aspect = param->sample_aspect_ratio;
116  if (param->frame_rate.num > 0 && param->frame_rate.den > 0)
117  s->frame_rate = param->frame_rate;
118  if (param->hw_frames_ctx) {
121  if (!s->hw_frames_ctx)
122  return AVERROR(ENOMEM);
123  }
124  break;
125  case AVMEDIA_TYPE_AUDIO:
126  if (param->format != AV_SAMPLE_FMT_NONE) {
127  s->sample_fmt = param->format;
128  }
129  if (param->sample_rate > 0)
130  s->sample_rate = param->sample_rate;
131  if (param->channel_layout)
132  s->channel_layout = param->channel_layout;
133  break;
134  default:
135  return AVERROR_BUG;
136  }
137 
138  return 0;
139 }
140 
141 int attribute_align_arg av_buffersrc_write_frame(AVFilterContext *ctx, const AVFrame *frame)
142 {
143  return av_buffersrc_add_frame_flags(ctx, (AVFrame *)frame,
145 }
146 
148 {
149  return av_buffersrc_add_frame_flags(ctx, frame, 0);
150 }
151 
153  AVFrame *frame, int flags);
154 
155 int attribute_align_arg av_buffersrc_add_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
156 {
157  AVFrame *copy = NULL;
158  int ret = 0;
159 
160  if (frame && frame->channel_layout &&
162  av_log(ctx, AV_LOG_ERROR, "Layout indicates a different number of channels than actually present\n");
163  return AVERROR(EINVAL);
164  }
165 
166  if (!(flags & AV_BUFFERSRC_FLAG_KEEP_REF) || !frame)
167  return av_buffersrc_add_frame_internal(ctx, frame, flags);
168 
169  if (!(copy = av_frame_alloc()))
170  return AVERROR(ENOMEM);
171  ret = av_frame_ref(copy, frame);
172  if (ret >= 0)
173  ret = av_buffersrc_add_frame_internal(ctx, copy, flags);
174 
175  av_frame_free(&copy);
176  return ret;
177 }
178 
179 static int push_frame(AVFilterGraph *graph)
180 {
181  int ret;
182 
183  while (1) {
184  ret = ff_filter_graph_run_once(graph);
185  if (ret == AVERROR(EAGAIN))
186  break;
187  if (ret < 0)
188  return ret;
189  }
190  return 0;
191 }
192 
194  AVFrame *frame, int flags)
195 {
196  BufferSourceContext *s = ctx->priv;
197  AVFrame *copy;
198  int refcounted, ret;
199 
200  s->nb_failed_requests = 0;
201 
202  if (!frame)
203  return av_buffersrc_close(ctx, AV_NOPTS_VALUE, flags);
204  if (s->eof)
205  return AVERROR(EINVAL);
206 
207  refcounted = !!frame->buf[0];
208 
209  if (!(flags & AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT)) {
210 
211  switch (ctx->outputs[0]->type) {
212  case AVMEDIA_TYPE_VIDEO:
213  CHECK_VIDEO_PARAM_CHANGE(ctx, s, frame->width, frame->height,
214  frame->format, frame->pts);
215  break;
216  case AVMEDIA_TYPE_AUDIO:
217  /* For layouts unknown on input but known on link after negotiation. */
218  if (!frame->channel_layout)
219  frame->channel_layout = s->channel_layout;
220  CHECK_AUDIO_PARAM_CHANGE(ctx, s, frame->sample_rate, frame->channel_layout,
221  frame->channels, frame->format, frame->pts);
222  break;
223  default:
224  return AVERROR(EINVAL);
225  }
226 
227  }
228 
229  if (!(copy = av_frame_alloc()))
230  return AVERROR(ENOMEM);
231 
232  if (refcounted) {
233  av_frame_move_ref(copy, frame);
234  } else {
235  ret = av_frame_ref(copy, frame);
236  if (ret < 0) {
237  av_frame_free(&copy);
238  return ret;
239  }
240  }
241 
242  ret = ff_filter_frame(ctx->outputs[0], copy);
243  if (ret < 0)
244  return ret;
245 
246  if ((flags & AV_BUFFERSRC_FLAG_PUSH)) {
247  ret = push_frame(ctx->graph);
248  if (ret < 0)
249  return ret;
250  }
251 
252  return 0;
253 }
254 
255 int av_buffersrc_close(AVFilterContext *ctx, int64_t pts, unsigned flags)
256 {
257  BufferSourceContext *s = ctx->priv;
258 
259  s->eof = 1;
261  return (flags & AV_BUFFERSRC_FLAG_PUSH) ? push_frame(ctx->graph) : 0;
262 }
263 
265 {
266  BufferSourceContext *c = ctx->priv;
267 
268  if (c->pix_fmt == AV_PIX_FMT_NONE || !c->w || !c->h ||
269  av_q2d(c->time_base) <= 0) {
270  av_log(ctx, AV_LOG_ERROR, "Invalid parameters provided.\n");
271  return AVERROR(EINVAL);
272  }
273 
274  av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d pixfmt:%s tb:%d/%d fr:%d/%d sar:%d/%d\n",
275  c->w, c->h, av_get_pix_fmt_name(c->pix_fmt),
278 
279 #if FF_API_SWS_PARAM_OPTION
280  if (c->sws_param)
281  av_log(ctx, AV_LOG_WARNING, "sws_param option is deprecated and ignored\n");
282 #endif
283 
284  return 0;
285 }
286 
288 {
289  return ((BufferSourceContext *)buffer_src->priv)->nb_failed_requests;
290 }
291 
292 #define OFFSET(x) offsetof(BufferSourceContext, x)
293 #define A AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_AUDIO_PARAM
294 #define V AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
295 
296 static const AVOption buffer_options[] = {
297  { "width", NULL, OFFSET(w), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, V },
298  { "video_size", NULL, OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, .flags = V },
299  { "height", NULL, OFFSET(h), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, V },
300  { "pix_fmt", NULL, OFFSET(pix_fmt), AV_OPT_TYPE_PIXEL_FMT, { .i64 = AV_PIX_FMT_NONE }, .min = AV_PIX_FMT_NONE, .max = INT_MAX, .flags = V },
301  { "sar", "sample aspect ratio", OFFSET(pixel_aspect), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, DBL_MAX, V },
302  { "pixel_aspect", "sample aspect ratio", OFFSET(pixel_aspect), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, DBL_MAX, V },
303  { "time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, DBL_MAX, V },
304  { "frame_rate", NULL, OFFSET(frame_rate), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, DBL_MAX, V },
305 #if FF_API_SWS_PARAM_OPTION
306  { "sws_param", NULL, OFFSET(sws_param), AV_OPT_TYPE_STRING, .flags = V },
307 #endif
308  { NULL },
309 };
310 
312 
313 static const AVOption abuffer_options[] = {
314  { "time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, 0, INT_MAX, A },
315  { "sample_rate", NULL, OFFSET(sample_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, A },
316  { "sample_fmt", NULL, OFFSET(sample_fmt), AV_OPT_TYPE_SAMPLE_FMT, { .i64 = AV_SAMPLE_FMT_NONE }, .min = AV_SAMPLE_FMT_NONE, .max = INT_MAX, .flags = A },
317  { "channel_layout", NULL, OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, .flags = A },
318  { "channels", NULL, OFFSET(channels), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, A },
319  { NULL },
320 };
321 
322 AVFILTER_DEFINE_CLASS(abuffer);
323 
325 {
326  BufferSourceContext *s = ctx->priv;
327  int ret = 0;
328 
329  if (s->sample_fmt == AV_SAMPLE_FMT_NONE) {
330  av_log(ctx, AV_LOG_ERROR, "Sample format was not set or was invalid\n");
331  return AVERROR(EINVAL);
332  }
333 
334  if (s->channel_layout_str || s->channel_layout) {
335  int n;
336 
337  if (!s->channel_layout) {
339  if (!s->channel_layout) {
340  av_log(ctx, AV_LOG_ERROR, "Invalid channel layout %s.\n",
341  s->channel_layout_str);
342  return AVERROR(EINVAL);
343  }
344  }
346  if (s->channels) {
347  if (n != s->channels) {
348  av_log(ctx, AV_LOG_ERROR,
349  "Mismatching channel count %d and layout '%s' "
350  "(%d channels)\n",
351  s->channels, s->channel_layout_str, n);
352  return AVERROR(EINVAL);
353  }
354  }
355  s->channels = n;
356  } else if (!s->channels) {
357  av_log(ctx, AV_LOG_ERROR, "Neither number of channels nor "
358  "channel layout specified\n");
359  return AVERROR(EINVAL);
360  }
361 
362  if (!s->time_base.num)
363  s->time_base = (AVRational){1, s->sample_rate};
364 
365  av_log(ctx, AV_LOG_VERBOSE,
366  "tb:%d/%d samplefmt:%s samplerate:%d chlayout:%s\n",
369 
370  return ret;
371 }
372 
373 static av_cold void uninit(AVFilterContext *ctx)
374 {
375  BufferSourceContext *s = ctx->priv;
377 }
378 
380 {
381  BufferSourceContext *c = ctx->priv;
384  AVFilterFormats *samplerates = NULL;
385  int ret;
386 
387  switch (ctx->outputs[0]->type) {
388  case AVMEDIA_TYPE_VIDEO:
389  if ((ret = ff_add_format (&formats, c->pix_fmt)) < 0 ||
390  (ret = ff_set_common_formats (ctx , formats )) < 0)
391  return ret;
392  break;
393  case AVMEDIA_TYPE_AUDIO:
394  if ((ret = ff_add_format (&formats , c->sample_fmt )) < 0 ||
395  (ret = ff_set_common_formats (ctx , formats )) < 0 ||
396  (ret = ff_add_format (&samplerates, c->sample_rate)) < 0 ||
397  (ret = ff_set_common_samplerates (ctx , samplerates )) < 0)
398  return ret;
399 
400  if ((ret = ff_add_channel_layout(&channel_layouts,
402  FF_COUNT2LAYOUT(c->channels))) < 0)
403  return ret;
404  if ((ret = ff_set_common_channel_layouts(ctx, channel_layouts)) < 0)
405  return ret;
406  break;
407  default:
408  return AVERROR(EINVAL);
409  }
410 
411  return 0;
412 }
413 
415 {
416  BufferSourceContext *c = link->src->priv;
417 
418  switch (link->type) {
419  case AVMEDIA_TYPE_VIDEO:
420  link->w = c->w;
421  link->h = c->h;
423 
424  if (c->hw_frames_ctx) {
426  if (!link->hw_frames_ctx)
427  return AVERROR(ENOMEM);
428  }
429  break;
430  case AVMEDIA_TYPE_AUDIO:
431  if (!c->channel_layout)
432  c->channel_layout = link->channel_layout;
433  break;
434  default:
435  return AVERROR(EINVAL);
436  }
437 
438  link->time_base = c->time_base;
439  link->frame_rate = c->frame_rate;
440  return 0;
441 }
442 
444 {
445  BufferSourceContext *c = link->src->priv;
446 
447  if (c->eof)
448  return AVERROR_EOF;
449  c->nb_failed_requests++;
450  return AVERROR(EAGAIN);
451 }
452 
454  {
455  .name = "default",
456  .type = AVMEDIA_TYPE_VIDEO,
457  .request_frame = request_frame,
458  .config_props = config_props,
459  },
460  { NULL }
461 };
462 
464  .name = "buffer",
465  .description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them accessible to the filterchain."),
466  .priv_size = sizeof(BufferSourceContext),
468 
469  .init = init_video,
470  .uninit = uninit,
471 
472  .inputs = NULL,
473  .outputs = avfilter_vsrc_buffer_outputs,
474  .priv_class = &buffer_class,
475 };
476 
478  {
479  .name = "default",
480  .type = AVMEDIA_TYPE_AUDIO,
481  .request_frame = request_frame,
482  .config_props = config_props,
483  },
484  { NULL }
485 };
486 
488  .name = "abuffer",
489  .description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them accessible to the filterchain."),
490  .priv_size = sizeof(BufferSourceContext),
492 
493  .init = init_audio,
494  .uninit = uninit,
495 
496  .inputs = NULL,
497  .outputs = avfilter_asrc_abuffer_outputs,
498  .priv_class = &abuffer_class,
499 };
#define NULL
Definition: coverity.c:32
static void copy(const float *p1, float *p2, const int length)
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
#define CHECK_AUDIO_PARAM_CHANGE(s, c, srate, ch_layout, ch_count, format, pts)
Definition: buffersrc.c:77
AVOption.
Definition: opt.h:248
AVRational pixel_aspect
Definition: buffersrc.c:53
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
Main libavfilter public API header.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:505
Memory buffer source API.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int num
Numerator.
Definition: rational.h:59
static av_cold int init_video(AVFilterContext *ctx)
Definition: buffersrc.c:264
static const AVFilterPad avfilter_vsrc_buffer_outputs[]
Definition: buffersrc.c:453
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
Immediately push the frame to the output.
Definition: buffersrc.h:46
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *channel_layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates...
Definition: formats.c:569
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:582
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
enum AVPixelFormat pix_fmt
Definition: buffersrc.c:52
static av_cold void uninit(AVFilterContext *ctx)
Definition: buffersrc.c:373
AVRational frame_rate
Video only, the frame rate of the input video.
Definition: buffersrc.h:100
#define OFFSET(x)
Definition: buffersrc.c:292
AVFilter ff_asrc_abuffer
Definition: buffersrc.c:487
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
struct AVFilterGraph * graph
filtergraph this filter belongs to
Definition: avfilter.h:358
const char * name
Pad name.
Definition: internal.h:60
AVRational sample_aspect_ratio
Video only, the sample (pixel) aspect ratio.
Definition: buffersrc.h:92
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
int ff_filter_graph_run_once(AVFilterGraph *graph)
Run one round of processing on a filter graph.
static const AVOption abuffer_options[]
Definition: buffersrc.c:313
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1091
#define av_cold
Definition: attributes.h:88
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
AVOptions.
timestamp utils, mostly useful for debugging/logging purposes
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVRational time_base
The timebase to be used for the timestamps on the input frames.
Definition: buffersrc.h:82
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:407
#define CHECK_VIDEO_PARAM_CHANGE(s, c, width, height, format, pts)
Definition: buffersrc.c:70
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
int sample_rate
Audio only, the audio sampling rate in samples per second.
Definition: buffersrc.h:111
static const AVFilterPad avfilter_asrc_abuffer_outputs[]
Definition: buffersrc.c:477
channels
Definition: aptx.h:33
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
int width
Definition: frame.h:372
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:588
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:339
uint64_t channel_layout
Audio only, the audio channel layout.
Definition: buffersrc.h:116
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
static int request_frame(AVFilterLink *link)
Definition: buffersrc.c:443
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
void * priv
private data for use by the filter
Definition: avfilter.h:356
int av_buffersrc_close(AVFilterContext *ctx, int64_t pts, unsigned flags)
Close the buffer source after EOF.
Definition: buffersrc.c:255
#define A
Definition: buffersrc.c:293
simple assert() macros that are a bit more flexible than ISO C assert().
int ff_add_format(AVFilterFormats **avff, int64_t fmt)
Add fmt to the list of media formats contained in *avff.
Definition: formats.c:333
AVRational time_base
time_base to set in the output link
Definition: buffersrc.c:46
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:49
int format
video: the pixel format, value corresponds to enum AVPixelFormat audio: the sample format...
Definition: buffersrc.h:78
AVRational frame_rate
frame_rate to set in the output link
Definition: buffersrc.c:47
reference-counted frame API
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:491
common internal API header
AVFILTER_DEFINE_CLASS(buffer)
int channels
number of audio channels, only used for audio.
Definition: frame.h:620
audio channel layout utility functions
This structure contains the parameters describing the frames that will be passed to this filter...
Definition: buffersrc.h:73
AVFormatContext * ctx
Definition: movenc.c:48
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
static av_cold int init_audio(AVFilterContext *ctx)
Definition: buffersrc.c:324
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
A list of supported channel layouts.
Definition: formats.h:86
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:387
AVBufferRef * hw_frames_ctx
Video with a hwaccel pixel format only.
Definition: buffersrc.h:106
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
static const AVOption buffer_options[]
Definition: buffersrc.c:296
#define V
Definition: buffersrc.c:294
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
static int push_frame(AVFilterGraph *graph)
Definition: buffersrc.c:179
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:113
Describe the class of an AVClass context structure.
Definition: log.h:67
int sample_rate
Sample rate of the audio data.
Definition: frame.h:486
Filter definition.
Definition: avfilter.h:145
Rational number (pair of numerator and denominator).
Definition: rational.h:58
static int config_props(AVFilterLink *link)
Definition: buffersrc.c:414
const char * name
Filter name.
Definition: avfilter.h:149
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
static int av_buffersrc_add_frame_internal(AVFilterContext *ctx, AVFrame *frame, int flags)
Definition: buffersrc.c:193
offset must point to two consecutive integers
Definition: opt.h:235
unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src)
Get the number of failed requests.
Definition: buffersrc.c:287
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:353
uint64_t channel_layout
Definition: buffersrc.c:64
static int64_t pts
#define flags(name, subs,...)
Definition: cbs_av1.c:560
AVBufferRef * hw_frames_ctx
Definition: buffersrc.c:58
int attribute_align_arg av_buffersrc_write_frame(AVFilterContext *ctx, const AVFrame *frame)
Add a frame to the buffer source.
Definition: buffersrc.c:141
AVFilter ff_vsrc_buffer
Definition: buffersrc.c:463
A reference to a data buffer.
Definition: buffer.h:81
common internal and external API header
int av_buffersrc_parameters_set(AVFilterContext *ctx, AVBufferSrcParameters *param)
Initialize the buffersrc or abuffersrc filter with the provided parameters.
Definition: buffersrc.c:98
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
int den
Denominator.
Definition: rational.h:60
int attribute_align_arg av_buffersrc_add_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
Add a frame to the buffer source.
Definition: buffersrc.c:155
unsigned nb_failed_requests
Definition: buffersrc.c:48
enum AVSampleFormat sample_fmt
Definition: buffersrc.c:62
static int query_formats(AVFilterContext *ctx)
Definition: buffersrc.c:379
Keep a reference to the frame.
Definition: buffersrc.h:53
A list of supported formats for one end of a filter link.
Definition: formats.h:65
AVBufferSrcParameters * av_buffersrc_parameters_alloc(void)
Allocate a new AVBufferSrcParameters instance.
Definition: buffersrc.c:87
void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: avfilter.c:211
An instance of a filter.
Definition: avfilter.h:341
Do not check for format changes.
Definition: buffersrc.h:41
int height
Definition: frame.h:372
const AVFilterPad * outputs
List of outputs, terminated by a zeroed element.
Definition: avfilter.h:173
#define FF_COUNT2LAYOUT(c)
Encode a channel count as a channel layout.
Definition: formats.h:103
int width
Video only, the display dimensions of the input frames.
Definition: buffersrc.h:87
formats
Definition: signature.h:48
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2489
internal API functions
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:344
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:576
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
GLuint buffer
Definition: opengl_enc.c:101
int attribute_align_arg av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame)
Add a frame to the buffer source.
Definition: buffersrc.c:147
char * channel_layout_str
Definition: buffersrc.c:65