47 int jobnr,
int nb_jobs);
55 for (
i = 0;
i < 9; ++
i) {
56 du = (
int)
u[
i] -
ctx->chromakey_uv[0];
57 dv = (
int)v[
i] -
ctx->chromakey_uv[1];
59 diff += sqrt((du * du + dv * dv) / (255.0 * 255.0 * 2));
64 if (
ctx->blend > 0.0001) {
67 return (
diff >
ctx->similarity) ? 255 : 0;
77 for (
i = 0;
i < 9; ++
i) {
78 du = (
int)
u[
i] -
ctx->chromakey_uv[0];
79 dv = (
int)v[
i] -
ctx->chromakey_uv[1];
81 diff += sqrt((du * du + dv * dv) / (
max *
max * 2));
86 if (
ctx->blend > 0.0001) {
121 const int slice_start = (
frame->
height * jobnr) / nb_jobs;
129 memset(
u,
ctx->chromakey_uv[0],
sizeof(
u));
130 memset(v,
ctx->chromakey_uv[1],
sizeof(v));
132 for (y = slice_start; y <
slice_end; ++y) {
134 for (yo = 0; yo < 3; ++yo) {
135 for (xo = 0; xo < 3; ++xo) {
151 const int slice_start = (
frame->
height * jobnr) / nb_jobs;
159 for (
int i = 0;
i < 9;
i++) {
160 u[
i] =
ctx->chromakey_uv[0];
161 v[
i] =
ctx->chromakey_uv[1];
164 for (y = slice_start; y <
slice_end; ++y) {
168 for (yo = 0; yo < 3; ++yo) {
169 for (xo = 0; xo < 3; ++xo) {
185 const int slice_start = ((
frame->
height >>
ctx->vsub_log2) * jobnr) / nb_jobs;
190 for (y = slice_start; y <
slice_end; ++y) {
197 du =
u -
ctx->chromakey_uv[0];
198 dv = v -
ctx->chromakey_uv[1];
200 diff = sqrt((du * du + dv * dv) / (255.0 * 255.0));
203 if (
ctx->blend > 0.0001) {
222 const int slice_start = ((
frame->
height >>
ctx->vsub_log2) * jobnr) / nb_jobs;
224 const int mid =
ctx->mid;
229 for (y = slice_start; y <
slice_end; ++y) {
236 du =
u -
ctx->chromakey_uv[0];
237 dv = v -
ctx->chromakey_uv[1];
239 diff = sqrt((du * du + dv * dv) / (
max *
max));
242 if (
ctx->blend > 0.0001) {
269 #define FIXNUM(x) lrint((x) * (1 << 10))
270 #define RGB_TO_U(rgb) (((- FIXNUM(0.16874) * rgb[0] - FIXNUM(0.33126) * rgb[1] + FIXNUM(0.50000) * rgb[2] + (1 << 9) - 1) >> 10) + 128)
271 #define RGB_TO_V(rgb) ((( FIXNUM(0.50000) * rgb[0] - FIXNUM(0.41869) * rgb[1] - FIXNUM(0.08131) * rgb[2] + (1 << 9) - 1) >> 10) + 128)
280 ctx->depth =
desc->comp[0].depth;
281 ctx->mid = 1 << (
ctx->depth - 1);
282 ctx->max = (1 <<
ctx->depth) - 1;
294 if (!strcmp(avctx->
filter->
name,
"chromakey")) {
350 ctx->hsub_log2 =
desc->log2_chroma_w;
351 ctx->vsub_log2 =
desc->log2_chroma_h;
357 char *res,
int res_len,
int flags)
388 #define OFFSET(x) offsetof(ChromakeyContext, x)
389 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
403 .description =
NULL_IF_CONFIG_SMALL(
"Turns a certain color into transparency. Operates on YUV colors."),
405 .priv_class = &chromakey_class,
444 .
name =
"chromahold",
447 .priv_class = &chromahold_class,
static const AVFilterPad inputs[]
static const AVFilterPad outputs[]
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next 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.
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Main libavfilter public API header.
#define flags(name, subs,...)
#define u(width, name, range_min, range_max)
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
static const int16_t alpha[]
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUV420P14
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
#define AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P10
Describe the class of an AVClass context structure.
const AVFilter * filter
the AVFilter of which this is an instance
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
void * priv
private data for use by the filter
AVFilterLink ** outputs
array of pointers to output links
avfilter_execute_func * execute
A link between two filters.
AVFilterContext * src
source filter
AVFilterContext * dst
dest filter
int format
agreed upon media format
A filter pad used for either input or output.
const char * name
Pad name.
const char * name
Filter name.
This structure describes decoded (raw) audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
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...
int(* do_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
uint8_t chromakey_rgba[4]
static const AVOption chromahold_options[]
static av_always_inline void get_pixel_uv(AVFrame *frame, int hsub_log2, int vsub_log2, int x, int y, uint8_t *u, uint8_t *v)
static uint8_t do_chromakey_pixel(ChromakeyContext *ctx, uint8_t u[9], uint8_t v[9])
AVFilter ff_vf_chromahold
static const AVOption chromakey_options[]
static av_cold int query_formats(AVFilterContext *avctx)
static int do_chromahold_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
static const AVFilterPad chromahold_inputs[]
static av_cold int config_output(AVFilterLink *outlink)
static const AVFilterPad chromakey_outputs[]
static av_cold int config_input(AVFilterLink *inlink)
static int filter_frame(AVFilterLink *link, AVFrame *frame)
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
static const AVFilterPad chromahold_outputs[]
static int do_chromahold16_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
static const AVFilterPad chromakey_inputs[]
AVFILTER_DEFINE_CLASS(chromakey)
static uint16_t do_chromakey_pixel16(ChromakeyContext *ctx, uint16_t u[9], uint16_t v[9])
static int do_chromakey16_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
static int do_chromakey_slice(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
static av_always_inline void get_pixel16_uv(AVFrame *frame, int hsub_log2, int vsub_log2, int x, int y, uint16_t *u, uint16_t *v)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static const int factor[16]