Go to the documentation of this file.
21 #include "config_components.h"
82 #define OFFSET(x) offsetof(LUT2Context, x)
83 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
84 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
103 for (
i = 0;
i < 4;
i++) {
112 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, \
113 AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, \
114 AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P, \
115 AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, \
116 AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, \
117 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
120 AV_PIX_FMT_GBRP9, AV_PIX_FMT_GRAY9, \
121 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, \
122 AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
125 AV_PIX_FMT_GRAY10, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10, \
126 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, \
127 AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
130 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12, \
131 AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12, \
132 AV_PIX_FMT_GRAY12, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRP12,
135 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, \
136 AV_PIX_FMT_GRAY14, AV_PIX_FMT_GBRP14,
139 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, \
140 AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16, \
141 AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GRAY16,
180 if (
s->tlut2 || !
s->odepth)
188 case 8:
pix_fmts = bit8_pix_fmts;
break;
189 case 9:
pix_fmts = bit9_pix_fmts;
break;
190 case 10:
pix_fmts = bit10_pix_fmts;
break;
191 case 12:
pix_fmts = bit12_pix_fmts;
break;
192 case 14:
pix_fmts = bit14_pix_fmts;
break;
193 case 16:
pix_fmts = bit16_pix_fmts;
break;
207 int vsub =
desc->log2_chroma_h;
211 s->heightx[0] =
s->heightx[3] =
inlink->h;
213 s->widthx[0] =
s->widthx[3] =
inlink->w;
217 s->depthx =
desc->comp[0].depth;
221 s->depthy =
desc->comp[0].depth;
234 int vsub =
desc->log2_chroma_h;
237 s->depthy =
desc->comp[0].depth;
240 s->heighty[0] =
s->heighty[3] =
inlink->h;
242 s->widthy[0] =
s->widthy[3] =
inlink->w;
247 #define DEFINE_LUT2(zname, xname, yname, ztype, xtype, ytype, zdiv, xdiv, ydiv) \
248 static int lut2_##zname##_##xname##_##yname(AVFilterContext *ctx, \
250 int jobnr, int nb_jobs) \
252 LUT2Context *s = ctx->priv; \
253 ThreadData *td = arg; \
254 AVFrame *out = td->out; \
255 AVFrame *srcx = td->srcx; \
256 AVFrame *srcy = td->srcy; \
257 const int odepth = s->odepth; \
260 for (p = 0; p < s->nb_planes; p++) { \
261 const int slice_start = (s->heightx[p] * jobnr) / nb_jobs; \
262 const int slice_end = (s->heightx[p] * (jobnr+1)) / nb_jobs; \
263 const uint16_t *lut = s->lut[p]; \
264 const xtype *srcxx; \
265 const ytype *srcyy; \
268 dst = (ztype *)(out->data[p] + slice_start * out->linesize[p]); \
269 srcxx = (const xtype *)(srcx->data[p] + slice_start * srcx->linesize[p]);\
270 srcyy = (const ytype *)(srcy->data[p] + slice_start * srcy->linesize[p]);\
272 for (y = slice_start; y < slice_end; y++) { \
273 for (x = 0; x < s->widthx[p]; x++) { \
274 dst[x] = av_clip_uintp2_c(lut[(srcyy[x] << s->depthx) | srcxx[x]], odepth); \
277 dst += out->linesize[p] / zdiv; \
278 srcxx += srcx->linesize[p] / xdiv; \
279 srcyy += srcy->linesize[p] / ydiv; \
285 DEFINE_LUT2(8, 8, 8, uint8_t, uint8_t, uint8_t, 1, 1, 1)
286 DEFINE_LUT2(8, 8, 16, uint8_t, uint8_t, uint16_t, 1, 1, 2)
287 DEFINE_LUT2(8, 16, 8, uint8_t, uint16_t, uint8_t, 1, 2, 1)
288 DEFINE_LUT2(8, 16, 16, uint8_t, uint16_t, uint16_t, 1, 2, 2)
289 DEFINE_LUT2(16, 8, 8, uint16_t, uint8_t, uint8_t, 2, 1, 1)
290 DEFINE_LUT2(16, 8, 16, uint16_t, uint8_t, uint16_t, 2, 1, 2)
291 DEFINE_LUT2(16, 16, 8, uint16_t, uint16_t, uint8_t, 2, 2, 1)
292 DEFINE_LUT2(16, 16, 16, uint16_t, uint16_t, uint16_t, 2, 2, 2)
306 if (
ctx->is_disabled || !srcy) {
336 s->depth =
s->depthx +
s->depthy;
337 s->nb_planes =
s->nb_planesx;
339 s->lut2 =
s->depth > 16 ? lut2_16_16_16 : lut2_8_8_8;
341 if (
s->depthx == 8 &&
s->depthy == 8 &&
s->odepth > 8)
342 s->lut2 = lut2_16_8_8;
343 if (
s->depthx > 8 &&
s->depthy == 8 &&
s->odepth > 8)
344 s->lut2 = lut2_16_16_8;
345 if (
s->depthx == 8 &&
s->depthy > 8 &&
s->odepth > 8)
346 s->lut2 = lut2_16_8_16;
347 if (
s->depthx == 8 &&
s->depthy == 8 &&
s->odepth == 8)
348 s->lut2 = lut2_8_8_8;
349 if (
s->depthx > 8 &&
s->depthy == 8 &&
s->odepth == 8)
350 s->lut2 = lut2_8_16_8;
351 if (
s->depthx == 8 &&
s->depthy > 8 &&
s->odepth == 8)
352 s->lut2 = lut2_8_8_16;
353 if (
s->depthx > 8 &&
s->depthy > 8 &&
s->odepth == 8)
354 s->lut2 = lut2_8_16_16;
356 s->odepth =
s->depthx;
359 for (p = 0; p <
s->nb_planes; p++) {
366 for (p = 0; p <
s->nb_planes; p++) {
372 s->comp_expr[p] =
NULL;
377 "Error when parsing the expression '%s' for the component %d.\n",
378 s->comp_expr_str[p], p);
383 for (y = 0; y < (1 <<
s->depthy); y++) {
385 for (x = 0; x < (1 <<
s->depthx); x++) {
390 "Error when evaluating the expression '%s' for the values %d and %d for the component %d.\n",
391 s->comp_expr_str[p], x, y, p);
395 s->lut[p][(y <<
s->depthx) + x] = res;
412 int vsub =
desc->log2_chroma_h;
415 outlink->
w = srcx->
w;
416 outlink->
h = srcx->
h;
423 s->height[0] =
s->height[3] = outlink->
h;
425 s->width[0] =
s->width[3] = outlink->
w;
432 if (srcx->
w != srcy->
w || srcx->
h != srcy->
h) {
434 "(size %dx%d) do not match the corresponding "
435 "second input link %s parameters (size %dx%d)\n",
436 ctx->input_pads[0].name, srcx->
w, srcx->
h,
437 ctx->input_pads[1].name,
442 if (
s->nb_planesx !=
s->nb_planesy) {
444 "(%d) do not match the corresponding "
445 "second input link %s number of planes (%d)\n",
446 ctx->input_pads[0].name,
s->nb_planesx,
447 ctx->input_pads[1].name,
s->nb_planesy);
451 if (
s->nb_planesx !=
s->nb_planes) {
453 "(%d) do not match the corresponding "
454 "output link %s number of planes (%d)\n",
455 ctx->input_pads[0].name,
s->nb_planesx,
456 ctx->output_pads[0].name,
s->nb_planes);
460 if (
s->widthx[1] !=
s->widthy[1] ||
s->heightx[1] !=
s->heighty[1]) {
462 "(size %dx%d) do not match the corresponding "
463 "second input link %s 2nd plane (size %dx%d)\n",
464 ctx->input_pads[0].name,
s->widthx[1],
s->heightx[1],
465 ctx->input_pads[1].name,
466 s->widthy[1],
s->heighty[1]);
470 if (
s->widthx[2] !=
s->widthy[2] ||
s->heightx[2] !=
s->heighty[2]) {
472 "(size %dx%d) do not match the corresponding "
473 "second input link %s 3rd plane (size %dx%d)\n",
474 ctx->input_pads[0].name,
s->widthx[2],
s->heightx[2],
475 ctx->input_pads[1].name,
476 s->widthy[2],
s->heighty[2]);
480 if (
s->widthx[1] !=
s->width[1] ||
s->heightx[1] !=
s->height[1]) {
482 "(size %dx%d) do not match the corresponding "
483 "output link %s 2nd plane (size %dx%d)\n",
484 ctx->input_pads[0].name,
s->widthx[1],
s->heightx[1],
485 ctx->output_pads[0].name,
s->width[1],
s->height[1]);
489 if (
s->widthx[2] !=
s->width[2] ||
s->heightx[2] !=
s->height[2]) {
491 "(size %dx%d) do not match the corresponding "
492 "output link %s 3rd plane (size %dx%d)\n",
493 ctx->input_pads[0].name,
s->widthx[2],
s->heightx[2],
494 ctx->output_pads[0].name,
s->width[2],
s->height[2]);
550 char *res,
int res_len,
int flags)
560 #define lut2_options options
567 .preinit = lut2_framesync_preinit,
569 .priv_class = &lut2_class,
580 #if CONFIG_TLUT2_FILTER
586 s->tlut2 = !strcmp(
ctx->filter->name,
"tlut2");
600 if (
ctx->is_disabled) {
616 td.srcy =
s->prev_frame;
628 static const AVOption tlut2_options[] = {
642 .filter_frame = tlut2_filter_frame,
657 .description =
NULL_IF_CONFIG_SMALL(
"Compute and apply a lookup table from two successive frames."),
659 .priv_class = &tlut2_class,
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
AVRational time_base
Time base for the incoming frames.
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
AVPixelFormat
Pixel format.
static int config_output(AVFilterLink *outlink)
int(* lut2)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
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
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe, unsigned get)
Get the current frame in an input.
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
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
This structure describes decoded (raw) audio or video data.
#define FILTER_QUERY_FUNC(func)
const AVFilter ff_vf_tlut2
#define DEFINE_LUT2(zname, xname, yname, ztype, xtype, ytype, zdiv, xdiv, ydiv)
const char * name
Filter name.
@ EXT_INFINITY
Extend the frame to infinity.
static int config_inputx(AVFilterLink *inlink)
A link between two filters.
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 av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
@ EXT_STOP
Completely stop all streams with this one.
unsigned sync
Synchronization level: frames on input at the highest sync level will generate output frame events.
static int process_frame(FFFrameSync *fs)
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.
double var_values[VAR_VARS_NB]
static const char *const var_names[]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int activate(AVFilterContext *ctx)
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
#define AV_CEIL_RSHIFT(a, b)
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
int(* init)(AVBSFContext *ctx)
static av_cold void uninit(AVFilterContext *ctx)
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0,...
static enum AVPixelFormat pix_fmts[]
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
#define FILTER_INPUTS(array)
Describe the class of an AVClass context structure.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
#define fs(width, name, subs,...)
static int lut2_config_output(AVFilterLink *outlink)
uint16_t * lut[4]
lookup table for each component
static const AVFilterPad inputs[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int format
agreed upon media format
AVFilterContext * src
source filter
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.
static enum AVPixelFormat all_pix_fmts[]
static const AVOption options[]
#define AVFILTER_DEFINE_CLASS(fname)
#define i(width, name, range_min, range_max)
int w
agreed upon image width
#define av_malloc_array(a, b)
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Used for passing data between threads.
static int config_inputy(AVFilterLink *inlink)
const char * name
Pad name.
static const AVFilterPad outputs[]
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
int ff_framesync_init(FFFrameSync *fs, AVFilterContext *parent, unsigned nb_in)
Initialize a frame sync structure.
enum FFFrameSyncExtMode before
Extrapolation mode for timestamps before the first frame.
const AVFilter ff_vf_lut2
int h
agreed upon image height
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link.
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define FILTER_OUTPUTS(array)
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
#define flags(name, subs,...)
enum FFFrameSyncExtMode after
Extrapolation mode for timestamps after the last frame.
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
static int query_formats(AVFilterContext *ctx)
FRAMESYNC_DEFINE_CLASS(lut2, LUT2Context, fs)