vf_lut.c File Reference

Compute a look-up table for binding the input value to the output value, and apply it to input video. More...

#include "config_components.h"
#include "libavutil/attributes.h"
#include "libavutil/bswap.h"
#include "libavutil/common.h"
#include "libavutil/eval.h"
#include "libavutil/mem.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "avfilter.h"
#include "drawutils.h"
#include "filters.h"
#include "formats.h"
#include "video.h"

Go to the source code of this file.

Data Structures
struct	LutContext
struct	thread_data

Macros
#define	Y   0
#define	U   1
#define	V   2
#define	R   0
#define	G   1
#define	B   2
#define	A   3
#define	OFFSET(x)
#define	FLAGS   AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
#define	YUV_FORMATS
#define	RGB_FORMATS
#define	GRAY_FORMATS
#define	LOAD_PACKED_COMMON
#define	LOAD_PLANAR_COMMON
#define	PLANAR_COMMON
#define	PACKED_THREAD_DATA
#define	PLANAR_THREAD_DATA
#define	DEFINE_LUT_FILTER(name_, description_, priv_class_)

Enumerations
enum	var_name {   VAR_W , VAR_H , VAR_VAL , VAR_MAXVAL ,   VAR_MINVAL , VAR_NEGVAL , VAR_CLIPVAL , VAR_VARS_NB }

