FFmpeg: libavfilter/vf_fade.c Source File

FFmpeg

[フレーム]

libavfilter

vf_fade.c

Go to the documentation of this file.

1 /*

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 */

22 /**

23 * @file

24 * video fade filter

25 * based heavily on vf_negate.c by Bobby Bingham

26 */

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"

40 #define R 0

41 #define G 1

42 #define B 2

43 #define A 3

45 #define Y 0

46 #define U 1

47 #define V 2

49 #define FADE_IN 0

50 #define FADE_OUT 1

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;

58 unsigned int black_level, black_level_scaled;

59 uint8_t is_packed_rgb;

60 uint8_t rgba_map[4];

61 int alpha;

62 uint64_t start_time, duration;

63 enum {VF_FADE_WAITING=0, VF_FADE_FADING, VF_FADE_DONE} fade_state;

64 uint8_t color_rgba[4]; ///< fade color

65 int black_fade; ///< if color_rgba is black

66 } FadeContext;

68 static av_cold int init(AVFilterContext *ctx)

69 {

70 FadeContext *s = ctx->priv;

72 s->fade_per_frame = (1 << 16) / s->nb_frames;

73 s->fade_state = VF_FADE_WAITING;

75 if (s->duration != 0) {

76 // If duration (seconds) is non-zero, assume that we are not fading based on frames

77 s->nb_frames = 0; // Mostly to clean up logging

78 }

80 // Choose what to log. If both time-based and frame-based options, both lines will be in the log

81 if (s->start_frame || s->nb_frames) {

82 av_log(ctx, AV_LOG_VERBOSE,

83 "type:%s start_frame:%d nb_frames:%d alpha:%d\n",

84 s->type == FADE_IN ? "in" : "out", s->start_frame,

85 s->nb_frames,s->alpha);

86 }

87 if (s->start_time || s->duration) {

88 av_log(ctx, AV_LOG_VERBOSE,

89 "type:%s start_time:%f duration:%f alpha:%d\n",

90 s->type == FADE_IN ? "in" : "out", (s->start_time / (double)AV_TIME_BASE),

91 (s->duration / (double)AV_TIME_BASE),s->alpha);

92 }

94 s->black_fade = !memcmp(s->color_rgba, "\x00\x00\x00\xff", 4);

95 return 0;

96 }

98 static int query_formats(AVFilterContext *ctx)

99 {

100 const FadeContext *s = ctx->priv;

101 static const enum AVPixelFormat pix_fmts[] = {

102 AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P,

103 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,

104 AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,

105 AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVJ440P,

106 AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,

107 AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,

108 AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,

109 AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,

110 AV_PIX_FMT_NONE

111 };

112 static const enum AVPixelFormat pix_fmts_rgb[] = {

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_NONE

117 };

118

119 if (s->black_fade)

120 ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));

121 else

122 ff_set_common_formats(ctx, ff_make_format_list(pix_fmts_rgb));

123 return 0;

124 }

125

126 const static enum AVPixelFormat studio_level_pix_fmts[] = {

127 AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P,

128 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,

129 AV_PIX_FMT_YUV440P,

130 AV_PIX_FMT_NONE

131 };

132

133 static int config_props(AVFilterLink *inlink)

134 {

135 FadeContext *s = inlink->dst->priv;

136 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(inlink->format);

137

138 s->hsub = pixdesc->log2_chroma_w;

139 s->vsub = pixdesc->log2_chroma_h;

140

141 s->bpp = pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR ?

142 1 :

143 av_get_bits_per_pixel(pixdesc) >> 3;

144 s->alpha &= !!(pixdesc->flags & AV_PIX_FMT_FLAG_ALPHA);

145 s->is_packed_rgb = ff_fill_rgba_map(s->rgba_map, inlink->format) >= 0;

146

147 /* use CCIR601/709 black level for studio-level pixel non-alpha components */

148 s->black_level =

149 ff_fmt_is_in(inlink->format, studio_level_pix_fmts) && !s->alpha ? 16 : 0;

150 /* 32768 = 1 << 15, it is an integer representation

151 * of 0.5 and is for rounding. */

152 s->black_level_scaled = (s->black_level << 16) + 32768;

153 return 0;

154 }

