noise_morpher.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/signal/checked_allocation.hpp>
 
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <complex>
#include <vector>
 
namespace pulp::signal {

template <typename SampleType = float>
class NoiseMorpherT {
public:
    static bool checked_retained_bytes(int num_bins, std::uint64_t target_max_bytes,
                                       std::uint64_t& bytes) noexcept {
        CheckedRetainedByteCharge charge(target_max_bytes);
        const auto bins = static_cast<std::uint64_t>(num_bins);
        if (!charge.add<SampleType>(bins) || !charge.add<SampleType>(bins))
            return false;
        bytes = charge.total();
        return true;
    }
 
    void prepare(int num_bins, std::uint64_t seed = 0x9e3779b97f4a7c15ull) {
        num_bins_ = num_bins;
        seed_ = seed ? seed : 0x9e3779b97f4a7c15ull;
        rng_ = seed_;
        env_a_.assign(static_cast<size_t>(num_bins), SampleType{0});
        env_b_.assign(static_cast<size_t>(num_bins), SampleType{0});
        have_prev_ = false;
    }
 
    int num_bins() const { return num_bins_; }
 
    void reset() {
        rng_ = seed_;
        have_prev_ = false;
    }

    void push_envelope(const SampleType* noise_mag) {
        std::copy(noise_mag, noise_mag + num_bins_, env_b_.begin());
        if (!have_prev_) {
            std::copy(env_b_.begin(), env_b_.end(), env_a_.begin());
            have_prev_ = true;
        }
    }

    void advance() { std::swap(env_a_, env_b_); }

    void set_synthesis_gain(SampleType g) {
        synth_gain_ = g > SampleType{0} ? g : SampleType{1};
    }
 
    void synthesize(SampleType frac, std::complex<SampleType>* out) {
        const SampleType f = frac < SampleType{0}
            ? SampleType{0}
            : (frac > SampleType{1} ? SampleType{1} : frac);
        for (int k = 0; k < num_bins_; ++k) {
            const SampleType mag = (env_a_[static_cast<size_t>(k)] * (SampleType{1} - f)
                            + env_b_[static_cast<size_t>(k)] * f) * synth_gain_;
            const SampleType phase = next_phase();
            out[k] = std::polar(mag, phase);
        }
    }

    void push_masked_envelope(const SampleType* full_mag, const SampleType* noise_mask) {
        for (int k = 0; k < num_bins_; ++k)
            scratch_[static_cast<size_t>(k)] = full_mag[k] * noise_mask[k];
        push_envelope(scratch_.data());
    }
 
    void prepare_masked_scratch() {
        scratch_.assign(static_cast<size_t>(num_bins_), SampleType{0});
    }
 
private:
    SampleType next_phase() {
        rng_ ^= rng_ >> 12;
        rng_ ^= rng_ << 25;
        rng_ ^= rng_ >> 27;
        const std::uint64_t r = rng_ * 0x2545f4914f6cdd1dull;
        // Uniform phase in [-pi, pi).
        const double u = static_cast<double>(r >> 11) * (1.0 / 9007199254740992.0);
        return static_cast<SampleType>((u * 2.0 - 1.0) * 3.14159265358979323846);
    }
 
    int num_bins_ = 0;
    SampleType synth_gain_ = SampleType{1};
    std::uint64_t seed_ = 0;
    std::uint64_t rng_ = 0;
    bool have_prev_ = false;
    std::vector<SampleType> env_a_;
    std::vector<SampleType> env_b_;
    std::vector<SampleType> scratch_;
};
 
using NoiseMorpher = NoiseMorpherT<float>;
using NoiseMorpher64 = NoiseMorpherT<double>;
 
} // namespace pulp::signal