math_utils.h

// SPDX-FileCopyrightText: © 2018-2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
/*
 * This file incorporates work covered by the following copyright and
 * permission notices:
 *
 * ---
 *
 * Copyright (C) 2017-2019 Robin Gareus <robin@gareus.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * ---
 */
 
#pragma once
 
#include <cmath>
#include <cstdint>
#include <limits>
#include <numbers>
#include <string>

namespace zrythm::utils::math
{

constexpr unsigned RMS_FRAMES = 1;

constexpr float ALMOST_SILENCE = 0.0000001f;
 
constexpr auto MINUS_INFINITY = -HUGE_VAL;

template <std::floating_point T>
constexpr bool
floats_near (T a, T b, T e)
{
  return std::abs (a - b) < e;
}

template <std::floating_point T>
constexpr bool
floats_equal (T a, T b)
{
  return floats_near (a, b, std::numeric_limits<T>::epsilon ());
}

template <std::floating_point T>
constexpr long
round_to_signed_32 (T x)
{
  if constexpr (std::is_same_v<T, float>)
    {
      return lroundf (x);
    }
  else
    {
      return lround (x);
    }
}

template <std::floating_point T>
constexpr long long
round_to_signed_64 (T x)
{
  if constexpr (std::is_same_v<T, float>)
    {
      return llroundf (x);
    }
  else
    {
      return llround (x);
    }
}

[[gnu::const]]
constexpr float
fast_log2 (float val)
{
  union
  {
    float f;
    int   i;
  } t{};
  t.f = val;
  int * const exp_ptr = &t.i;
  int         x = *exp_ptr;
  const auto  log_2 = (float) (((x >> 23) & 255) - 128);
 
  x &= ~(255 << 23);
  x += 127 << 23;
 
  *exp_ptr = x;
 
  val = ((-1.0f / 3) * t.f + 2) * t.f - 2.0f / 3;
 
  return (val + log_2);
}
 
[[gnu::const]]
constexpr auto
fast_log (const float val)
{
  return (fast_log2 (val) * std::numbers::ln2_v<float>);
}
 
[[gnu::const]]
constexpr auto
fast_log10 (const float val)
{
  return fast_log2 (val) / 3.312500f;
}

template <std::floating_point T>
[[gnu::const]]
static inline T
get_fader_val_from_amp (T amp)
{
  constexpr T fader_coefficient1 =
    /*192.f * logf (2.f);*/
    133.084258667509499408f;
  constexpr T fader_coefficient2 =
    /*powf (logf (2.f), 8.f) * powf (198.f, 8.f);*/
    1.25870863180257576e17f;
 
  /* to prevent weird values when amp is very
   * small */
  if (amp <= 0.00001f)
    {
      return 1e-20f;
    }
 
  if (floats_equal (amp, 1.f))
    {
      amp = 1.f + 1e-20f;
    }
  T fader =
    std::powf (
      // note: don't use fast_log here - it causes weirdness in faders
      (6.f * std::logf (amp)) + fader_coefficient1, 8.f)
    / fader_coefficient2;
  return fader;
}

template <std::floating_point T>
[[gnu::const]]
static inline T
get_amp_val_from_fader (T fader)
{
  constexpr float val1 = 1.f / 6.f;
  return std::powf (
    2.f, (val1) * (-192.f + 198.f * std::powf (fader, 1.f / 8.f)));
}

template <std::floating_point T>
[[gnu::const]]
static inline T
amp_to_dbfs (T amp)
{
  return 20.f * std::log10f (amp);
}

float
calculate_rms_amp (const float * buf, uint32_t nframes);

template <std::floating_point T>
static inline T
calculate_rms_db (const T * buf, uint32_t nframes)
{
  return amp_to_dbfs (calculate_rms_amp (buf, nframes));
}

template <std::floating_point T>
[[gnu::const]]
static inline T
dbfs_to_amp (T dbfs)
{
  return std::powf (10.f, (dbfs / 20.f));
}

template <std::floating_point T>
[[gnu::const]]
static inline T
dbfs_to_fader_val (T dbfs)
{
  return get_fader_val_from_amp (dbfs_to_amp (dbfs));
}

bool
assert_nonnann (float x);

bool
is_string_valid_float (const std::string &str, float * ret);
 
} // namespace zrythm::utils::math