sequencer::audio Namespace Reference

Namespaces
	base_notes
	underlying_t
	wave
	window

Classes
struct	current_buffer_t
class	delay_t
class	double_buffer_reader_t
class	double_buffer_t
class	dry_wet_t
class	envelope_t
class	note_t
class	oscillator_t
struct	read_write_lockable
class	repeated_delay_t
class	ring_buffer_iterator_t
class	ring_buffer_t
class	sample_read_write_base_t
class	sample_reader_t
struct	sample_t
class	sample_writer_t
class	stereo_delay_t

Typedefs
using	stereo_repeated_delay_t = stereo_delay_t< repeated_delay_t< delay_t > >

Enumerations
enum	half_note_t : int
enum	oscillator_wave_form {   oscillator_wave_form::sine, oscillator_wave_form::triangular, oscillator_wave_form::square, oscillator_wave_form::saw,   oscillator_wave_form::pulse, oscillator_wave_form::ramp, oscillator_wave_form::noise }
enum	mode_t : underlying_t::mode_t { mode_t::mono = 1, mode_t::stereo = 2 }

Functions
std::pair< float, float >	operator* (float a, std::pair< float, float > p)
std::pair< float, float >	operator+ (float a, std::pair< float, float > p)
template<class T >
constexpr T	compute_dry_ratio (T x) noexcept
template<class T >
constexpr T	compute_wet_ratio (T x) noexcept
template<class T >
auto	create_table ()
template<class T >
auto &	gauss_table ()
template<class T , class Size >
std::complex< T >	compute_gauss (Size k, Size size)
template<class Container >
auto	radix2 (const Container &x)
template<class Container , class Result >
void	radix2 (const Container &x, Result &result)
template<class Container >
auto	inverse_radix2 (Container x)
template<class T , std::enable_if_t< !is_complex_v< T > > * = nullptr>
std::vector< std::complex< T > >	fft (const std::vector< T > &x)
template<class T , std::enable_if_t< !is_complex_v< T > > * = nullptr>
std::pair< std::vector< std::complex< T > >, std::vector< std::complex< T > > >	fft (const std::vector< T > &x, const std::vector< T > &y)
template<class T , std::enable_if_t< !is_complex_v< T > > * = nullptr>
void	fft (const std::vector< T > &x, std::vector< std::complex< T > > &result)
template<class T , std::enable_if_t< !is_complex_v< T > > * = nullptr>
std::vector< T >	fft_abs_scaled (const std::vector< T > &x)
template<class T , std::enable_if_t< !is_complex_v< T > > * = nullptr>
std::vector< T >	inverse_fft (const std::vector< std::complex< T > > &x)
constexpr int	to_int (half_note_t half_note) noexcept
double	increase_by_half_notes (double frequency, half_note_t half_notes) noexcept
double	increase_by_half_notes (double frequency, double half_notes) noexcept
double	get_harmonic (double frequency, int n)
constexpr underlying_t::mode_t	channels (mode_t mode) noexcept
void	swap (sample_t &lhs, sample_t &rhs)
constexpr auto	ideal_high_pass (double freq, double cutoff) noexcept
constexpr auto	ideal_low_pass (double freq, double cutoff) noexcept
constexpr auto	low_pass (double freq, double gain, double transition)
constexpr auto	high_pass (double freq, double gain, double transition)
constexpr auto	low_shelf (double freq, double gain, double transition)
constexpr auto	high_shelf (double freq, double gain, double transition)
template<class Container , class TransferFunction >
void	filter (Container &c, TransferFunction f, double base_frequency)
template<class Container , class TransferFunction1 , class TransferFunction2 >
void	filter (Container &c, TransferFunction1 f, TransferFunction2 g, double base_frequency)

Variables
template<class T >
constexpr std::complex< T >	imag = std::complex< T >{0, 1}

Typedef Documentation

stereo_repeated_delay_t

using sequencer::audio::stereo_repeated_delay_t = typedef stereo_delay_t< repeated_delay_t< delay_t > >

Enumeration Type Documentation

half_note_t

enum sequencer::audio::half_note_t : int

strong

mode_t

enum sequencer::audio::mode_t : underlying_t::mode_t

strong

Enumerator
mono
stereo

oscillator_wave_form

enum sequencer::audio::oscillator_wave_form

strong

Enumerator
sine
triangular
square
saw
pulse
ramp
noise

