FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/vf_premultiply.c
Date: 2024-02-29 09:57:37
Exec Total Coverage
Lines: 0 382 0.0%
Functions: 0 25 0.0%
Branches: 0 210 0.0%

Line Branch Exec Source
1 /*
2 * Copyright (c) 2016 Paul B Mahol
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "config_components.h"
22
23 #include "libavutil/imgutils.h"
24 #include "libavutil/pixdesc.h"
25 #include "libavutil/opt.h"
26 #include "avfilter.h"
27 #include "filters.h"
28 #include "formats.h"
29 #include "framesync.h"
30 #include "internal.h"
31 #include "video.h"
32
33 typedef struct ThreadData {
34 AVFrame *m, *a, *d;
35 } ThreadData;
36
37 typedef struct PreMultiplyContext {
38 const AVClass *class;
39 int width[4], height[4];
40 int linesize[4];
41 int nb_planes;
42 int planes;
43 int inverse;
44 int inplace;
45 int half, depth, offset, max;
46 FFFrameSync fs;
47
48 void (*premultiply[4])(const uint8_t *msrc, const uint8_t *asrc,
49 uint8_t *dst,
50 ptrdiff_t mlinesize, ptrdiff_t alinesize,
51 ptrdiff_t dlinesize,
52 int w, int h,
53 int half, int shift, int offset);
54 } PreMultiplyContext;
55
56 #define OFFSET(x) offsetof(PreMultiplyContext, x)
57 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
58
59 static const AVOption options[] = {
60 { "planes", "set planes", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS },
61 { "inplace","enable inplace mode", OFFSET(inplace), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
62 { NULL }
63 };
64
65 AVFILTER_DEFINE_CLASS_EXT(premultiply, "(un)premultiply", options);
66
67 static int query_formats(AVFilterContext *ctx)
68 {
69 PreMultiplyContext *s = ctx->priv;
70
71 static const enum AVPixelFormat no_alpha_pix_fmts[] = {
72 AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
73 AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
74 AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,
75 AV_PIX_FMT_YUV444P16,
76 AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
77 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRPF32,
78 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
79 AV_PIX_FMT_NONE
80 };
81
82 static const enum AVPixelFormat alpha_pix_fmts[] = {
83 AV_PIX_FMT_YUVA444P,
84 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUVA444P16,
85 AV_PIX_FMT_GBRAP,
86 AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GBRAPF32,
87 AV_PIX_FMT_NONE
88 };
89
90 return ff_set_common_formats_from_list(ctx, s->inplace ? alpha_pix_fmts : no_alpha_pix_fmts);
91 }
92
93 static void premultiply8(const uint8_t *msrc, const uint8_t *asrc,
94 uint8_t *dst,
95 ptrdiff_t mlinesize, ptrdiff_t alinesize,
96 ptrdiff_t dlinesize,
97 int w, int h,
98 int half, int shift, int offset)
99 {
100 int x, y;
101
102 for (y = 0; y < h; y++) {
103 for (x = 0; x < w; x++) {
104 dst[x] = ((msrc[x] * (((asrc[x] >> 1) & 1) + asrc[x])) + 128) >> 8;
105 }
106
107 dst += dlinesize;
108 msrc += mlinesize;
109 asrc += alinesize;
110 }
111 }
112
113 static void premultiply8yuv(const uint8_t *msrc, const uint8_t *asrc,
114 uint8_t *dst,
115 ptrdiff_t mlinesize, ptrdiff_t alinesize,
116 ptrdiff_t dlinesize,
117 int w, int h,
118 int half, int shift, int offset)
119 {
120 int x, y;
121
122 for (y = 0; y < h; y++) {
123 for (x = 0; x < w; x++) {
124 dst[x] = ((((msrc[x] - 128) * (((asrc[x] >> 1) & 1) + asrc[x]))) >> 8) + 128;
125 }
126
127 dst += dlinesize;
128 msrc += mlinesize;
129 asrc += alinesize;
130 }
131 }
132
133 static void premultiply8offset(const uint8_t *msrc, const uint8_t *asrc,
134 uint8_t *dst,
135 ptrdiff_t mlinesize, ptrdiff_t alinesize,
136 ptrdiff_t dlinesize,
137 int w, int h,
138 int half, int shift, int offset)
139 {
140 int x, y;
141
142 for (y = 0; y < h; y++) {
143 for (x = 0; x < w; x++) {
144 dst[x] = ((((msrc[x] - offset) * (((asrc[x] >> 1) & 1) + asrc[x])) + 128) >> 8) + offset;
145 }
146
147 dst += dlinesize;
148 msrc += mlinesize;
149 asrc += alinesize;
150 }
151 }
152
153 static void premultiply16(const uint8_t *mmsrc, const uint8_t *aasrc,
154 uint8_t *ddst,
155 ptrdiff_t mlinesize, ptrdiff_t alinesize,
156 ptrdiff_t dlinesize,
157 int w, int h,
158 int half, int shift, int offset)
159 {
160 const uint16_t *msrc = (const uint16_t *)mmsrc;
161 const uint16_t *asrc = (const uint16_t *)aasrc;
162 uint16_t *dst = (uint16_t *)ddst;
163 int x, y;
164
165 for (y = 0; y < h; y++) {
166 for (x = 0; x < w; x++) {
167 dst[x] = ((msrc[x] * (((asrc[x] >> 1) & 1) + asrc[x])) + half) >> shift;
168 }
169
170 dst += dlinesize / 2;
171 msrc += mlinesize / 2;
172 asrc += alinesize / 2;
173 }
174 }
175
176 static void premultiply16yuv(const uint8_t *mmsrc, const uint8_t *aasrc,
177 uint8_t *ddst,
178 ptrdiff_t mlinesize, ptrdiff_t alinesize,
179 ptrdiff_t dlinesize,
180 int w, int h,
181 int half, int shift, int offset)
182 {
183 const uint16_t *msrc = (const uint16_t *)mmsrc;
184 const uint16_t *asrc = (const uint16_t *)aasrc;
185 uint16_t *dst = (uint16_t *)ddst;
186 int x, y;
187
188 for (y = 0; y < h; y++) {
189 for (x = 0; x < w; x++) {
190 dst[x] = ((((msrc[x] - half) * (int64_t)(((asrc[x] >> 1) & 1) + asrc[x]))) >> shift) + half;
191 }
192
193 dst += dlinesize / 2;
194 msrc += mlinesize / 2;
195 asrc += alinesize / 2;
196 }
197 }
198
199 static void premultiply16offset(const uint8_t *mmsrc, const uint8_t *aasrc,
200 uint8_t *ddst,
201 ptrdiff_t mlinesize, ptrdiff_t alinesize,
202 ptrdiff_t dlinesize,
203 int w, int h,
204 int half, int shift, int offset)
205 {
206 const uint16_t *msrc = (const uint16_t *)mmsrc;
207 const uint16_t *asrc = (const uint16_t *)aasrc;
208 uint16_t *dst = (uint16_t *)ddst;
209 int x, y;
210
211 for (y = 0; y < h; y++) {
212 for (x = 0; x < w; x++) {
213 dst[x] = ((((msrc[x] - offset) * (int64_t)(((asrc[x] >> 1) & 1) + asrc[x])) + half) >> shift) + offset;
214 }
215
216 dst += dlinesize / 2;
217 msrc += mlinesize / 2;
218 asrc += alinesize / 2;
219 }
220 }
221
222 static void premultiplyf32(const uint8_t *mmsrc, const uint8_t *aasrc,
223 uint8_t *ddst,
224 ptrdiff_t mlinesize, ptrdiff_t alinesize,
225 ptrdiff_t dlinesize,
226 int w, int h,
227 int half, int shift, int offset)
228 {
229 const float *msrc = (const float *)mmsrc;
230 const float *asrc = (const float *)aasrc;
231 float *dst = (float *)ddst;
232 int x, y;
233
234 for (y = 0; y < h; y++) {
235 for (x = 0; x < w; x++) {
236 dst[x] = msrc[x] * asrc[x];
237 }
238
239 dst += dlinesize / 4;
240 msrc += mlinesize / 4;
241 asrc += alinesize / 4;
242 }
243 }
244
245 static void premultiplyf32offset(const uint8_t *mmsrc, const uint8_t *aasrc,
246 uint8_t *ddst,
247 ptrdiff_t mlinesize, ptrdiff_t alinesize,
248 ptrdiff_t dlinesize,
249 int w, int h,
250 int half, int shift, int offset)
251 {
252 const float *msrc = (const float *)mmsrc;
253 const float *asrc = (const float *)aasrc;
254 float *dst = (float *)ddst;
255 int x, y;
256
257 float offsetf = offset / 65535.0f;
258
259 for (y = 0; y < h; y++) {
260 for (x = 0; x < w; x++) {
261 dst[x] = ((msrc[x] - offsetf) * asrc[x]) + offsetf;
262 }
263
264 dst += dlinesize / 4;
265 msrc += mlinesize / 4;
266 asrc += alinesize / 4;
267 }
268 }
269
270 static void unpremultiply8(const uint8_t *msrc, const uint8_t *asrc,
271 uint8_t *dst,
272 ptrdiff_t mlinesize, ptrdiff_t alinesize,
273 ptrdiff_t dlinesize,
274 int w, int h,
275 int half, int max, int offset)
276 {
277 int x, y;
278
279 for (y = 0; y < h; y++) {
280 for (x = 0; x < w; x++) {
281 if (asrc[x] > 0 && asrc[x] < 255)
282 dst[x] = FFMIN(msrc[x] * 255 / asrc[x], 255);
283 else
284 dst[x] = msrc[x];
285 }
286
287 dst += dlinesize;
288 msrc += mlinesize;
289 asrc += alinesize;
290 }
291 }
292
293 static void unpremultiply8yuv(const uint8_t *msrc, const uint8_t *asrc,
294 uint8_t *dst,
295 ptrdiff_t mlinesize, ptrdiff_t alinesize,
296 ptrdiff_t dlinesize,
297 int w, int h,
298 int half, int max, int offset)
299 {
300 int x, y;
301
302 for (y = 0; y < h; y++) {
303 for (x = 0; x < w; x++) {
304 if (asrc[x] > 0 && asrc[x] < 255)
305 dst[x] = FFMIN((msrc[x] - 128) * 255 / asrc[x] + 128, 255);
306 else
307 dst[x] = msrc[x];
308 }
309
310 dst += dlinesize;
311 msrc += mlinesize;
312 asrc += alinesize;
313 }
314 }
315
316 static void unpremultiply8offset(const uint8_t *msrc, const uint8_t *asrc,
317 uint8_t *dst,
318 ptrdiff_t mlinesize, ptrdiff_t alinesize,
319 ptrdiff_t dlinesize,
320 int w, int h,
321 int half, int max, int offset)
322 {
323 int x, y;
324
325 for (y = 0; y < h; y++) {
326 for (x = 0; x < w; x++) {
327 if (asrc[x] > 0 && asrc[x] < 255)
328 dst[x] = FFMIN(FFMAX(msrc[x] - offset, 0) * 255 / asrc[x] + offset, 255);
329 else
330 dst[x] = msrc[x];
331 }
332
333 dst += dlinesize;
334 msrc += mlinesize;
335 asrc += alinesize;
336 }
337 }
338
339 static void unpremultiply16(const uint8_t *mmsrc, const uint8_t *aasrc,
340 uint8_t *ddst,
341 ptrdiff_t mlinesize, ptrdiff_t alinesize,
342 ptrdiff_t dlinesize,
343 int w, int h,
344 int half, int max, int offset)
345 {
346 const uint16_t *msrc = (const uint16_t *)mmsrc;
347 const uint16_t *asrc = (const uint16_t *)aasrc;
348 uint16_t *dst = (uint16_t *)ddst;
349 int x, y;
350
351 for (y = 0; y < h; y++) {
352 for (x = 0; x < w; x++) {
353 if (asrc[x] > 0 && asrc[x] < max)
354 dst[x] = FFMIN(msrc[x] * (unsigned)max / asrc[x], max);
355 else
356 dst[x] = msrc[x];
357 }
358
359 dst += dlinesize / 2;
360 msrc += mlinesize / 2;
361 asrc += alinesize / 2;
362 }
363 }
364
365 static void unpremultiply16yuv(const uint8_t *mmsrc, const uint8_t *aasrc,
366 uint8_t *ddst,
367 ptrdiff_t mlinesize, ptrdiff_t alinesize,
368 ptrdiff_t dlinesize,
369 int w, int h,
370 int half, int max, int offset)
371 {
372 const uint16_t *msrc = (const uint16_t *)mmsrc;
373 const uint16_t *asrc = (const uint16_t *)aasrc;
374 uint16_t *dst = (uint16_t *)ddst;
375 int x, y;
376
377 for (y = 0; y < h; y++) {
378 for (x = 0; x < w; x++) {
379 if (asrc[x] > 0 && asrc[x] < max)
380 dst[x] = FFMAX(FFMIN((msrc[x] - half) * max / asrc[x], half - 1), -half) + half;
381 else
382 dst[x] = msrc[x];
383 }
384
385 dst += dlinesize / 2;
386 msrc += mlinesize / 2;
387 asrc += alinesize / 2;
388 }
389 }
390
391 static void unpremultiply16offset(const uint8_t *mmsrc, const uint8_t *aasrc,
392 uint8_t *ddst,
393 ptrdiff_t mlinesize, ptrdiff_t alinesize,
394 ptrdiff_t dlinesize,
395 int w, int h,
396 int half, int max, int offset)
397 {
398 const uint16_t *msrc = (const uint16_t *)mmsrc;
399 const uint16_t *asrc = (const uint16_t *)aasrc;
400 uint16_t *dst = (uint16_t *)ddst;
401 int x, y;
402
403 for (y = 0; y < h; y++) {
404 for (x = 0; x < w; x++) {
405 if (asrc[x] > 0 && asrc[x] < max)
406 dst[x] = FFMAX(FFMIN(FFMAX(msrc[x] - offset, 0) * (unsigned)max / asrc[x] + offset, max), 0);
407 else
408 dst[x] = msrc[x];
409 }
410
411 dst += dlinesize / 2;
412 msrc += mlinesize / 2;
413 asrc += alinesize / 2;
414 }
415 }
416
417 static void unpremultiplyf32(const uint8_t *mmsrc, const uint8_t *aasrc,
418 uint8_t *ddst,
419 ptrdiff_t mlinesize, ptrdiff_t alinesize,
420 ptrdiff_t dlinesize,
421 int w, int h,
422 int half, int max, int offset)
423 {
424 const float *msrc = (const float *)mmsrc;
425 const float *asrc = (const float *)aasrc;
426
427 float *dst = (float *)ddst;
428 int x, y;
429
430 for (y = 0; y < h; y++) {
431 for (x = 0; x < w; x++) {
432 if (asrc[x] > 0.0f)
433 dst[x] = msrc[x] / asrc[x];
434 else
435 dst[x] = msrc[x];
436 }
437
438 dst += dlinesize / 4;
439 msrc += mlinesize / 4;
440 asrc += alinesize / 4;
441 }
442 }
443
444 static void unpremultiplyf32offset(const uint8_t *mmsrc, const uint8_t *aasrc,
445 uint8_t *ddst,
446 ptrdiff_t mlinesize, ptrdiff_t alinesize,
447 ptrdiff_t dlinesize,
448 int w, int h,
449 int half, int max, int offset)
450 {
451 const float *msrc = (const float *)mmsrc;
452 const float *asrc = (const float *)aasrc;
453
454 float *dst = (float *)ddst;
455 int x, y;
456
457 float offsetf = offset / 65535.0f;
458
459 for (y = 0; y < h; y++) {
460 for (x = 0; x < w; x++) {
461 if (asrc[x] > 0.0f)
462 dst[x] = (msrc[x] - offsetf) / asrc[x] + offsetf;
463 else
464 dst[x] = msrc[x];
465 }
466
467 dst += dlinesize / 4;
468 msrc += mlinesize / 4;
469 asrc += alinesize / 4;
470 }
471 }
472
473 static int premultiply_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
474 {
475 PreMultiplyContext *s = ctx->priv;
476 ThreadData *td = arg;
477 AVFrame *out = td->d;
478 AVFrame *alpha = td->a;
479 AVFrame *base = td->m;
480 int p;
481
482 for (p = 0; p < s->nb_planes; p++) {
483 const int slice_start = (s->height[p] * jobnr) / nb_jobs;
484 const int slice_end = (s->height[p] * (jobnr+1)) / nb_jobs;
485
486 if (!((1 << p) & s->planes) || p == 3) {
487 av_image_copy_plane(out->data[p] + slice_start * out->linesize[p],
488 out->linesize[p],
489 base->data[p] + slice_start * base->linesize[p],
490 base->linesize[p],
491 s->linesize[p], slice_end - slice_start);
492 continue;
493 }
494
495 s->premultiply[p](base->data[p] + slice_start * base->linesize[p],
496 s->inplace ? alpha->data[3] + slice_start * alpha->linesize[3] :
497 alpha->data[0] + slice_start * alpha->linesize[0],
498 out->data[p] + slice_start * out->linesize[p],
499 base->linesize[p], s->inplace ? alpha->linesize[3] : alpha->linesize[0],
500 out->linesize[p],
501 s->width[p], slice_end - slice_start,
502 s->half, s->inverse ? s->max : s->depth, s->offset);
503 }
504
505 return 0;
506 }
507
508 static int filter_frame(AVFilterContext *ctx,
509 AVFrame **out, AVFrame *base, AVFrame *alpha)
510 {
511 PreMultiplyContext *s = ctx->priv;
512 AVFilterLink *outlink = ctx->outputs[0];
513
514 if (ctx->is_disabled) {
515 *out = av_frame_clone(base);
516 if (!*out)
517 return AVERROR(ENOMEM);
518 } else {
519 ThreadData td;
520 int full, limited;
521
522 *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
523 if (!*out)
524 return AVERROR(ENOMEM);
525 av_frame_copy_props(*out, base);
526
527 full = base->color_range == AVCOL_RANGE_JPEG;
528 limited = base->color_range == AVCOL_RANGE_MPEG;
529
530 if (s->inverse) {
531 switch (outlink->format) {
532 case AV_PIX_FMT_YUV444P:
533 case AV_PIX_FMT_YUVA444P:
534 s->premultiply[0] = full ? unpremultiply8 : unpremultiply8offset;
535 s->premultiply[1] = s->premultiply[2] = unpremultiply8yuv;
536 break;
537 case AV_PIX_FMT_YUVJ444P:
538 s->premultiply[0] = unpremultiply8;
539 s->premultiply[1] = s->premultiply[2] = unpremultiply8yuv;
540 break;
541 case AV_PIX_FMT_GBRP:
542 case AV_PIX_FMT_GBRAP:
543 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiply8offset : unpremultiply8;
544 break;
545 case AV_PIX_FMT_YUV444P9:
546 case AV_PIX_FMT_YUVA444P9:
547 case AV_PIX_FMT_YUV444P10:
548 case AV_PIX_FMT_YUVA444P10:
549 case AV_PIX_FMT_YUV444P12:
550 case AV_PIX_FMT_YUVA444P12:
551 case AV_PIX_FMT_YUV444P14:
552 case AV_PIX_FMT_YUV444P16:
553 case AV_PIX_FMT_YUVA444P16:
554 s->premultiply[0] = full ? unpremultiply16 : unpremultiply16offset;
555 s->premultiply[1] = s->premultiply[2] = unpremultiply16yuv;
556 break;
557 case AV_PIX_FMT_GBRP9:
558 case AV_PIX_FMT_GBRP10:
559 case AV_PIX_FMT_GBRAP10:
560 case AV_PIX_FMT_GBRP12:
561 case AV_PIX_FMT_GBRAP12:
562 case AV_PIX_FMT_GBRP14:
563 case AV_PIX_FMT_GBRP16:
564 case AV_PIX_FMT_GBRAP16:
565 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiply16offset : unpremultiply16;
566 break;
567 case AV_PIX_FMT_GBRPF32:
568 case AV_PIX_FMT_GBRAPF32:
569 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiplyf32offset : unpremultiplyf32;
570 break;
571 case AV_PIX_FMT_GRAY8:
572 s->premultiply[0] = limited ? unpremultiply8offset : unpremultiply8;
573 break;
574 case AV_PIX_FMT_GRAY9:
575 case AV_PIX_FMT_GRAY10:
576 case AV_PIX_FMT_GRAY12:
577 case AV_PIX_FMT_GRAY14:
578 case AV_PIX_FMT_GRAY16:
579 s->premultiply[0] = limited ? unpremultiply16offset : unpremultiply16;
580 break;
581 }
582 } else {
583 switch (outlink->format) {
584 case AV_PIX_FMT_YUV444P:
585 case AV_PIX_FMT_YUVA444P:
586 s->premultiply[0] = full ? premultiply8 : premultiply8offset;
587 s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
588 break;
589 case AV_PIX_FMT_YUVJ444P:
590 s->premultiply[0] = premultiply8;
591 s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
592 break;
593 case AV_PIX_FMT_GBRP:
594 case AV_PIX_FMT_GBRAP:
595 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply8offset : premultiply8;
596 break;
597 case AV_PIX_FMT_YUV444P9:
598 case AV_PIX_FMT_YUVA444P9:
599 case AV_PIX_FMT_YUV444P10:
600 case AV_PIX_FMT_YUVA444P10:
601 case AV_PIX_FMT_YUV444P12:
602 case AV_PIX_FMT_YUVA444P12:
603 case AV_PIX_FMT_YUV444P14:
604 case AV_PIX_FMT_YUV444P16:
605 case AV_PIX_FMT_YUVA444P16:
606 s->premultiply[0] = full ? premultiply16 : premultiply16offset;
607 s->premultiply[1] = s->premultiply[2] = premultiply16yuv;
608 break;
609 case AV_PIX_FMT_GBRP9:
610 case AV_PIX_FMT_GBRP10:
611 case AV_PIX_FMT_GBRAP10:
612 case AV_PIX_FMT_GBRP12:
613 case AV_PIX_FMT_GBRAP12:
614 case AV_PIX_FMT_GBRP14:
615 case AV_PIX_FMT_GBRP16:
616 case AV_PIX_FMT_GBRAP16:
617 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply16offset : premultiply16;
618 break;
619 case AV_PIX_FMT_GBRPF32:
620 case AV_PIX_FMT_GBRAPF32:
621 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiplyf32offset: premultiplyf32;
622 break;
623 case AV_PIX_FMT_GRAY8:
624 s->premultiply[0] = limited ? premultiply8offset : premultiply8;
625 break;
626 case AV_PIX_FMT_GRAY9:
627 case AV_PIX_FMT_GRAY10:
628 case AV_PIX_FMT_GRAY12:
629 case AV_PIX_FMT_GRAY14:
630 case AV_PIX_FMT_GRAY16:
631 s->premultiply[0] = limited ? premultiply16offset : premultiply16;
632 break;
633 }
634 }
635
636 td.d = *out;
637 td.a = alpha;
638 td.m = base;
639 ff_filter_execute(ctx, premultiply_slice, &td, NULL,
640 FFMIN(s->height[0], ff_filter_get_nb_threads(ctx)));
641 }
642
643 return 0;
644 }
645
646 static int process_frame(FFFrameSync *fs)
647 {
648 AVFilterContext *ctx = fs->parent;
649 PreMultiplyContext *s = fs->opaque;
650 AVFilterLink *outlink = ctx->outputs[0];
651 AVFrame *out = NULL, *base, *alpha;
652 int ret;
653
654 if ((ret = ff_framesync_get_frame(&s->fs, 0, &base, 0)) < 0 ||
655 (ret = ff_framesync_get_frame(&s->fs, 1, &alpha, 0)) < 0)
656 return ret;
657
658 if ((ret = filter_frame(ctx, &out, base, alpha)) < 0)
659 return ret;
660
661 out->pts = av_rescale_q(base->pts, s->fs.time_base, outlink->time_base);
662
663 return ff_filter_frame(outlink, out);
664 }
665
666 static int config_input(AVFilterLink *inlink)
667 {
668 AVFilterContext *ctx = inlink->dst;
669 PreMultiplyContext *s = ctx->priv;
670 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
671 int vsub, hsub, ret;
672
673 s->nb_planes = av_pix_fmt_count_planes(inlink->format);
674
675 if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
676 return ret;
677
678 hsub = desc->log2_chroma_w;
679 vsub = desc->log2_chroma_h;
680 s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
681 s->height[0] = s->height[3] = inlink->h;
682 s->width[1] = s->width[2] = AV_CEIL_RSHIFT(inlink->w, hsub);
683 s->width[0] = s->width[3] = inlink->w;
684
685 s->depth = desc->flags & AV_PIX_FMT_FLAG_FLOAT ? 16 : desc->comp[0].depth;
686 s->max = (1 << s->depth) - 1;
687 s->half = (1 << s->depth) / 2;
688 s->offset = 16 << (s->depth - 8);
689
690 return 0;
691 }
692
693 static int config_output(AVFilterLink *outlink)
694 {
695 AVFilterContext *ctx = outlink->src;
696 PreMultiplyContext *s = ctx->priv;
697 AVFilterLink *base = ctx->inputs[0];
698 AVFilterLink *alpha;
699 FFFrameSyncIn *in;
700 int ret;
701
702 if (!s->inplace) {
703 alpha = ctx->inputs[1];
704
705 if (base->w != alpha->w ||
706 base->h != alpha->h) {
707 av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
708 "(size %dx%d) do not match the corresponding "
709 "second input link %s parameters (%dx%d) ",
710 ctx->input_pads[0].name, base->w, base->h,
711 ctx->input_pads[1].name, alpha->w, alpha->h);
712 return AVERROR(EINVAL);
713 }
714 }
715
716 outlink->w = base->w;
717 outlink->h = base->h;
718 outlink->time_base = base->time_base;
719 outlink->sample_aspect_ratio = base->sample_aspect_ratio;
720 outlink->frame_rate = base->frame_rate;
721
722 if (s->inplace)
723 return 0;
724
725 if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
726 return ret;
727
728 in = s->fs.in;
729 in[0].time_base = base->time_base;
730 in[1].time_base = alpha->time_base;
731 in[0].sync = 1;
732 in[0].before = EXT_STOP;
733 in[0].after = EXT_INFINITY;
734 in[1].sync = 1;
735 in[1].before = EXT_STOP;
736 in[1].after = EXT_INFINITY;
737 s->fs.opaque = s;
738 s->fs.on_event = process_frame;
739
740 return ff_framesync_configure(&s->fs);
741 }
742
743 static int activate(AVFilterContext *ctx)
744 {
745 PreMultiplyContext *s = ctx->priv;
746
747 if (s->inplace) {
748 AVFrame *frame = NULL;
749 AVFrame *out = NULL;
750 int ret, status;
751 int64_t pts;
752
753 FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);
754
755 if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &frame)) > 0) {
756 ret = filter_frame(ctx, &out, frame, frame);
757 av_frame_free(&frame);
758 if (ret < 0)
759 return ret;
760 ret = ff_filter_frame(ctx->outputs[0], out);
761 }
762 if (ret < 0) {
763 return ret;
764 } else if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
765 ff_outlink_set_status(ctx->outputs[0], status, pts);
766 return 0;
767 } else {
768 if (ff_outlink_frame_wanted(ctx->outputs[0]))
769 ff_inlink_request_frame(ctx->inputs[0]);
770 return 0;
771 }
772 } else {
773 return ff_framesync_activate(&s->fs);
774 }
775 }
776
777 static av_cold int init(AVFilterContext *ctx)
778 {
779 PreMultiplyContext *s = ctx->priv;
780 AVFilterPad pad = { 0 };
781 int ret;
782
783 if (!strcmp(ctx->filter->name, "unpremultiply"))
784 s->inverse = 1;
785
786 pad.type = AVMEDIA_TYPE_VIDEO;
787 pad.name = "main";
788 pad.config_props = config_input;
789
790 if ((ret = ff_append_inpad(ctx, &pad)) < 0)
791 return ret;
792
793 if (!s->inplace) {
794 pad.type = AVMEDIA_TYPE_VIDEO;
795 pad.name = "alpha";
796 pad.config_props = NULL;
797
798 if ((ret = ff_append_inpad(ctx, &pad)) < 0)
799 return ret;
800 }
801
802 return 0;
803 }
804
805 static av_cold void uninit(AVFilterContext *ctx)
806 {
807 PreMultiplyContext *s = ctx->priv;
808
809 if (!s->inplace)
810 ff_framesync_uninit(&s->fs);
811 }
812
813 static const AVFilterPad premultiply_outputs[] = {
814 {
815 .name = "default",
816 .type = AVMEDIA_TYPE_VIDEO,
817 .config_props = config_output,
818 },
819 };
820
821 #if CONFIG_PREMULTIPLY_FILTER
822
823 const AVFilter ff_vf_premultiply = {
824 .name = "premultiply",
825 .description = NULL_IF_CONFIG_SMALL("PreMultiply first stream with first plane of second stream."),
826 .priv_size = sizeof(PreMultiplyContext),
827 .init = init,
828 .uninit = uninit,
829 .activate = activate,
830 .inputs = NULL,
831 FILTER_OUTPUTS(premultiply_outputs),
832 FILTER_QUERY_FUNC(query_formats),
833 .priv_class = &premultiply_class,
834 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
835 AVFILTER_FLAG_DYNAMIC_INPUTS |
836 AVFILTER_FLAG_SLICE_THREADS,
837 };
838
839 #endif /* CONFIG_PREMULTIPLY_FILTER */
840
841 #if CONFIG_UNPREMULTIPLY_FILTER
842
843 const AVFilter ff_vf_unpremultiply = {
844 .name = "unpremultiply",
845 .description = NULL_IF_CONFIG_SMALL("UnPreMultiply first stream with first plane of second stream."),
846 .priv_class = &premultiply_class,
847 .priv_size = sizeof(PreMultiplyContext),
848 .init = init,
849 .uninit = uninit,
850 .activate = activate,
851 .inputs = NULL,
852 FILTER_OUTPUTS(premultiply_outputs),
853 FILTER_QUERY_FUNC(query_formats),
854 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
855 AVFILTER_FLAG_DYNAMIC_INPUTS |
856 AVFILTER_FLAG_SLICE_THREADS,
857 };
858
859 #endif /* CONFIG_UNPREMULTIPLY_FILTER */
860