dsp.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2020-2022 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __UTILS_DSP_H__
#define __UTILS_DSP_H__
 
#include "zrythm-config.h"
 
#include <cstddef>
 
#include "utils/math.h"
#include "zrythm.h"
 
#include <glib.h>
 
#ifdef HAVE_LSP_DSP
#  include <lsp-plug.in/dsp/dsp.h>
#endif
 
NONNULL HOT static inline void
dsp_fill (float * buf, float val, size_t size)
{
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      lsp::dsp::fill (buf, val, size);
    }
  else
    {
#endif
      for (size_t i = 0; i < size; i++)
        {
          buf[i] = val;
        }
#ifdef HAVE_LSP_DSP
    }
#endif
}
 
NONNULL HOT static inline void
dsp_limit1 (float * buf, float minf, float maxf, size_t size)
{
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      lsp::dsp::limit1 (buf, minf, maxf, size);
    }
  else
    {
#endif
      for (size_t i = 0; i < size; i++)
        {
          buf[i] = CLAMP (buf[i], minf, maxf);
        }
#ifdef HAVE_LSP_DSP
    }
#endif
}
 
NONNULL HOT static inline void
dsp_copy (float * dest, const float * src, size_t size)
{
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      lsp::dsp::copy (dest, src, size);
    }
  else
    {
#endif
      for (size_t i = 0; i < size; i++)
        {
          dest[i] = src[i];
        }
#ifdef HAVE_LSP_DSP
    }
#endif
}
 
NONNULL HOT static inline void
dsp_mul_k2 (float * dest, float k, size_t size)
{
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      lsp::dsp::mul_k2 (dest, k, size);
    }
  else
    {
#endif
      for (size_t i = 0; i < size; i++)
        {
          dest[i] *= k;
        }
#ifdef HAVE_LSP_DSP
    }
#endif
}
 
NONNULL WARN_UNUSED_RESULT static inline float
dsp_abs_max (float * buf, size_t size)
{
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      return lsp::dsp::abs_max (buf, size);
    }
  else
    {
#endif
      float ret = 1e-20f;
      for (size_t i = 0; i < size; i++)
        {
          if (fabsf (buf[i]) > ret)
            {
              ret = fabsf (buf[i]);
            }
        }
      return ret;
#ifdef HAVE_LSP_DSP
    }
#endif
}
 
HOT NONNULL static inline bool
dsp_abs_max_with_existing_peak (float * buf, float * cur_peak, size_t size)
{
  float new_peak = *cur_peak;
 
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      new_peak = lsp::dsp::abs_max (buf, size);
    }
  else
    {
#endif
      for (size_t i = 0; i < size; i++)
        {
          float val = fabsf (buf[i]);
          if (val > new_peak)
            {
              new_peak = val;
            }
        }
#ifdef HAVE_LSP_DSP
    }
#endif
 
  bool changed = !math_floats_equal (new_peak, *cur_peak);
  *cur_peak = new_peak;
 
  return changed;
}
 
NONNULL float
dsp_min (float * buf, size_t size);
 
NONNULL float
dsp_max (float * buf, size_t size);
 
NONNULL HOT static inline void
dsp_add2 (float * dest, const float * src, size_t count)
{
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      lsp::dsp::add2 (dest, src, count);
    }
  else
    {
#endif
      for (size_t i = 0; i < count; i++)
        {
          dest[i] = dest[i] + src[i];
        }
#ifdef HAVE_LSP_DSP
    }
#endif
}
 
NONNULL HOT static inline void
dsp_mix2 (float * dest, const float * src, float k1, float k2, size_t size)
{
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      lsp::dsp::mix2 (dest, src, k1, k2, size);
    }
  else
    {
#endif
      for (size_t i = 0; i < size; i++)
        {
          dest[i] = dest[i] * k1 + src[i] * k2;
        }
#ifdef HAVE_LSP_DSP
    }
#endif
}
 
NONNULL HOT static inline void
dsp_reverse1 (float * dest, size_t size)
{
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      lsp::dsp::reverse1 (dest, size);
    }
  else
    {
#endif
      for (size_t i = 0; i < size; i++)
        {
          dest[i] = dest[(size - i) - 1];
        }
#ifdef HAVE_LSP_DSP
    }
#endif
}
 
NONNULL HOT static inline void
dsp_reverse2 (float * dest, float * src, size_t size)
{
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      lsp::dsp::reverse2 (dest, src, size);
    }
  else
    {
#endif
      for (size_t i = 0; i < size; i++)
        {
          dest[i] = src[(size - i) - 1];
        }
#ifdef HAVE_LSP_DSP
    }
#endif
}
 
NONNULL HOT static inline void
dsp_normalize (float * dest, const float * src, size_t size)
{
#ifdef HAVE_LSP_DSP
  if (ZRYTHM_USE_OPTIMIZED_DSP)
    {
      lsp::dsp::normalize (dest, src, size);
    }
  else
    {
#endif
      dsp_copy (dest, src, size);
      float abs_peak = dsp_abs_max (dest, size);
      dsp_mul_k2 (dest, 1.f / abs_peak, size);
#ifdef HAVE_LSP_DSP
    }
#endif
}
 
NONNULL void
dsp_mix_add2 (
  float *       dest,
  const float * src1,
  const float * src2,
  float         k1,
  float         k2,
  size_t        size);
 
NONNULL void
dsp_linear_fade_in_from (
  float * dest,
  int32_t start_offset,
  int32_t total_frames_to_fade,
  size_t  size,
  float   fade_from_multiplier);
 
NONNULL void
dsp_linear_fade_out_to (
  float * dest,
  int32_t start_offset,
  int32_t total_frames_to_fade,
  size_t  size,
  float   fade_to_multiplier);
 
NONNULL void
dsp_make_mono (float * l, float * r, size_t size, bool equal_power);
 
#endif