155

156 static av_always_inline void filter_rgb(FadeContext *s, const AVFrame *frame,

157 int slice_start, int slice_end,

158 int do_alpha, int step)

159 {

160 int i, j;

161 const uint8_t r_idx = s->rgba_map[R];

162 const uint8_t g_idx = s->rgba_map[G];

163 const uint8_t b_idx = s->rgba_map[B];

164 const uint8_t a_idx = s->rgba_map[A];

165 const uint8_t *c = s->color_rgba;

166

167 for (i = slice_start; i < slice_end; i++) {

168 uint8_t *p = frame->data[0] + i * frame->linesize[0];

169 for (j = 0; j < frame->width; j++) {

170 #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)

171 p[r_idx] = INTERP(r_idx, 0);

172 p[g_idx] = INTERP(g_idx, 1);

173 p[b_idx] = INTERP(b_idx, 2);

174 if (do_alpha)

175 p[a_idx] = INTERP(a_idx, 3);

176 p += step;

177 }

178 }

179 }

180

181 static int filter_slice_rgb(AVFilterContext *ctx, void *arg, int jobnr,

182 int nb_jobs)

183 {

184 FadeContext *s = ctx->priv;

185 AVFrame *frame = arg;

186 int slice_start = (frame->height * jobnr ) / nb_jobs;

187 int slice_end = (frame->height * (jobnr+1)) / nb_jobs;

188

189 if (s->alpha) filter_rgb(s, frame, slice_start, slice_end, 1, 4);

190 else if (s->bpp == 3) filter_rgb(s, frame, slice_start, slice_end, 0, 3);

191 else if (s->bpp == 4) filter_rgb(s, frame, slice_start, slice_end, 0, 4);

192 else av_assert0(0);

193

194 return 0;

195 }

196

197 static int filter_slice_luma(AVFilterContext *ctx, void *arg, int jobnr,

198 int nb_jobs)

199 {

200 FadeContext *s = ctx->priv;

201 AVFrame *frame = arg;

202 int slice_start = (frame->height * jobnr ) / nb_jobs;

203 int slice_end = (frame->height * (jobnr+1)) / nb_jobs;

204 int i, j;

205

206 for (i = slice_start; i < slice_end; i++) {

207 uint8_t *p = frame->data[0] + i * frame->linesize[0];

208 for (j = 0; j < frame->width * s->bpp; j++) {

209 /* s->factor is using 16 lower-order bits for decimal

210 * places. 32768 = 1 << 15, it is an integer representation

211 * of 0.5 and is for rounding. */

212 *p = ((*p - s->black_level) * s->factor + s->black_level_scaled) >> 16;

213 p++;

214 }

215 }

216

217 return 0;

218 }

219

220 static int filter_slice_chroma(AVFilterContext *ctx, void *arg, int jobnr,

221 int nb_jobs)

222 {

223 FadeContext *s = ctx->priv;

224 AVFrame *frame = arg;

225 int i, j, plane;

226 const int width = FF_CEIL_RSHIFT(frame->width, s->hsub);

227 const int height= FF_CEIL_RSHIFT(frame->height, s->vsub);

228 int slice_start = (height * jobnr ) / nb_jobs;

229 int slice_end = (height * (jobnr+1)) / nb_jobs;

230

231 for (plane = 1; plane < 3; plane++) {

232 for (i = slice_start; i < slice_end; i++) {

233 uint8_t *p = frame->data[plane] + i * frame->linesize[plane];

234 for (j = 0; j < width; j++) {

235 /* 8421367 = ((128 << 1) + 1) << 15. It is an integer

236 * representation of 128.5. The .5 is for rounding

237 * purposes. */

238 *p = ((*p - 128) * s->factor + 8421367) >> 16;

239 p++;

240 }

241 }

242 }

243

244 return 0;

245 }

