Go to the documentation of this file.
37 #define FF_INTERNAL_FIELDS 1
46 #include "libavutil/ffversion.h"
53 "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64
" pos:%"PRId64,
55 ref->linesize[0],
ref->linesize[1],
ref->linesize[2],
ref->linesize[3],
59 ff_tlog(
ctx,
" a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
60 ref->sample_aspect_ratio.num,
ref->sample_aspect_ratio.den,
62 !
ref->interlaced_frame ?
'P' :
63 ref->top_field_first ?
'T' :
'B',
67 if (
ref->nb_samples) {
85 return FFMPEG_CONFIGURATION;
90 #define LICENSE_PREFIX "libavfilter license: "
111 idx =
FFMIN(idx, *count);
119 if (!newpads || !newlinks)
122 memmove(*pads + idx + 1, *pads + idx,
sizeof(
AVFilterPad) * (*count - idx));
125 (*links)[idx] =
NULL;
128 for (
i = idx + 1;
i < *count;
i++)
130 (*(
unsigned *)((
uint8_t *) (*links)[
i] + padidx_off))++;
144 if (
src->nb_outputs <= srcpad || dst->
nb_inputs <= dstpad ||
145 src->outputs[srcpad] || dst->
inputs[dstpad])
150 "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
164 link->srcpad = &
src->output_pads[srcpad];
166 link->type =
src->output_pads[srcpad].type;
186 #if FF_API_FILTER_GET_SET
207 filter->outputs[
i]->frame_blocked_in = 0;
218 link->frame_wanted_out = 0;
219 link->frame_blocked_in = 0;
241 unsigned filt_srcpad_idx,
unsigned filt_dstpad_idx)
244 unsigned dstpad_idx =
link->dstpad -
link->dst->input_pads;
247 "between the filter '%s' and the filter '%s'\n",
250 link->dst->inputs[dstpad_idx] =
NULL;
253 link->dst->inputs[dstpad_idx] =
link;
259 link->dstpad = &
filt->input_pads[filt_srcpad_idx];
260 filt->inputs[filt_srcpad_idx] =
link;
264 if (
link->out_formats)
266 &
filt->outputs[filt_dstpad_idx]->out_formats);
267 if (
link->out_samplerates)
269 &
filt->outputs[filt_dstpad_idx]->out_samplerates);
270 if (
link->out_channel_layouts)
272 &
filt->outputs[filt_dstpad_idx]->out_channel_layouts);
283 for (
i = 0;
i <
filter->nb_inputs;
i ++) {
290 "Not all input and output are properly linked (%d).\n",
i);
298 switch (
link->init_state) {
301 case AVLINK_STARTINIT:
305 link->init_state = AVLINK_STARTINIT;
310 if (!(config_link =
link->srcpad->config_props)) {
311 if (
link->src->nb_inputs != 1) {
313 "with more than one input "
314 "must set config_props() "
315 "callbacks on all outputs\n");
318 }
else if ((
ret = config_link(
link)) < 0) {
320 "Failed to configure output pad on %s\n",
325 switch (
link->type) {
327 if (!
link->time_base.num && !
link->time_base.den)
335 if (!
link->frame_rate.num && !
link->frame_rate.den)
343 "Video source filters must set their output link's "
344 "width and height\n");
351 if (!
link->time_base.num && !
link->time_base.den)
355 if (!
link->time_base.num && !
link->time_base.den)
362 "should not be set by non-hwframe-aware filter");
368 if ((config_link =
link->dstpad->config_props))
369 if ((
ret = config_link(
link)) < 0) {
371 "Failed to configure input pad on %s\n",
376 link->init_state = AVLINK_INIT;
387 "link[%p s:%dx%d fmt:%s %s->%s]%s",
390 link->src ?
link->src->filter->name :
"",
391 link->dst ?
link->dst->filter->name :
"",
398 "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
401 link->src ?
link->src->filter->name :
"",
402 link->dst ?
link->dst->filter->name :
"",
412 if (
link->status_out)
413 return link->status_out;
414 if (
link->status_in) {
424 return link->status_out;
427 link->frame_wanted_out = 1;
435 int64_t
r = INT64_MAX;
437 for (
i = 0;
i <
ctx->nb_inputs;
i++)
443 for (
i = 0;
i <
ctx->nb_inputs;
i++)
456 link->frame_blocked_in = 1;
457 if (
link->srcpad->request_frame)
459 else if (
link->src->inputs[0])
496 "with filter '%s'\n",
ctx->filter->name);
504 if (!
ctx->var_values) {
506 if (!
ctx->var_values) {
516 "Error when evaluating the expression '%s' for enable\n",
524 ctx->enable_str = expr_dup;
535 if (
link->graph &&
link->age_index >= 0)
541 if(!strcmp(cmd,
"ping")){
542 char local_res[256] = {0};
546 res_len =
sizeof(local_res);
549 if (res == local_res)
552 }
else if(!strcmp(cmd,
"enable")) {
554 }
else if(
filter->filter->process_command) {
567 for (count = 0; pads->
name; count++)
575 return ctx->name ?
ctx->name :
ctx->filter->name;
581 if (!prev &&
ctx->filter &&
ctx->filter->priv_class &&
ctx->priv)
593 if (
f->priv_class == prev)
603 return f->priv_class;
608 #define OFFSET(x) offsetof(AVFilterContext, x)
609 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM
616 { .i64 = 0 }, 0, INT_MAX,
FLAGS },
617 {
"extra_hw_frames",
"Number of extra hardware frames to allocate for the user",
633 int *
ret,
int nb_jobs)
637 for (
i = 0;
i < nb_jobs;
i++) {
683 if (
ret->nb_inputs ) {
685 if (!
ret->input_pads)
694 if (
ret->nb_outputs) {
696 if (!
ret->output_pads)
752 if (
filter->filter->uninit)
755 for (
i = 0;
i <
filter->nb_inputs;
i++) {
758 for (
i = 0;
i <
filter->nb_outputs;
i++) {
762 if (
filter->filter->priv_class)
773 while(
filter->command_queue){
786 if (
ctx->nb_threads > 0)
787 return FFMIN(
ctx->nb_threads,
ctx->graph->nb_threads);
788 return ctx->graph->nb_threads;
804 const char *shorthand =
NULL;
816 &parsed_key, &
value);
861 if (
ctx->enable_str) {
870 const char *
arg,
char *res,
int res_len,
int flags)
874 if (!
ctx->filter->priv_class)
898 ctx->thread_type = 0;
901 if (
ctx->filter->priv_class) {
909 if (
ctx->filter->init_opaque)
911 else if (
ctx->filter->init)
913 else if (
ctx->filter->init_dict)
926 if (!
filter->filter->priv_class) {
928 "options, but options were provided: %s.\n", args);
932 #if FF_API_OLD_FILTER_OPTS_ERROR
933 if ( !strcmp(
filter->filter->name,
"format") ||
934 !strcmp(
filter->filter->name,
"noformat") ||
935 !strcmp(
filter->filter->name,
"frei0r") ||
936 !strcmp(
filter->filter->name,
"frei0r_src") ||
937 !strcmp(
filter->filter->name,
"ocv") ||
938 !strcmp(
filter->filter->name,
"pan") ||
939 !strcmp(
filter->filter->name,
"pp") ||
940 !strcmp(
filter->filter->name,
"aevalsrc")) {
953 if (!strcmp(
filter->filter->name,
"frei0r") ||
954 !strcmp(
filter->filter->name,
"ocv"))
956 else if (!strcmp(
filter->filter->name,
"frei0r_src"))
959 while (nb_leading--) {
968 deprecated = strchr(p,
':') !=
NULL;
970 if (!strcmp(
filter->filter->name,
"aevalsrc")) {
972 while ((p = strchr(p,
':')) && p[1] !=
':') {
973 const char *epos = strchr(p + 1,
'=');
974 const char *spos = strchr(p + 1,
':');
975 const int next_token_is_opt = epos && (!spos || epos < spos);
976 if (next_token_is_opt) {
984 if (p && *p ==
':') {
986 memmove(p, p + 1, strlen(p));
989 while ((p = strchr(p,
':')))
994 "'|' to separate the list items ('%s' instead of '%s')\n",
1031 return pads[pad_idx].
name;
1036 return pads[pad_idx].
type;
1067 link->frame_count_out++;
1082 if (strcmp(
link->dst->filter->name,
"buffersink") &&
1083 strcmp(
link->dst->filter->name,
"format") &&
1084 strcmp(
link->dst->filter->name,
"idet") &&
1085 strcmp(
link->dst->filter->name,
"null") &&
1086 strcmp(
link->dst->filter->name,
"scale")) {
1110 link->frame_blocked_in =
link->frame_wanted_out = 0;
1111 link->frame_count_in++;
1137 unsigned nb_samples, nb_frames,
i, p;
1151 if (nb_samples +
frame->nb_samples >
max) {
1152 if (nb_samples <
min)
1156 nb_samples +=
frame->nb_samples;
1174 for (
i = 0;
i < nb_frames;
i++) {
1178 p +=
frame->nb_samples;
1181 if (p < nb_samples) {
1182 unsigned n = nb_samples - p;
1213 link->frame_count_out--;
1215 if (ret < 0 && ret != link->status_out) {
1227 unsigned out = 0, progress = 0;
1231 if (!
filter->nb_outputs) {
1235 while (!
in->status_out) {
1261 for (
i = 0;
i <
filter->nb_inputs;
i++) {
1266 for (
i = 0;
i <
filter->nb_inputs;
i++) {
1267 if (
filter->inputs[
i]->status_in && !
filter->inputs[
i]->status_out) {
1272 for (
i = 0;
i <
filter->nb_outputs;
i++) {
1273 if (
filter->outputs[
i]->frame_wanted_out &&
1274 !
filter->outputs[
i]->frame_blocked_in) {
1422 filter->filter->activate));
1433 *rpts =
link->current_pts;
1435 return *rstatus = 0;
1436 if (
link->status_out)
1437 return *rstatus =
link->status_out;
1438 if (!
link->status_in)
1439 return *rstatus = 0;
1440 *rstatus =
link->status_out =
link->status_in;
1442 *rpts =
link->current_pts;
1473 link->frame_count_out++;
1484 if (
link->fifo.samples_skipped) {
1505 if (
link->status_in)
1530 switch (
link->type) {
1549 switch (
link->type) {
1556 0, 0,
frame->nb_samples,
1575 "Processing command time:%f command:%s arg:%s\n",
1579 cmd=
link->dst->command_queue;
1606 link->frame_wanted_out = 1;
1612 if (
link->status_out)
1614 link->frame_wanted_out = 0;
1615 link->frame_blocked_in = 0;
1621 if (!
link->status_in)
1627 return link->status_in;
1636 int default_pool_size)
1645 if (
frames->initial_pool_size == 0) {
1650 frames->initial_pool_size = default_pool_size;
static void error(const char *err)
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
int(* func)(AVBPrint *dst, const char *in, const char *arg)
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
#define AV_LOG_WARNING
Something somehow does not look correct.
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
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
static FilteringContext * filter_ctx
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
#define FF_FILTER_FLAG_HWFRAME_AWARE
The filter is aware of hardware frames, and any hardware frame context should not be automatically pr...
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
int() avfilter_action_func(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
A function pointer passed to the AVFilterGraph::execute callback to be executed multiple times,...
#define AVERROR_EOF
End of file.
uint8_t * data
The data buffer.
double * var_values
variable values for the enable expression
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
#define LIBAVFILTER_VERSION_INT
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
static const AVClass * filter_child_class_next(const AVClass *prev)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int is_disabled
the enabled state from the last expression evaluation
static av_cold int end(AVCodecContext *avctx)
int ff_filter_activate(AVFilterContext *filter)
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
This structure describes decoded (raw) audio or video data.
static void free_link(AVFilterLink *link)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
void ff_command_queue_pop(AVFilterContext *filter)
static int process_options(AVFilterContext *ctx, AVDictionary **options, const char *args)
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
#define AV_OPT_FLAG_RUNTIME_PARAM
a generic parameter which can be set by the user at runtime
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
void * av_mallocz_array(size_t nmemb, size_t size)
#define AV_LOG_VERBOSE
Detailed information.
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg)
Init a frame queue and attach it to a global structure.
static const char * default_filter_name(void *filter_ctx)
AVFormatInternal * internal
An opaque field for libavformat internal usage.
A link between two filters.
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
AVFilterContext * ff_filter_alloc(const AVFilter *filter, const char *inst_name)
Allocate a new filter context and return it.
static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t samples, AVRational time_base)
Skip samples from the first frame in the queue.
struct AVFilterGraph * graph
filtergraph this filter belongs to
int offset
The offset relative to the context structure where the option value is stored.
char * enable_str
enable expression string
if it could not because there are no more frames
int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
Insert a filter in the middle of an existing link.
const AVFilter * av_filter_iterate(void **opaque)
Iterate over all registered filters.
int extra_hw_frames
Sets the number of extra hardware frames which the filter will allocate on its output links for use i...
int avfilter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
#define AVERROR_OPTION_NOT_FOUND
Option not found.
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
A filter pad used for either input or output.
const char * avfilter_license(void)
Return the libavfilter license.
AVFilterPad * input_pads
array of input pads
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
Test if enough samples are available on the link.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
static int ff_request_frame_to_filter(AVFilterLink *link)
void ff_avfilter_link_set_out_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the destination filter.
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
int flags
Flags modifying the (de)muxer behaviour.
int channels
number of audio channels, only used for audio.
int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
Make the filter instance process a command.
int avfilter_pad_count(const AVFilterPad *pads)
Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int flags
A combination of AVFILTER_FLAG_*.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
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.
static int ff_filter_frame_to_filter(AVFilterLink *link)
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
AVFrame * ff_framequeue_take(FFFrameQueue *fq)
Take the first frame in the queue.
int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
Make sure a frame is writable.
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
AVFrame * ff_inlink_peek_frame(AVFilterLink *link, size_t idx)
Access a frame in the link fifo without consuming it.
#define LIBAVUTIL_VERSION_INT
static void filter_unblock(AVFilterContext *filter)
Clear frame_blocked_in on all outputs.
Describe the class of an AVClass context structure.
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
Add a frame.
void ff_framequeue_free(FFFrameQueue *fq)
Free the queue and all queued frames.
#define LIBAVFILTER_VERSION_MICRO
Rational number (pair of numerator and denominator).
AVFilterLink ** inputs
array of pointers to input links
char * name
name of this filter instance
static int take_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
int(* filter_frame)(AVFilterLink *link, AVFrame *frame)
Filtering callback.
void av_opt_free(void *obj)
Free all allocated objects in obj.
static const AVClass avfilter_class
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
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
size_t ff_inlink_queued_frames(AVFilterLink *link)
Get the number of frames available on the link.
static void consume_update(AVFilterLink *link, const AVFrame *frame)
const char av_filter_ffversion[]
#define AV_OPT_SEARCH_FAKE_OBJ
The obj passed to av_opt_find() is fake – only a double pointer to AVClass instead of a required poin...
@ AV_CLASS_CATEGORY_FILTER
void ff_frame_pool_uninit(FFFramePool **pool)
Deallocate the frame pool.
const OptionDef options[]
unsigned nb_inputs
number of input pads
static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)
void ff_inlink_set_status(AVFilterLink *link, int status)
Set the status on an input link.
int ff_inlink_check_available_frame(AVFilterLink *link)
Test if a frame is available on the link.
static void copy(const float *p1, float *p2, const int length)
int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
Evaluate the timeline expression of the link for the time and properties of the frame.
#define FF_TPRINTF_START(ctx, func)
void avfilter_link_set_closed(AVFilterLink *link, int closed)
Set the closed field of a link.
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
int sample_rate
Sample rate of the audio data.
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
#define AV_NOPTS_VALUE
Undefined timestamp value.
static int set_enable_expr(AVFilterContext *ctx, const char *expr)
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
static const int8_t filt[NUMTAPS]
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
void avfilter_link_free(AVFilterLink **link)
Free the link in *link, and set its pointer to NULL.
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
int needs_writable
The filter expects writable frames from its input link, duplicating data buffers if needed.
uint64_t channel_layout
Channel layout of the audio data.
const AVOption * av_opt_find2(void *obj, const char *name, const char *unit, int opt_flags, int search_flags, void **target_obj)
Look for an option in an object.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
#define AV_LOG_INFO
Standard information.
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
AVFrame * ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
Access a frame in the queue, without removing it.
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
int av_samples_copy(uint8_t **dst, uint8_t *const *src, int dst_offset, int src_offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Copy samples from src to dst.
static const AVOption avfilter_options[]
static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
#define i(width, name, range_min, range_max)
static void * filter_child_next(void *obj, void *prev)
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.
uint8_t ** extended_data
pointers to the data planes/channels.
static int filter_frame(DBEContext *s, AVFrame *frame)
#define av_malloc_array(a, b)
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
static int samples_ready(AVFilterLink *link, unsigned min)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static uint64_t ff_framequeue_queued_samples(const FFFrameQueue *fq)
Get the number of queued samples.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
int ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, AVFilterPad **pads, AVFilterLink ***links, AVFilterPad *newpad)
Insert a new pad.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Pad name.
int ff_inlink_queued_samples(AVFilterLink *link)
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
This struct describes a set or pool of "hardware" frames (i.e.
enum AVMediaType type
AVFilterPad type.
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 links
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
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
const char * avfilter_configuration(void)
Return the libavfilter build-time configuration.
int av_opt_get_key_value(const char **ropts, const char *key_val_sep, const char *pairs_sep, unsigned flags, char **rkey, char **rval)
Extract a key-value pair from the beginning of a string.
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
static size_t ff_framequeue_queued_frames(const FFFrameQueue *fq)
Get the number of queued frames.
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame.
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
const struct AVOption * option
a pointer to the first option specified in the class if any or NULL
void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
Remove a filter from a graph;.
int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
Initialize a filter with the supplied dictionary of options.
void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
Update the position of a link in the age heap.
void ff_tlog_ref(void *ctx, AVFrame *ref, int end)
void * enable
parsed expression (AVExpr*)
static int ref[MAX_W *MAX_W]
Filter the word “frame” indicates either a video frame or a group of audio samples
void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
char * arg
optional argument for the command
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
char * av_strdup(const char *s)
Duplicate a string.
void avfilter_free(AVFilterContext *filter)
Free a filter context.
static int default_filter_frame(AVFilterLink *link, AVFrame *frame)
int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
Process the commands queued in the link up to the time of the frame.
#define AVFILTER_FLAG_SUPPORT_TIMELINE
Handy mask to test whether the filter supports or no the timeline feature (internally or generically)...
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
static const char *const var_names[]
static int ff_filter_activate_default(AVFilterContext *filter)
int avfilter_link_get_channels(AVFilterLink *link)
#define flags(name, subs,...)
const AVFilter * filter
the AVFilter of which this is an instance
@ AV_OPT_FLAG_IMPLICIT_KEY
Accept to parse a value without a key; the key will then be returned as NULL.
unsigned avfilter_version(void)
Return the LIBAVFILTER_VERSION_INT constant.
const AVClass * avfilter_get_class(void)
static int request_frame(AVFilterLink *outlink)
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
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.
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.
int ff_filter_init_hw_frames(AVFilterContext *avctx, AVFilterLink *link, int default_pool_size)
Perform any additional setup required for hardware frames.
double time
time expressed in seconds