162 #define OFFSET(x) offsetof(SelectContext, x) 163 #define DEFINE_OPTIONS(filt_name, FLAGS) \ 164 static const AVOption filt_name##_options[] = { \ 165 { "expr", "set an expression to use for selecting frames", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "1" }, .flags=FLAGS }, \ 166 { "e", "set an expression to use for selecting frames", OFFSET(expr_str), AV_OPT_TYPE_STRING, { .str = "1" }, .flags=FLAGS }, \ 167 { "outputs", "set the number of outputs", OFFSET(nb_outputs), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, .flags=FLAGS }, \ 168 { "n", "set the number of outputs", OFFSET(nb_outputs), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, .flags=FLAGS }, \ 204 #define INTERLACE_TYPE_P 0 205 #define INTERLACE_TYPE_T 1 206 #define INTERLACE_TYPE_B 2 219 for (
int plane = 0; plane < select->
nb_planes; plane++) {
286 for (
int plane = 0; plane < select->
nb_planes; plane++) {
290 select->
width[plane], select->
height[plane], &plane_sad);
292 count += select->
width[plane] * select->
height[plane];
296 mafd = (double)sad / count / (1ULL << (select->
bitdepth - 8));
311 if (start_time_entry) {
313 if (pts >= start_time) {
314 if (duration_entry) {
316 if (pts < start_time + duration)
346 switch (inlink->
type) {
368 "n:%f pts:%f t:%f key:%d",
374 switch (inlink->
type) {
391 }
else if (
isnan(res) || res < 0) {
448 #if CONFIG_ASELECT_FILTER 458 if ((ret =
init(ctx)) < 0)
469 static const AVFilterPad avfilter_af_aselect_inputs[] = {
482 .init = aselect_init,
485 .
inputs = avfilter_af_aselect_inputs,
486 .priv_class = &aselect_class,
491 #if CONFIG_SELECT_FILTER 527 if ((ret =
init(ctx)) < 0)
533 static const AVFilterPad avfilter_vf_select_inputs[] = {
550 .priv_class = &select_class,
551 .
inputs = avfilter_vf_select_inputs,
void(* ff_scene_sad_fn)(SCENE_SAD_PARAMS)
int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
Compute the size of an image line with format pix_fmt and width width for the plane plane...
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
static av_cold void uninit(AVFilterContext *ctx)
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Main libavfilter public API header.
packed RGB 8:8:8, 24bpp, RGBRGB...
ff_scene_sad_fn ff_scene_sad_get_fn(int depth)
int h
agreed upon image height
#define AV_OPT_FLAG_AUDIO_PARAM
static __device__ float ceilf(float a)
enum AVMediaType type
AVFilterPad type.
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.
static double get_concatdec_select(AVFrame *frame, int64_t pts)
const char * name
Pad name.
AVFilterLink ** inputs
array of pointers to input links
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
AVFilterPad * output_pads
array of output pads
static int64_t start_time
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
ff_scene_sad_fn sad
Sum of the absolute difference function (scene detect only)
static void select_frame(AVFilterContext *ctx, AVFrame *frame)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
AVDictionary * metadata
metadata.
int interlaced_frame
The content of the picture is interlaced.
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
A filter pad used for either input or output.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
A link between two filters.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
int sample_rate
samples per second
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
static __device__ float fabs(float a)
double var_values[VAR_VARS_NB]
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
unsigned nb_outputs
number of output pads
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
void * priv
private data for use by the filter
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link...
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
int select_out
mark the selected output pad index
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int w
agreed upon image width
char * av_asprintf(const char *fmt,...)
static int config_input(AVFilterLink *inlink)
common internal API header
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
uint8_t nb_components
The number of components each pixel has, (1-4)
enum AVPictureType pict_type
Picture type of the frame.
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
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
packed RGB 8:8:8, 24bpp, BGRBGR...
AVFilterContext * src
source filter
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
int format
agreed upon media format
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
const AVFilterPad * inputs
List of inputs, terminated by a zeroed element.
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define AV_OPT_FLAG_VIDEO_PARAM
static double get_scene_score(AVFilterContext *ctx, AVFrame *frame)
a very simple circular buffer FIFO implementation
double prev_mafd
previous MAFD (scene detect only)
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
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
#define AV_PIX_FMT_YUV420P10
Describe the class of an AVClass context structure.
const char * name
Filter name.
AVFilterLink ** outputs
array of pointers to output links
static enum AVPixelFormat pix_fmts[]
static int request_frame(AVFilterLink *outlink)
#define flags(name, subs,...)
enum AVMediaType type
filter media type
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int do_scene_detect
1 if the expression requires scene detection variables, 0 otherwise
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
AVFrame * prev_picref
previous frame (scene detect only)
#define DEFINE_OPTIONS(filt_name, FLAGS)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static int query_formats(AVFilterContext *ctx)
static av_cold int init(AVFilterContext *ctx)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int top_field_first
If the content is interlaced, is top field displayed first.
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
AVFilterContext * dst
dest filter
#define AVFILTER_DEFINE_CLASS(fname)
int key_frame
1 -> keyframe, 0-> not
int(* request_frame)(AVFilterLink *link)
Frame request callback.
static const char *const var_names[]
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end 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
int depth
Number of bits in the component.
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
AVPixelFormat
Pixel format.
int nb_samples
number of audio samples (per channel) described by this frame
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
const AVFilter * filter
the AVFilter of which this is an instance
simple arithmetic expression evaluator
#define AV_CEIL_RSHIFT(a, b)