246

247 static int filter_slice_alpha(AVFilterContext *ctx, void *arg, int jobnr,

248 int nb_jobs)

249 {

250 FadeContext *s = ctx->priv;

251 AVFrame *frame = arg;

252 int plane = s->is_packed_rgb ? 0 : A;

253 int slice_start = (frame->height * jobnr ) / nb_jobs;

254 int slice_end = (frame->height * (jobnr+1)) / nb_jobs;

255 int i, j;

256

257 for (i = slice_start; i < slice_end; i++) {

258 uint8_t *p = frame->data[plane] + i * frame->linesize[plane] + s->is_packed_rgb*s->rgba_map[A];

259 int step = s->is_packed_rgb ? 4 : 1;

260 for (j = 0; j < frame->width; j++) {

261 /* s->factor is using 16 lower-order bits for decimal

262 * places. 32768 = 1 << 15, it is an integer representation

263 * of 0.5 and is for rounding. */

264 *p = ((*p - s->black_level) * s->factor + s->black_level_scaled) >> 16;

265 p += step;

266 }

267 }

268

269 return 0;

270 }

271

272 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)

273 {

274 AVFilterContext *ctx = inlink->dst;

275 FadeContext *s = ctx->priv;

276 double frame_timestamp = frame->pts == AV_NOPTS_VALUE ? -1 : frame->pts * av_q2d(inlink->time_base);

277

278 // Calculate Fade assuming this is a Fade In

279 if (s->fade_state == VF_FADE_WAITING) {

280 s->factor=0;

281 if (frame_timestamp >= s->start_time/(double)AV_TIME_BASE

282 && inlink->frame_count >= s->start_frame) {

283 // Time to start fading

284 s->fade_state = VF_FADE_FADING;

285

286 // Save start time in case we are starting based on frames and fading based on time

287 if (s->start_time == 0 && s->start_frame != 0) {

288 s->start_time = frame_timestamp*(double)AV_TIME_BASE;

289 }

290

291 // Save start frame in case we are starting based on time and fading based on frames

292 if (s->start_time != 0 && s->start_frame == 0) {

293 s->start_frame = inlink->frame_count;

294 }

295 }

296 }

297 if (s->fade_state == VF_FADE_FADING) {

298 if (s->duration == 0) {

299 // Fading based on frame count

300 s->factor = (inlink->frame_count - s->start_frame) * s->fade_per_frame;

301 if (inlink->frame_count > s->start_frame + s->nb_frames) {

302 s->fade_state = VF_FADE_DONE;

303 }

304

305 } else {

306 // Fading based on duration

307 s->factor = (frame_timestamp - s->start_time/(double)AV_TIME_BASE)

308 * (float) UINT16_MAX / (s->duration/(double)AV_TIME_BASE);

309 if (frame_timestamp > s->start_time/(double)AV_TIME_BASE

310 + s->duration/(double)AV_TIME_BASE) {

311 s->fade_state = VF_FADE_DONE;

312 }

313 }

314 }

315 if (s->fade_state == VF_FADE_DONE) {

316 s->factor=UINT16_MAX;

317 }

318

319 s->factor = av_clip_uint16(s->factor);

320

321 // Invert fade_factor if Fading Out

322 if (s->type == FADE_OUT) {

323 s->factor=UINT16_MAX-s->factor;

324 }

325

326 if (s->factor < UINT16_MAX) {

327 if (s->alpha) {

328 ctx->internal->execute(ctx, filter_slice_alpha, frame, NULL,

329 FFMIN(frame->height, ctx->graph->nb_threads));

330 } else if (s->is_packed_rgb && !s->black_fade) {

331 ctx->internal->execute(ctx, filter_slice_rgb, frame, NULL,

332 FFMIN(frame->height, ctx->graph->nb_threads));

333 } else {

334 /* luma, or rgb plane in case of black */

335 ctx->internal->execute(ctx, filter_slice_luma, frame, NULL,

336 FFMIN(frame->height, ctx->graph->nb_threads));

337

338 if (frame->data[1] && frame->data[2]) {

339 /* chroma planes */

340 ctx->internal->execute(ctx, filter_slice_chroma, frame, NULL,

341 FFMIN(frame->height, ctx->graph->nb_threads));

342 }

343 }

344 }

345

346 return ff_filter_frame(inlink->dst->outputs[0], frame);

347 }

