VAR_VARS_NB
};
-typedef struct {
+typedef struct EvalContext {
const AVClass *class;
char *sample_rate_str;
int sample_rate;
#include "avfilter.h"
#include "internal.h"
-typedef struct {
+typedef struct AudioFadeContext {
const AVClass *class;
int type;
int curve, curve2;
#define SWR_CH_MAX 64
-typedef struct {
+typedef struct AMergeContext {
const AVClass *class;
int nb_inputs;
int route[SWR_CH_MAX]; /**< channels routing, see copy_samples */
#include "audio.h"
#include "internal.h"
-typedef struct {
+typedef struct APadContext {
const AVClass *class;
int64_t next_pts;
#include "audio.h"
#include "internal.h"
-typedef struct {
+typedef struct AResampleContext {
const AVClass *class;
int sample_rate_arg;
double ratio;
#include "internal.h"
#include "formats.h"
-typedef struct {
+typedef struct ASNSContext {
const AVClass *class;
int nb_out_samples; ///< how many samples to output
AVAudioFifo *fifo; ///< samples are queued here
#include "avfilter.h"
#include "internal.h"
-typedef struct {
+typedef struct ASetRateContext {
const AVClass *class;
int sample_rate;
int rescale_pts;
uint64_t nb_samples;
} ChannelStats;
-typedef struct {
+typedef struct AudioStatsContext {
const AVClass *class;
ChannelStats *chstats;
int nb_channels;
/**
* A fragment of audio waveform
*/
-typedef struct {
+typedef struct AudioFragment {
// index of the first sample of this fragment in the overall waveform;
// 0: input sample position
// 1: output sample position
/**
* Filter state machine
*/
-typedef struct {
+typedef struct ATempoContext {
const AVClass *class;
// ring-buffer of input samples, necessary because some times
0, -5,
4, 0};
-typedef struct {
+typedef struct EarwaxContext {
int16_t taps[NUMTAPS * 2];
} EarwaxContext;
};
#define NB_GAIN_ENTRY_MAX 4096
-typedef struct {
+typedef struct GainEntry {
double freq;
double gain;
} GainEntry;
-typedef struct {
+typedef struct OverlapIndex {
int buf_idx;
int overlap_idx;
} OverlapIndex;
-typedef struct {
+typedef struct FIREqualizerContext {
const AVClass *class;
RDFTContext *analysis_rdft;
/** tone generator: sample_number, frequency, sample_rate, amplitude */
#define TONEGEN16(sn, f, sr, a) (int16_t)(sin((6.28318530718 * (sn) * (f)) /(sr)) * (a) * 0x7fff)
-typedef struct {
+typedef struct hdcd_state {
uint64_t window;
unsigned char readahead;
"?", "A", "B", "A+B"
};
-typedef struct {
+typedef struct hdcd_detection_data {
hdcd_dv hdcd_detected;
hdcd_pf packet_type;
int total_packets; /**< valid packets */
#include "avfilter.h"
#include "internal.h"
-typedef struct {
+typedef struct VolDetectContext {
/**
* Number of samples at each PCM value.
* histogram[0x8000 + i] is the number of samples at value i.
#include "libavutil/lfg.h"
#include "libavutil/random_seed.h"
-typedef struct {
+typedef struct ANoiseSrcContext {
const AVClass *class;
int sample_rate;
double amplitude;
#include "avfilter.h"
#include "internal.h"
-typedef struct {
+typedef struct ANullContext {
const AVClass *class;
char *channel_layout_str;
uint64_t channel_layout;
#include "formats.h"
#include "internal.h"
-typedef struct {
+typedef struct FliteContext {
const AVClass *class;
char *voice_str;
char *textfile;
#include "avfilter.h"
#include "internal.h"
-typedef struct {
+typedef struct SineContext {
const AVClass *class;
double frequency;
double beep_factor;
#define TYPE_ALL 2
-typedef struct {
+typedef struct ConcatContext {
const AVClass *class;
unsigned nb_streams[TYPE_ALL]; /**< number of out streams of each type */
unsigned nb_segments;
#include "avfilter.h"
#include "internal.h"
-typedef struct {
+typedef struct Coeffs {
FFTSample *val;
int start, len;
} Coeffs;
-typedef struct {
+typedef struct RGBFloat {
float r, g, b;
} RGBFloat;
-typedef struct {
+typedef struct YUVFloat {
float y, u, v;
} YUVFloat;
YUVFloat yuv;
} ColorFloat;
-typedef struct {
+typedef struct ShowCQTContext {
const AVClass *class;
AVFilterContext *ctx;
AVFrame *axis_frame;
enum SlideMode { REPLACE, SCROLL, FULLFRAME, RSCROLL, NB_SLIDES };
enum Orientation { VERTICAL, HORIZONTAL, NB_ORIENTATIONS };
-typedef struct {
+typedef struct ShowSpectrumContext {
const AVClass *class;
int w, h;
AVFrame *outpicref;
struct frame_node *next;
};
-typedef struct {
+typedef struct ShowWavesContext {
const AVClass *class;
int w, h;
AVRational rate;
#include <stdint.h>
-typedef struct {
+typedef struct FFBoundingBox {
int x1, x2, y1, y2;
} FFBoundingBox;
/**
* Struct to use for initializing a buffersink context.
*/
-typedef struct {
+typedef struct AVBufferSinkParams {
const enum AVPixelFormat *pixel_fmts; ///< list of allowed pixel formats, terminated by AV_PIX_FMT_NONE
} AVBufferSinkParams;
/**
* Struct to use for initializing an abuffersink context.
*/
-typedef struct {
+typedef struct AVABufferSinkParams {
const enum AVSampleFormat *sample_fmts; ///< list of allowed sample formats, terminated by AV_SAMPLE_FMT_NONE
const int64_t *channel_layouts; ///< list of allowed channel layouts, terminated by -1
const int *channel_counts; ///< list of allowed channel counts, terminated by -1
SEARCH_COUNT
};
-typedef struct {
+typedef struct IntMotionVector {
int x; ///< Horizontal shift
int y; ///< Vertical shift
} IntMotionVector;
-typedef struct {
+typedef struct MotionVector {
double x; ///< Horizontal shift
double y; ///< Vertical shift
} MotionVector;
-typedef struct {
+typedef struct Transform {
MotionVector vec; ///< Motion vector
double angle; ///< Angle of rotation
double zoom; ///< Zoom percentage
#if CONFIG_OPENCL
-typedef struct {
+typedef struct DeshakeOpenclContext {
cl_command_queue command_queue;
cl_program program;
cl_kernel kernel_luma;
#define MAX_R 64
-typedef struct {
+typedef struct DeshakeContext {
const AVClass *class;
int counts[2*MAX_R+1][2*MAX_R+1]; /// < Scratch buffer for motion search
double *angles; ///< Scratch buffer for block angles
#include "deshake.h"
-typedef struct {
+typedef struct float4 {
float x;
float y;
float z;
#include "framesync.h"
#include "internal.h"
-typedef struct {
+typedef struct FFDualInputContext {
FFFrameSync fs;
AVFrame *(*process)(AVFilterContext *ctx, AVFrame *main, const AVFrame *second);
*
* You should not need to modify this struct directly.
*/
-typedef struct {
+typedef struct FFEBUR128State {
int mode; /**< The current mode. */
unsigned int channels; /**< The number of channels. */
unsigned long samplerate; /**< The sample rate. */
NB_ACTION
};
-typedef struct {
+typedef struct BenchContext {
const AVClass *class;
int action;
int64_t max, min;
struct rect { int x, y, w, h; };
-typedef struct {
+typedef struct EBUR128Context {
const AVClass *class; ///< AVClass context for log and options purpose
/* peak metering */
#include "audio.h"
#include "video.h"
-typedef struct {
+typedef struct InterleaveContext {
const AVClass *class;
int nb_inputs;
struct FFBufQueue *queues;
NB_MODES
};
-typedef struct {
+typedef struct PermsContext {
const AVClass *class;
AVLFG lfg;
int64_t random_seed;
return pbuf->str;
}
-typedef struct {
+typedef struct Command {
int flags;
char *target, *command, *arg;
int index;
} Command;
-typedef struct {
+typedef struct Interval {
int64_t start_ts; ///< start timestamp expressed as microseconds units
int64_t end_ts; ///< end timestamp expressed as microseconds units
int index; ///< unique index for these interval commands
int enabled; ///< current time detected inside this interval
} Interval;
-typedef struct {
+typedef struct SendCmdContext {
const AVClass *class;
Interval *intervals;
int nb_intervals;
#include "audio.h"
#include "video.h"
-typedef struct {
+typedef struct ZMQContext {
const AVClass *class;
void *zmq;
void *responder;
zmq_ctx_destroy(zmq->zmq);
}
-typedef struct {
+typedef struct Command {
char *target, *command, *arg;
} Command;
NB_FORMATS
};
-typedef struct {
+typedef struct Point {
uint8_t x;
uint8_t y;
} Point;
-typedef struct {
+typedef struct Block {
Point up;
Point to;
} Block;
-typedef struct {
+typedef struct ElemCat {
int av_elem; /* average element category */
short left_count; /* count of blocks that will be added together */
short block_count; /* count of blocks per element */
struct MatchingInfo* next;
} MatchingInfo;
-typedef struct {
+typedef struct StreamContext {
AVRational time_base;
/* needed for xml_export */
int w; /* height */
int exported; /* boolean whether stream already exported */
} StreamContext;
-typedef struct {
+typedef struct SignatureContext {
const AVClass *class;
/* input parameters */
int mode;
FineSignature *b[COARSE_SIZE];
} pairs[COARSE_SIZE];
- typedef struct {
+ typedef struct hspace_elem {
int dist;
size_t score;
FineSignature *a;
MODE_NB,
};
-typedef struct {
+typedef struct TInterlaceContext {
const AVClass *class;
int mode; ///< TInterlaceMode, interlace mode selected
AVRational preout_time_base;
#if CONFIG_OPENCL
-typedef struct {
+typedef struct UnsharpOpenclContext {
cl_command_queue command_queue;
cl_program program;
cl_kernel kernel_default;
enum { Y, U, V, A };
-typedef struct {
+typedef struct AlphaMergeContext {
int is_packed_rgb;
uint8_t rgba_map[4];
struct FFBufQueue queue_main;
#include "bbox.h"
#include "internal.h"
-typedef struct {
+typedef struct BBoxContext {
const AVClass *class;
int min_val;
} BBoxContext;
#include "avfilter.h"
#include "internal.h"
-typedef struct {
+typedef struct BlackDetectContext {
const AVClass *class;
double black_min_duration_time; ///< minimum duration of detected black, in seconds
int64_t black_min_duration; ///< minimum duration of detected black, expressed in timebase units
#define FRAME_TYPE_P (1<<1)
#define FRAME_TYPE_B (1<<2)
-typedef struct {
+typedef struct CodecViewContext {
const AVClass *class;
unsigned mv;
unsigned frame_type;
#define B 2
#define A 3
-typedef struct {
+typedef struct Range {
double shadows;
double midtones;
double highlights;
} Range;
-typedef struct {
+typedef struct ColorBalanceContext {
const AVClass *class;
Range cyan_red;
Range magenta_green;
#define B 2
#define A 3
-typedef struct {
+typedef struct ColorChannelMixerContext {
const AVClass *class;
double rr, rg, rb, ra;
double gr, gg, gb, ga;
#define B 2
#define A 3
-typedef struct {
+typedef struct Range {
double in_min, in_max;
double out_min, out_max;
} Range;
-typedef struct {
+typedef struct ColorLevelsContext {
const AVClass *class;
Range range[4];
int nb_comp;
COLOR_MODE_COUNT
};
-typedef struct {
+typedef struct ColorMatrixContext {
const AVClass *class;
int yuv_convert[25][3][3];
int interlaced;
NB_PRESETS,
};
-typedef struct {
+typedef struct CurvesContext {
const AVClass *class;
int preset;
char *comp_points_str[NB_COMP + 1];
int64_t totdiff;
};
-typedef struct {
+typedef struct DecimateContext {
const AVClass *class;
struct qitem *queue; ///< window of cycle frames and the associated data diff
int fid; ///< current frame id in the queue
#include "internal.h"
#include "video.h"
-typedef struct {
+typedef struct DejudderContext {
const AVClass *class;
int64_t *ringbuff;
int i1, i2, i3, i4;
#include "internal.h"
#include "video.h"
-typedef struct {
+typedef struct DetelecineContext {
const AVClass *class;
int first_field;
char *pattern;
char *directions;
};
-typedef struct {
+typedef struct EdgeDetectContext {
const AVClass *class;
struct plane_info planes[3];
int nb_planes;
} EQParameters;
-typedef struct {
+typedef struct EQContext {
const AVClass *class;
EQParameters param[3];
#define PLANE_U 0x20
#define PLANE_V 0x40
-typedef struct {
+typedef struct ExtractPlanesContext {
const AVClass *class;
int requested_planes;
int map[4];
#define MAX_PLANES 4
-typedef struct {
+typedef struct FFTFILTContext {
const AVClass *class;
RDFTContext *rdft;
enum FieldType { FIELD_TYPE_TOP = 0, FIELD_TYPE_BOTTOM };
-typedef struct {
+typedef struct FieldContext {
const AVClass *class;
int type; ///< FieldType
int nb_planes; ///< number of planes of the current format
NB_COMBDBG
};
-typedef struct {
+typedef struct FieldMatchContext {
const AVClass *class;
AVFrame *prv, *src, *nxt; ///< main sliding window of 3 frames
#include "libavutil/pixdesc.h"
#include "internal.h"
-typedef struct {
+typedef struct GEQContext {
const AVClass *class;
AVExpr *e[4]; ///< expressions for each plane
char *expr_str[4+3]; ///< expression strings for each plane
HISTEQ_ANTIBANDING_NB,
};
-typedef struct {
+typedef struct HisteqContext {
const AVClass *class;
float strength;
float intensity;
typedef int (*hqxfunc_t)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
-typedef struct {
+typedef struct HQXContext {
const AVClass *class;
int n;
hqxfunc_t func;
VAR_NB
};
-typedef struct {
+typedef struct HueContext {
const AVClass *class;
float hue_deg; /* hue expressed in degrees */
float hue; /* hue expressed in radians */
REPEAT_BOTTOM,
} RepeatedField;
-typedef struct {
+typedef struct IDETContext {
const AVClass *class;
float interlace_threshold;
float progressive_threshold;
MODE_DEINTERLEAVE
};
-typedef struct {
+typedef struct IlContext {
const AVClass *class;
int luma_mode, chroma_mode, alpha_mode; ///<FilterMode
int luma_swap, chroma_swap, alpha_swap;
#include "formats.h"
#include "internal.h"
-typedef struct {
+typedef struct KerndeintContext {
const AVClass *class;
int frame; ///< frame count, starting from 0
int thresh, map, order, sharp, twoway;
PARITY_BFF = 1, ///< bottom field first
};
-typedef struct {
+typedef struct MCDeintContext {
const AVClass *class;
int mode; ///< MCDeintMode
int parity; ///< MCDeintParity
#include "formats.h"
#include "video.h"
-typedef struct {
+typedef struct DecimateContext {
const AVClass *class;
int lo, hi; ///< lower and higher threshold number of differences
///< values for 8x8 blocks
#define WEIGHT_LUT_NBITS 9
#define WEIGHT_LUT_SIZE (1<<WEIGHT_LUT_NBITS)
-typedef struct {
+typedef struct NLMeansContext {
const AVClass *class;
int nb_planes;
int chroma_w, chroma_h;
#define NOISE_AVERAGED 8
#define NOISE_PATTERN 16
-typedef struct {
+typedef struct FilterParams {
int strength;
unsigned flags;
AVLFG lfg;
int rand_shift_init;
} FilterParams;
-typedef struct {
+typedef struct NoiseContext {
const AVClass *class;
int nb_planes;
int bytewidth[4];
#include "avfilter.h"
#include "internal.h"
-typedef struct {
+typedef struct OWDenoiseContext {
const AVClass *class;
double luma_strength;
double chroma_strength;
#define NBITS 5
#define HIST_SIZE (1<<(3*NBITS))
-typedef struct {
+typedef struct PaletteGenContext {
const AVClass *class;
int max_colors;
#include "libpostproc/postprocess.h"
-typedef struct {
+typedef struct PPFilterContext {
const AVClass *class;
char *subfilters;
int mode_id;
#include "lavfutils.h"
#include "lswsutils.h"
-typedef struct {
+typedef struct RemovelogoContext {
const AVClass *class;
char *filename;
/* Stores our collection of masks. The first is for an array of
#include "formats.h"
#include "internal.h"
-typedef struct {
+typedef struct FilterParam {
float radius;
float pre_filter_radius;
float strength;
int color_diff_coeff[COLOR_DIFF_COEFF_SIZE];
} FilterParam;
-typedef struct {
+typedef struct SabContext {
const AVClass *class;
FilterParam luma;
FilterParam chroma;
AVFrame *in, *out;
} ThreadData;
-typedef struct {
+typedef struct SelectiveColorContext {
const AVClass *class;
int correction_method;
char *opt_cmyk_adjust[NB_RANGES];
#include "avfilter.h"
#include "internal.h"
-typedef struct {
+typedef struct SeparateFieldsContext {
int nb_planes;
AVFrame *second;
} SeparateFieldsContext;
MODE_PROG,
};
-typedef struct {
+typedef struct SetFieldContext {
const AVClass *class;
int mode; ///< SetFieldMode
} SetFieldContext;
#include "internal.h"
#include "video.h"
-typedef struct {
+typedef struct ShowPaletteContext {
const AVClass *class;
int size;
} ShowPaletteContext;
FILT_NUMB
};
-typedef struct {
+typedef struct SignalstatsContext {
const AVClass *class;
int chromah; // height of chroma plane
int chromaw; // width of chroma plane
#define THRESHOLD_MIN -30
#define THRESHOLD_MAX 30
-typedef struct {
+typedef struct FilterParam {
float radius;
float strength;
int threshold;
struct SwsContext *filter_context;
} FilterParam;
-typedef struct {
+typedef struct SmartblurContext {
const AVClass *class;
FilterParam luma;
FilterParam chroma;
#define MAX_LEVEL 6 /* quality levels */
-typedef struct {
+typedef struct SPPContext {
const AVClass *av_class;
int log2_count;
#include "formats.h"
#include "video.h"
-typedef struct {
+typedef struct AssContext {
const AVClass *class;
ASS_Library *library;
ASS_Renderer *renderer;
#include "internal.h"
#include "video.h"
-typedef struct {
+typedef struct Super2xSaIContext {
/* masks used for two pixels interpolation */
uint32_t hi_pixel_mask;
uint32_t lo_pixel_mask;
#include "internal.h"
#include "video.h"
-typedef struct {
+typedef struct TelecineContext {
const AVClass *class;
int first_field;
char *pattern;
int histogram[HIST_SIZE]; ///< RGB color distribution histogram of the frame
};
-typedef struct {
+typedef struct ThumbContext {
const AVClass *class;
int n; ///< current frame
int n_frames; ///< number of frames for analysis
#include "video.h"
#include "internal.h"
-typedef struct {
+typedef struct TileContext {
const AVClass *class;
unsigned w, h;
unsigned margin;
#define MAX_LEVEL 8 /* quality levels */
#define BLOCK 16
-typedef struct {
+typedef struct USPPContext {
const AVClass *av_class;
int log2_count;
int hsub, vsub;
#include "vidstabutils.h"
-typedef struct {
+typedef struct StabData {
const AVClass *class;
VSMotionDetect md;
#include "vidstabutils.h"
-typedef struct {
+typedef struct TransformContext {
const AVClass *class;
VSTransformData td;
EVAL_MODE_NB
};
-typedef struct {
+typedef struct VignetteContext {
const AVClass *class;
const AVPixFmtDescriptor *desc;
int backward;
typedef int (*xbrfunc_t)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
-typedef struct {
+typedef struct XBRContext {
const AVClass *class;
int n;
xbrfunc_t func;
}
/** struct to hold a valid context for logging from within vid.stab lib */
-typedef struct {
+typedef struct VS2AVLogCtx {
const AVClass *class;
} VS2AVLogCtx;
#include "formats.h"
#include "video.h"
-typedef struct {
+typedef struct CellAutoContext {
const AVClass *class;
int w, h;
char *filename;
#include "formats.h"
#include "video.h"
-typedef struct {
+typedef struct LifeContext {
const AVClass *class;
int w, h;
char *filename;
uint32_t val;
} Point;
-typedef struct {
+typedef struct MBContext {
const AVClass *class;
int w, h;
AVRational frame_rate;
projects / ffmpeg / commitdiff