53 #define OFFSET(x) offsetof(W3FDIFContext, x) 54 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM 55 #define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, 0, 0, FLAGS, unit } 62 CONST(
"frame",
"send one frame for each frame", 0,
"mode"),
63 CONST(
"field",
"send one frame for each field", 1,
"mode"),
65 CONST(
"tff",
"assume top field first", 0,
"parity"),
66 CONST(
"bff",
"assume bottom field first", 1,
"parity"),
67 CONST(
"auto",
"auto detect parity", -1,
"parity"),
69 CONST(
"all",
"deinterlace all frames", 0,
"deint"),
70 CONST(
"interlaced",
"only deinterlace frames marked as interlaced", 1,
"deint"),
117 *work_line = *in_lines_cur[0]++ * coef[0];
118 *work_line++ += *in_lines_cur[1]++ * coef[1];
129 *work_line = *in_lines_cur[0]++ * coef[0];
130 *work_line += *in_lines_cur[1]++ * coef[1];
131 *work_line += *in_lines_cur[2]++ * coef[2];
132 *work_line++ += *in_lines_cur[3]++ * coef[3];
144 *work_line += *in_lines_cur[0]++ * coef[0];
145 *work_line += *in_lines_adj[0]++ * coef[0];
146 *work_line += *in_lines_cur[1]++ * coef[1];
147 *work_line += *in_lines_adj[1]++ * coef[1];
148 *work_line += *in_lines_cur[2]++ * coef[2];
149 *work_line++ += *in_lines_adj[2]++ * coef[2];
161 *work_line += *in_lines_cur[0]++ * coef[0];
162 *work_line += *in_lines_adj[0]++ * coef[0];
163 *work_line += *in_lines_cur[1]++ * coef[1];
164 *work_line += *in_lines_adj[1]++ * coef[1];
165 *work_line += *in_lines_cur[2]++ * coef[2];
166 *work_line += *in_lines_adj[2]++ * coef[2];
167 *work_line += *in_lines_cur[3]++ * coef[3];
168 *work_line += *in_lines_adj[3]++ * coef[3];
169 *work_line += *in_lines_cur[4]++ * coef[4];
170 *work_line++ += *in_lines_adj[4]++ * coef[4];
178 for (j = 0; j <
linesize; j++, out_pixel++, work_pixel++)
179 *out_pixel =
av_clip(*work_pixel, 0, 255 * 256 * 128) >> 15;
186 uint16_t *in_lines_cur[2] = { (uint16_t *)in_lines_cur8[0], (uint16_t *)in_lines_cur8[1] };
191 *work_line = *in_lines_cur[0]++ * coef[0];
192 *work_line++ += *in_lines_cur[1]++ * coef[1];
200 uint16_t *in_lines_cur[4] = { (uint16_t *)in_lines_cur8[0],
201 (uint16_t *)in_lines_cur8[1],
202 (uint16_t *)in_lines_cur8[2],
203 (uint16_t *)in_lines_cur8[3] };
208 *work_line = *in_lines_cur[0]++ * coef[0];
209 *work_line += *in_lines_cur[1]++ * coef[1];
210 *work_line += *in_lines_cur[2]++ * coef[2];
211 *work_line++ += *in_lines_cur[3]++ * coef[3];
220 uint16_t *in_lines_cur[3] = { (uint16_t *)in_lines_cur8[0],
221 (uint16_t *)in_lines_cur8[1],
222 (uint16_t *)in_lines_cur8[2] };
223 uint16_t *in_lines_adj[3] = { (uint16_t *)in_lines_adj8[0],
224 (uint16_t *)in_lines_adj8[1],
225 (uint16_t *)in_lines_adj8[2] };
230 *work_line += *in_lines_cur[0]++ * coef[0];
231 *work_line += *in_lines_adj[0]++ * coef[0];
232 *work_line += *in_lines_cur[1]++ * coef[1];
233 *work_line += *in_lines_adj[1]++ * coef[1];
234 *work_line += *in_lines_cur[2]++ * coef[2];
235 *work_line++ += *in_lines_adj[2]++ * coef[2];
244 uint16_t *in_lines_cur[5] = { (uint16_t *)in_lines_cur8[0],
245 (uint16_t *)in_lines_cur8[1],
246 (uint16_t *)in_lines_cur8[2],
247 (uint16_t *)in_lines_cur8[3],
248 (uint16_t *)in_lines_cur8[4] };
249 uint16_t *in_lines_adj[5] = { (uint16_t *)in_lines_adj8[0],
250 (uint16_t *)in_lines_adj8[1],
251 (uint16_t *)in_lines_adj8[2],
252 (uint16_t *)in_lines_adj8[3],
253 (uint16_t *)in_lines_adj8[4] };
258 *work_line += *in_lines_cur[0]++ * coef[0];
259 *work_line += *in_lines_adj[0]++ * coef[0];
260 *work_line += *in_lines_cur[1]++ * coef[1];
261 *work_line += *in_lines_adj[1]++ * coef[1];
262 *work_line += *in_lines_cur[2]++ * coef[2];
263 *work_line += *in_lines_adj[2]++ * coef[2];
264 *work_line += *in_lines_cur[3]++ * coef[3];
265 *work_line += *in_lines_adj[3]++ * coef[3];
266 *work_line += *in_lines_cur[4]++ * coef[4];
267 *work_line++ += *in_lines_adj[4]++ * coef[4];
273 uint16_t *out_pixel = (uint16_t *)out_pixel8;
277 for (j = 0; j <
linesize; j++, out_pixel++, work_pixel++)
278 *out_pixel =
av_clip(*work_pixel, 0, max) >> 15;
312 s->
max = ((1 << depth) - 1) * 256 * 128;
354 static const int16_t
coef_lf[2][4] = {{ 16384, 16384, 0, 0},
355 { -852, 17236, 17236, -852}};
357 static const int16_t
coef_hf[2][5] = {{ -2048, 4096, -2048, 0, 0},
358 { 1016, -3801, 5570, -3801, 1016}};
365 int jobnr,
int nb_jobs,
int plane)
373 uint8_t *in_line, *in_lines_cur[5], *in_lines_adj[5];
381 const int cur_line_stride = cur->
linesize[plane];
382 const int adj_line_stride = adj->
linesize[plane];
383 const int dst_line_stride = out->
linesize[plane];
384 const int start = (height * jobnr) / nb_jobs;
385 const int end = (height * (jobnr+1)) / nb_jobs;
393 y_out = start + (tff ^ (start & 1));
395 in_line = cur_data + (y_out * cur_line_stride);
396 out_line = dst_data + (y_out * dst_line_stride);
398 while (y_out < end) {
399 memcpy(out_line, in_line, linesize);
401 in_line += cur_line_stride * 2;
402 out_line += dst_line_stride * 2;
406 y_out = start + ((!tff) ^ (start & 1));
408 out_line = dst_data + (y_out * dst_line_stride);
410 while (y_out < end) {
413 y_in = (y_out + 1) + (j * 2) - n_coef_lf[
filter];
417 while (y_in >= height)
420 in_lines_cur[j] = cur_data + (y_in * cur_line_stride);
424 switch (n_coef_lf[filter]) {
436 y_in = (y_out + 1) + (j * 2) - n_coef_hf[
filter];
440 while (y_in >= height)
443 in_lines_cur[j] = cur_data + (y_in * cur_line_stride);
444 in_lines_adj[j] = adj_data + (y_in * adj_line_stride);
448 switch (n_coef_hf[filter]) {
460 out_pixel = out_line;
466 out_line += dst_line_stride * 2;
473 int jobnr,
int nb_jobs)
500 int64_t cur_pts = s->
cur->
pts;
501 int64_t next_pts = s->
next->
pts;
504 out->
pts = cur_pts + next_pts;
552 if (ret < 0 || s->
mode == 0)
576 }
else if (ret < 0) {
622 .priv_class = &w3fdif_class,
#define AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_YUVA422P9
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
#define AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_YUVA422P10
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Main libavfilter public API header.
static void filter16_scale(uint8_t *out_pixel8, const int32_t *work_pixel, int linesize, int max)
int h
agreed upon image height
#define AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_YUV420P12
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
int is_disabled
the enabled state from the last expression evaluation
static void filter_complex_low(int32_t *work_line, uint8_t *in_lines_cur[4], const int16_t *coef, int linesize)
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
#define AV_PIX_FMT_GRAY10
const char * name
Pad name.
#define AV_PIX_FMT_GRAY12
static const AVOption w3fdif_options[]
AVFilterLink ** inputs
array of pointers to input links
static int config_input(AVFilterLink *inlink)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
AVFILTER_DEFINE_CLASS(w3fdif)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
#define AV_PIX_FMT_YUVA420P9
static void filter16_complex_high(int32_t *work_line, uint8_t *in_lines_cur8[5], uint8_t *in_lines_adj8[5], const int16_t *coef, int linesize)
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
void(* filter_complex_low)(int32_t *work_line, uint8_t *in_lines_cur[4], const int16_t *coef, int linesize)
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
static void filter_complex_high(int32_t *work_line, uint8_t *in_lines_cur[5], uint8_t *in_lines_adj[5], const int16_t *coef, int linesize)
#define AVERROR_EOF
End of file.
#define AV_PIX_FMT_YUV444P16
int interlaced_frame
The content of the picture is interlaced.
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUVA420P16
void(* filter_simple_high)(int32_t *work_line, uint8_t *in_lines_cur[3], uint8_t *in_lines_adj[3], const int16_t *coef, int linesize)
A filter pad used for either input or output.
int linesize[4]
bytes of pixel data per line for each plane
A link between two filters.
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
AVFrame * next
previous, current, next frames
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int query_formats(AVFilterContext *ctx)
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0, will be automatically copied from the first input of the source filter if it exists.
static const int16_t coef_hf[2][5]
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
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 * priv
private data for use by the filter
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
#define AV_PIX_FMT_YUVA444P16
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link...
#define AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_YUV444P10
int planeheight[4]
height of each plane
#define AV_PIX_FMT_GBRAP16
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int w
agreed upon image width
#define AV_PIX_FMT_YUV422P9
static void filter16_complex_low(int32_t *work_line, uint8_t *in_lines_cur8[4], const int16_t *coef, int linesize)
#define AV_PIX_FMT_GBRP16
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
#define AV_PIX_FMT_GRAY16
int field
which field are we on, 0 or 1
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
static int deinterlace_plane_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs, int plane)
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
#define AV_PIX_FMT_YUVA444P12
int mode
0 is frame, 1 is field
static const int16_t coef_lf[2][4]
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
void(* filter_scale)(uint8_t *out_pixel, const int32_t *work_pixel, int linesize, int max)
AVFilterContext * src
source filter
#define AV_PIX_FMT_YUVA444P10
static const int8_t n_coef_hf[2]
#define AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_GBRP14
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
static const AVFilterPad outputs[]
int format
agreed upon media format
#define AV_PIX_FMT_YUV420P16
static int config_output(AVFilterLink *outlink)
#define AV_PIX_FMT_YUV420P14
Used for passing data between threads.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define AV_PIX_FMT_GRAY14
static const int8_t n_coef_lf[2]
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
#define AV_PIX_FMT_YUV420P10
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Describe the class of an AVClass context structure.
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
const char * name
Filter name.
#define AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV420P9
static void filter16_simple_high(int32_t *work_line, uint8_t *in_lines_cur8[3], uint8_t *in_lines_adj8[3], const int16_t *coef, int linesize)
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
AVFilterLink ** outputs
array of pointers to output links
static enum AVPixelFormat pix_fmts[]
#define AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_GBRP12
#define flags(name, subs,...)
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV444P12
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define CONST(name, help, val, unit)
static const AVFilterPad w3fdif_inputs[]
void(* filter_simple_low)(int32_t *work_line, uint8_t *in_lines_cur[2], const int16_t *coef, int linesize)
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
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal and external API header
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
planar GBRA 4:4:4:4 32bpp
int deint
which frames to deinterlace
#define AV_PIX_FMT_YUVA444P9
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
static int deinterlace_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
void(* filter_complex_high)(int32_t *work_line, uint8_t *in_lines_cur[5], uint8_t *in_lines_adj[5], const int16_t *coef, int linesize)
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
int parity
frame field parity
avfilter_execute_func * execute
int top_field_first
If the content is interlaced, is top field displayed first.
AVFilterContext * dst
dest filter
static const AVFilterPad w3fdif_outputs[]
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
static void filter16_simple_low(int32_t *work_line, uint8_t *in_lines_cur8[2], const int16_t *coef, int linesize)
static av_cold void uninit(AVFilterContext *ctx)
void ff_w3fdif_init_x86(W3FDIFDSPContext *dsp, int depth)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
static void filter_scale(uint8_t *out_pixel, const int32_t *work_pixel, int linesize, int max)
static void filter_simple_low(int32_t *work_line, uint8_t *in_lines_cur[2], const int16_t *coef, int linesize)
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
int32_t ** work_line
lines we are calculating
static int request_frame(AVFilterLink *outlink)
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.
AVPixelFormat
Pixel format.
int filter
0 is simple, 1 is more complex
mode
Use these values in ebur128_init (or'ed).
static void filter_simple_high(int32_t *work_line, uint8_t *in_lines_cur[3], uint8_t *in_lines_adj[3], const int16_t *coef, int linesize)
#define AV_PIX_FMT_YUV422P16
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define AV_PIX_FMT_YUVA422P12
#define AV_CEIL_RSHIFT(a, b)