git.sesse.net Git - ffmpeg/blob - libavfilter/vf_fade.c

   1 /*
   2  * Copyright (c) 2010 Brandon Mintern
   3  * Copyright (c) 2007 Bobby Bingham
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * video fade filter
  25  * based heavily on vf_negate.c by Bobby Bingham
  26  */
  27
  28 #include "libavutil/avassert.h"
  29 #include "libavutil/avstring.h"
  30 #include "libavutil/common.h"
  31 #include "libavutil/eval.h"
  32 #include "libavutil/opt.h"
  33 #include "libavutil/pixdesc.h"
  34 #include "avfilter.h"
  35 #include "drawutils.h"
  36 #include "formats.h"
  37 #include "internal.h"
  38 #include "video.h"
  39
  40 #define R 0
  41 #define G 1
  42 #define B 2
  43 #define A 3
  44
  45 #define Y 0
  46 #define U 1
  47 #define V 2
  48
  49 #define FADE_IN  0
  50 #define FADE_OUT 1
  51
  52 typedef struct FadeContext {
  53     const AVClass *class;
  54     int type;
  55     int factor, fade_per_frame;
  56     int start_frame, nb_frames;
  57     int hsub, vsub, bpp, depth;
  58     unsigned int black_level, black_level_scaled;
  59     uint8_t is_rgb;
  60     uint8_t is_packed_rgb;
  61     uint8_t rgba_map[4];
  62     int alpha;
  63     int is_planar;
  64     uint64_t start_time, duration;
  65     uint64_t start_time_pts, duration_pts;
  66     enum {VF_FADE_WAITING=0, VF_FADE_FADING, VF_FADE_DONE} fade_state;
  67     uint8_t color_rgba[4];  ///< fade color
  68     int black_fade;         ///< if color_rgba is black
  69     int (*filter_slice_luma)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
  70     int (*filter_slice_chroma)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
  71     int (*filter_slice_alpha)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
  72 } FadeContext;
  73
  74 static av_cold int init(AVFilterContext *ctx)
  75 {
  76     FadeContext *s = ctx->priv;
  77
  78     s->fade_per_frame = (1 << 16) / s->nb_frames;
  79     s->fade_state = VF_FADE_WAITING;
  80
  81     if (s->duration != 0) {
  82         // If duration (seconds) is non-zero, assume that we are not fading based on frames
  83         s->nb_frames = 0; // Mostly to clean up logging
  84     }
  85
  86     // Choose what to log. If both time-based and frame-based options, both lines will be in the log
  87     if (s->start_frame || s->nb_frames) {
  88         av_log(ctx, AV_LOG_VERBOSE,
  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);
  92     }
  93     if (s->start_time || s->duration) {
  94         av_log(ctx, AV_LOG_VERBOSE,
  95                "type:%s start_time:%f duration:%f alpha:%d\n",
  96                s->type == FADE_IN ? "in" : "out", (s->start_time / (double)AV_TIME_BASE),
  97                (s->duration / (double)AV_TIME_BASE),s->alpha);
  98     }
  99
 100     s->black_fade = !memcmp(s->color_rgba, "\x00\x00\x00\xff", 4);
 101     return 0;
 102 }
 103
 104 static int query_formats(AVFilterContext *ctx)
 105 {
 106     const FadeContext *s = ctx->priv;
 107     static const enum AVPixelFormat pix_fmts[] = {
 108         AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
 109         AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,
 110         AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
 111         AV_PIX_FMT_YUV440P,  AV_PIX_FMT_YUVJ440P,
 112         AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
 113         AV_PIX_FMT_RGB24,    AV_PIX_FMT_BGR24,
 114         AV_PIX_FMT_ARGB,     AV_PIX_FMT_ABGR,
 115         AV_PIX_FMT_RGBA,     AV_PIX_FMT_BGRA,
 116         AV_PIX_FMT_GBRP,     AV_PIX_FMT_GBRAP,
 117         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
 118         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
 119         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
 120         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
 121         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
 122         AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
 123         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
 124         AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12,
 125         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
 126         AV_PIX_FMT_NONE
 127     };
 128     static const enum AVPixelFormat pix_fmts_rgb[] = {
 129         AV_PIX_FMT_RGB24,    AV_PIX_FMT_BGR24,
 130         AV_PIX_FMT_ARGB,     AV_PIX_FMT_ABGR,
 131         AV_PIX_FMT_RGBA,     AV_PIX_FMT_BGRA,
 132         AV_PIX_FMT_GBRP,
 133         AV_PIX_FMT_NONE
 134     };
 135     static const enum AVPixelFormat pix_fmts_alpha[] = {
 136         AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
 137         AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
 138         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
 139         AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12,
 140         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
 141         AV_PIX_FMT_ARGB,     AV_PIX_FMT_ABGR,
 142         AV_PIX_FMT_RGBA,     AV_PIX_FMT_BGRA,
 143         AV_PIX_FMT_GBRAP,
 144         AV_PIX_FMT_NONE
 145     };
 146     static const enum AVPixelFormat pix_fmts_rgba[] = {
 147         AV_PIX_FMT_ARGB,     AV_PIX_FMT_ABGR,
 148         AV_PIX_FMT_RGBA,     AV_PIX_FMT_BGRA,
 149         AV_PIX_FMT_GBRAP,
 150         AV_PIX_FMT_NONE
 151     };
 152     AVFilterFormats *fmts_list;
 153
 154     if (s->alpha) {
 155         if (s->black_fade)
 156             fmts_list = ff_make_format_list(pix_fmts_alpha);
 157         else
 158             fmts_list = ff_make_format_list(pix_fmts_rgba);
 159     } else {
 160         if (s->black_fade)
 161             fmts_list = ff_make_format_list(pix_fmts);
 162         else
 163             fmts_list = ff_make_format_list(pix_fmts_rgb);
 164     }
 165     if (!fmts_list)
 166         return AVERROR(ENOMEM);
 167     return ff_set_common_formats(ctx, fmts_list);
 168 }
 169
 170 const static enum AVPixelFormat studio_level_pix_fmts[] = {
 171     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
 172     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,
 173     AV_PIX_FMT_YUV440P,
 174     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
 175     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
 176     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
 177     AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
 178     AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
 179     AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
 180     AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
 181     AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12,
 182     AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
 183     AV_PIX_FMT_NONE
 184 };
 185
 186 static av_always_inline void filter_rgb(FadeContext *s, const AVFrame *frame,
 187                                         int slice_start, int slice_end,
 188                                         int do_alpha, int step)
 189 {
 190     int i, j;
 191     const uint8_t r_idx  = s->rgba_map[R];
 192     const uint8_t g_idx  = s->rgba_map[G];
 193     const uint8_t b_idx  = s->rgba_map[B];
 194     const uint8_t a_idx  = s->rgba_map[A];
 195     const uint8_t *c = s->color_rgba;
 196
 197     for (i = slice_start; i < slice_end; i++) {
 198         uint8_t *p = frame->data[0] + i * frame->linesize[0];
 199         for (j = 0; j < frame->width; j++) {
 200 #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)
 201             p[r_idx] = INTERP(r_idx, 0);
 202             p[g_idx] = INTERP(g_idx, 1);
 203             p[b_idx] = INTERP(b_idx, 2);
 204             if (do_alpha)
 205                 p[a_idx] = INTERP(a_idx, 3);
 206             p += step;
 207         }
 208     }
 209 }
 210
 211 static av_always_inline void filter_rgb_planar(FadeContext *s, const AVFrame *frame,
 212                                                int slice_start, int slice_end,
 213                                                int do_alpha)
 214 {
 215     int i, j;
 216     const uint8_t *c = s->color_rgba;
 217
 218     for (i = slice_start; i < slice_end; i++) {
 219         uint8_t *pg = frame->data[0] + i * frame->linesize[0];
 220         uint8_t *pb = frame->data[1] + i * frame->linesize[1];
 221         uint8_t *pr = frame->data[2] + i * frame->linesize[2];
 222         uint8_t *pa = frame->data[3] + i * frame->linesize[3];
 223         for (j = 0; j < frame->width; j++) {
 224 #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)
 225             pr[j] = INTERPP(pr[j], 0);
 226             pg[j] = INTERPP(pg[j], 1);
 227             pb[j] = INTERPP(pb[j], 2);
 228             if (do_alpha)
 229                 pa[j] = INTERPP(pa[j], 3);
 230         }
 231     }
 232 }
 233
 234 static int filter_slice_rgb(AVFilterContext *ctx, void *arg, int jobnr,
 235                             int nb_jobs)
 236 {
 237     FadeContext *s = ctx->priv;
 238     AVFrame *frame = arg;
 239     int slice_start = (frame->height *  jobnr   ) / nb_jobs;
 240     int slice_end   = (frame->height * (jobnr+1)) / nb_jobs;
 241
 242     if      (s->is_planar && s->alpha)
 243                           filter_rgb_planar(s, frame, slice_start, slice_end, 1);
 244     else if (s->is_planar)
 245                           filter_rgb_planar(s, frame, slice_start, slice_end, 0);
 246     else if (s->alpha)    filter_rgb(s, frame, slice_start, slice_end, 1, 4);
 247     else if (s->bpp == 3) filter_rgb(s, frame, slice_start, slice_end, 0, 3);
 248     else if (s->bpp == 4) filter_rgb(s, frame, slice_start, slice_end, 0, 4);
 249     else                  av_assert0(0);
 250
 251     return 0;
 252 }
 253
 254 static int filter_slice_luma(AVFilterContext *ctx, void *arg, int jobnr,
 255                              int nb_jobs)
 256 {
 257     FadeContext *s = ctx->priv;
 258     AVFrame *frame = arg;
 259     int slice_start = (frame->height *  jobnr   ) / nb_jobs;
 260     int slice_end   = (frame->height * (jobnr+1)) / nb_jobs;
 261     int i, j;
 262
 263     for (int k = 0; k < 1 + 2 * (s->is_planar && s->is_rgb); k++) {
 264         for (i = slice_start; i < slice_end; i++) {
 265             uint8_t *p = frame->data[k] + i * frame->linesize[k];
 266             for (j = 0; j < frame->width * s->bpp; j++) {
 267                 /* s->factor is using 16 lower-order bits for decimal
 268                  * places. 32768 = 1 << 15, it is an integer representation
 269                  * of 0.5 and is for rounding. */
 270                 *p = ((*p - s->black_level) * s->factor + s->black_level_scaled) >> 16;
 271                 p++;
 272             }
 273         }
 274     }
 275
 276     return 0;
 277 }
 278
 279 static int filter_slice_luma16(AVFilterContext *ctx, void *arg, int jobnr,
 280                                int nb_jobs)
 281 {
 282     FadeContext *s = ctx->priv;
 283     AVFrame *frame = arg;
 284     int slice_start = (frame->height *  jobnr   ) / nb_jobs;
 285     int slice_end   = (frame->height * (jobnr+1)) / nb_jobs;
 286     int i, j;
 287
 288     for (int k = 0; k < 1 + 2 * (s->is_planar && s->is_rgb); k++) {
 289         for (i = slice_start; i < slice_end; i++) {
 290             uint16_t *p = (uint16_t *)(frame->data[k] + i * frame->linesize[k]);
 291             for (j = 0; j < frame->width * s->bpp; j++) {
 292                 /* s->factor is using 16 lower-order bits for decimal
 293                  * places. 32768 = 1 << 15, it is an integer representation
 294                  * of 0.5 and is for rounding. */
 295                 *p = ((*p - s->black_level) * s->factor + s->black_level_scaled) >> 16;
 296                 p++;
 297             }
 298         }
 299     }
 300
 301     return 0;
 302 }
 303
 304 static int filter_slice_chroma(AVFilterContext *ctx, void *arg, int jobnr,
 305                                int nb_jobs)
 306 {
 307     FadeContext *s = ctx->priv;
 308     AVFrame *frame = arg;
 309     int i, j, plane;
 310     const int width = AV_CEIL_RSHIFT(frame->width, s->hsub);
 311     const int height= AV_CEIL_RSHIFT(frame->height, s->vsub);
 312     int slice_start = (height *  jobnr   ) / nb_jobs;
 313     int slice_end   = FFMIN(((height * (jobnr+1)) / nb_jobs), frame->height);
 314
 315     for (plane = 1; plane < 3; plane++) {
 316         for (i = slice_start; i < slice_end; i++) {
 317             uint8_t *p = frame->data[plane] + i * frame->linesize[plane];
 318             for (j = 0; j < width; j++) {
 319                 /* 8421367 = ((128 << 1) + 1) << 15. It is an integer
 320                  * representation of 128.5. The .5 is for rounding
 321                  * purposes. */
 322                 *p = ((*p - 128) * s->factor + 8421367) >> 16;
 323                 p++;
 324             }
 325         }
 326     }
 327
 328     return 0;
 329 }
 330
 331 static int filter_slice_chroma16(AVFilterContext *ctx, void *arg, int jobnr,
 332                                  int nb_jobs)
 333 {
 334     FadeContext *s = ctx->priv;
 335     AVFrame *frame = arg;
 336     int i, j, plane;
 337     const int width = AV_CEIL_RSHIFT(frame->width, s->hsub);
 338     const int height= AV_CEIL_RSHIFT(frame->height, s->vsub);
 339     const int mid = 1 << (s->depth - 1);
 340     const int add = ((mid << 1) + 1) << 15;
 341     int slice_start = (height *  jobnr   ) / nb_jobs;
 342     int slice_end   = FFMIN(((height * (jobnr+1)) / nb_jobs), frame->height);
 343
 344     for (plane = 1; plane < 3; plane++) {
 345         for (i = slice_start; i < slice_end; i++) {
 346             uint16_t *p = (uint16_t *)(frame->data[plane] + i * frame->linesize[plane]);
 347             for (j = 0; j < width; j++) {
 348                 *p = ((*p - mid) * s->factor + add) >> 16;
 349                 p++;
 350             }
 351         }
 352     }
 353
 354     return 0;
 355 }
 356
 357 static int filter_slice_alpha(AVFilterContext *ctx, void *arg, int jobnr,
 358                               int nb_jobs)
 359 {
 360     FadeContext *s = ctx->priv;
 361     AVFrame *frame = arg;
 362     int plane = s->is_packed_rgb ? 0 : A;
 363     int slice_start = (frame->height *  jobnr   ) / nb_jobs;
 364     int slice_end   = (frame->height * (jobnr+1)) / nb_jobs;
 365     int i, j;
 366
 367     for (i = slice_start; i < slice_end; i++) {
 368         uint8_t *p = frame->data[plane] + i * frame->linesize[plane] + s->is_packed_rgb*s->rgba_map[A];
 369         int step = s->is_packed_rgb ? 4 : 1;
 370         for (j = 0; j < frame->width; j++) {
 371             /* s->factor is using 16 lower-order bits for decimal
 372              * places. 32768 = 1 << 15, it is an integer representation
 373              * of 0.5 and is for rounding. */
 374             *p = ((*p - s->black_level) * s->factor + s->black_level_scaled) >> 16;
 375             p += step;
 376         }
 377     }
 378
 379     return 0;
 380 }
 381
 382 static int filter_slice_alpha16(AVFilterContext *ctx, void *arg, int jobnr,
 383                                 int nb_jobs)
 384 {
 385     FadeContext *s = ctx->priv;
 386     AVFrame *frame = arg;
 387     int plane = s->is_packed_rgb ? 0 : A;
 388     int slice_start = (frame->height *  jobnr   ) / nb_jobs;
 389     int slice_end   = (frame->height * (jobnr+1)) / nb_jobs;
 390     int i, j;
 391
 392     for (i = slice_start; i < slice_end; i++) {
 393         uint16_t *p = (uint16_t *)(frame->data[plane] + i * frame->linesize[plane]) + s->is_packed_rgb*s->rgba_map[A];
 394         int step = s->is_packed_rgb ? 4 : 1;
 395         for (j = 0; j < frame->width; j++) {
 396             /* s->factor is using 16 lower-order bits for decimal
 397              * places. 32768 = 1 << 15, it is an integer representation
 398              * of 0.5 and is for rounding. */
 399             *p = ((*p - s->black_level) * s->factor + s->black_level_scaled) >> 16;
 400             p += step;
 401         }
 402     }
 403
 404     return 0;
 405 }
 406
 407 static int config_input(AVFilterLink *inlink)
 408 {
 409     FadeContext *s = inlink->dst->priv;
 410     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(inlink->format);
 411
 412     s->hsub = pixdesc->log2_chroma_w;
 413     s->vsub = pixdesc->log2_chroma_h;
 414
 415     ff_fill_rgba_map(s->rgba_map, inlink->format);
 416
 417     s->depth = pixdesc->comp[0].depth;
 418     s->bpp = pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR ?
 419              1 :
 420              av_get_bits_per_pixel(pixdesc) >> 3;
 421     s->alpha &= !!(pixdesc->flags & AV_PIX_FMT_FLAG_ALPHA);
 422     s->is_planar = pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR;
 423     s->is_rgb = pixdesc->flags & AV_PIX_FMT_FLAG_RGB;
 424     s->is_packed_rgb = !s->is_planar && s->is_rgb;
 425
 426     if (s->duration)
 427         s->duration_pts = av_rescale_q(s->duration, AV_TIME_BASE_Q, inlink->time_base);
 428     if (s->start_time)
 429         s->start_time_pts = av_rescale_q(s->start_time, AV_TIME_BASE_Q, inlink->time_base);
 430
 431     /* use CCIR601/709 black level for studio-level pixel non-alpha components */
 432     s->black_level =
 433             ff_fmt_is_in(inlink->format, studio_level_pix_fmts) && !s->alpha ? 16 * (1 << (s->depth - 8)): 0;
 434     /* 32768 = 1 << 15, it is an integer representation
 435      * of 0.5 and is for rounding. */
 436     s->black_level_scaled = (s->black_level << 16) + 32768;
 437
 438     s->filter_slice_luma   = s->depth <= 8 ? filter_slice_luma   : filter_slice_luma16;
 439     s->filter_slice_chroma = s->depth <= 8 ? filter_slice_chroma : filter_slice_chroma16;
 440     s->filter_slice_alpha  = s->depth <= 8 ? filter_slice_alpha  : filter_slice_alpha16;
 441
 442     return 0;
 443 }
 444
 445 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
 446 {
 447     AVFilterContext *ctx = inlink->dst;
 448     FadeContext *s       = ctx->priv;
 449
 450     // Calculate Fade assuming this is a Fade In
 451     if (s->fade_state == VF_FADE_WAITING) {
 452         s->factor=0;
 453         if (frame->pts >= s->start_time_pts
 454             && inlink->frame_count_out >= s->start_frame) {
 455             // Time to start fading
 456             s->fade_state = VF_FADE_FADING;
 457
 458             // Save start time in case we are starting based on frames and fading based on time
 459             if (s->start_time_pts == 0 && s->start_frame != 0) {
 460                 s->start_time_pts = frame->pts;
 461             }
 462
 463             // Save start frame in case we are starting based on time and fading based on frames
 464             if (s->start_time_pts != 0 && s->start_frame == 0) {
 465                 s->start_frame = inlink->frame_count_out;
 466             }
 467         }
 468     }
 469     if (s->fade_state == VF_FADE_FADING) {
 470         if (s->duration_pts == 0) {
 471             // Fading based on frame count
 472             s->factor = (inlink->frame_count_out - s->start_frame) * s->fade_per_frame;
 473             if (inlink->frame_count_out > s->start_frame + s->nb_frames) {
 474                 s->fade_state = VF_FADE_DONE;
 475             }
 476
 477         } else {
 478             // Fading based on duration
 479             s->factor = (frame->pts - s->start_time_pts) * UINT16_MAX / s->duration_pts;
 480             if (frame->pts > s->start_time_pts + s->duration_pts) {
 481                 s->fade_state = VF_FADE_DONE;
 482             }
 483         }
 484     }
 485     if (s->fade_state == VF_FADE_DONE) {
 486         s->factor=UINT16_MAX;
 487     }
 488
 489     s->factor = av_clip_uint16(s->factor);
 490
 491     // Invert fade_factor if Fading Out
 492     if (s->type == FADE_OUT) {
 493         s->factor=UINT16_MAX-s->factor;
 494     }
 495
 496     if (s->factor < UINT16_MAX) {
 497         if (s->alpha) {
 498             ctx->internal->execute(ctx, s->filter_slice_alpha, frame, NULL,
 499                                 FFMIN(frame->height, ff_filter_get_nb_threads(ctx)));
 500         } else if (s->is_rgb && !s->black_fade) {
 501             ctx->internal->execute(ctx, filter_slice_rgb, frame, NULL,
 502                                    FFMIN(frame->height, ff_filter_get_nb_threads(ctx)));
 503         } else {
 504             /* luma, or rgb plane in case of black */
 505             ctx->internal->execute(ctx, s->filter_slice_luma, frame, NULL,
 506                                 FFMIN(frame->height, ff_filter_get_nb_threads(ctx)));
 507
 508             if (frame->data[1] && frame->data[2] && !s->is_rgb) {
 509                 /* chroma planes */
 510                 ctx->internal->execute(ctx, s->filter_slice_chroma, frame, NULL,
 511                                     FFMIN(frame->height, ff_filter_get_nb_threads(ctx)));
 512             }
 513         }
 514     }
 515
 516     return ff_filter_frame(inlink->dst->outputs[0], frame);
 517 }
 518
 519
 520 #define OFFSET(x) offsetof(FadeContext, x)
 521 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 522
 523 static const AVOption fade_options[] = {
 524     { "type", "set the fade direction", OFFSET(type), AV_OPT_TYPE_INT, { .i64 = FADE_IN }, FADE_IN, FADE_OUT, FLAGS, "type" },
 525     { "t",    "set the fade direction", OFFSET(type), AV_OPT_TYPE_INT, { .i64 = FADE_IN }, FADE_IN, FADE_OUT, FLAGS, "type" },
 526         { "in",  "fade-in",  0, AV_OPT_TYPE_CONST, { .i64 = FADE_IN },  .flags = FLAGS, .unit = "type" },
 527         { "out", "fade-out", 0, AV_OPT_TYPE_CONST, { .i64 = FADE_OUT }, .flags = FLAGS, .unit = "type" },
 528     { "start_frame", "Number of the first frame to which to apply the effect.",
 529                                                     OFFSET(start_frame), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
 530     { "s",           "Number of the first frame to which to apply the effect.",
 531                                                     OFFSET(start_frame), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
 532     { "nb_frames",   "Number of frames to which the effect should be applied.",
 533                                                     OFFSET(nb_frames),   AV_OPT_TYPE_INT, { .i64 = 25 }, 1, INT_MAX, FLAGS },
 534     { "n",           "Number of frames to which the effect should be applied.",
 535                                                     OFFSET(nb_frames),   AV_OPT_TYPE_INT, { .i64 = 25 }, 1, INT_MAX, FLAGS },
 536     { "alpha",       "fade alpha if it is available on the input", OFFSET(alpha),       AV_OPT_TYPE_BOOL, {.i64 = 0    }, 0,       1, FLAGS },
 537     { "start_time",  "Number of seconds of the beginning of the effect.",
 538                                                     OFFSET(start_time),  AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT64_MAX, FLAGS },
 539     { "st",          "Number of seconds of the beginning of the effect.",
 540                                                     OFFSET(start_time),  AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT64_MAX, FLAGS },
 541     { "duration",    "Duration of the effect in seconds.",
 542                                                     OFFSET(duration),    AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT64_MAX, FLAGS },
 543     { "d",           "Duration of the effect in seconds.",
 544                                                     OFFSET(duration),    AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT64_MAX, FLAGS },
 545     { "color",       "set color",                   OFFSET(color_rgba),  AV_OPT_TYPE_COLOR,    {.str = "black"}, 0, 0, FLAGS },
 546     { "c",           "set color",                   OFFSET(color_rgba),  AV_OPT_TYPE_COLOR,    {.str = "black"}, 0, 0, FLAGS },
 547     { NULL }
 548 };
 549
 550 AVFILTER_DEFINE_CLASS(fade);
 551
 552 static const AVFilterPad avfilter_vf_fade_inputs[] = {
 553     {
 554         .name           = "default",
 555         .type           = AVMEDIA_TYPE_VIDEO,
 556         .config_props   = config_input,
 557         .filter_frame   = filter_frame,
 558         .needs_writable = 1,
 559     },
 560     { NULL }
 561 };
 562
 563 static const AVFilterPad avfilter_vf_fade_outputs[] = {
 564     {
 565         .name = "default",
 566         .type = AVMEDIA_TYPE_VIDEO,
 567     },
 568     { NULL }
 569 };
 570
 571 const AVFilter ff_vf_fade = {
 572     .name          = "fade",
 573     .description   = NULL_IF_CONFIG_SMALL("Fade in/out input video."),
 574     .init          = init,
 575     .priv_size     = sizeof(FadeContext),
 576     .priv_class    = &fade_class,
 577     .query_formats = query_formats,
 578     .inputs        = avfilter_vf_fade_inputs,
 579     .outputs       = avfilter_vf_fade_outputs,
 580     .flags         = AVFILTER_FLAG_SLICE_THREADS |
 581                      AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 582 };