Functions
static av_cold void	uninit (AVFilterContext *ctx)
static int	query_formats (const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
static double	clip (void *opaque, double val)
	Clip value val in the minval - maxval range.
static double	compute_gammaval (void *opaque, double gamma)
	Compute gamma correction for value val, assuming the minval-maxval range, val is clipped to a value contained in the same interval.
static double	compute_gammaval709 (void *opaque, double gamma)
	Compute ITU Rec.709 gamma correction of value val.
static int	config_props (AVFilterLink *inlink)
static int	lut_packed_16bits (AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int	lut_packed_8bits (AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int	lut_planar_16bits (AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int	lut_planar_8bits (AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int	filter_frame (AVFilterLink *inlink, AVFrame *in)
static int	process_command (AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
	AVFILTER_DEFINE_CLASS_EXT (lut, "lut/lutyuv/lutrgb", options)

Variables
static const char *const	var_names []
static const AVOption	options []
static enum AVPixelFormat	yuv_pix_fmts [] = { YUV_FORMATS, AV_PIX_FMT_NONE }
static enum AVPixelFormat	rgb_pix_fmts [] = { RGB_FORMATS, AV_PIX_FMT_NONE }
static enum AVPixelFormat	all_pix_fmts [] = { RGB_FORMATS, YUV_FORMATS, GRAY_FORMATS, AV_PIX_FMT_NONE }
static double(*const	funcs1 [])(void *, double)
static const char *const	funcs1_names []
static const AVFilterPad	inputs []

Detailed Description

Compute a look-up table for binding the input value to the output value, and apply it to input video.

Definition in file vf_lut.c.

Macro Definition Documentation

Y

#define Y   0

Definition at line 77 of file vf_lut.c.

U

#define U   1

Definition at line 78 of file vf_lut.c.

V

#define V   2

Definition at line 79 of file vf_lut.c.

R

#define R   0

Definition at line 80 of file vf_lut.c.

G

#define G   1

Definition at line 81 of file vf_lut.c.

B

#define B   2

Definition at line 82 of file vf_lut.c.

A

#define A   3

Definition at line 83 of file vf_lut.c.

OFFSET

#define OFFSET

(

x

)

Value:

offsetof(LutContext, x)

Definition at line 85 of file vf_lut.c.

FLAGS

#define FLAGS   AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM

Definition at line 86 of file vf_lut.c.

YUV_FORMATS

#define YUV_FORMATS

Value:

    AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,    \
    AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,    \
    AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,   \
    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,   \
    AV_PIX_FMT_YUVJ440P,                                             \
    AV_PIX_FMT_YUV444P9LE, AV_PIX_FMT_YUV422P9LE, AV_PIX_FMT_YUV420P9LE, \
    AV_PIX_FMT_YUV444P10LE, AV_PIX_FMT_YUV422P10LE, AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUV440P10LE, \
    AV_PIX_FMT_YUV444P12LE, AV_PIX_FMT_YUV422P12LE, AV_PIX_FMT_YUV420P12LE, AV_PIX_FMT_YUV440P12LE, \
    AV_PIX_FMT_YUV444P14LE, AV_PIX_FMT_YUV422P14LE, AV_PIX_FMT_YUV420P14LE, \
    AV_PIX_FMT_YUV444P16LE, AV_PIX_FMT_YUV422P16LE, AV_PIX_FMT_YUV420P16LE, \
    AV_PIX_FMT_YUVA444P16LE, AV_PIX_FMT_YUVA422P16LE, AV_PIX_FMT_YUVA420P16LE

Definition at line 115 of file vf_lut.c.

RGB_FORMATS

#define RGB_FORMATS

Value:

    AV_PIX_FMT_ARGB,         AV_PIX_FMT_RGBA,         \
    AV_PIX_FMT_ABGR,         AV_PIX_FMT_BGRA,         \
    AV_PIX_FMT_RGB24,        AV_PIX_FMT_BGR24,        \
    AV_PIX_FMT_RGB48LE,      AV_PIX_FMT_RGBA64LE,     \
    AV_PIX_FMT_GBRP,         AV_PIX_FMT_GBRAP,        \
    AV_PIX_FMT_GBRP9LE,      AV_PIX_FMT_GBRP10LE,     \
    AV_PIX_FMT_GBRAP10LE,                             \
    AV_PIX_FMT_GBRP12LE,     AV_PIX_FMT_GBRP14LE,     \
    AV_PIX_FMT_GBRP16LE,     AV_PIX_FMT_GBRAP12LE,    \
    AV_PIX_FMT_GBRAP16LE

Definition at line 128 of file vf_lut.c.

GRAY_FORMATS

#define GRAY_FORMATS

Value:

    AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9LE, AV_PIX_FMT_GRAY10LE, \
    AV_PIX_FMT_GRAY12LE, AV_PIX_FMT_GRAY14LE, AV_PIX_FMT_GRAY16LE

Definition at line 140 of file vf_lut.c.

LOAD_PACKED_COMMON

#define LOAD_PACKED_COMMON

Value:

    LutContext *s = ctx->priv;\
    const struct thread_data *td = arg;\
\
    int i, j;\
    const int w = td->w;\
    const int h = td->h;\
    AVFrame *in = td->in;\
    AVFrame *out = td->out;\
    const uint16_t (*tab)[256*256] = (const uint16_t (*)[256*256])s->lut;\
    const int step = s->step;\
\
    const int slice_start = ff_slice_pos(h, jobnr, nb_jobs); \
    const int slice_end   = ff_slice_pos(h, jobnr + 1, nb_jobs); \

Definition at line 349 of file vf_lut.c.

Referenced by lut_packed_16bits(), and lut_packed_8bits().

LOAD_PLANAR_COMMON

#define LOAD_PLANAR_COMMON

Value:

    LutContext *s = ctx->priv;\
    const struct thread_data *td = arg;\
    int i, j, plane;\
    AVFrame *in = td->in;\
    AVFrame *out = td->out;\

Definition at line 430 of file vf_lut.c.

Referenced by lut_planar_16bits(), and lut_planar_8bits().

PLANAR_COMMON

#define PLANAR_COMMON

Value:

        int vsub = plane == 1 || plane == 2 ? s->vsub : 0;\
        int hsub = plane == 1 || plane == 2 ? s->hsub : 0;\
        int h = AV_CEIL_RSHIFT(td->h, vsub);\
        int w = AV_CEIL_RSHIFT(td->w, hsub);\
        const uint16_t *tab = s->lut[plane];\
\
        const int slice_start = ff_slice_pos(h, jobnr, nb_jobs); \
        const int slice_end   = ff_slice_pos(h, jobnr + 1, nb_jobs); \

Definition at line 437 of file vf_lut.c.

Referenced by lut_planar_16bits(), and lut_planar_8bits().

PACKED_THREAD_DATA

#define PACKED_THREAD_DATA

Value:

 struct thread_data td = {\
            .in  = in,\
            .out = out,\
            .w   = inlink->w,\
            .h   = in->height,\
        };\

Definition at line 506 of file vf_lut.c.

Referenced by filter_frame().

PLANAR_THREAD_DATA

#define PLANAR_THREAD_DATA

Value:

 struct thread_data td = {\
            .in  = in,\
            .out = out,\
            .w   = inlink->w,\
            .h   = inlink->h,\
        };\

Definition at line 514 of file vf_lut.c.

Referenced by filter_frame().

DEFINE_LUT_FILTER

#define DEFINE_LUT_FILTER	(		name_,
			description_,
			priv_class_ )

Value:

    const FFFilter ff_vf_##name_ = {                                    \
        .p.name        = #name_,                                        \
        .p.description = NULL_IF_CONFIG_SMALL(description_),            \
        .p.priv_class  = &priv_class_ ## _class,                        \
        .p.flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC |       \
                         AVFILTER_FLAG_SLICE_THREADS,                   \
        .priv_size     = sizeof(LutContext),                            \
        .init          = name_##_init,                                  \
        .uninit        = uninit,                                        \
        FILTER_INPUTS(inputs),                                          \
        FILTER_OUTPUTS(ff_video_default_filterpad),                     \
        FILTER_QUERY_FUNC2(query_formats),                              \
        .process_command = process_command,                             \
    }

Definition at line 592 of file vf_lut.c.

Enumeration Type Documentation

var_name

enum var_name

Enumerator
VAR_W
VAR_H
VAR_VAL
VAR_MAXVAL
VAR_MINVAL
VAR_NEGVAL
VAR_CLIPVAL
VAR_VARS_NB

Definition at line 53 of file vf_lut.c.

Function Documentation

uninit()

static av_cold void uninit ( AVFilterContext * ctx )

static

Definition at line 103 of file vf_lut.c.

query_formats()

static int query_formats ( const AVFilterContext * ctx, AVFilterFormatsConfig ** cfg_in, AVFilterFormatsConfig ** cfg_out )

static

Definition at line 148 of file vf_lut.c.

clip()

static double clip ( void * opaque, double val )

static

Clip value val in the minval - maxval range.

Definition at line 163 of file vf_lut.c.

compute_gammaval()

static double compute_gammaval ( void * opaque, double gamma )

static

Compute gamma correction for value val, assuming the minval-maxval range, val is clipped to a value contained in the same interval.

Definition at line 176 of file vf_lut.c.

compute_gammaval709()

static double compute_gammaval709 ( void * opaque, double gamma )

static

Compute ITU Rec.709 gamma correction of value val.

Definition at line 189 of file vf_lut.c.

config_props()

static int config_props ( AVFilterLink * inlink )

static

Definition at line 215 of file vf_lut.c.

Referenced by process_command().

lut_packed_16bits()

static int lut_packed_16bits ( AVFilterContext * ctx, void * arg, int jobnr, int nb_jobs )

static

Definition at line 365 of file vf_lut.c.

Referenced by filter_frame().

lut_packed_8bits()

static int lut_packed_8bits ( AVFilterContext * ctx, void * arg, int jobnr, int nb_jobs )

static

Definition at line 402 of file vf_lut.c.

Referenced by filter_frame().

lut_planar_16bits()

static int lut_planar_16bits ( AVFilterContext * ctx, void * arg, int jobnr, int nb_jobs )

static

Definition at line 448 of file vf_lut.c.

Referenced by filter_frame().

lut_planar_8bits()

static int lut_planar_8bits ( AVFilterContext * ctx, void * arg, int jobnr, int nb_jobs )

static

Definition at line 480 of file vf_lut.c.

Referenced by filter_frame().

filter_frame()

static int filter_frame ( AVFilterLink * inlink, AVFrame * in )

static

Definition at line 522 of file vf_lut.c.

process_command()

static int process_command ( AVFilterContext * ctx, const char * cmd, const char * args, char * res, int res_len, int flags )

static

Definition at line 573 of file vf_lut.c.

AVFILTER_DEFINE_CLASS_EXT()

AVFILTER_DEFINE_CLASS_EXT	(	lut	,
		"lut/lutyuv/lutrgb"	,
		options	)

Variable Documentation

var_names

const char* const var_names[]

static

Initial value:

= {
    "w",        
    "h",        
    "val",      
    "maxval",   
    "minval",   
    "negval",   
    "clipval",
    NULL
}

Definition at line 42 of file vf_lut.c.

options

const AVOption options[]

static

Initial value:

= {
    { "c0", "set component #0 expression", OFFSET(comp_expr_str[0]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { "c1", "set component #1 expression", OFFSET(comp_expr_str[1]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { "c2", "set component #2 expression", OFFSET(comp_expr_str[2]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { "c3", "set component #3 expression", OFFSET(comp_expr_str[3]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { "y",  "set Y expression",            OFFSET(comp_expr_str[Y]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { "u",  "set U expression",            OFFSET(comp_expr_str[U]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { "v",  "set V expression",            OFFSET(comp_expr_str[V]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { "r",  "set R expression",            OFFSET(comp_expr_str[R]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { "g",  "set G expression",            OFFSET(comp_expr_str[G]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { "b",  "set B expression",            OFFSET(comp_expr_str[B]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { "a",  "set A expression",            OFFSET(comp_expr_str[A]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
    { NULL }
}

Definition at line 88 of file vf_lut.c.

yuv_pix_fmts

enum AVPixelFormat yuv_pix_fmts[] = { YUV_FORMATS, AV_PIX_FMT_NONE }

static

Definition at line 144 of file vf_lut.c.

rgb_pix_fmts

enum AVPixelFormat rgb_pix_fmts[] = { RGB_FORMATS, AV_PIX_FMT_NONE }

static

Definition at line 145 of file vf_lut.c.

all_pix_fmts

enum AVPixelFormat all_pix_fmts[] = { RGB_FORMATS, YUV_FORMATS, GRAY_FORMATS, AV_PIX_FMT_NONE }

static

Definition at line 146 of file vf_lut.c.

funcs1

double(*const funcs1[])(void *, double) ( void * , double  )

static

Initial value:

= {
    clip,
    compute_gammaval,
    compute_gammaval709,
    NULL
}

Definition at line 201 of file vf_lut.c.

Referenced by av_expr_parse(), av_expr_parse_and_eval(), and config_props().

funcs1_names

const char* const funcs1_names[]

static

Initial value:

= {
    "clip",
    "gammaval",
    "gammaval709",
    NULL
}

Definition at line 208 of file vf_lut.c.

Referenced by config_props().

inputs

const AVFilterPad inputs[]

static

Initial value:

= {
    { .name         = "default",
      .type         = AVMEDIA_TYPE_VIDEO,
      .filter_frame = filter_frame,
      .config_props = config_props,
    },
}

Definition at line 584 of file vf_lut.c.