Go to the documentation of this file.
78 s->fade_per_frame = (1 << 16) /
s->nb_frames;
79 s->fade_state = VF_FADE_WAITING;
81 if (
s->duration != 0) {
87 if (
s->start_frame ||
s->nb_frames) {
89 "type:%s start_frame:%d nb_frames:%d alpha:%d\n",
90 s->type ==
FADE_IN ?
"in" :
"out",
s->start_frame,
91 s->nb_frames,
s->alpha);
93 if (
s->start_time ||
s->duration) {
95 "type:%s start_time:%f duration:%f alpha:%d\n",
100 s->black_fade = !memcmp(
s->color_rgba,
"\x00\x00\x00\xff", 4);
186 int do_alpha,
int step)
189 const uint8_t r_idx =
s->rgba_map[
R];
190 const uint8_t g_idx =
s->rgba_map[
G];
191 const uint8_t b_idx =
s->rgba_map[
B];
192 const uint8_t a_idx =
s->rgba_map[
A];
193 const uint8_t *
c =
s->color_rgba;
196 uint8_t *p =
frame->data[0] +
i *
frame->linesize[0];
197 for (j = 0; j <
frame->width; j++) {
198 #define INTERP(c_name, c_idx) av_clip_uint8(((c[c_idx]<<16) + ((int)p[c_name] - (int)c[c_idx]) * s->factor + (1<<15)) >> 16)
199 p[r_idx] =
INTERP(r_idx, 0);
200 p[g_idx] =
INTERP(g_idx, 1);
201 p[b_idx] =
INTERP(b_idx, 2);
203 p[a_idx] =
INTERP(a_idx, 3);
214 const uint8_t *
c =
s->color_rgba;
217 uint8_t *pg =
frame->data[0] +
i *
frame->linesize[0];
218 uint8_t *pb =
frame->data[1] +
i *
frame->linesize[1];
219 uint8_t *pr =
frame->data[2] +
i *
frame->linesize[2];
220 uint8_t *pa =
frame->data[3] +
i *
frame->linesize[3];
221 for (j = 0; j <
frame->width; j++) {
222 #define INTERPP(c_name, c_idx) av_clip_uint8(((c[c_idx]<<16) + ((int)c_name - (int)c[c_idx]) * s->factor + (1<<15)) >> 16)
237 int slice_start = (
frame->height * jobnr ) / nb_jobs;
240 if (
s->is_planar &&
s->alpha)
242 else if (
s->is_planar)
257 int slice_start = (
frame->height * jobnr ) / nb_jobs;
261 for (
int k = 0; k < 1 + 2 * (
s->is_planar &&
s->is_rgb); k++) {
263 uint8_t *p =
frame->data[k] +
i *
frame->linesize[k];
264 for (j = 0; j <
frame->width *
s->bpp; j++) {
268 *p = ((*p -
s->black_level) *
s->factor +
s->black_level_scaled) >> 16;
282 int slice_start = (
frame->height * jobnr ) / nb_jobs;
286 for (
int k = 0; k < 1 + 2 * (
s->is_planar &&
s->is_rgb); k++) {
288 uint16_t *p = (uint16_t *)(
frame->data[k] +
i *
frame->linesize[k]);
289 for (j = 0; j <
frame->width *
s->bpp; j++) {
293 *p = ((*p -
s->black_level) *
s->factor +
s->black_level_scaled) >> 16;
310 int slice_start = (
height * jobnr ) / nb_jobs;
313 for (plane = 1; plane < 3; plane++) {
315 uint8_t *p =
frame->data[plane] +
i *
frame->linesize[plane];
316 for (j = 0; j <
width; j++) {
320 *p = ((*p - 128) *
s->factor + 8421367) >> 16;
337 const int mid = 1 << (
s->depth - 1);
338 const int add = ((mid << 1) + 1) << 15;
339 int slice_start = (
height * jobnr ) / nb_jobs;
342 for (plane = 1; plane < 3; plane++) {
344 uint16_t *p = (uint16_t *)(
frame->data[plane] +
i *
frame->linesize[plane]);
345 for (j = 0; j <
width; j++) {
346 *p = ((*p - mid) *
s->factor +
add) >> 16;
360 int plane =
s->is_packed_rgb ? 0 :
A;
361 int slice_start = (
frame->height * jobnr ) / nb_jobs;
366 uint8_t *p =
frame->data[plane] +
i *
frame->linesize[plane] +
s->is_packed_rgb*
s->rgba_map[
A];
367 int step =
s->is_packed_rgb ? 4 : 1;
368 for (j = 0; j <
frame->width; j++) {
372 *p = ((*p -
s->black_level) *
s->factor +
s->black_level_scaled) >> 16;
385 int plane =
s->is_packed_rgb ? 0 :
A;
386 int slice_start = (
frame->height * jobnr ) / nb_jobs;
391 uint16_t *p = (uint16_t *)(
frame->data[plane] +
i *
frame->linesize[plane]) +
s->is_packed_rgb*
s->rgba_map[
A];
392 int step =
s->is_packed_rgb ? 4 : 1;
393 for (j = 0; j <
frame->width; j++) {
397 *p = ((*p -
s->black_level) *
s->factor +
s->black_level_scaled) >> 16;
422 s->is_packed_rgb = !
s->is_planar &&
s->is_rgb;
434 s->black_level_scaled = (
s->black_level << 16) + 32768;
449 if (
s->fade_state == VF_FADE_WAITING) {
451 if (
frame->pts >=
s->start_time_pts
452 &&
inlink->frame_count_out >=
s->start_frame) {
454 s->fade_state = VF_FADE_FADING;
457 if (
s->start_time_pts == 0 &&
s->start_frame != 0) {
458 s->start_time_pts =
frame->pts;
462 if (
s->start_time_pts != 0 &&
s->start_frame == 0) {
463 s->start_frame =
inlink->frame_count_out;
467 if (
s->fade_state == VF_FADE_FADING) {
468 if (
s->duration_pts == 0) {
470 s->factor = (
inlink->frame_count_out -
s->start_frame) *
s->fade_per_frame;
471 if (
inlink->frame_count_out >
s->start_frame +
s->nb_frames) {
472 s->fade_state = VF_FADE_DONE;
477 s->factor = (
frame->pts -
s->start_time_pts) * UINT16_MAX /
s->duration_pts;
478 if (
frame->pts >
s->start_time_pts +
s->duration_pts) {
479 s->fade_state = VF_FADE_DONE;
483 if (
s->fade_state == VF_FADE_DONE) {
484 s->factor=UINT16_MAX;
491 s->factor=UINT16_MAX-
s->factor;
494 if (
s->factor < UINT16_MAX) {
498 }
else if (
s->is_rgb && !
s->black_fade) {
506 if (
frame->data[1] &&
frame->data[2] && !
s->is_rgb) {
518 #define OFFSET(x) offsetof(FadeContext, x)
519 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
526 {
"start_frame",
"Number of the first frame to which to apply the effect.",
528 {
"s",
"Number of the first frame to which to apply the effect.",
530 {
"nb_frames",
"Number of frames to which the effect should be applied.",
532 {
"n",
"Number of frames to which the effect should be applied.",
535 {
"start_time",
"Number of seconds of the beginning of the effect.",
537 {
"st",
"Number of seconds of the beginning of the effect.",
539 {
"duration",
"Duration of the effect in seconds.",
541 {
"d",
"Duration of the effect in seconds.",
572 .priv_class = &fade_class,
#define AV_PIX_FMT_YUVA422P16
AVPixelFormat
Pixel format.
static enum AVPixelFormat pix_fmts_rgb[3]
static int filter_slice_rgb(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int filter_slice_alpha16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
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)
static av_cold int init(AVFilterContext *ctx)
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
int(* filter_slice_luma)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
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
static int query_formats(AVFilterContext *ctx)
#define AV_PIX_FMT_YUVA422P9
This structure describes decoded (raw) audio or video data.
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
#define AV_PIX_FMT_YUVA420P16
int depth
Number of bits in the component.
#define AV_PIX_FMT_YUVA420P10
const static enum AVPixelFormat studio_level_pix_fmts[]
#define FILTER_QUERY_FUNC(func)
#define AV_PIX_FMT_YUV420P10
#define AV_LOG_VERBOSE
Detailed information.
static enum AVPixelFormat pixel_fmts[]
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
const char * name
Filter name.
static int filter_slice_alpha(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
A link between two filters.
#define AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA420P9
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
static int filter_slice_luma16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUV422P9
static const AVFilterPad avfilter_vf_fade_inputs[]
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
static int filter_slice_chroma(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
A filter pad used for either input or output.
#define AV_PIX_FMT_YUV444P10
static const AVOption fade_options[]
#define AV_PIX_FMT_YUV422P16
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
const AVFilter ff_vf_fade
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
#define AV_PIX_FMT_YUV444P16
#define AV_CEIL_RSHIFT(a, b)
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
unsigned int black_level_scaled
static enum AVPixelFormat pix_fmts[]
#define AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FILTER_INPUTS(array)
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Describe the class of an AVClass context structure.
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
static int filter_slice_chroma16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
enum FadeContext::@228 fade_state
int(* filter_slice_chroma)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_PIX_FMT_YUV422P10
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
static int config_input(AVFilterLink *inlink)
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
static int64_t start_time
#define AV_PIX_FMT_YUV422P12
static av_always_inline void filter_rgb(FadeContext *s, const AVFrame *frame, int slice_start, int slice_end, int do_alpha, int step)
#define AV_PIX_FMT_YUV444P12
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
#define AV_PIX_FMT_YUVA444P10
#define INTERP(c_name, c_idx)
int black_fade
if color_rgba is black
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
static av_always_inline void filter_rgb_planar(FadeContext *s, const AVFrame *frame, int slice_start, int slice_end, int do_alpha)
#define i(width, name, range_min, range_max)
static int filter_slice_luma(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int(* filter_slice_alpha)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define AV_TIME_BASE
Internal time base represented as integer.
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
const char * name
Pad name.
static void fade(uint8_t *dst, ptrdiff_t dst_linesize, const uint8_t *src, ptrdiff_t src_linesize, int width, int height, int alpha, int beta)
#define AV_PIX_FMT_YUV444P9
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
#define AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV422P14
AVFILTER_DEFINE_CLASS(fade)
#define AV_PIX_FMT_YUVA422P12
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
uint8_t color_rgba[4]
fade color
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
static float add(float src0, float src1)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static const int16_t alpha[]
#define FILTER_OUTPUTS(array)
#define INTERPP(c_name, c_idx)
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
#define AV_PIX_FMT_YUV440P12
#define AV_PIX_FMT_YUV444P14
static const AVFilterPad avfilter_vf_fade_outputs[]
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
#define AV_PIX_FMT_YUV420P14
#define AVFILTERPAD_FLAG_NEEDS_WRITABLE
The filter expects writable frames from its input link, duplicating data buffers if needed.