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