51 static const char *
const var_names[] = {
"X",
"Y",
"W",
"H",
"SW",
"SH",
"T",
"N",
"A",
"B",
"TOP",
"BOTTOM",
NULL };
52 enum {
VAR_X,
VAR_Y,
VAR_W,
VAR_H,
VAR_SW,
VAR_SH,
VAR_T,
VAR_N,
VAR_A,
VAR_B,
VAR_TOP,
VAR_BOTTOM,
VAR_VARS_NB };
63 #define OFFSET(x) offsetof(BlendContext, x)
64 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
122 #define COPY(src, depth) \
123 static void blend_copy ## src##_##depth(const uint8_t *top, ptrdiff_t top_linesize, \
124 const uint8_t *bottom, ptrdiff_t bottom_linesize,\
125 uint8_t *dst, ptrdiff_t dst_linesize, \
126 ptrdiff_t width, ptrdiff_t height, \
127 FilterParams *param, double *values, int starty) \
129 av_image_copy_plane(dst, dst_linesize, src, src ## _linesize, \
130 width * depth / 8, height); \
145 const uint8_t *bottom, ptrdiff_t bottom_linesize,
146 uint8_t *dst, ptrdiff_t dst_linesize,
150 const double opacity = param->
opacity;
154 for (j = 0; j <
width; j++) {
155 dst[j] = top[j] * opacity + bottom[j] * (1. - opacity);
159 bottom += bottom_linesize;
164 const uint8_t *_bottom, ptrdiff_t bottom_linesize,
165 uint8_t *_dst, ptrdiff_t dst_linesize,
169 const uint16_t *top = (uint16_t*)_top;
170 const uint16_t *bottom = (uint16_t*)_bottom;
171 uint16_t *dst = (uint16_t*)_dst;
172 const double opacity = param->
opacity;
176 bottom_linesize /= 2;
179 for (j = 0; j <
width; j++) {
180 dst[j] = top[j] * opacity + bottom[j] * (1. - opacity);
184 bottom += bottom_linesize;
189 const uint8_t *_bottom, ptrdiff_t bottom_linesize,
190 uint8_t *_dst, ptrdiff_t dst_linesize,
194 const float *top = (
float*)_top;
195 const float *bottom = (
float*)_bottom;
196 float *dst = (
float*)_dst;
197 const double opacity = param->
opacity;
201 bottom_linesize /= 4;
204 for (j = 0; j <
width; j++) {
205 dst[j] = top[j] * opacity + bottom[j] * (1. - opacity);
209 bottom += bottom_linesize;
213 #define DEFINE_BLEND8(name, expr) \
214 static void blend_## name##_8bit(const uint8_t *top, ptrdiff_t top_linesize, \
215 const uint8_t *bottom, ptrdiff_t bottom_linesize, \
216 uint8_t *dst, ptrdiff_t dst_linesize, \
217 ptrdiff_t width, ptrdiff_t height, \
218 FilterParams *param, double *values, int starty) \
220 double opacity = param->opacity; \
223 for (i = 0; i < height; i++) { \
224 for (j = 0; j < width; j++) { \
225 dst[j] = top[j] + ((expr) - top[j]) * opacity; \
227 dst += dst_linesize; \
228 top += top_linesize; \
229 bottom += bottom_linesize; \
233 #define DEFINE_BLEND16(name, expr, depth) \
234 static void blend_## name##_##depth##bit(const uint8_t *_top, ptrdiff_t top_linesize,\
235 const uint8_t *_bottom, ptrdiff_t bottom_linesize, \
236 uint8_t *_dst, ptrdiff_t dst_linesize, \
237 ptrdiff_t width, ptrdiff_t height, \
238 FilterParams *param, double *values, int starty) \
240 const uint16_t *top = (const uint16_t*)_top; \
241 const uint16_t *bottom = (const uint16_t*)_bottom; \
242 uint16_t *dst = (uint16_t*)_dst; \
243 double opacity = param->opacity; \
247 bottom_linesize /= 2; \
249 for (i = 0; i < height; i++) { \
250 for (j = 0; j < width; j++) { \
251 dst[j] = top[j] + ((expr) - top[j]) * opacity; \
253 dst += dst_linesize; \
254 top += top_linesize; \
255 bottom += bottom_linesize; \
259 #define DEFINE_BLEND32(name, expr, depth) \
260 static void blend_## name##_##depth##bit(const uint8_t *_top, ptrdiff_t top_linesize,\
261 const uint8_t *_bottom, ptrdiff_t bottom_linesize, \
262 uint8_t *_dst, ptrdiff_t dst_linesize, \
263 ptrdiff_t width, ptrdiff_t height, \
264 FilterParams *param, double *values, int starty) \
266 const float *top = (const float*)_top; \
267 const float *bottom = (const float*)_bottom; \
268 float *dst = (float*)_dst; \
269 double opacity = param->opacity; \
273 bottom_linesize /= 4; \
275 for (i = 0; i < height; i++) { \
276 for (j = 0; j < width; j++) { \
277 dst[j] = top[j] + ((expr) - top[j]) * opacity; \
279 dst += dst_linesize; \
280 top += top_linesize; \
281 bottom += bottom_linesize; \
288 #define MULTIPLY(x, a, b) ((x) * (((a) * (b)) / 255))
289 #define SCREEN(x, a, b) (255 - (x) * ((255 - (a)) * (255 - (b)) / 255))
290 #define BURN(a, b) (((a) == 0) ? (a) : FFMAX(0, 255 - ((255 - (b)) << 8) / (a)))
291 #define DODGE(a, b) (((a) == 255) ? (a) : FFMIN(255, (((b) << 8) / (255 - (a)))))
314 DEFINE_BLEND8(softlight, (
A > 127) ?
B + (255 -
B) * (
A - 127.5) / 127.5 * (0.5 -
fabs(
B - 127.5) / 255):
B -
B * ((127.5 -
A) / 127.5) * (0.5 -
fabs(
B - 127.5)/255))
331 #define MULTIPLY(x, a, b) ((x) * (((a) * (b)) / 65535))
332 #define SCREEN(x, a, b) (65535 - (x) * ((65535 - (a)) * (65535 - (b)) / 65535))
333 #define BURN(a, b) (((a) == 0) ? (a) : FFMAX(0, 65535 - ((65535 - (b)) << 16) / (a)))
334 #define DODGE(a, b) (((a) == 65535) ? (a) : FFMIN(65535, (((b) << 16) / (65535 - (a)))))
357 DEFINE_BLEND16(softlight, (
A > 32767) ?
B + (65535 -
B) * (
A - 32767.5) / 32767.5 * (0.5 -
fabs(
B - 32767.5) / 65535):
B -
B * ((32767.5 -
A) / 32767.5) * (0.5 -
fabs(
B - 32767.5)/65535), 16)
374 #define MULTIPLY(x, a, b) ((x) * (((a) * (b)) / 1023))
375 #define SCREEN(x, a, b) (1023 - (x) * ((1023 - (a)) * (1023 - (b)) / 1023))
376 #define BURN(a, b) (((a) == 0) ? (a) : FFMAX(0, 1023 - ((1023 - (b)) << 10) / (a)))
377 #define DODGE(a, b) (((a) == 1023) ? (a) : FFMIN(1023, (((b) << 10) / (1023 - (a)))))
400 DEFINE_BLEND16(softlight, (
A > 511) ?
B + (1023 -
B) * (
A - 511.5) / 511.5 * (0.5 -
fabs(
B - 511.5) / 1023):
B -
B * ((511.5 -
A) / 511.5) * (0.5 -
fabs(
B - 511.5)/1023), 10)
417 #define MULTIPLY(x, a, b) ((x) * (((a) * (b)) / 4095))
418 #define SCREEN(x, a, b) (4095 - (x) * ((4095 - (a)) * (4095 - (b)) / 4095))
419 #define BURN(a, b) (((a) == 0) ? (a) : FFMAX(0, 4095 - ((4095 - (b)) << 12) / (a)))
420 #define DODGE(a, b) (((a) == 4095) ? (a) : FFMIN(4095, (((b) << 12) / (4095 - (a)))))
443 DEFINE_BLEND16(softlight, (
A > 2047) ?
B + (4095 -
B) * (
A - 2047.5) / 2047.5 * (0.5 -
fabs(
B - 2047.5) / 4095):
B -
B * ((2047.5 -
A) / 2047.5) * (0.5 -
fabs(
B - 2047.5)/4095), 12)
460 #define MULTIPLY(x, a, b) ((x) * (((a) * (b)) / 511))
461 #define SCREEN(x, a, b) (511 - (x) * ((511 - (a)) * (511 - (b)) / 511))
462 #define BURN(a, b) (((a) == 0) ? (a) : FFMAX(0, 511 - ((511 - (b)) << 9) / (a)))
463 #define DODGE(a, b) (((a) == 511) ? (a) : FFMIN(511, (((b) << 9) / (511 - (a)))))
486 DEFINE_BLEND16(softlight, (
A > 511) ?
B + (511 -
B) * (
A - 511.5) / 511.5 * (0.5 -
fabs(
B - 511.5) / 511):
B -
B * ((511.5 -
A) / 511.5) * (0.5 -
fabs(
B - 511.5)/511), 9)
503 #define MULTIPLY(x, a, b) ((x) * (((a) * (b)) / 1.0))
504 #define SCREEN(x, a, b) (1.0 - (x) * ((1.0 - (a)) * (1.0 - (b)) / 1.0))
505 #define BURN(a, b) (((a) <= 0.0) ? (a) : FFMAX(0.0, 1.0 - (1.0 - (b)) / (a)))
506 #define DODGE(a, b) (((a) >= 1.0) ? (a) : FFMIN(1.0, ((b) / (1.0 - (a)))))
529 DEFINE_BLEND32(softlight, (
A > 0.5) ?
B + (1.0 -
B) * (
A - 0.5) / 0.5 * (0.5 -
fabs(
B - 0.5) / 1.0):
B -
B * ((0.5 -
A) / 0.5) * (0.5 -
fabs(
B - 0.5)/1.0), 32)
541 #define DEFINE_BLEND_EXPR(type, name, div) \
542 static void blend_expr_## name(const uint8_t *_top, ptrdiff_t top_linesize, \
543 const uint8_t *_bottom, ptrdiff_t bottom_linesize, \
544 uint8_t *_dst, ptrdiff_t dst_linesize, \
545 ptrdiff_t width, ptrdiff_t height, \
546 FilterParams *param, double *values, int starty) \
548 const type *top = (type*)_top; \
549 const type *bottom = (type*)_bottom; \
550 type *dst = (type*)_dst; \
551 AVExpr *e = param->e; \
553 dst_linesize /= div; \
554 top_linesize /= div; \
555 bottom_linesize /= div; \
557 for (y = 0; y < height; y++) { \
558 values[VAR_Y] = y + starty; \
559 for (x = 0; x < width; x++) { \
561 values[VAR_TOP] = values[VAR_A] = top[x]; \
562 values[VAR_BOTTOM] = values[VAR_B] = bottom[x]; \
563 dst[x] = av_expr_eval(e, values, NULL); \
565 dst += dst_linesize; \
566 top += top_linesize; \
567 bottom += bottom_linesize; \
578 int slice_start = (
td->h * jobnr ) / nb_jobs;
582 const uint8_t *bottom =
td->bottom->data[
td->plane];
586 values[
VAR_N] =
td->inlink->frame_count_out;
590 values[
VAR_SW] =
td->w / (double)
td->dst->width;
591 values[
VAR_SH] =
td->h / (
double)
td->dst->height;
593 td->param->blend(top + slice_start *
td->top->linesize[
td->plane],
594 td->top->linesize[
td->plane],
595 bottom + slice_start *
td->bottom->linesize[
td->plane],
596 td->bottom->linesize[
td->plane],
597 dst + slice_start *
td->dst->linesize[
td->plane],
598 td->dst->linesize[
td->plane],
599 td->w,
height,
td->param, &values[0], slice_start);
617 for (plane = 0; plane <
s->nb_planes; plane++) {
618 int hsub = plane == 1 || plane == 2 ?
s->hsub : 0;
619 int vsub = plane == 1 || plane == 2 ?
s->vsub : 0;
623 ThreadData td = { .top = top_buf, .bottom = bottom_buf, .dst = dst_buf,
624 .w = outw, .h = outh, .param = param, .plane = plane,
639 AVFrame *top_buf, *bottom_buf, *dst_buf;
655 s->tblend = !strcmp(
ctx->filter->name,
"tblend");
701 #define DEFINE_INIT_BLEND_FUNC(depth, nbits) \
702 static av_cold void init_blend_func_##depth##_##nbits##bit(FilterParams *param) \
704 switch (param->mode) { \
705 case BLEND_ADDITION: param->blend = blend_addition_##depth##bit; break; \
706 case BLEND_GRAINMERGE: param->blend = blend_grainmerge_##depth##bit; break; \
707 case BLEND_AND: param->blend = blend_and_##depth##bit; break; \
708 case BLEND_AVERAGE: param->blend = blend_average_##depth##bit; break; \
709 case BLEND_BURN: param->blend = blend_burn_##depth##bit; break; \
710 case BLEND_DARKEN: param->blend = blend_darken_##depth##bit; break; \
711 case BLEND_DIFFERENCE: param->blend = blend_difference_##depth##bit; break; \
712 case BLEND_GRAINEXTRACT: param->blend = blend_grainextract_##depth##bit; break; \
713 case BLEND_DIVIDE: param->blend = blend_divide_##depth##bit; break; \
714 case BLEND_DODGE: param->blend = blend_dodge_##depth##bit; break; \
715 case BLEND_EXCLUSION: param->blend = blend_exclusion_##depth##bit; break; \
716 case BLEND_EXTREMITY: param->blend = blend_extremity_##depth##bit; break; \
717 case BLEND_FREEZE: param->blend = blend_freeze_##depth##bit; break; \
718 case BLEND_GLOW: param->blend = blend_glow_##depth##bit; break; \
719 case BLEND_HARDLIGHT: param->blend = blend_hardlight_##depth##bit; break; \
720 case BLEND_HARDMIX: param->blend = blend_hardmix_##depth##bit; break; \
721 case BLEND_HEAT: param->blend = blend_heat_##depth##bit; break; \
722 case BLEND_LIGHTEN: param->blend = blend_lighten_##depth##bit; break; \
723 case BLEND_LINEARLIGHT: param->blend = blend_linearlight_##depth##bit; break; \
724 case BLEND_MULTIPLY: param->blend = blend_multiply_##depth##bit; break; \
725 case BLEND_MULTIPLY128: param->blend = blend_multiply128_##depth##bit; break; \
726 case BLEND_NEGATION: param->blend = blend_negation_##depth##bit; break; \
727 case BLEND_NORMAL: param->blend = blend_normal_##nbits##bit; break; \
728 case BLEND_OR: param->blend = blend_or_##depth##bit; break; \
729 case BLEND_OVERLAY: param->blend = blend_overlay_##depth##bit; break; \
730 case BLEND_PHOENIX: param->blend = blend_phoenix_##depth##bit; break; \
731 case BLEND_PINLIGHT: param->blend = blend_pinlight_##depth##bit; break; \
732 case BLEND_REFLECT: param->blend = blend_reflect_##depth##bit; break; \
733 case BLEND_SCREEN: param->blend = blend_screen_##depth##bit; break; \
734 case BLEND_SOFTLIGHT: param->blend = blend_softlight_##depth##bit; break; \
735 case BLEND_SUBTRACT: param->blend = blend_subtract_##depth##bit; break; \
736 case BLEND_VIVIDLIGHT: param->blend = blend_vividlight_##depth##bit; break; \
737 case BLEND_XOR: param->blend = blend_xor_##depth##bit; break; \
751 init_blend_func_8_8bit(param);
754 init_blend_func_9_16bit(param);
757 init_blend_func_10_16bit(param);
760 init_blend_func_12_16bit(param);
763 init_blend_func_16_16bit(param);
766 init_blend_func_32_32bit(param);
770 if (param->opacity == 0 && param->mode !=
BLEND_NORMAL) {
771 param->blend = depth > 8 ? depth > 16 ? blend_copytop_32 : blend_copytop_16 : blend_copytop_8;
773 if (param->opacity == 1)
774 param->blend = depth > 8 ? depth > 16 ? blend_copytop_32 : blend_copytop_16 : blend_copytop_8;
775 else if (param->opacity == 0)
776 param->blend = depth > 8 ? depth > 16 ? blend_copybottom_32 : blend_copybottom_16 : blend_copybottom_8;
791 if (
s->all_mode >= 0)
792 param->
mode =
s->all_mode;
793 if (
s->all_opacity < 1)
808 param->
blend =
s->depth > 8 ?
s->depth > 16 ? blend_expr_32bit : blend_expr_16bit : blend_expr_8bit;
830 if (toplink->
w != bottomlink->
w || toplink->
h != bottomlink->
h) {
832 "(size %dx%d) do not match the corresponding "
833 "second input link %s parameters (size %dx%d)\n",
834 ctx->input_pads[
TOP].name, toplink->
w, toplink->
h,
835 ctx->input_pads[
BOTTOM].name, bottomlink->
w, bottomlink->
h);
840 outlink->
w = toplink->
w;
841 outlink->
h = toplink->
h;
870 char *res,
int res_len,
int flags)
881 #if CONFIG_BLEND_FILTER
912 .preinit = blend_framesync_preinit,
920 .priv_class = &blend_class,
927 #if CONFIG_TBLEND_FILTER
938 if (
ctx->is_disabled)
950 #define tblend_options blend_options
957 .filter_frame = tblend_filter_frame,
975 .priv_class = &tblend_class,
static const AVFilterPad inputs[]
static const AVFilterPad outputs[]
static int activate(AVFilterContext *ctx)
static SoftFloat_IEEE754 multiply(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b)
multiply two softfloats and handle the rounding off
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.
void ff_blend_init_x86(FilterParams *param, int depth)
#define flags(name, subs,...)
#define bit(string, value)
#define fs(width, name, subs,...)
#define AV_CEIL_RSHIFT(a, b)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static __device__ float fabs(float a)
mode
Use these values in ebur128_init (or'ed).
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
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.
simple arithmetic expression evaluator
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)
Initialize a frame sync structure for dualinput.
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
char * av_strdup(const char *s)
Duplicate a string.
#define AV_NOPTS_VALUE
Undefined timestamp value.
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
#define AVFILTER_DEFINE_CLASS(fname)
static const AVOption blend_options[]
static void blend_normal_32bit(const uint8_t *_top, ptrdiff_t top_linesize, const uint8_t *_bottom, ptrdiff_t bottom_linesize, uint8_t *_dst, ptrdiff_t dst_linesize, ptrdiff_t width, ptrdiff_t height, FilterParams *param, double *values, int starty)
#define DEFINE_INIT_BLEND_FUNC(depth, nbits)
void ff_blend_init(FilterParams *param, int depth)
static void blend_normal_16bit(const uint8_t *_top, ptrdiff_t top_linesize, const uint8_t *_bottom, ptrdiff_t bottom_linesize, uint8_t *_dst, ptrdiff_t dst_linesize, ptrdiff_t width, ptrdiff_t height, FilterParams *param, double *values, int starty)
FRAMESYNC_DEFINE_CLASS(blend, BlendContext, fs)
static int blend_frame_for_dualinput(FFFrameSync *fs)
static int query_formats(AVFilterContext *ctx)
#define DEFINE_BLEND32(name, expr, depth)
#define DEFINE_BLEND_EXPR(type, name, div)
static const char *const var_names[]
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
static av_cold int init(AVFilterContext *ctx)
static av_cold void uninit(AVFilterContext *ctx)
static int config_params(AVFilterContext *ctx)
static void blend_normal_8bit(const uint8_t *top, ptrdiff_t top_linesize, const uint8_t *bottom, ptrdiff_t bottom_linesize, uint8_t *dst, ptrdiff_t dst_linesize, ptrdiff_t width, ptrdiff_t height, FilterParams *param, double *values, int starty)
static AVFrame * blend_frame(AVFilterContext *ctx, AVFrame *top_buf, const AVFrame *bottom_buf)
static int config_output(AVFilterLink *outlink)
#define MULTIPLY(x, a, b)
#define DEFINE_BLEND8(name, expr)
#define DEFINE_BLEND16(name, expr, depth)
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static enum AVPixelFormat pix_fmts[]
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_GBRAP16
#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_GBRP10
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_GRAYF32
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y 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_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
#define AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV440P10
#define AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P10
#define FF_ARRAY_ELEMS(a)
Describe the class of an AVClass context structure.
int depth
Number of bits in the component.
A link between two filters.
int w
agreed upon image width
int h
agreed upon image height
AVFilterContext * src
source filter
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link.
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0,...
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.
AVFormatInternal * internal
An opaque field for libavformat internal usage.
This structure describes decoded (raw) audio or video data.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
int vsub
chroma subsampling values
void(* blend)(const uint8_t *top, ptrdiff_t top_linesize, const uint8_t *bottom, ptrdiff_t bottom_linesize, uint8_t *dst, ptrdiff_t dst_linesize, ptrdiff_t width, ptrdiff_t height, struct FilterParams *param, double *values, int starty)
Used for passing data between threads.
static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.