History

avfilter/vf_colorchannelmixer: add option to preserve lightness

Paul B Mahol committed 5 years ago

Commit b2bbced1 parent 257a83b2 files · +297 −84Browse files

Unified · Split

2 files
  1. doc/filters.texi +3 −0
  2. libavfilter/vf_colorchannelmixer.c +294 −84
doc/filters.texi+3−0
@@ -8065,6 +8065,9 @@ Adjust contribution of input red, green, blue and alpha channels for output alph · 8064 unmodified lines
80658065 Default is @code{1} for @var{aa}, and @code{0} for @var{ar}, @var{ag} and @var{ab}.
80668066
80678067 Allowed ranges for options are @code{[-2.0, 2.0]}.
8068+
8069+@item pl
8070+Preserve lightness when changing colors. Default is disabled.
80688071 @end table
80698072
80708073 @subsection Examples
libavfilter/vf_colorchannelmixer.c+294−84
@@ -18,6 +18,8 @@ · 17 unmodified lines
1818 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
1919 */
2020
21+#include <float.h>
22+
2123 #include "libavutil/opt.h"
2224 #include "libavutil/pixdesc.h"
2325 #include "avfilter.h"
@@ -41,6 +43,8 @@ typedef struct ColorChannelMixerContext { · 17 unmodified lines
4143 double gr, gg, gb, ga;
4244 double br, bg, bb, ba;
4345 double ar, ag, ab, aa;
46+ double sr, sg, sb;
47+ int preserve_lightness;
4448
4549 int *lut[4][4];
4650
@@ -48,7 +52,7 @@ typedef struct ColorChannelMixerContext { · 1 unmodified line
4852
4953 uint8_t rgba_map[4];
5054
51− int (*filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
55+ int (*filter_slice[2])(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
5256 } ColorChannelMixerContext;
5357
5458 #define OFFSET(x) offsetof(ColorChannelMixerContext, x)
@@ -71,6 +75,7 @@ static const AVOption colorchannelmixer_options[] = { · 16 unmodified lines
7175 { "ag", "set the green gain for the alpha channel", OFFSET(ag), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -2, 2, FLAGS },
7276 { "ab", "set the blue gain for the alpha channel", OFFSET(ab), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -2, 2, FLAGS },
7377 { "aa", "set the alpha gain for the alpha channel", OFFSET(aa), AV_OPT_TYPE_DOUBLE, {.dbl=1}, -2, 2, FLAGS },
78+ { "pl", "preserve lightness", OFFSET(preserve_lightness), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
7479 { NULL }
7580 };
7681
@@ -101,8 +106,15 @@ static int query_formats(AVFilterContext *ctx) · 24 unmodified lines
101106 return ff_set_common_formats(ctx, fmts_list);
102107 }
103108
109+static void preservel(float *r, float *g, float *b, float lin, float lout)
110+{
111+ *r *= lout / lin;
112+ *g *= lout / lin;
113+ *b *= lout / lin;
114+}
115+
104116 static av_always_inline int filter_slice_rgba_planar(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs,
105− int have_alpha)
117+ int have_alpha, int pl)
106118 {
107119 ColorChannelMixerContext *s = ctx->priv;
108120 ThreadData *td = arg;
@@ -126,19 +138,42 @@ static av_always_inline int filter_slice_rgba_planar(AVFilterContext *ctx, void · 17 unmodified lines
126138 const uint8_t gin = srcg[j];
127139 const uint8_t bin = srcb[j];
128140 const uint8_t ain = have_alpha ? srca[j] : 0;
141+ int rout, gout, bout;
142+ float lin;
143+
144+ if (pl)
145+ lin = FFMAX3(rin, gin, bin) / 255.f + FFMIN3(rin, gin, bin) / 255.f;
146+
147+ rout = s->lut[R][R][rin] +
148+ s->lut[R][G][gin] +
149+ s->lut[R][B][bin] +
150+ (have_alpha == 1 ? s->lut[R][A][ain] : 0);
151+ gout = s->lut[G][R][rin] +
152+ s->lut[G][G][gin] +
153+ s->lut[G][B][bin] +
154+ (have_alpha == 1 ? s->lut[G][A][ain] : 0);
155+ bout = s->lut[B][R][rin] +
156+ s->lut[B][G][gin] +
157+ s->lut[B][B][bin] +
158+ (have_alpha == 1 ? s->lut[B][A][ain] : 0);
159+
160+ if (pl) {
161+ float frout = rout / (255.f * s->sr);
162+ float fgout = gout / (255.f * s->sg);
163+ float fbout = bout / (255.f * s->sb);
164+ float lout = FFMAX3(frout, fgout, fbout) + FFMIN3(frout, fgout, fbout);
165+
166+ preservel(&frout, &fgout, &fbout, lin, lout);
167+
168+ rout = lrintf(frout * 255.f);
169+ gout = lrintf(fgout * 255.f);
170+ bout = lrintf(fbout * 255.f);
171+ }
172+
173+ dstr[j] = av_clip_uint8(rout);
174+ dstg[j] = av_clip_uint8(gout);
175+ dstb[j] = av_clip_uint8(bout);
129176
130− dstr[j] = av_clip_uint8(s->lut[R][R][rin] +
131− s->lut[R][G][gin] +
132− s->lut[R][B][bin] +
133− (have_alpha == 1 ? s->lut[R][A][ain] : 0));
134− dstg[j] = av_clip_uint8(s->lut[G][R][rin] +
135− s->lut[G][G][gin] +
136− s->lut[G][B][bin] +
137− (have_alpha == 1 ? s->lut[G][A][ain] : 0));
138− dstb[j] = av_clip_uint8(s->lut[B][R][rin] +
139− s->lut[B][G][gin] +
140− s->lut[B][B][bin] +
141− (have_alpha == 1 ? s->lut[B][A][ain] : 0));
142177 if (have_alpha == 1) {
143178 dsta[j] = av_clip_uint8(s->lut[A][R][rin] +
144179 s->lut[A][G][gin] +
@@ -161,7 +196,7 @@ static av_always_inline int filter_slice_rgba_planar(AVFilterContext *ctx, void · 16 unmodified lines
161196 }
162197
163198 static av_always_inline int filter_slice_rgba16_planar(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs,
164− int have_alpha, int depth)
199+ int have_alpha, int depth, int pl)
165200 {
166201 ColorChannelMixerContext *s = ctx->priv;
167202 ThreadData *td = arg;
@@ -177,6 +212,8 @@ static av_always_inline int filter_slice_rgba16_planar(AVFilterContext *ctx, voi · 9 unmodified lines
177212 uint16_t *dstb = (uint16_t *)(out->data[1] + slice_start * out->linesize[1]);
178213 uint16_t *dstr = (uint16_t *)(out->data[2] + slice_start * out->linesize[2]);
179214 uint16_t *dsta = (uint16_t *)(out->data[3] + slice_start * out->linesize[3]);
215+ const float scale = 1.f / ((1 << depth) - 1);
216+ const float factor = (1 << depth) - 1;
180217 int i, j;
181218
182219 for (i = slice_start; i < slice_end; i++) {
@@ -185,19 +222,42 @@ static av_always_inline int filter_slice_rgba16_planar(AVFilterContext *ctx, voi · 2 unmodified lines
185222 const uint16_t gin = srcg[j];
186223 const uint16_t bin = srcb[j];
187224 const uint16_t ain = have_alpha ? srca[j] : 0;
225+ int rout, gout, bout;
226+ float lin;
227+
228+ if (pl)
229+ lin = FFMAX3(rin, gin, bin) * scale + FFMIN3(rin, gin, bin) * scale;
230+
231+ rout = s->lut[R][R][rin] +
232+ s->lut[R][G][gin] +
233+ s->lut[R][B][bin] +
234+ (have_alpha == 1 ? s->lut[R][A][ain] : 0);
235+ gout = s->lut[G][R][rin] +
236+ s->lut[G][G][gin] +
237+ s->lut[G][B][bin] +
238+ (have_alpha == 1 ? s->lut[G][A][ain] : 0);
239+ bout = s->lut[B][R][rin] +
240+ s->lut[B][G][gin] +
241+ s->lut[B][B][bin] +
242+ (have_alpha == 1 ? s->lut[B][A][ain] : 0);
243+
244+ if (pl) {
245+ float frout = rout / (factor * s->sr);
246+ float fgout = gout / (factor * s->sg);
247+ float fbout = bout / (factor * s->sb);
248+ float lout = FFMAX3(frout, fgout, fbout) + FFMIN3(frout, fgout, fbout);
249+
250+ preservel(&frout, &fgout, &fbout, lin, lout);
251+
252+ rout = lrintf(frout * factor);
253+ gout = lrintf(fgout * factor);
254+ bout = lrintf(fbout * factor);
255+ }
256+
257+ dstr[j] = av_clip_uintp2(rout, depth);
258+ dstg[j] = av_clip_uintp2(gout, depth);
259+ dstb[j] = av_clip_uintp2(bout, depth);
188260
189− dstr[j] = av_clip_uintp2(s->lut[R][R][rin] +
190− s->lut[R][G][gin] +
191− s->lut[R][B][bin] +
192− (have_alpha == 1 ? s->lut[R][A][ain] : 0), depth);
193− dstg[j] = av_clip_uintp2(s->lut[G][R][rin] +
194− s->lut[G][G][gin] +
195− s->lut[G][B][bin] +
196− (have_alpha == 1 ? s->lut[G][A][ain] : 0), depth);
197− dstb[j] = av_clip_uintp2(s->lut[B][R][rin] +
198− s->lut[B][G][gin] +
199− s->lut[B][B][bin] +
200− (have_alpha == 1 ? s->lut[B][A][ain] : 0), depth);
201261 if (have_alpha == 1) {
202262 dsta[j] = av_clip_uintp2(s->lut[A][R][rin] +
203263 s->lut[A][G][gin] +
@@ -221,56 +281,106 @@ static av_always_inline int filter_slice_rgba16_planar(AVFilterContext *ctx, voi · 17 unmodified lines
221281
222282 static int filter_slice_gbrp(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
223283 {
224− return filter_slice_rgba_planar(ctx, arg, jobnr, nb_jobs, 0);
284+ return filter_slice_rgba_planar(ctx, arg, jobnr, nb_jobs, 0, 0);
225285 }
226286
227287 static int filter_slice_gbrap(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
228288 {
229− return filter_slice_rgba_planar(ctx, arg, jobnr, nb_jobs, 1);
289+ return filter_slice_rgba_planar(ctx, arg, jobnr, nb_jobs, 1, 0);
290+}
291+
292+static int filter_slice_gbrp_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
293+{
294+ return filter_slice_rgba_planar(ctx, arg, jobnr, nb_jobs, 0, 1);
295+}
296+
297+static int filter_slice_gbrap_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
298+{
299+ return filter_slice_rgba_planar(ctx, arg, jobnr, nb_jobs, 1, 1);
230300 }
231301
232302 static int filter_slice_gbrp9(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
233303 {
234− return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 9);
304+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 9, 0);
235305 }
236306
237307 static int filter_slice_gbrp10(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
238308 {
239− return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 10);
309+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 10, 0);
240310 }
241311
242312 static int filter_slice_gbrap10(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
243313 {
244− return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 1, 10);
314+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 1, 10, 0);
245315 }
246316
247317 static int filter_slice_gbrp12(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
248318 {
249− return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 12);
319+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 12, 0);
250320 }
251321
252322 static int filter_slice_gbrap12(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
253323 {
254− return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 1, 12);
324+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 1, 12, 0);
255325 }
256326
257327 static int filter_slice_gbrp14(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
258328 {
259− return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 14);
329+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 14, 0);
260330 }
261331
262332 static int filter_slice_gbrp16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
263333 {
264− return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 16);
334+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 16, 0);
265335 }
266336
267337 static int filter_slice_gbrap16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
268338 {
269− return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 1, 16);
339+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 1, 16, 0);
340+}
341+
342+static int filter_slice_gbrp9_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
343+{
344+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 9, 1);
345+}
346+
347+static int filter_slice_gbrp10_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
348+{
349+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 10, 1);
350+}
351+
352+static int filter_slice_gbrap10_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
353+{
354+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 1, 10, 1);
355+}
356+
357+static int filter_slice_gbrp12_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
358+{
359+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 12, 1);
360+}
361+
362+static int filter_slice_gbrap12_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
363+{
364+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 1, 12, 1);
365+}
366+
367+static int filter_slice_gbrp14_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
368+{
369+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 14, 1);
370+}
371+
372+static int filter_slice_gbrp16_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
373+{
374+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 0, 16, 1);
375+}
376+
377+static int filter_slice_gbrap16_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
378+{
379+ return filter_slice_rgba16_planar(ctx, arg, jobnr, nb_jobs, 1, 16, 1);
270380 }
271381
272382 static av_always_inline int filter_slice_rgba_packed(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs,
273− int have_alpha, int step)
383+ int have_alpha, int step, int pl)
274384 {
275385 ColorChannelMixerContext *s = ctx->priv;
276386 ThreadData *td = arg;
@@ -295,19 +405,42 @@ static av_always_inline int filter_slice_rgba_packed(AVFilterContext *ctx, void · 18 unmodified lines
295405 const uint8_t gin = src[j + goffset];
296406 const uint8_t bin = src[j + boffset];
297407 const uint8_t ain = src[j + aoffset];
408+ int rout, gout, bout;
409+ float lin;
410+
411+ if (pl)
412+ lin = FFMAX3(rin, gin, bin) / 255.f + FFMIN3(rin, gin, bin) / 255.f;
413+
414+ rout = s->lut[R][R][rin] +
415+ s->lut[R][G][gin] +
416+ s->lut[R][B][bin] +
417+ (have_alpha == 1 ? s->lut[R][A][ain] : 0);
418+ gout = s->lut[G][R][rin] +
419+ s->lut[G][G][gin] +
420+ s->lut[G][B][bin] +
421+ (have_alpha == 1 ? s->lut[G][A][ain] : 0);
422+ bout = s->lut[B][R][rin] +
423+ s->lut[B][G][gin] +
424+ s->lut[B][B][bin] +
425+ (have_alpha == 1 ? s->lut[B][A][ain] : 0);
426+
427+ if (pl) {
428+ float frout = rout / (255.f * s->sr);
429+ float fgout = gout / (255.f * s->sg);
430+ float fbout = bout / (255.f * s->sb);
431+ float lout = FFMAX3(frout, fgout, fbout) + FFMIN3(frout, fgout, fbout);
432+
433+ preservel(&frout, &fgout, &fbout, lin, lout);
434+
435+ rout = lrintf(frout * 255.f);
436+ gout = lrintf(fgout * 255.f);
437+ bout = lrintf(fbout * 255.f);
438+ }
439+
440+ dst[j + roffset] = av_clip_uint8(rout);
441+ dst[j + goffset] = av_clip_uint8(gout);
442+ dst[j + boffset] = av_clip_uint8(bout);
298443
299− dst[j + roffset] = av_clip_uint8(s->lut[R][R][rin] +
300− s->lut[R][G][gin] +
301− s->lut[R][B][bin] +
302− (have_alpha == 1 ? s->lut[R][A][ain] : 0));
303− dst[j + goffset] = av_clip_uint8(s->lut[G][R][rin] +
304− s->lut[G][G][gin] +
305− s->lut[G][B][bin] +
306− (have_alpha == 1 ? s->lut[G][A][ain] : 0));
307− dst[j + boffset] = av_clip_uint8(s->lut[B][R][rin] +
308− s->lut[B][G][gin] +
309− s->lut[B][B][bin] +
310− (have_alpha == 1 ? s->lut[B][A][ain] : 0));
311444 if (have_alpha == 1) {
312445 dst[j + aoffset] = av_clip_uint8(s->lut[A][R][rin] +
313446 s->lut[A][G][gin] +
@@ -325,7 +458,7 @@ static av_always_inline int filter_slice_rgba_packed(AVFilterContext *ctx, void · 11 unmodified lines
325458 }
326459
327460 static av_always_inline int filter_slice_rgba16_packed(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs,
328− int have_alpha, int step)
461+ int have_alpha, int step, int pl)
329462 {
330463 ColorChannelMixerContext *s = ctx->priv;
331464 ThreadData *td = arg;
@@ -350,19 +483,42 @@ static av_always_inline int filter_slice_rgba16_packed(AVFilterContext *ctx, voi · 18 unmodified lines
350483 const uint16_t gin = src[j + goffset];
351484 const uint16_t bin = src[j + boffset];
352485 const uint16_t ain = src[j + aoffset];
486+ int rout, gout, bout;
487+ float lin;
488+
489+ if (pl)
490+ lin = FFMAX3(rin, gin, bin) / 65535.f + FFMIN3(rin, gin, bin) / 65535.f;
491+
492+ rout = s->lut[R][R][rin] +
493+ s->lut[R][G][gin] +
494+ s->lut[R][B][bin] +
495+ (have_alpha == 1 ? s->lut[R][A][ain] : 0);
496+ gout = s->lut[G][R][rin] +
497+ s->lut[G][G][gin] +
498+ s->lut[G][B][bin] +
499+ (have_alpha == 1 ? s->lut[G][A][ain] : 0);
500+ bout = s->lut[B][R][rin] +
501+ s->lut[B][G][gin] +
502+ s->lut[B][B][bin] +
503+ (have_alpha == 1 ? s->lut[B][A][ain] : 0);
504+
505+ if (pl) {
506+ float frout = rout / (65535.f * s->sr);
507+ float fgout = gout / (65535.f * s->sg);
508+ float fbout = bout / (65535.f * s->sb);
509+ float lout = FFMAX3(frout, fgout, fbout) + FFMIN3(frout, fgout, fbout);
510+
511+ preservel(&frout, &fgout, &fbout, lin, lout);
512+
513+ rout = lrintf(frout * 65535.f);
514+ gout = lrintf(fgout * 65535.f);
515+ bout = lrintf(fbout * 65535.f);
516+ }
517+
518+ dst[j + roffset] = av_clip_uint16(rout);
519+ dst[j + goffset] = av_clip_uint16(gout);
520+ dst[j + boffset] = av_clip_uint16(bout);
353521
354− dst[j + roffset] = av_clip_uint16(s->lut[R][R][rin] +
355− s->lut[R][G][gin] +
356− s->lut[R][B][bin] +
357− (have_alpha == 1 ? s->lut[R][A][ain] : 0));
358− dst[j + goffset] = av_clip_uint16(s->lut[G][R][rin] +
359− s->lut[G][G][gin] +
360− s->lut[G][B][bin] +
361− (have_alpha == 1 ? s->lut[G][A][ain] : 0));
362− dst[j + boffset] = av_clip_uint16(s->lut[B][R][rin] +
363− s->lut[B][G][gin] +
364− s->lut[B][B][bin] +
365− (have_alpha == 1 ? s->lut[B][A][ain] : 0));
366522 if (have_alpha == 1) {
367523 dst[j + aoffset] = av_clip_uint16(s->lut[A][R][rin] +
368524 s->lut[A][G][gin] +
@@ -380,27 +536,52 @@ static av_always_inline int filter_slice_rgba16_packed(AVFilterContext *ctx, voi · 11 unmodified lines
380536
381537 static int filter_slice_rgba64(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
382538 {
383− return filter_slice_rgba16_packed(ctx, arg, jobnr, nb_jobs, 1, 4);
539+ return filter_slice_rgba16_packed(ctx, arg, jobnr, nb_jobs, 1, 4, 0);
384540 }
385541
386542 static int filter_slice_rgb48(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
387543 {
388− return filter_slice_rgba16_packed(ctx, arg, jobnr, nb_jobs, 0, 3);
544+ return filter_slice_rgba16_packed(ctx, arg, jobnr, nb_jobs, 0, 3, 0);
545+}
546+
547+static int filter_slice_rgba64_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
548+{
549+ return filter_slice_rgba16_packed(ctx, arg, jobnr, nb_jobs, 1, 4, 1);
550+}
551+
552+static int filter_slice_rgb48_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
553+{
554+ return filter_slice_rgba16_packed(ctx, arg, jobnr, nb_jobs, 0, 3, 1);
389555 }
390556
391557 static int filter_slice_rgba(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
392558 {
393− return filter_slice_rgba_packed(ctx, arg, jobnr, nb_jobs, 1, 4);
559+ return filter_slice_rgba_packed(ctx, arg, jobnr, nb_jobs, 1, 4, 0);
394560 }
395561
396562 static int filter_slice_rgb24(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
397563 {
398− return filter_slice_rgba_packed(ctx, arg, jobnr, nb_jobs, 0, 3);
564+ return filter_slice_rgba_packed(ctx, arg, jobnr, nb_jobs, 0, 3, 0);
399565 }
400566
401567 static int filter_slice_rgb0(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
402568 {
403− return filter_slice_rgba_packed(ctx, arg, jobnr, nb_jobs, -1, 4);
569+ return filter_slice_rgba_packed(ctx, arg, jobnr, nb_jobs, -1, 4, 0);
570+}
571+
572+static int filter_slice_rgba_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
573+{
574+ return filter_slice_rgba_packed(ctx, arg, jobnr, nb_jobs, 1, 4, 1);
575+}
576+
577+static int filter_slice_rgb24_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
578+{
579+ return filter_slice_rgba_packed(ctx, arg, jobnr, nb_jobs, 0, 3, 1);
580+}
581+
582+static int filter_slice_rgb0_pl(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
583+{
584+ return filter_slice_rgba_packed(ctx, arg, jobnr, nb_jobs, -1, 4, 1);
404585 }
405586
406587 static int config_output(AVFilterLink *outlink)
@@ -424,6 +605,19 @@ static int config_output(AVFilterLink *outlink) · 17 unmodified lines
424605 s->lut[i][j] = buffer;
425606 }
426607
608+ s->sr = s->rr + s->rg + s->rb + s->ra;
609+ s->sg = s->gr + s->gg + s->gb + s->ga;
610+ s->sb = s->br + s->bg + s->bb + s->ba;
611+
612+ if (fabs(s->sr) <= DBL_EPSILON)
613+ s->sr = 1.;
614+
615+ if (fabs(s->sg) <= DBL_EPSILON)
616+ s->sg = 1.;
617+
618+ if (fabs(s->sb) <= DBL_EPSILON)
619+ s->sb = 1.;
620+
427621 for (i = 0; i < size; i++) {
428622 s->lut[R][R][i] = lrint(i * s->rr);
429623 s->lut[R][G][i] = lrint(i * s->rg);
@@ -449,57 +643,72 @@ static int config_output(AVFilterLink *outlink) · 19 unmodified lines
449643 switch (outlink->format) {
450644 case AV_PIX_FMT_BGR24:
451645 case AV_PIX_FMT_RGB24:
452− s->filter_slice = filter_slice_rgb24;
646+ s->filter_slice[0] = filter_slice_rgb24;
647+ s->filter_slice[1] = filter_slice_rgb24_pl;
453648 break;
454649 case AV_PIX_FMT_0BGR:
455650 case AV_PIX_FMT_0RGB:
456651 case AV_PIX_FMT_BGR0:
457652 case AV_PIX_FMT_RGB0:
458− s->filter_slice = filter_slice_rgb0;
653+ s->filter_slice[0] = filter_slice_rgb0;
654+ s->filter_slice[1] = filter_slice_rgb0_pl;
459655 break;
460656 case AV_PIX_FMT_ABGR:
461657 case AV_PIX_FMT_ARGB:
462658 case AV_PIX_FMT_BGRA:
463659 case AV_PIX_FMT_RGBA:
464− s->filter_slice = filter_slice_rgba;
660+ s->filter_slice[0] = filter_slice_rgba;
661+ s->filter_slice[1] = filter_slice_rgba_pl;
465662 break;
466663 case AV_PIX_FMT_BGR48:
467664 case AV_PIX_FMT_RGB48:
468− s->filter_slice = filter_slice_rgb48;
665+ s->filter_slice[0] = filter_slice_rgb48;
666+ s->filter_slice[1] = filter_slice_rgb48_pl;
469667 break;
470668 case AV_PIX_FMT_BGRA64:
471669 case AV_PIX_FMT_RGBA64:
472− s->filter_slice = filter_slice_rgba64;
670+ s->filter_slice[0] = filter_slice_rgba64;
671+ s->filter_slice[1] = filter_slice_rgba64_pl;
473672 break;
474673 case AV_PIX_FMT_GBRP:
475− s->filter_slice = filter_slice_gbrp;
674+ s->filter_slice[0] = filter_slice_gbrp;
675+ s->filter_slice[1] = filter_slice_gbrp_pl;
476676 break;
477677 case AV_PIX_FMT_GBRAP:
478− s->filter_slice = filter_slice_gbrap;
678+ s->filter_slice[0] = filter_slice_gbrap;
679+ s->filter_slice[1] = filter_slice_gbrap_pl;
479680 break;
480681 case AV_PIX_FMT_GBRP9:
481− s->filter_slice = filter_slice_gbrp9;
682+ s->filter_slice[0] = filter_slice_gbrp9;
683+ s->filter_slice[1] = filter_slice_gbrp9_pl;
482684 break;
483685 case AV_PIX_FMT_GBRP10:
484− s->filter_slice = filter_slice_gbrp10;
686+ s->filter_slice[0] = filter_slice_gbrp10;
687+ s->filter_slice[1] = filter_slice_gbrp10_pl;
485688 break;
486689 case AV_PIX_FMT_GBRAP10:
487− s->filter_slice = filter_slice_gbrap10;
690+ s->filter_slice[0] = filter_slice_gbrap10;
691+ s->filter_slice[1] = filter_slice_gbrap10_pl;
488692 break;
489693 case AV_PIX_FMT_GBRP12:
490− s->filter_slice = filter_slice_gbrp12;
694+ s->filter_slice[0] = filter_slice_gbrp12;
695+ s->filter_slice[1] = filter_slice_gbrp12_pl;
491696 break;
492697 case AV_PIX_FMT_GBRAP12:
493− s->filter_slice = filter_slice_gbrap12;
698+ s->filter_slice[0] = filter_slice_gbrap12;
699+ s->filter_slice[1] = filter_slice_gbrap12_pl;
494700 break;
495701 case AV_PIX_FMT_GBRP14:
496− s->filter_slice = filter_slice_gbrp14;
702+ s->filter_slice[0] = filter_slice_gbrp14;
703+ s->filter_slice[1] = filter_slice_gbrp14_pl;
497704 break;
498705 case AV_PIX_FMT_GBRP16:
499− s->filter_slice = filter_slice_gbrp16;
706+ s->filter_slice[0] = filter_slice_gbrp16;
707+ s->filter_slice[1] = filter_slice_gbrp16_pl;
500708 break;
501709 case AV_PIX_FMT_GBRAP16:
502− s->filter_slice = filter_slice_gbrap16;
710+ s->filter_slice[0] = filter_slice_gbrap16;
711+ s->filter_slice[1] = filter_slice_gbrap16_pl;
503712 break;
504713 }
505714
@@ -511,6 +720,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in) · 5 unmodified lines
511720 AVFilterContext *ctx = inlink->dst;
512721 ColorChannelMixerContext *s = ctx->priv;
513722 AVFilterLink *outlink = ctx->outputs[0];
723+ const int pl = s->preserve_lightness;
514724 ThreadData td;
515725 AVFrame *out;
516726
@@ -527,7 +737,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in) · 10 unmodified lines
527737
528738 td.in = in;
529739 td.out = out;
530− ctx->internal->execute(ctx, s->filter_slice, &td, NULL, FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
740+ ctx->internal->execute(ctx, s->filter_slice[pl], &td, NULL, FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
531741
532742 if (in != out)
533743 av_frame_free(&in);

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t