FFmpeg coverage

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

	Total	Coverage
Lines:	276	0.0%
Functions:	7	0.0%
Branches:	136	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2018 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 "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
    
      #define A 3
    
      typedef struct VibranceContext {
    
          const AVClass *class;
    
          float intensity;
    
          float balance[3];
    
          float lcoeffs[3];
    
          int alternate;
    
          int step;
    
          int depth;
    
          uint8_t rgba_map[4];
    
          int (*do_slice)(AVFilterContext *s, void *arg,
    
                          int jobnr, int nb_jobs);
    
      } VibranceContext;
    
      ✗
      static inline float lerpf(float v0, float v1, float f)
    
      {
    
      ✗
          return v0 + (v1 - v0) * f;
    
      }
    
      typedef struct ThreadData {
    
          AVFrame *out, *in;
    
      } ThreadData;
    
      ✗
      static int vibrance_slice8(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
    
      {
    
      ✗
          VibranceContext *s = avctx->priv;
    
      ✗
          ThreadData *td = arg;
    
      ✗
          AVFrame *frame = td->out;
    
      ✗
          AVFrame *in = td->in;
    
      ✗
          const int width = frame->width;
    
      ✗
          const int height = frame->height;
    
      ✗
          const float scale = 1.f / 255.f;
    
      ✗
          const float gc = s->lcoeffs[0];
    
      ✗
          const float bc = s->lcoeffs[1];
    
      ✗
          const float rc = s->lcoeffs[2];
    
      ✗
          const float intensity = s->intensity;
    
      ✗
          const float alternate = s->alternate ? 1.f : -1.f;
    
      ✗
          const float gintensity = intensity * s->balance[0];
    
      ✗
          const float bintensity = intensity * s->balance[1];
    
      ✗
          const float rintensity = intensity * s->balance[2];
    
      ✗
          const float sgintensity = alternate * FFSIGN(gintensity);
    
      ✗
          const float sbintensity = alternate * FFSIGN(bintensity);
    
      ✗
          const float srintensity = alternate * FFSIGN(rintensity);
    
      ✗
          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];
    
      ✗
          const ptrdiff_t alinesize = frame->linesize[3];
    
      ✗
          const ptrdiff_t gslinesize = in->linesize[0];
    
      ✗
          const ptrdiff_t bslinesize = in->linesize[1];
    
      ✗
          const ptrdiff_t rslinesize = in->linesize[2];
    
      ✗
          const ptrdiff_t aslinesize = in->linesize[3];
    
      ✗
          const uint8_t *gsrc = in->data[0] + slice_start * glinesize;
    
      ✗
          const uint8_t *bsrc = in->data[1] + slice_start * blinesize;
    
      ✗
          const uint8_t *rsrc = in->data[2] + slice_start * rlinesize;
    
      ✗
          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 uint8_t *asrc = in->data[3];
    
      ✗
          uint8_t *aptr = frame->data[3];
    
      ✗
          for (int y = slice_start; y < slice_end; y++) {
    
      ✗
              for (int x = 0; x < width; x++) {
    
      ✗
                  float g = gsrc[x] * scale;
    
      ✗
                  float b = bsrc[x] * scale;
    
      ✗
                  float r = rsrc[x] * scale;
    
      ✗
                  float max_color = FFMAX3(r, g, b);
    
      ✗
                  float min_color = FFMIN3(r, g, b);
    
      ✗
                  float color_saturation = max_color - min_color;
    
      ✗
                  float luma = g * gc + r * rc + b * bc;
    
      ✗
                  const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
    
      ✗
                  const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
    
      ✗
                  const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
    
      ✗
                  g = lerpf(luma, g, cg);
    
      ✗
                  b = lerpf(luma, b, cb);
    
      ✗
                  r = lerpf(luma, r, cr);
    
      ✗
                  gptr[x] = av_clip_uint8(g * 255.f);
    
      ✗
                  bptr[x] = av_clip_uint8(b * 255.f);
    
      ✗
                  rptr[x] = av_clip_uint8(r * 255.f);
    
              }
    
      ✗
              if (aptr && alinesize && frame != in)
    
      ✗
                  memcpy(aptr + alinesize * y, asrc + aslinesize * y, width);
    
      ✗
              gsrc += gslinesize;
    
      ✗
              bsrc += bslinesize;
    
      ✗
              rsrc += rslinesize;
    
      ✗
              gptr += glinesize;
    
      ✗
              bptr += blinesize;
    
      ✗
              rptr += rlinesize;
    
          }
    
      ✗
          return 0;
    
      }
    
      ✗
      static int vibrance_slice16(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
    
      {
    
      ✗
          VibranceContext *s = avctx->priv;
    
      ✗
          ThreadData *td = arg;
    
      ✗
          AVFrame *frame = td->out;
    
      ✗
          AVFrame *in = td->in;
    
      ✗
          const int depth = s->depth;
    
      ✗
          const float max = (1 << depth) - 1;
    
      ✗
          const float scale = 1.f / max;
    
      ✗
          const float gc = s->lcoeffs[0];
    
      ✗
          const float bc = s->lcoeffs[1];
    
      ✗
          const float rc = s->lcoeffs[2];
    
      ✗
          const int width = frame->width;
    
      ✗
          const int height = frame->height;
    
      ✗
          const float intensity = s->intensity;
    
      ✗
          const float alternate = s->alternate ? 1.f : -1.f;
    
      ✗
          const float gintensity = intensity * s->balance[0];
    
      ✗
          const float bintensity = intensity * s->balance[1];
    
      ✗
          const float rintensity = intensity * s->balance[2];
    
      ✗
          const float sgintensity = alternate * FFSIGN(gintensity);
    
      ✗
          const float sbintensity = alternate * FFSIGN(bintensity);
    
      ✗
          const float srintensity = alternate * FFSIGN(rintensity);
    
      ✗
          const int slice_start = (height * jobnr) / nb_jobs;
    
      ✗
          const int slice_end = (height * (jobnr + 1)) / nb_jobs;
    
      ✗
          const ptrdiff_t gslinesize = in->linesize[0] / 2;
    
      ✗
          const ptrdiff_t bslinesize = in->linesize[1] / 2;
    
      ✗
          const ptrdiff_t rslinesize = in->linesize[2] / 2;
    
      ✗
          const ptrdiff_t aslinesize = in->linesize[3] / 2;
    
      ✗
          const ptrdiff_t glinesize = frame->linesize[0] / 2;
    
      ✗
          const ptrdiff_t blinesize = frame->linesize[1] / 2;
    
      ✗
          const ptrdiff_t rlinesize = frame->linesize[2] / 2;
    
      ✗
          const ptrdiff_t alinesize = frame->linesize[3] / 2;
    
      ✗
          const uint16_t *gsrc = (const uint16_t *)in->data[0] + slice_start * gslinesize;
    
      ✗
          const uint16_t *bsrc = (const uint16_t *)in->data[1] + slice_start * bslinesize;
    
      ✗
          const uint16_t *rsrc = (const uint16_t *)in->data[2] + slice_start * rslinesize;
    
      ✗
          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 uint16_t *asrc = (const uint16_t *)in->data[3];
    
      ✗
          uint16_t *aptr = (uint16_t *)frame->data[3];
    
      ✗
          for (int y = slice_start; y < slice_end; y++) {
    
      ✗
              for (int x = 0; x < width; x++) {
    
      ✗
                  float g = gsrc[x] * scale;
    
      ✗
                  float b = bsrc[x] * scale;
    
      ✗
                  float r = rsrc[x] * scale;
    
      ✗
                  float max_color = FFMAX3(r, g, b);
    
      ✗
                  float min_color = FFMIN3(r, g, b);
    
      ✗
                  float color_saturation = max_color - min_color;
    
      ✗
                  float luma = g * gc + r * rc + b * bc;
    
      ✗
                  const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
    
      ✗
                  const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
    
      ✗
                  const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
    
      ✗
                  g = lerpf(luma, g, cg);
    
      ✗
                  b = lerpf(luma, b, cb);
    
      ✗
                  r = lerpf(luma, r, cr);
    
      ✗
                  gptr[x] = av_clip_uintp2_c(g * max, depth);
    
      ✗
                  bptr[x] = av_clip_uintp2_c(b * max, depth);
    
      ✗
                  rptr[x] = av_clip_uintp2_c(r * max, depth);
    
              }
    
      ✗
              if (aptr && alinesize && frame != in)
    
      ✗
                  memcpy(aptr + alinesize * y, asrc + aslinesize * y, width * 2);
    
      ✗
              gsrc += gslinesize;
    
      ✗
              bsrc += bslinesize;
    
      ✗
              rsrc += rslinesize;
    
      ✗
              gptr += glinesize;
    
      ✗
              bptr += blinesize;
    
      ✗
              rptr += rlinesize;
    
          }
    
      ✗
          return 0;
    
      }
    
      ✗
      static int vibrance_slice8p(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
    
      {
    
      ✗
          VibranceContext *s = avctx->priv;
    
      ✗
          ThreadData *td = arg;
    
      ✗
          AVFrame *frame = td->out;
    
      ✗
          AVFrame *in = td->in;
    
      ✗
          const int step = s->step;
    
      ✗
          const int width = frame->width;
    
      ✗
          const int height = frame->height;
    
      ✗
          const float scale = 1.f / 255.f;
    
      ✗
          const float gc = s->lcoeffs[0];
    
      ✗
          const float bc = s->lcoeffs[1];
    
      ✗
          const float rc = s->lcoeffs[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];
    
      ✗
          const uint8_t aoffset = s->rgba_map[A];
    
      ✗
          const float intensity = s->intensity;
    
      ✗
          const float alternate = s->alternate ? 1.f : -1.f;
    
      ✗
          const float gintensity = intensity * s->balance[0];
    
      ✗
          const float bintensity = intensity * s->balance[1];
    
      ✗
          const float rintensity = intensity * s->balance[2];
    
      ✗
          const float sgintensity = alternate * FFSIGN(gintensity);
    
      ✗
          const float sbintensity = alternate * FFSIGN(bintensity);
    
      ✗
          const float srintensity = alternate * FFSIGN(rintensity);
    
      ✗
          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 ptrdiff_t slinesize = in->linesize[0];
    
      ✗
          const uint8_t *src = in->data[0] + slice_start * slinesize;
    
      ✗
          uint8_t *ptr = frame->data[0] + slice_start * linesize;
    
      ✗
          for (int y = slice_start; y < slice_end; y++) {
    
      ✗
              for (int x = 0; x < width; x++) {
    
      ✗
                  float g = src[x * step + goffset] * scale;
    
      ✗
                  float b = src[x * step + boffset] * scale;
    
      ✗
                  float r = src[x * step + roffset] * scale;
    
      ✗
                  float max_color = FFMAX3(r, g, b);
    
      ✗
                  float min_color = FFMIN3(r, g, b);
    
      ✗
                  float color_saturation = max_color - min_color;
    
      ✗
                  float luma = g * gc + r * rc + b * bc;
    
      ✗
                  const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
    
      ✗
                  const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
    
      ✗
                  const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
    
      ✗
                  g = lerpf(luma, g, cg);
    
      ✗
                  b = lerpf(luma, b, cb);
    
      ✗
                  r = lerpf(luma, r, cr);
    
      ✗
                  ptr[x * step + goffset] = av_clip_uint8(g * 255.f);
    
      ✗
                  ptr[x * step + boffset] = av_clip_uint8(b * 255.f);
    
      ✗
                  ptr[x * step + roffset] = av_clip_uint8(r * 255.f);
    
      ✗
                  if (frame != in)
    
      ✗
                      ptr[x * step + aoffset] = src[x * step + aoffset];
    
              }
    
      ✗
              ptr += linesize;
    
      ✗
              src += slinesize;
    
          }
    
      ✗
          return 0;
    
      }
    
      ✗
      static int vibrance_slice16p(AVFilterContext *avctx, void *arg, int jobnr, int nb_jobs)
    
      {
    
      ✗
          VibranceContext *s = avctx->priv;
    
      ✗
          ThreadData *td = arg;
    
      ✗
          AVFrame *frame = td->out;
    
      ✗
          AVFrame *in = td->in;
    
      ✗
          const int step = s->step;
    
      ✗
          const int depth = s->depth;
    
      ✗
          const float max = (1 << depth) - 1;
    
      ✗
          const float scale = 1.f / max;
    
      ✗
          const float gc = s->lcoeffs[0];
    
      ✗
          const float bc = s->lcoeffs[1];
    
      ✗
          const float rc = s->lcoeffs[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];
    
      ✗
          const uint8_t aoffset = s->rgba_map[A];
    
      ✗
          const int width = frame->width;
    
      ✗
          const int height = frame->height;
    
      ✗
          const float intensity = s->intensity;
    
      ✗
          const float alternate = s->alternate ? 1.f : -1.f;
    
      ✗
          const float gintensity = intensity * s->balance[0];
    
      ✗
          const float bintensity = intensity * s->balance[1];
    
      ✗
          const float rintensity = intensity * s->balance[2];
    
      ✗
          const float sgintensity = alternate * FFSIGN(gintensity);
    
      ✗
          const float sbintensity = alternate * FFSIGN(bintensity);
    
      ✗
          const float srintensity = alternate * FFSIGN(rintensity);
    
      ✗
          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 ptrdiff_t slinesize = in->linesize[0] / 2;
    
      ✗
          const uint16_t *src = (const uint16_t *)in->data[0] + slice_start * slinesize;
    
      ✗
          uint16_t *ptr = (uint16_t *)frame->data[0] + slice_start * linesize;
    
      ✗
          for (int y = slice_start; y < slice_end; y++) {
    
      ✗
              for (int x = 0; x < width; x++) {
    
      ✗
                  float g = src[x * step + goffset] * scale;
    
      ✗
                  float b = src[x * step + boffset] * scale;
    
      ✗
                  float r = src[x * step + roffset] * scale;
    
      ✗
                  float max_color = FFMAX3(r, g, b);
    
      ✗
                  float min_color = FFMIN3(r, g, b);
    
      ✗
                  float color_saturation = max_color - min_color;
    
      ✗
                  float luma = g * gc + r * rc + b * bc;
    
      ✗
                  const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
    
      ✗
                  const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
    
      ✗
                  const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
    
      ✗
                  g = lerpf(luma, g, cg);
    
      ✗
                  b = lerpf(luma, b, cb);
    
      ✗
                  r = lerpf(luma, r, cr);
    
      ✗
                  ptr[x * step + goffset] = av_clip_uintp2_c(g * max, depth);
    
      ✗
                  ptr[x * step + boffset] = av_clip_uintp2_c(b * max, depth);
    
      ✗
                  ptr[x * step + roffset] = av_clip_uintp2_c(r * max, depth);
    
      ✗
                  if (frame != in)
    
      ✗
                      ptr[x * step + aoffset] = src[x * step + aoffset];
    
              }
    
      ✗
              ptr += linesize;
    
      ✗
              src += slinesize;
    
          }
    
      ✗
          return 0;
    
      }
    
      ✗
      static int filter_frame(AVFilterLink *link, AVFrame *in)
    
      {
    
      ✗
          AVFilterContext *avctx = link->dst;
    
      ✗
          AVFilterLink *outlink = avctx->outputs[0];
    
      ✗
          VibranceContext *s = avctx->priv;
    
          ThreadData td;
    
          AVFrame *out;
    
          int res;
    
      ✗
          if (av_frame_is_writable(in)) {
    
      ✗
              out = in;
    
          } else {
    
      ✗
              out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
    
      ✗
              if (!out) {
    
      ✗
                  av_frame_free(&in);
    
      ✗
                  return AVERROR(ENOMEM);
    
              }
    
      ✗
              av_frame_copy_props(out, in);
    
          }
    
      ✗
          td.out = out;
    
      ✗
          td.in = in;
    
      ✗
          if (res = ff_filter_execute(avctx, s->do_slice, &td, NULL,
    
      ✗
                                      FFMIN(out->height, ff_filter_get_nb_threads(avctx))))
    
      ✗
              return res;
    
      ✗
          if (out != in)
    
      ✗
              av_frame_free(&in);
    
      ✗
          return ff_filter_frame(outlink, out);
    
      }
    
      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 *avctx = inlink->dst;
    
      ✗
          VibranceContext *s = avctx->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 ? vibrance_slice8 : vibrance_slice16;
    
      ✗
          if (!planar)
    
      ✗
              s->do_slice = s->depth <= 8 ? vibrance_slice8p : vibrance_slice16p;
    
      ✗
          ff_fill_rgba_map(s->rgba_map, inlink->format);
    
      ✗
          return 0;
    
      }
    
      static const AVFilterPad vibrance_inputs[] = {
    
          {
    
              .name           = "default",
    
              .type           = AVMEDIA_TYPE_VIDEO,
    
              .filter_frame   = filter_frame,
    
              .config_props   = config_input,
    
          },
    
      };
    
      #define OFFSET(x) offsetof(VibranceContext, x)
    
      #define VF AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
    
      static const AVOption vibrance_options[] = {
    
          { "intensity", "set the intensity value",   OFFSET(intensity),  AV_OPT_TYPE_FLOAT, {.dbl=0},       -2,  2, VF },
    
          { "rbal", "set the red balance value",      OFFSET(balance[2]), AV_OPT_TYPE_FLOAT, {.dbl=1},      -10, 10, VF },
    
          { "gbal", "set the green balance value",    OFFSET(balance[0]), AV_OPT_TYPE_FLOAT, {.dbl=1},      -10, 10, VF },
    
          { "bbal", "set the blue balance value",     OFFSET(balance[1]), AV_OPT_TYPE_FLOAT, {.dbl=1},      -10, 10, VF },
    
          { "rlum", "set the red luma coefficient",   OFFSET(lcoeffs[2]), AV_OPT_TYPE_FLOAT, {.dbl=0.212656}, 0,  1, VF },
    
          { "glum", "set the green luma coefficient", OFFSET(lcoeffs[0]), AV_OPT_TYPE_FLOAT, {.dbl=0.715158}, 0,  1, VF },
    
          { "blum", "set the blue luma coefficient",  OFFSET(lcoeffs[1]), AV_OPT_TYPE_FLOAT, {.dbl=0.072186}, 0,  1, VF },
    
          { "alternate", "use alternate colors",      OFFSET(alternate),  AV_OPT_TYPE_BOOL,  {.i64=0},        0,  1, VF },
    
          { NULL }
    
      };
    
      AVFILTER_DEFINE_CLASS(vibrance);
    
      const FFFilter ff_vf_vibrance = {
    
          .p.name        = "vibrance",
    
          .p.description = NULL_IF_CONFIG_SMALL("Boost or alter saturation."),
    
          .p.priv_class  = &vibrance_class,
    
          .p.flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
    
          .priv_size     = sizeof(VibranceContext),
    
          FILTER_INPUTS(vibrance_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) 2018 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 "libavutil/opt.h"
22		#include "libavutil/pixdesc.h"
23		#include "avfilter.h"
24		#include "drawutils.h"
25		#include "filters.h"
26		#include "video.h"
27
28		#define R 0
29		#define G 1
30		#define B 2
31		#define A 3
32
33		typedef struct VibranceContext {
34		const AVClass *class;
35
36		float intensity;
37		float balance[3];
38		float lcoeffs[3];
39		int alternate;
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		} VibranceContext;
48
49	✗	static inline float lerpf(float v0, float v1, float f)
50		{
51	✗	return v0 + (v1 - v0) * f;
52		}
53
54		typedef struct ThreadData {
55		AVFrame out, in;
56		} ThreadData;
57
58	✗	static int vibrance_slice8(AVFilterContext avctx, void arg, int jobnr, int nb_jobs)
59		{
60	✗	VibranceContext *s = avctx->priv;
61	✗	ThreadData *td = arg;
62	✗	AVFrame *frame = td->out;
63	✗	AVFrame *in = td->in;
64	✗	const int width = frame->width;
65	✗	const int height = frame->height;
66	✗	const float scale = 1.f / 255.f;
67	✗	const float gc = s->lcoeffs[0];
68	✗	const float bc = s->lcoeffs[1];
69	✗	const float rc = s->lcoeffs[2];
70	✗	const float intensity = s->intensity;
71	✗	const float alternate = s->alternate ? 1.f : -1.f;
72	✗	const float gintensity = intensity * s->balance[0];
73	✗	const float bintensity = intensity * s->balance[1];
74	✗	const float rintensity = intensity * s->balance[2];
75	✗	const float sgintensity = alternate * FFSIGN(gintensity);
76	✗	const float sbintensity = alternate * FFSIGN(bintensity);
77	✗	const float srintensity = alternate * FFSIGN(rintensity);
78	✗	const int slice_start = (height * jobnr) / nb_jobs;
79	✗	const int slice_end = (height * (jobnr + 1)) / nb_jobs;
80	✗	const ptrdiff_t glinesize = frame->linesize[0];
81	✗	const ptrdiff_t blinesize = frame->linesize[1];
82	✗	const ptrdiff_t rlinesize = frame->linesize[2];
83	✗	const ptrdiff_t alinesize = frame->linesize[3];
84	✗	const ptrdiff_t gslinesize = in->linesize[0];
85	✗	const ptrdiff_t bslinesize = in->linesize[1];
86	✗	const ptrdiff_t rslinesize = in->linesize[2];
87	✗	const ptrdiff_t aslinesize = in->linesize[3];
88	✗	const uint8_t gsrc = in->data[0] + slice_start glinesize;
89	✗	const uint8_t bsrc = in->data[1] + slice_start blinesize;
90	✗	const uint8_t rsrc = in->data[2] + slice_start rlinesize;
91	✗	uint8_t gptr = frame->data[0] + slice_start glinesize;
92	✗	uint8_t bptr = frame->data[1] + slice_start blinesize;
93	✗	uint8_t rptr = frame->data[2] + slice_start rlinesize;
94	✗	const uint8_t *asrc = in->data[3];
95	✗	uint8_t *aptr = frame->data[3];
96
97	✗	for (int y = slice_start; y < slice_end; y++) {
98	✗	for (int x = 0; x < width; x++) {
99	✗	float g = gsrc[x] * scale;
100	✗	float b = bsrc[x] * scale;
101	✗	float r = rsrc[x] * scale;
102	✗	float max_color = FFMAX3(r, g, b);
103	✗	float min_color = FFMIN3(r, g, b);
104	✗	float color_saturation = max_color - min_color;
105	✗	float luma = g * gc + r * rc + b * bc;
106	✗	const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
107	✗	const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
108	✗	const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
109
110	✗	g = lerpf(luma, g, cg);
111	✗	b = lerpf(luma, b, cb);
112	✗	r = lerpf(luma, r, cr);
113
114	✗	gptr[x] = av_clip_uint8(g * 255.f);
115	✗	bptr[x] = av_clip_uint8(b * 255.f);
116	✗	rptr[x] = av_clip_uint8(r * 255.f);
117		}
118
119	✗	if (aptr && alinesize && frame != in)
120	✗	memcpy(aptr + alinesize * y, asrc + aslinesize * y, width);
121
122	✗	gsrc += gslinesize;
123	✗	bsrc += bslinesize;
124	✗	rsrc += rslinesize;
125	✗	gptr += glinesize;
126	✗	bptr += blinesize;
127	✗	rptr += rlinesize;
128		}
129
130	✗	return 0;
131		}
132
133	✗	static int vibrance_slice16(AVFilterContext avctx, void arg, int jobnr, int nb_jobs)
134		{
135	✗	VibranceContext *s = avctx->priv;
136	✗	ThreadData *td = arg;
137	✗	AVFrame *frame = td->out;
138	✗	AVFrame *in = td->in;
139	✗	const int depth = s->depth;
140	✗	const float max = (1 << depth) - 1;
141	✗	const float scale = 1.f / max;
142	✗	const float gc = s->lcoeffs[0];
143	✗	const float bc = s->lcoeffs[1];
144	✗	const float rc = s->lcoeffs[2];
145	✗	const int width = frame->width;
146	✗	const int height = frame->height;
147	✗	const float intensity = s->intensity;
148	✗	const float alternate = s->alternate ? 1.f : -1.f;
149	✗	const float gintensity = intensity * s->balance[0];
150	✗	const float bintensity = intensity * s->balance[1];
151	✗	const float rintensity = intensity * s->balance[2];
152	✗	const float sgintensity = alternate * FFSIGN(gintensity);
153	✗	const float sbintensity = alternate * FFSIGN(bintensity);
154	✗	const float srintensity = alternate * FFSIGN(rintensity);
155	✗	const int slice_start = (height * jobnr) / nb_jobs;
156	✗	const int slice_end = (height * (jobnr + 1)) / nb_jobs;
157	✗	const ptrdiff_t gslinesize = in->linesize[0] / 2;
158	✗	const ptrdiff_t bslinesize = in->linesize[1] / 2;
159	✗	const ptrdiff_t rslinesize = in->linesize[2] / 2;
160	✗	const ptrdiff_t aslinesize = in->linesize[3] / 2;
161	✗	const ptrdiff_t glinesize = frame->linesize[0] / 2;
162	✗	const ptrdiff_t blinesize = frame->linesize[1] / 2;
163	✗	const ptrdiff_t rlinesize = frame->linesize[2] / 2;
164	✗	const ptrdiff_t alinesize = frame->linesize[3] / 2;
165	✗	const uint16_t gsrc = (const uint16_t )in->data[0] + slice_start * gslinesize;
166	✗	const uint16_t bsrc = (const uint16_t )in->data[1] + slice_start * bslinesize;
167	✗	const uint16_t rsrc = (const uint16_t )in->data[2] + slice_start * rslinesize;
168	✗	uint16_t gptr = (uint16_t )frame->data[0] + slice_start * glinesize;
169	✗	uint16_t bptr = (uint16_t )frame->data[1] + slice_start * blinesize;
170	✗	uint16_t rptr = (uint16_t )frame->data[2] + slice_start * rlinesize;
171	✗	const uint16_t asrc = (const uint16_t )in->data[3];
172	✗	uint16_t aptr = (uint16_t )frame->data[3];
173
174	✗	for (int y = slice_start; y < slice_end; y++) {
175	✗	for (int x = 0; x < width; x++) {
176	✗	float g = gsrc[x] * scale;
177	✗	float b = bsrc[x] * scale;
178	✗	float r = rsrc[x] * scale;
179	✗	float max_color = FFMAX3(r, g, b);
180	✗	float min_color = FFMIN3(r, g, b);
181	✗	float color_saturation = max_color - min_color;
182	✗	float luma = g * gc + r * rc + b * bc;
183	✗	const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
184	✗	const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
185	✗	const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
186
187	✗	g = lerpf(luma, g, cg);
188	✗	b = lerpf(luma, b, cb);
189	✗	r = lerpf(luma, r, cr);
190
191	✗	gptr[x] = av_clip_uintp2_c(g * max, depth);
192	✗	bptr[x] = av_clip_uintp2_c(b * max, depth);
193	✗	rptr[x] = av_clip_uintp2_c(r * max, depth);
194		}
195
196	✗	if (aptr && alinesize && frame != in)
197	✗	memcpy(aptr + alinesize * y, asrc + aslinesize * y, width * 2);
198
199	✗	gsrc += gslinesize;
200	✗	bsrc += bslinesize;
201	✗	rsrc += rslinesize;
202	✗	gptr += glinesize;
203	✗	bptr += blinesize;
204	✗	rptr += rlinesize;
205		}
206
207	✗	return 0;
208		}
209
210	✗	static int vibrance_slice8p(AVFilterContext avctx, void arg, int jobnr, int nb_jobs)
211		{
212	✗	VibranceContext *s = avctx->priv;
213	✗	ThreadData *td = arg;
214	✗	AVFrame *frame = td->out;
215	✗	AVFrame *in = td->in;
216	✗	const int step = s->step;
217	✗	const int width = frame->width;
218	✗	const int height = frame->height;
219	✗	const float scale = 1.f / 255.f;
220	✗	const float gc = s->lcoeffs[0];
221	✗	const float bc = s->lcoeffs[1];
222	✗	const float rc = s->lcoeffs[2];
223	✗	const uint8_t roffset = s->rgba_map[R];
224	✗	const uint8_t goffset = s->rgba_map[G];
225	✗	const uint8_t boffset = s->rgba_map[B];
226	✗	const uint8_t aoffset = s->rgba_map[A];
227	✗	const float intensity = s->intensity;
228	✗	const float alternate = s->alternate ? 1.f : -1.f;
229	✗	const float gintensity = intensity * s->balance[0];
230	✗	const float bintensity = intensity * s->balance[1];
231	✗	const float rintensity = intensity * s->balance[2];
232	✗	const float sgintensity = alternate * FFSIGN(gintensity);
233	✗	const float sbintensity = alternate * FFSIGN(bintensity);
234	✗	const float srintensity = alternate * FFSIGN(rintensity);
235	✗	const int slice_start = (height * jobnr) / nb_jobs;
236	✗	const int slice_end = (height * (jobnr + 1)) / nb_jobs;
237	✗	const ptrdiff_t linesize = frame->linesize[0];
238	✗	const ptrdiff_t slinesize = in->linesize[0];
239	✗	const uint8_t src = in->data[0] + slice_start slinesize;
240	✗	uint8_t ptr = frame->data[0] + slice_start linesize;
241
242	✗	for (int y = slice_start; y < slice_end; y++) {
243	✗	for (int x = 0; x < width; x++) {
244	✗	float g = src[x * step + goffset] * scale;
245	✗	float b = src[x * step + boffset] * scale;
246	✗	float r = src[x * step + roffset] * scale;
247	✗	float max_color = FFMAX3(r, g, b);
248	✗	float min_color = FFMIN3(r, g, b);
249	✗	float color_saturation = max_color - min_color;
250	✗	float luma = g * gc + r * rc + b * bc;
251	✗	const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
252	✗	const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
253	✗	const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
254
255	✗	g = lerpf(luma, g, cg);
256	✗	b = lerpf(luma, b, cb);
257	✗	r = lerpf(luma, r, cr);
258
259	✗	ptr[x * step + goffset] = av_clip_uint8(g * 255.f);
260	✗	ptr[x * step + boffset] = av_clip_uint8(b * 255.f);
261	✗	ptr[x * step + roffset] = av_clip_uint8(r * 255.f);
262
263	✗	if (frame != in)
264	✗	ptr[x * step + aoffset] = src[x * step + aoffset];
265		}
266
267	✗	ptr += linesize;
268	✗	src += slinesize;
269		}
270
271	✗	return 0;
272		}
273
274	✗	static int vibrance_slice16p(AVFilterContext avctx, void arg, int jobnr, int nb_jobs)
275		{
276	✗	VibranceContext *s = avctx->priv;
277	✗	ThreadData *td = arg;
278	✗	AVFrame *frame = td->out;
279	✗	AVFrame *in = td->in;
280	✗	const int step = s->step;
281	✗	const int depth = s->depth;
282	✗	const float max = (1 << depth) - 1;
283	✗	const float scale = 1.f / max;
284	✗	const float gc = s->lcoeffs[0];
285	✗	const float bc = s->lcoeffs[1];
286	✗	const float rc = s->lcoeffs[2];
287	✗	const uint8_t roffset = s->rgba_map[R];
288	✗	const uint8_t goffset = s->rgba_map[G];
289	✗	const uint8_t boffset = s->rgba_map[B];
290	✗	const uint8_t aoffset = s->rgba_map[A];
291	✗	const int width = frame->width;
292	✗	const int height = frame->height;
293	✗	const float intensity = s->intensity;
294	✗	const float alternate = s->alternate ? 1.f : -1.f;
295	✗	const float gintensity = intensity * s->balance[0];
296	✗	const float bintensity = intensity * s->balance[1];
297	✗	const float rintensity = intensity * s->balance[2];
298	✗	const float sgintensity = alternate * FFSIGN(gintensity);
299	✗	const float sbintensity = alternate * FFSIGN(bintensity);
300	✗	const float srintensity = alternate * FFSIGN(rintensity);
301	✗	const int slice_start = (height * jobnr) / nb_jobs;
302	✗	const int slice_end = (height * (jobnr + 1)) / nb_jobs;
303	✗	const ptrdiff_t linesize = frame->linesize[0] / 2;
304	✗	const ptrdiff_t slinesize = in->linesize[0] / 2;
305	✗	const uint16_t src = (const uint16_t )in->data[0] + slice_start * slinesize;
306	✗	uint16_t ptr = (uint16_t )frame->data[0] + slice_start * linesize;
307
308	✗	for (int y = slice_start; y < slice_end; y++) {
309	✗	for (int x = 0; x < width; x++) {
310	✗	float g = src[x * step + goffset] * scale;
311	✗	float b = src[x * step + boffset] * scale;
312	✗	float r = src[x * step + roffset] * scale;
313	✗	float max_color = FFMAX3(r, g, b);
314	✗	float min_color = FFMIN3(r, g, b);
315	✗	float color_saturation = max_color - min_color;
316	✗	float luma = g * gc + r * rc + b * bc;
317	✗	const float cg = 1.f + gintensity * (1.f - sgintensity * color_saturation);
318	✗	const float cb = 1.f + bintensity * (1.f - sbintensity * color_saturation);
319	✗	const float cr = 1.f + rintensity * (1.f - srintensity * color_saturation);
320
321	✗	g = lerpf(luma, g, cg);
322	✗	b = lerpf(luma, b, cb);
323	✗	r = lerpf(luma, r, cr);
324
325	✗	ptr[x * step + goffset] = av_clip_uintp2_c(g * max, depth);
326	✗	ptr[x * step + boffset] = av_clip_uintp2_c(b * max, depth);
327	✗	ptr[x * step + roffset] = av_clip_uintp2_c(r * max, depth);
328	✗	if (frame != in)
329	✗	ptr[x * step + aoffset] = src[x * step + aoffset];
330		}
331
332	✗	ptr += linesize;
333	✗	src += slinesize;
334		}
335
336	✗	return 0;
337		}
338
339	✗	static int filter_frame(AVFilterLink link, AVFrame in)
340		{
341	✗	AVFilterContext *avctx = link->dst;
342	✗	AVFilterLink *outlink = avctx->outputs[0];
343	✗	VibranceContext *s = avctx->priv;
344		ThreadData td;
345		AVFrame *out;
346		int res;
347
348	✗	if (av_frame_is_writable(in)) {
349	✗	out = in;
350		} else {
351	✗	out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
352	✗	if (!out) {
353	✗	av_frame_free(&in);
354	✗	return AVERROR(ENOMEM);
355		}
356	✗	av_frame_copy_props(out, in);
357		}
358
359	✗	td.out = out;
360	✗	td.in = in;
361	✗	if (res = ff_filter_execute(avctx, s->do_slice, &td, NULL,
362	✗	FFMIN(out->height, ff_filter_get_nb_threads(avctx))))
363	✗	return res;
364
365	✗	if (out != in)
366	✗	av_frame_free(&in);
367	✗	return ff_filter_frame(outlink, out);
368		}
369
370		static const enum AVPixelFormat pixel_fmts[] = {
371		AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
372		AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
373		AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
374		AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR,
375		AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
376		AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
377		AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12,
378		AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
379		AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
380		AV_PIX_FMT_RGB48, AV_PIX_FMT_BGR48,
381		AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
382		AV_PIX_FMT_NONE
383		};
384
385	✗	static av_cold int config_input(AVFilterLink *inlink)
386		{
387	✗	AVFilterContext *avctx = inlink->dst;
388	✗	VibranceContext *s = avctx->priv;
389	✗	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
390	✗	int planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR;
391
392	✗	s->step = desc->nb_components;
393	✗	if (inlink->format == AV_PIX_FMT_RGB0 \|\|
394	✗	inlink->format == AV_PIX_FMT_0RGB \|\|
395	✗	inlink->format == AV_PIX_FMT_BGR0 \|\|
396	✗	inlink->format == AV_PIX_FMT_0BGR)
397	✗	s->step = 4;
398
399	✗	s->depth = desc->comp[0].depth;
400	✗	s->do_slice = s->depth <= 8 ? vibrance_slice8 : vibrance_slice16;
401	✗	if (!planar)
402	✗	s->do_slice = s->depth <= 8 ? vibrance_slice8p : vibrance_slice16p;
403
404	✗	ff_fill_rgba_map(s->rgba_map, inlink->format);
405
406	✗	return 0;
407		}
408
409		static const AVFilterPad vibrance_inputs[] = {
410		{
411		.name = "default",
412		.type = AVMEDIA_TYPE_VIDEO,
413		.filter_frame = filter_frame,
414		.config_props = config_input,
415		},
416		};
417
418		#define OFFSET(x) offsetof(VibranceContext, x)
419		#define VF AV_OPT_FLAG_FILTERING_PARAM\|AV_OPT_FLAG_VIDEO_PARAM\|AV_OPT_FLAG_RUNTIME_PARAM
420
421		static const AVOption vibrance_options[] = {
422		{ "intensity", "set the intensity value", OFFSET(intensity), AV_OPT_TYPE_FLOAT, {.dbl=0}, -2, 2, VF },
423		{ "rbal", "set the red balance value", OFFSET(balance[2]), AV_OPT_TYPE_FLOAT, {.dbl=1}, -10, 10, VF },
424		{ "gbal", "set the green balance value", OFFSET(balance[0]), AV_OPT_TYPE_FLOAT, {.dbl=1}, -10, 10, VF },
425		{ "bbal", "set the blue balance value", OFFSET(balance[1]), AV_OPT_TYPE_FLOAT, {.dbl=1}, -10, 10, VF },
426		{ "rlum", "set the red luma coefficient", OFFSET(lcoeffs[2]), AV_OPT_TYPE_FLOAT, {.dbl=0.212656}, 0, 1, VF },
427		{ "glum", "set the green luma coefficient", OFFSET(lcoeffs[0]), AV_OPT_TYPE_FLOAT, {.dbl=0.715158}, 0, 1, VF },
428		{ "blum", "set the blue luma coefficient", OFFSET(lcoeffs[1]), AV_OPT_TYPE_FLOAT, {.dbl=0.072186}, 0, 1, VF },
429		{ "alternate", "use alternate colors", OFFSET(alternate), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, VF },
430		{ NULL }
431		};
432
433		AVFILTER_DEFINE_CLASS(vibrance);
434
435		const FFFilter ff_vf_vibrance = {
436		.p.name = "vibrance",
437		.p.description = NULL_IF_CONFIG_SMALL("Boost or alter saturation."),
438		.p.priv_class = &vibrance_class,
439		.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC \| AVFILTER_FLAG_SLICE_THREADS,
440		.priv_size = sizeof(VibranceContext),
441		FILTER_INPUTS(vibrance_inputs),
442		FILTER_OUTPUTS(ff_video_default_filterpad),
443		FILTER_PIXFMTS_ARRAY(pixel_fmts),
444		.process_command = ff_filter_process_command,
445		};
446

Function (Line)	Call count	Block coverage
config_input (line 385)	not called	0.0%
filter_frame (line 339)	not called	0.0%
lerpf (line 49)	not called	0.0%
vibrance_slice16 (line 133)	not called	0.0%
vibrance_slice16p (line 274)	not called	0.0%
vibrance_slice8 (line 58)	not called	0.0%
vibrance_slice8p (line 210)	not called	0.0%