FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavfilter/vf_colorcontrast.c
Date:	2026-04-24 19:58:39

	Total	Coverage
Lines:	166	0.0%
Functions:	7	0.0%
Branches:	138	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2021 Paul B Mahol
    
       *
    
       * This file is part of FFmpeg.
    
       *
    
       * FFmpeg is free software; you can redistribute it and/or
    
       * modify it under the terms of the GNU Lesser General Public
    
       * License as published by the Free Software Foundation; either
    
       * version 2.1 of the License, or (at your option) any later version.
    
       *
    
       * FFmpeg is distributed in the hope that it will be useful,
    
       * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
       * Lesser General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU Lesser General Public
    
       * License along with FFmpeg; if not, write to the Free Software
    
       * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    
       */
    
      #include <float.h>
    
      #include "libavutil/opt.h"
    
      #include "libavutil/pixdesc.h"
    
      #include "avfilter.h"
    
      #include "drawutils.h"
    
      #include "filters.h"
    
      #include "video.h"
    
      #define R 0
    
      #define G 1
    
      #define B 2
    
      typedef struct ColorContrastContext {
    
          const AVClass *class;
    
          float rc, gm, by;
    
          float rcw, gmw, byw;
    
          float preserve;
    
          int step;
    
          int depth;
    
          uint8_t rgba_map[4];
    
          int (*do_slice)(AVFilterContext *s, void *arg,
    
                          int jobnr, int nb_jobs);
    
      } ColorContrastContext;
    
      ✗
      static inline float lerpf(float v0, float v1, float f)
    
      {
    
      ✗
          return v0 + (v1 - v0) * f;
    
      }
    
      #define PROCESS(max)                                                    \
    
          br = (b + r) * 0.5f;                                                \
    
          gb = (g + b) * 0.5f;                                                \
    
          rg = (r + g) * 0.5f;                                                \
    
                                                                              \
    
          gd = g - br;                                                        \
    
          bd = b - rg;                                                        \
    
          rd = r - gb;                                                        \
    
                                                                              \
    
          g0 = g + gd * gm;                                                   \
    
          b0 = b - gd * gm;                                                   \
    
          r0 = r - gd * gm;                                                   \
    
                                                                              \
    
          g1 = g - bd * by;                                                   \
    
          b1 = b + bd * by;                                                   \
    
          r1 = r - bd * by;                                                   \
    
                                                                              \
    
          g2 = g - rd * rc;                                                   \
    
          b2 = b - rd * rc;                                                   \
    
          r2 = r + rd * rc;                                                   \
    
                                                                              \
    
          ng = av_clipf((g0 * gmw + g1 * byw + g2 * rcw) * scale, 0.f, max);  \
    
          nb = av_clipf((b0 * gmw + b1 * byw + b2 * rcw) * scale, 0.f, max);  \
    
          nr = av_clipf((r0 * gmw + r1 * byw + r2 * rcw) * scale, 0.f, max);  \
    
                                                                              \
    
          li = FFMAX3(r, g, b) + FFMIN3(r, g, b);                             \
    
          lo = FFMAX3(nr, ng, nb) + FFMIN3(nr, ng, nb) + FLT_EPSILON;         \
    
          lf = li / lo;                                                       \
    
                                                                              \
    
          r = nr * lf;                                                        \
    
          g = ng * lf;                                                        \
    
          b = nb * lf;                                                        \
    
                                                                              \
    
          nr = lerpf(nr, r, preserve);                                        \
    
          ng = lerpf(ng, g, preserve);                                        \
    
          nb = lerpf(nb, b, preserve);
    
      ✗
      static int colorcontrast_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
    
      {
    
      ✗
          ColorContrastContext *s = ctx->priv;
    
      ✗
          AVFrame *frame = arg;
    
      ✗
          const int width = frame->width;
    
      ✗
          const int height = frame->height;
    
      ✗
          const int slice_start = (height * jobnr) / nb_jobs;
    
      ✗
          const int slice_end = (height * (jobnr + 1)) / nb_jobs;
    
      ✗
          const ptrdiff_t glinesize = frame->linesize[0];
    
      ✗
          const ptrdiff_t blinesize = frame->linesize[1];
    
      ✗
          const ptrdiff_t rlinesize = frame->linesize[2];
    
      ✗
          uint8_t *gptr = frame->data[0] + slice_start * glinesize;
    
      ✗
          uint8_t *bptr = frame->data[1] + slice_start * blinesize;
    
      ✗
          uint8_t *rptr = frame->data[2] + slice_start * rlinesize;
    
      ✗
          const float preserve = s->preserve;
    
      ✗
          const float gm = s->gm * 0.5f;
    
      ✗
          const float by = s->by * 0.5f;
    
      ✗
          const float rc = s->rc * 0.5f;
    
      ✗
          const float gmw = s->gmw;
    
      ✗
          const float byw = s->byw;
    
      ✗
          const float rcw = s->rcw;
    
      ✗
          const float sum = gmw + byw + rcw;
    
      ✗
          const float scale = 1.f / sum;
    
      ✗
          for (int y = slice_start; y < slice_end && sum > FLT_EPSILON; y++) {
    
      ✗
              for (int x = 0; x < width; x++) {
    
      ✗
                  float g = gptr[x];
    
      ✗
                  float b = bptr[x];
    
      ✗
                  float r = rptr[x];
    
                  float g0, g1, g2;
    
                  float b0, b1, b2;
    
                  float r0, r1, r2;
    
                  float gd, bd, rd;
    
                  float gb, br, rg;
    
                  float nr, ng, nb;
    
                  float li, lo, lf;
    
      ✗
                  PROCESS(255.f);
    
      ✗
                  gptr[x] = av_clip_uint8(ng);
    
      ✗
                  bptr[x] = av_clip_uint8(nb);
    
      ✗
                  rptr[x] = av_clip_uint8(nr);
    
              }
    
      ✗
              gptr += glinesize;
    
      ✗
              bptr += blinesize;
    
      ✗
              rptr += rlinesize;
    
          }
    
      ✗
          return 0;
    
      }
    
      ✗
      static int colorcontrast_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
    
      {
    
      ✗
          ColorContrastContext *s = ctx->priv;
    
      ✗
          AVFrame *frame = arg;
    
      ✗
          const int depth = s->depth;
    
      ✗
          const float max = (1 << depth) - 1;
    
      ✗
          const int width = frame->width;
    
      ✗
          const int height = frame->height;
    
      ✗
          const int slice_start = (height * jobnr) / nb_jobs;
    
      ✗
          const int slice_end = (height * (jobnr + 1)) / nb_jobs;
    
      ✗
          const ptrdiff_t glinesize = frame->linesize[0] / 2;
    
      ✗
          const ptrdiff_t blinesize = frame->linesize[1] / 2;
    
      ✗
          const ptrdiff_t rlinesize = frame->linesize[2] / 2;
    
      ✗
          uint16_t *gptr = (uint16_t *)frame->data[0] + slice_start * glinesize;
    
      ✗
          uint16_t *bptr = (uint16_t *)frame->data[1] + slice_start * blinesize;
    
      ✗
          uint16_t *rptr = (uint16_t *)frame->data[2] + slice_start * rlinesize;
    
      ✗
          const float preserve = s->preserve;
    
      ✗
          const float gm = s->gm * 0.5f;
    
      ✗
          const float by = s->by * 0.5f;
    
      ✗
          const float rc = s->rc * 0.5f;
    
      ✗
          const float gmw = s->gmw;
    
      ✗
          const float byw = s->byw;
    
      ✗
          const float rcw = s->rcw;
    
      ✗
          const float sum = gmw + byw + rcw;
    
      ✗
          const float scale = 1.f / sum;
    
      ✗
          for (int y = slice_start; y < slice_end && sum > FLT_EPSILON; y++) {
    
      ✗
              for (int x = 0; x < width; x++) {
    
      ✗
                  float g = gptr[x];
    
      ✗
                  float b = bptr[x];
    
      ✗
                  float r = rptr[x];
    
                  float g0, g1, g2;
    
                  float b0, b1, b2;
    
                  float r0, r1, r2;
    
                  float gd, bd, rd;
    
                  float gb, br, rg;
    
                  float nr, ng, nb;
    
                  float li, lo, lf;
    
      ✗
                  PROCESS(max);
    
      ✗
                  gptr[x] = av_clip_uintp2_c(ng, depth);
    
      ✗
                  bptr[x] = av_clip_uintp2_c(nb, depth);
    
      ✗
                  rptr[x] = av_clip_uintp2_c(nr, depth);
    
              }
    
      ✗
              gptr += glinesize;
    
      ✗
              bptr += blinesize;
    
      ✗
              rptr += rlinesize;
    
          }
    
      ✗
          return 0;
    
      }
    
      ✗
      static int colorcontrast_slice8p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
    
      {
    
      ✗
          ColorContrastContext *s = ctx->priv;
    
      ✗
          AVFrame *frame = arg;
    
      ✗
          const int step = s->step;
    
      ✗
          const int width = frame->width;
    
      ✗
          const int height = frame->height;
    
      ✗
          const int slice_start = (height * jobnr) / nb_jobs;
    
      ✗
          const int slice_end = (height * (jobnr + 1)) / nb_jobs;
    
      ✗
          const ptrdiff_t linesize = frame->linesize[0];
    
      ✗
          const uint8_t roffset = s->rgba_map[R];
    
      ✗
          const uint8_t goffset = s->rgba_map[G];
    
      ✗
          const uint8_t boffset = s->rgba_map[B];
    
      ✗
          uint8_t *ptr = frame->data[0] + slice_start * linesize;
    
      ✗
          const float preserve = s->preserve;
    
      ✗
          const float gm = s->gm * 0.5f;
    
      ✗
          const float by = s->by * 0.5f;
    
      ✗
          const float rc = s->rc * 0.5f;
    
      ✗
          const float gmw = s->gmw;
    
      ✗
          const float byw = s->byw;
    
      ✗
          const float rcw = s->rcw;
    
      ✗
          const float sum = gmw + byw + rcw;
    
      ✗
          const float scale = 1.f / sum;
    
      ✗
          for (int y = slice_start; y < slice_end && sum > FLT_EPSILON; y++) {
    
      ✗
              for (int x = 0; x < width; x++) {
    
      ✗
                  float g = ptr[x * step + goffset];
    
      ✗
                  float b = ptr[x * step + boffset];
    
      ✗
                  float r = ptr[x * step + roffset];
    
                  float g0, g1, g2;
    
                  float b0, b1, b2;
    
                  float r0, r1, r2;
    
                  float gd, bd, rd;
    
                  float gb, br, rg;
    
                  float nr, ng, nb;
    
                  float li, lo, lf;
    
      ✗
                  PROCESS(255.f);
    
      ✗
                  ptr[x * step + goffset] = av_clip_uint8(ng);
    
      ✗
                  ptr[x * step + boffset] = av_clip_uint8(nb);
    
      ✗
                  ptr[x * step + roffset] = av_clip_uint8(nr);
    
              }
    
      ✗
              ptr += linesize;
    
          }
    
      ✗
          return 0;
    
      }
    
      ✗
      static int colorcontrast_slice16p(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
    
      {
    
      ✗
          ColorContrastContext *s = ctx->priv;
    
      ✗
          AVFrame *frame = arg;
    
      ✗
          const int step = s->step;
    
      ✗
          const int depth = s->depth;
    
      ✗
          const float max = (1 << depth) - 1;
    
      ✗
          const int width = frame->width;
    
      ✗
          const int height = frame->height;
    
      ✗
          const int slice_start = (height * jobnr) / nb_jobs;
    
      ✗
          const int slice_end = (height * (jobnr + 1)) / nb_jobs;
    
      ✗
          const ptrdiff_t linesize = frame->linesize[0] / 2;
    
      ✗
          const uint8_t roffset = s->rgba_map[R];
    
      ✗
          const uint8_t goffset = s->rgba_map[G];
    
      ✗
          const uint8_t boffset = s->rgba_map[B];
    
      ✗
          uint16_t *ptr = (uint16_t *)frame->data[0] + slice_start * linesize;
    
      ✗
          const float preserve = s->preserve;
    
      ✗
          const float gm = s->gm * 0.5f;
    
      ✗
          const float by = s->by * 0.5f;
    
      ✗
          const float rc = s->rc * 0.5f;
    
      ✗
          const float gmw = s->gmw;
    
      ✗
          const float byw = s->byw;
    
      ✗
          const float rcw = s->rcw;
    
      ✗
          const float sum = gmw + byw + rcw;
    
      ✗
          const float scale = 1.f / sum;
    
      ✗
          for (int y = slice_start; y < slice_end && sum > FLT_EPSILON; y++) {
    
      ✗
              for (int x = 0; x < width; x++) {
    
      ✗
                  float g = ptr[x * step + goffset];
    
      ✗
                  float b = ptr[x * step + boffset];
    
      ✗
                  float r = ptr[x * step + roffset];
    
                  float g0, g1, g2;
    
                  float b0, b1, b2;
    
                  float r0, r1, r2;
    
                  float gd, bd, rd;
    
                  float gb, br, rg;
    
                  float nr, ng, nb;
    
                  float li, lo, lf;
    
      ✗
                  PROCESS(max);
    
      ✗
                  ptr[x * step + goffset] = av_clip_uintp2_c(ng, depth);
    
      ✗
                  ptr[x * step + boffset] = av_clip_uintp2_c(nb, depth);
    
      ✗
                  ptr[x * step + roffset] = av_clip_uintp2_c(nr, depth);
    
              }
    
      ✗
              ptr += linesize;
    
          }
    
      ✗
          return 0;
    
      }
    
      ✗
      static int filter_frame(AVFilterLink *link, AVFrame *frame)
    
      {
    
      ✗
          AVFilterContext *ctx = link->dst;
    
      ✗
          ColorContrastContext *s = ctx->priv;
    
          int res;
    
      ✗
          if (res = ff_filter_execute(ctx, s->do_slice, frame, NULL,
    
      ✗
                                      FFMIN(frame->height, ff_filter_get_nb_threads(ctx))))
    
      ✗
              return res;
    
      ✗
          return ff_filter_frame(ctx->outputs[0], frame);
    
      }
    
      static const enum AVPixelFormat pixel_fmts[] = {
    
          AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
    
          AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
    
          AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
    
          AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,
    
          AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
    
          AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
    
          AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
    
          AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
    
          AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
    
          AV_PIX_FMT_RGB48,  AV_PIX_FMT_BGR48,
    
          AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
    
          AV_PIX_FMT_NONE
    
      };
    
      ✗
      static av_cold int config_input(AVFilterLink *inlink)
    
      {
    
      ✗
          AVFilterContext *ctx = inlink->dst;
    
      ✗
          ColorContrastContext *s = ctx->priv;
    
      ✗
          const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
    
      ✗
          int planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR;
    
      ✗
          s->step = desc->nb_components;
    
      ✗
          if (inlink->format == AV_PIX_FMT_RGB0 ||
    
      ✗
              inlink->format == AV_PIX_FMT_0RGB ||
    
      ✗
              inlink->format == AV_PIX_FMT_BGR0 ||
    
      ✗
              inlink->format == AV_PIX_FMT_0BGR)
    
      ✗
              s->step = 4;
    
      ✗
          s->depth = desc->comp[0].depth;
    
      ✗
          s->do_slice = s->depth <= 8 ? colorcontrast_slice8 : colorcontrast_slice16;
    
      ✗
          if (!planar)
    
      ✗
              s->do_slice = s->depth <= 8 ? colorcontrast_slice8p : colorcontrast_slice16p;
    
      ✗
          ff_fill_rgba_map(s->rgba_map, inlink->format);
    
      ✗
          return 0;
    
      }
    
      static const AVFilterPad colorcontrast_inputs[] = {
    
          {
    
              .name           = "default",
    
              .type           = AVMEDIA_TYPE_VIDEO,
    
              .flags          = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
    
              .filter_frame   = filter_frame,
    
              .config_props   = config_input,
    
          },
    
      };
    
      #define OFFSET(x) offsetof(ColorContrastContext, x)
    
      #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
    
      static const AVOption colorcontrast_options[] = {
    
          { "rc",  "set the red-cyan contrast",      OFFSET(rc),  AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, VF },
    
          { "gm",  "set the green-magenta contrast", OFFSET(gm),  AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, VF },
    
          { "by",  "set the blue-yellow contrast",   OFFSET(by),  AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, VF },
    
          { "rcw", "set the red-cyan weight",        OFFSET(rcw), AV_OPT_TYPE_FLOAT, {.dbl=0},  0, 1, VF },
    
          { "gmw", "set the green-magenta weight",   OFFSET(gmw), AV_OPT_TYPE_FLOAT, {.dbl=0},  0, 1, VF },
    
          { "byw", "set the blue-yellow weight",     OFFSET(byw), AV_OPT_TYPE_FLOAT, {.dbl=0},  0, 1, VF },
    
          { "pl",  "set the amount of preserving lightness", OFFSET(preserve), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, VF },
    
          { NULL }
    
      };
    
      AVFILTER_DEFINE_CLASS(colorcontrast);
    
      const FFFilter ff_vf_colorcontrast = {
    
          .p.name        = "colorcontrast",
    
          .p.description = NULL_IF_CONFIG_SMALL("Adjust color contrast between RGB components."),
    
          .p.priv_class  = &colorcontrast_class,
    
          .p.flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
    
          .priv_size     = sizeof(ColorContrastContext),
    
          FILTER_INPUTS(colorcontrast_inputs),
    
          FILTER_OUTPUTS(ff_video_default_filterpad),
    
          FILTER_PIXFMTS_ARRAY(pixel_fmts),
    
          .process_command = ff_filter_process_command,
    
      };

Line	Exec	Source
1		/*
2		* Copyright (c) 2021 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 <float.h>
22
23		#include "libavutil/opt.h"
24		#include "libavutil/pixdesc.h"
25		#include "avfilter.h"
26		#include "drawutils.h"
27		#include "filters.h"
28		#include "video.h"
29
30		#define R 0
31		#define G 1
32		#define B 2
33
34		typedef struct ColorContrastContext {
35		const AVClass *class;
36
37		float rc, gm, by;
38		float rcw, gmw, byw;
39		float preserve;
40
41		int step;
42		int depth;
43		uint8_t rgba_map[4];
44
45		int (do_slice)(AVFilterContext s, void *arg,
46		int jobnr, int nb_jobs);
47		} ColorContrastContext;
48
49	✗	static inline float lerpf(float v0, float v1, float f)
50		{
51	✗	return v0 + (v1 - v0) * f;
52		}
53
54		#define PROCESS(max) \
55		br = (b + r) * 0.5f; \
56		gb = (g + b) * 0.5f; \
57		rg = (r + g) * 0.5f; \
58		\
59		gd = g - br; \
60		bd = b - rg; \
61		rd = r - gb; \
62		\
63		g0 = g + gd * gm; \
64		b0 = b - gd * gm; \
65		r0 = r - gd * gm; \
66		\
67		g1 = g - bd * by; \
68		b1 = b + bd * by; \
69		r1 = r - bd * by; \
70		\
71		g2 = g - rd * rc; \
72		b2 = b - rd * rc; \
73		r2 = r + rd * rc; \
74		\
75		ng = av_clipf((g0 * gmw + g1 * byw + g2 * rcw) * scale, 0.f, max); \
76		nb = av_clipf((b0 * gmw + b1 * byw + b2 * rcw) * scale, 0.f, max); \
77		nr = av_clipf((r0 * gmw + r1 * byw + r2 * rcw) * scale, 0.f, max); \
78		\
79		li = FFMAX3(r, g, b) + FFMIN3(r, g, b); \
80		lo = FFMAX3(nr, ng, nb) + FFMIN3(nr, ng, nb) + FLT_EPSILON; \
81		lf = li / lo; \
82		\
83		r = nr * lf; \
84		g = ng * lf; \
85		b = nb * lf; \
86		\
87		nr = lerpf(nr, r, preserve); \
88		ng = lerpf(ng, g, preserve); \
89		nb = lerpf(nb, b, preserve);
90
91	✗	static int colorcontrast_slice8(AVFilterContext ctx, void arg, int jobnr, int nb_jobs)
92		{
93	✗	ColorContrastContext *s = ctx->priv;
94	✗	AVFrame *frame = arg;
95	✗	const int width = frame->width;
96	✗	const int height = frame->height;
97	✗	const int slice_start = (height * jobnr) / nb_jobs;
98	✗	const int slice_end = (height * (jobnr + 1)) / nb_jobs;
99	✗	const ptrdiff_t glinesize = frame->linesize[0];
100	✗	const ptrdiff_t blinesize = frame->linesize[1];
101	✗	const ptrdiff_t rlinesize = frame->linesize[2];
102	✗	uint8_t gptr = frame->data[0] + slice_start glinesize;
103	✗	uint8_t bptr = frame->data[1] + slice_start blinesize;
104	✗	uint8_t rptr = frame->data[2] + slice_start rlinesize;
105	✗	const float preserve = s->preserve;
106	✗	const float gm = s->gm * 0.5f;
107	✗	const float by = s->by * 0.5f;
108	✗	const float rc = s->rc * 0.5f;
109	✗	const float gmw = s->gmw;
110	✗	const float byw = s->byw;
111	✗	const float rcw = s->rcw;
112	✗	const float sum = gmw + byw + rcw;
113	✗	const float scale = 1.f / sum;
114
115	✗	for (int y = slice_start; y < slice_end && sum > FLT_EPSILON; y++) {
116	✗	for (int x = 0; x < width; x++) {
117	✗	float g = gptr[x];
118	✗	float b = bptr[x];
119	✗	float r = rptr[x];
120		float g0, g1, g2;
121		float b0, b1, b2;
122		float r0, r1, r2;
123		float gd, bd, rd;
124		float gb, br, rg;
125		float nr, ng, nb;
126		float li, lo, lf;
127
128	✗	PROCESS(255.f);
129
130	✗	gptr[x] = av_clip_uint8(ng);
131	✗	bptr[x] = av_clip_uint8(nb);
132	✗	rptr[x] = av_clip_uint8(nr);
133		}
134
135	✗	gptr += glinesize;
136	✗	bptr += blinesize;
137	✗	rptr += rlinesize;
138		}
139
140	✗	return 0;
141		}
142
143	✗	static int colorcontrast_slice16(AVFilterContext ctx, void arg, int jobnr, int nb_jobs)
144		{
145	✗	ColorContrastContext *s = ctx->priv;
146	✗	AVFrame *frame = arg;
147	✗	const int depth = s->depth;
148	✗	const float max = (1 << depth) - 1;
149	✗	const int width = frame->width;
150	✗	const int height = frame->height;
151	✗	const int slice_start = (height * jobnr) / nb_jobs;
152	✗	const int slice_end = (height * (jobnr + 1)) / nb_jobs;
153	✗	const ptrdiff_t glinesize = frame->linesize[0] / 2;
154	✗	const ptrdiff_t blinesize = frame->linesize[1] / 2;
155	✗	const ptrdiff_t rlinesize = frame->linesize[2] / 2;
156	✗	uint16_t gptr = (uint16_t )frame->data[0] + slice_start * glinesize;
157	✗	uint16_t bptr = (uint16_t )frame->data[1] + slice_start * blinesize;
158	✗	uint16_t rptr = (uint16_t )frame->data[2] + slice_start * rlinesize;
159	✗	const float preserve = s->preserve;
160	✗	const float gm = s->gm * 0.5f;
161	✗	const float by = s->by * 0.5f;
162	✗	const float rc = s->rc * 0.5f;
163	✗	const float gmw = s->gmw;
164	✗	const float byw = s->byw;
165	✗	const float rcw = s->rcw;
166	✗	const float sum = gmw + byw + rcw;
167	✗	const float scale = 1.f / sum;
168
169	✗	for (int y = slice_start; y < slice_end && sum > FLT_EPSILON; y++) {
170	✗	for (int x = 0; x < width; x++) {
171	✗	float g = gptr[x];
172	✗	float b = bptr[x];
173	✗	float r = rptr[x];
174		float g0, g1, g2;
175		float b0, b1, b2;
176		float r0, r1, r2;
177		float gd, bd, rd;
178		float gb, br, rg;
179		float nr, ng, nb;
180		float li, lo, lf;
181
182	✗	PROCESS(max);
183
184	✗	gptr[x] = av_clip_uintp2_c(ng, depth);
185	✗	bptr[x] = av_clip_uintp2_c(nb, depth);
186	✗	rptr[x] = av_clip_uintp2_c(nr, depth);
187		}
188
189	✗	gptr += glinesize;
190	✗	bptr += blinesize;
191	✗	rptr += rlinesize;
192		}
193
194	✗	return 0;
195		}
196
197	✗	static int colorcontrast_slice8p(AVFilterContext ctx, void arg, int jobnr, int nb_jobs)
198		{
199	✗	ColorContrastContext *s = ctx->priv;
200	✗	AVFrame *frame = arg;
201	✗	const int step = s->step;
202	✗	const int width = frame->width;
203	✗	const int height = frame->height;
204	✗	const int slice_start = (height * jobnr) / nb_jobs;
205	✗	const int slice_end = (height * (jobnr + 1)) / nb_jobs;
206	✗	const ptrdiff_t linesize = frame->linesize[0];
207	✗	const uint8_t roffset = s->rgba_map[R];
208	✗	const uint8_t goffset = s->rgba_map[G];
209	✗	const uint8_t boffset = s->rgba_map[B];
210	✗	uint8_t ptr = frame->data[0] + slice_start linesize;
211	✗	const float preserve = s->preserve;
212	✗	const float gm = s->gm * 0.5f;
213	✗	const float by = s->by * 0.5f;
214	✗	const float rc = s->rc * 0.5f;
215	✗	const float gmw = s->gmw;
216	✗	const float byw = s->byw;
217	✗	const float rcw = s->rcw;
218	✗	const float sum = gmw + byw + rcw;
219	✗	const float scale = 1.f / sum;
220
221	✗	for (int y = slice_start; y < slice_end && sum > FLT_EPSILON; y++) {
222	✗	for (int x = 0; x < width; x++) {
223	✗	float g = ptr[x * step + goffset];
224	✗	float b = ptr[x * step + boffset];
225	✗	float r = ptr[x * step + roffset];
226		float g0, g1, g2;
227		float b0, b1, b2;
228		float r0, r1, r2;
229		float gd, bd, rd;
230		float gb, br, rg;
231		float nr, ng, nb;
232		float li, lo, lf;
233
234	✗	PROCESS(255.f);
235
236	✗	ptr[x * step + goffset] = av_clip_uint8(ng);
237	✗	ptr[x * step + boffset] = av_clip_uint8(nb);
238	✗	ptr[x * step + roffset] = av_clip_uint8(nr);
239		}
240
241	✗	ptr += linesize;
242		}
243
244	✗	return 0;
245		}
246
247	✗	static int colorcontrast_slice16p(AVFilterContext ctx, void arg, int jobnr, int nb_jobs)
248		{
249	✗	ColorContrastContext *s = ctx->priv;
250	✗	AVFrame *frame = arg;
251	✗	const int step = s->step;
252	✗	const int depth = s->depth;
253	✗	const float max = (1 << depth) - 1;
254	✗	const int width = frame->width;
255	✗	const int height = frame->height;
256	✗	const int slice_start = (height * jobnr) / nb_jobs;
257	✗	const int slice_end = (height * (jobnr + 1)) / nb_jobs;
258	✗	const ptrdiff_t linesize = frame->linesize[0] / 2;
259	✗	const uint8_t roffset = s->rgba_map[R];
260	✗	const uint8_t goffset = s->rgba_map[G];
261	✗	const uint8_t boffset = s->rgba_map[B];
262	✗	uint16_t ptr = (uint16_t )frame->data[0] + slice_start * linesize;
263	✗	const float preserve = s->preserve;
264	✗	const float gm = s->gm * 0.5f;
265	✗	const float by = s->by * 0.5f;
266	✗	const float rc = s->rc * 0.5f;
267	✗	const float gmw = s->gmw;
268	✗	const float byw = s->byw;
269	✗	const float rcw = s->rcw;
270	✗	const float sum = gmw + byw + rcw;
271	✗	const float scale = 1.f / sum;
272
273	✗	for (int y = slice_start; y < slice_end && sum > FLT_EPSILON; y++) {
274	✗	for (int x = 0; x < width; x++) {
275	✗	float g = ptr[x * step + goffset];
276	✗	float b = ptr[x * step + boffset];
277	✗	float r = ptr[x * step + roffset];
278		float g0, g1, g2;
279		float b0, b1, b2;
280		float r0, r1, r2;
281		float gd, bd, rd;
282		float gb, br, rg;
283		float nr, ng, nb;
284		float li, lo, lf;
285
286	✗	PROCESS(max);
287
288	✗	ptr[x * step + goffset] = av_clip_uintp2_c(ng, depth);
289	✗	ptr[x * step + boffset] = av_clip_uintp2_c(nb, depth);
290	✗	ptr[x * step + roffset] = av_clip_uintp2_c(nr, depth);
291		}
292
293	✗	ptr += linesize;
294		}
295
296	✗	return 0;
297		}
298
299	✗	static int filter_frame(AVFilterLink link, AVFrame frame)
300		{
301	✗	AVFilterContext *ctx = link->dst;
302	✗	ColorContrastContext *s = ctx->priv;
303		int res;
304
305	✗	if (res = ff_filter_execute(ctx, s->do_slice, frame, NULL,
306	✗	FFMIN(frame->height, ff_filter_get_nb_threads(ctx))))
307	✗	return res;
308
309	✗	return ff_filter_frame(ctx->outputs[0], frame);
310		}
311
312		static const enum AVPixelFormat pixel_fmts[] = {
313		AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
314		AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
315		AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
316		AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,
317		AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
318		AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
319		AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
320		AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
321		AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
322		AV_PIX_FMT_RGB48, AV_PIX_FMT_BGR48,
323		AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
324		AV_PIX_FMT_NONE
325		};
326
327	✗	static av_cold int config_input(AVFilterLink *inlink)
328		{
329	✗	AVFilterContext *ctx = inlink->dst;
330	✗	ColorContrastContext *s = ctx->priv;
331	✗	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
332	✗	int planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR;
333
334	✗	s->step = desc->nb_components;
335	✗	if (inlink->format == AV_PIX_FMT_RGB0 \|\|
336	✗	inlink->format == AV_PIX_FMT_0RGB \|\|
337	✗	inlink->format == AV_PIX_FMT_BGR0 \|\|
338	✗	inlink->format == AV_PIX_FMT_0BGR)
339	✗	s->step = 4;
340
341	✗	s->depth = desc->comp[0].depth;
342	✗	s->do_slice = s->depth <= 8 ? colorcontrast_slice8 : colorcontrast_slice16;
343	✗	if (!planar)
344	✗	s->do_slice = s->depth <= 8 ? colorcontrast_slice8p : colorcontrast_slice16p;
345
346	✗	ff_fill_rgba_map(s->rgba_map, inlink->format);
347
348	✗	return 0;
349		}
350
351		static const AVFilterPad colorcontrast_inputs[] = {
352		{
353		.name = "default",
354		.type = AVMEDIA_TYPE_VIDEO,
355		.flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
356		.filter_frame = filter_frame,
357		.config_props = config_input,
358		},
359		};
360
361		#define OFFSET(x) offsetof(ColorContrastContext, x)
362		#define VF AV_OPT_FLAG_FILTERING_PARAM\|AV_OPT_FLAG_VIDEO_PARAM\|AV_OPT_FLAG_RUNTIME_PARAM
363
364		static const AVOption colorcontrast_options[] = {
365		{ "rc", "set the red-cyan contrast", OFFSET(rc), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, VF },
366		{ "gm", "set the green-magenta contrast", OFFSET(gm), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, VF },
367		{ "by", "set the blue-yellow contrast", OFFSET(by), AV_OPT_TYPE_FLOAT, {.dbl=0}, -1, 1, VF },
368		{ "rcw", "set the red-cyan weight", OFFSET(rcw), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, VF },
369		{ "gmw", "set the green-magenta weight", OFFSET(gmw), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, VF },
370		{ "byw", "set the blue-yellow weight", OFFSET(byw), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, VF },
371		{ "pl", "set the amount of preserving lightness", OFFSET(preserve), AV_OPT_TYPE_FLOAT, {.dbl=0}, 0, 1, VF },
372		{ NULL }
373		};
374
375		AVFILTER_DEFINE_CLASS(colorcontrast);
376
377		const FFFilter ff_vf_colorcontrast = {
378		.p.name = "colorcontrast",
379		.p.description = NULL_IF_CONFIG_SMALL("Adjust color contrast between RGB components."),
380		.p.priv_class = &colorcontrast_class,
381		.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC \| AVFILTER_FLAG_SLICE_THREADS,
382		.priv_size = sizeof(ColorContrastContext),
383		FILTER_INPUTS(colorcontrast_inputs),
384		FILTER_OUTPUTS(ff_video_default_filterpad),
385		FILTER_PIXFMTS_ARRAY(pixel_fmts),
386		.process_command = ff_filter_process_command,
387		};
388

Function (Line)	Call count	Block coverage
colorcontrast_slice16 (line 143)	not called	0.0%
colorcontrast_slice16p (line 247)	not called	0.0%
colorcontrast_slice8 (line 91)	not called	0.0%
colorcontrast_slice8p (line 197)	not called	0.0%
config_input (line 327)	not called	0.0%
filter_frame (line 299)	not called	0.0%
lerpf (line 49)	not called	0.0%