Function Documentation

channels()

constexpr underlying_t::mode_t sequencer::audio::channels ( mode_t  mode )

noexcept

compute_dry_ratio()

template<class T >

constexpr T sequencer::audio::compute_dry_ratio ( T  x )

noexcept

compute_gauss()

template<class T , class Size >

std::complex< T > sequencer::audio::compute_gauss	(	Size	k,
		Size	size
	)

compute_wet_ratio()

template<class T >

constexpr T sequencer::audio::compute_wet_ratio ( T  x )

noexcept

create_table()

template<class T >

auto sequencer::audio::create_table

(

)

fft() [1/3]

template<class T , std::enable_if_t< !is_complex_v< T > > * = nullptr>

std::vector< std::complex< T > > sequencer::audio::fft

(

const std::vector< T > &

x

)

fft() [2/3]

template<class T , std::enable_if_t< !is_complex_v< T > > * = nullptr>

std::pair< std::vector< std::complex< T > >, std::vector< std::complex< T > > > sequencer::audio::fft	(	const std::vector< T > &	x,
		const std::vector< T > &	y
	)

fft() [3/3]

template<class T , std::enable_if_t< !is_complex_v< T > > * = nullptr>

void sequencer::audio::fft	(	const std::vector< T > &	x,
		std::vector< std::complex< T > > &	result
	)

fft_abs_scaled()

template<class T , std::enable_if_t< !is_complex_v< T > > * = nullptr>

std::vector< T > sequencer::audio::fft_abs_scaled

(

const std::vector< T > &

x

)

filter() [1/2]

template<class Container , class TransferFunction >

void sequencer::audio::filter	(	Container &	c,
		TransferFunction	f,
		double	base_frequency
	)

filter() [2/2]

template<class Container , class TransferFunction1 , class TransferFunction2 >

void sequencer::audio::filter	(	Container &	c,
		TransferFunction1	f,
		TransferFunction2	g,
		double	base_frequency
	)

gauss_table()

template<class T >

auto& sequencer::audio::gauss_table

(

)

get_harmonic()

double sequencer::audio::get_harmonic ( double  frequency, int  n  )

inline

high_pass()

constexpr auto sequencer::audio::high_pass	(	double	freq,
		double	gain,
		double	transition
	)

high_shelf()

constexpr auto sequencer::audio::high_shelf	(	double	freq,
		double	gain,
		double	transition
	)

ideal_high_pass()

constexpr auto sequencer::audio::ideal_high_pass ( double  freq, double  cutoff  )

noexcept

ideal_low_pass()

constexpr auto sequencer::audio::ideal_low_pass ( double  freq, double  cutoff  )

noexcept

increase_by_half_notes() [1/2]

double sequencer::audio::increase_by_half_notes ( double  frequency, half_note_t  half_notes  )

inlinenoexcept

increase_by_half_notes() [2/2]

double sequencer::audio::increase_by_half_notes ( double  frequency, double  half_notes  )

inlinenoexcept

inverse_fft()

template<class T , std::enable_if_t< !is_complex_v< T > > * = nullptr>

std::vector< T > sequencer::audio::inverse_fft

(

const std::vector< std::complex< T > > &

x

)

inverse_radix2()

template<class Container >

auto sequencer::audio::inverse_radix2

(

Container

x

)

low_pass()

constexpr auto sequencer::audio::low_pass	(	double	freq,
		double	gain,
		double	transition
	)

low_shelf()

constexpr auto sequencer::audio::low_shelf	(	double	freq,
		double	gain,
		double	transition
	)

operator*()

std::pair< float, float > sequencer::audio::operator* ( float  a, std::pair< float, float >  p  )

inline

operator+()

std::pair< float, float > sequencer::audio::operator+ ( float  a, std::pair< float, float >  p  )

inline

radix2() [1/2]

template<class Container >

auto sequencer::audio::radix2

(

const Container &

x

)

radix2() [2/2]

template<class Container , class Result >

void sequencer::audio::radix2	(	const Container &	x,
		Result &	result
	)

swap()

void sequencer::audio::swap ( sample_t &  lhs, sample_t &  rhs  )

inline

to_int()

constexpr int sequencer::audio::to_int ( half_note_t  half_note )

noexcept

Variable Documentation

imag

template<class T >

constexpr std::complex< T > sequencer::audio::imag = std::complex< T >{0, 1}