348

349

350 #define OFFSET(x) offsetof(FadeContext, x)

351 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

352

353 static const AVOption fade_options[] = {

354 { "type", "'in' or 'out' for fade-in/fade-out", OFFSET(type), AV_OPT_TYPE_INT, { .i64 = FADE_IN }, FADE_IN, FADE_OUT, FLAGS, "type" },

355 { "t", "'in' or 'out' for fade-in/fade-out", OFFSET(type), AV_OPT_TYPE_INT, { .i64 = FADE_IN }, FADE_IN, FADE_OUT, FLAGS, "type" },

356 { "in", "fade-in", 0, AV_OPT_TYPE_CONST, { .i64 = FADE_IN }, .unit = "type" },

357 { "out", "fade-out", 0, AV_OPT_TYPE_CONST, { .i64 = FADE_OUT }, .unit = "type" },

358 { "start_frame", "Number of the first frame to which to apply the effect.",

359 OFFSET(start_frame), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },

360 { "s", "Number of the first frame to which to apply the effect.",

361 OFFSET(start_frame), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },

362 { "nb_frames", "Number of frames to which the effect should be applied.",

363 OFFSET(nb_frames), AV_OPT_TYPE_INT, { .i64 = 25 }, 0, INT_MAX, FLAGS },

364 { "n", "Number of frames to which the effect should be applied.",

365 OFFSET(nb_frames), AV_OPT_TYPE_INT, { .i64 = 25 }, 0, INT_MAX, FLAGS },

366 { "alpha", "fade alpha if it is available on the input", OFFSET(alpha), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, FLAGS },

367 { "start_time", "Number of seconds of the beginning of the effect.",

368 OFFSET(start_time), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT32_MAX, FLAGS },

369 { "st", "Number of seconds of the beginning of the effect.",

370 OFFSET(start_time), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT32_MAX, FLAGS },

371 { "duration", "Duration of the effect in seconds.",

372 OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT32_MAX, FLAGS },

373 { "d", "Duration of the effect in seconds.",

374 OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT32_MAX, FLAGS },

375 { "color", "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, CHAR_MIN, CHAR_MAX, FLAGS },

376 { "c", "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, CHAR_MIN, CHAR_MAX, FLAGS },

377 { NULL }

378 };

379

380 AVFILTER_DEFINE_CLASS(fade);

381

382 static const AVFilterPad avfilter_vf_fade_inputs[] = {

383 {

384 .name = "default",

385 .type = AVMEDIA_TYPE_VIDEO,

386 .config_props = config_props,

387 .filter_frame = filter_frame,

388 .needs_writable = 1,

389 },

390 { NULL }

391 };

392

393 static const AVFilterPad avfilter_vf_fade_outputs[] = {

394 {

395 .name = "default",

396 .type = AVMEDIA_TYPE_VIDEO,

397 },

398 { NULL }

399 };

400

401 AVFilter ff_vf_fade = {

402 .name = "fade",

403 .description = NULL_IF_CONFIG_SMALL("Fade in/out input video."),

404 .init = init,

405 .priv_size = sizeof(FadeContext),

406 .priv_class = &fade_class,

407 .query_formats = query_formats,

408 .inputs = avfilter_vf_fade_inputs,

409 .outputs = avfilter_vf_fade_outputs,

410 .flags = AVFILTER_FLAG_SLICE_THREADS,

411 };

Generated on Sun Mar 8 2015 02:35:06 for FFmpeg by doxygen 1.8.2