ame_Conversion.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ame_Math.hpp"
 
#include <algorithm>
#include <cmath>
#include <concepts>
 
namespace ame
{
enum class NoteValue
{
    N1_DOT = 2880,
    N1 = 1920,
    N1_TRIPLET = 1280,
    N2_DOT = 1440,
    N2 = 960,
    N2_TRIPLET = 640,
    N4_DOT = 720,
    N4 = 480, 
    N4_TRIPLET = 320,
    N8_DOT = 360,
    N8 = 240,
    N8_TRIPLET = 160,
    N16_DOT = 180,
    N16 = 120,
    N16_TRIPLET = 80,
    N32_DOT = 90,
    N32 = 60,
    N32_TRIPLET = 40,
    N64_DOT = 45,
    N64 = 30,
    N64_TRIPLET = 20,
    // N128_DOT cannot be expressed as an integer number of ticks
    N128 = 15,
    N128_TRIPLET = 10
};
 
//==============================================================================
//Constants
inline constexpr int32_t Q23_MAX = 8388607;
inline constexpr int32_t Q23_MIN = -8388608;
inline constexpr float Q23_ABSMAX = 8388608.0f;
 
//==============================================================================
constexpr void floatToQ23 (const float src[], int32_t dest[], const uint32_t blockSize)
{
#if defined(__GNUC__) && (__GNUC__ >= 8)
    #pragma GCC unroll 4
#endif
    for (uint32_t i = 0; i < blockSize; ++i)
    {
        dest[i] = std::clamp (static_cast<int32_t> (src[i] * Q23_MAX), Q23_MIN, Q23_MAX);
    }
}
 
constexpr void q23ToFloat (const int32_t src[], float dest[], const uint32_t blockSize)
{
#if defined(__GNUC__) && (__GNUC__ >= 8)
    #pragma GCC unroll 4
#endif
    for (uint32_t i = 0; i < blockSize; ++i)
    {
        dest[i] = static_cast<float> (src[i]) / Q23_ABSMAX;
    }
}
 
constexpr void interleaveSamples (const float** source, float* dest, const uint_fast32_t numSamples, const uint_fast32_t numChannels)
{
    for (uint_fast32_t chan = 0; chan < numChannels; ++chan)
    {
        auto i = chan;
        const auto* src = source[chan];
 
        for (uint_fast32_t j = 0; j < numSamples; ++j)
        {
            dest[i] = src[j];
            i += numChannels;
        }
    }
}
 
inline void deinterleaveSamples (const float* source, float** dest, const uint_fast32_t numSamples, const uint_fast32_t numChannels)
{
    for (uint_fast32_t chan = 0; chan < numChannels; ++chan)
    {
        uint_fast32_t i = chan;
 
        for (uint_fast32_t k = 0; k < numSamples; ++k)
        {
            dest[chan][k] = source[i];
            i += numChannels;
        }
    }
}
 
//==============================================================================
// Frequency
 
inline float semitoneToRatio (const float semitone)
{
    return std::pow (2.0f, semitone / 12.0f);
}
 
constexpr float freqToPeriod (const float freq) noexcept { return 1.0f / freq; }
 
constexpr float periodToFreq (const float period) noexcept { return 1.0f / period; }
 
inline float freqToMidi (const float freq, const float A3Freq = 440.0f)
{
    return 12.0f * std::log2f (freq / A3Freq) + 69.0f;
}
 
inline float midiToFreq (const float midiNote, const float A3Freq = 440.0f)
{
    return A3Freq * std::pow (2.0f, (midiNote - 69.0f) / 12.0f);
}
 
inline std::pair<float, float> cartopol (const float real, const float imag)
{
    const float amplitude = std::sqrt (real * real + imag * imag);
    const float angle = std::atan2 (imag, real);
    return { amplitude, angle };
}
 
inline std::pair<float, float> poltocar (const float amplitude, const float angle)
{
    const float real = amplitude * cosf (angle);
    const float imag = amplitude * sinf (angle);
    return { real, imag };
}
 
//==============================================================================
//time
 
constexpr float bpmToMs (float bpm) { return 60000.0f / bpm; }
 
constexpr float msToBpm (float ms) { return 60000.0f / ms; }
 
//==============================================================================
//volume
constexpr float decibelsToGain (const float dB) noexcept
{
    return dB > -100.0f
               ? std::pow (10.0f, dB * 0.05f)
               : 0.0f; // Outputs 0 if the input is less than -100dB
}
 
constexpr float gainToDecibels (const float gain) noexcept
{
    return gain > 0.00001f
               ? std::log10 (gain) * 20.0f
               : -100.0f; // Minimum output value -100dB
}
 
//==============================================================================
template <std::floating_point FloatType>
constexpr FloatType deg2rad (FloatType degree) noexcept
{
    return degree * (ame::pi<FloatType> / static_cast<FloatType> (180.0));
}
 
template <std::floating_point FloatType>
constexpr FloatType rad2deg (FloatType radian) noexcept
{
    return radian * (static_cast<FloatType> (180.0) / ame::pi<FloatType>);
}
} // namespace ame