Klang C++ 0.7.15
Language Reference (draft)
Loading...
Searching...
No Matches
klang::signals< CHANNELS >

A multi-channel audio signal (e.g. stereo). More...

#include <klang.h>

Public Member Functions

 signals (float initial=0.f)
 Create a multi-channel signal by broadcasting the given value.
 
 signals (double initial)
 Create a multi-channel signal by broadcasting the given value.
 
 signals (int initial)
 Create a multi-channel signal by broadcasting the given value.
 
 signals (const klang::signal &initial)
 Create a multi-channel signal by broadcasting the given signal.
 
 signals (float left, float right)
 Create a multi-channel signal with the first two channel values; remaining channels are zero.
 
 signals (double left, double right)
 Create a multi-channel signal with the first two channel values; remaining channels are zero.
 
 signals (int left, int right)
 Create a multi-channel signal with the first two channel values; remaining channels are zero.
 
template<typename... Args, typename = std::enable_if_t<sizeof...(Args) == CHANNELS && (std::is_convertible_v<Args, signal> && ...)>>
 signals (Args &... initial)
 Create a multi-channel signal with the given channel values.
 
template<typename... Args, typename = std::enable_if_t<sizeof...(Args) == CHANNELS && (std::is_scalar_v<Args> && ...)>>
 signals (Args... initial)
 Create a multi-channel signal with the given channel values.
 
template<typename TYPE , std::enable_if_t<!std::is_arithmetic_v< std::decay_t< TYPE > > &&!std::is_same_v< std::decay_t< TYPE >, klang::signal > &&std::is_convertible_v< TYPE &, klang::signal >, int > = 0>
 signals (TYPE &initial)
 Evaluate a mono Klang object once and broadcast its signal to every channel.
 
klang::signal sum () const
 Return the sum of all channels.
 
klang::signal average () const
 Return the arithmetic mean of all channels.
 
klang::signal mono () const
 Return the default mono downmix: the arithmetic mean of all channels.
 
signal & operator[] (int index)
 Return a reference to the signal at the specified index (0 = left, 1 = right).
 
const signal & operator[] (int index) const
 Return a read-only reference to the signal at the specified index (0 = left, 1 = right).
 
int channels () const
 Returns the number of channels in the signal.
 
const signals & operator<< (const signals &input)
 Feedback operator (prevents further processing of returned value).
 
signals & operator>> (signals &destination) const
 Stream operator (feedforward; allows further processing).
 
signals & operator+= (const signals x)
 Add (mix) another signal to the signal.
 
signals & operator-= (const signals x)
 Subtract another signal from the signal.
 
signals & operator*= (const signals x)
 Multiply (modulate) signal by another signal.
 
signals & operator/= (const signals x)
 Divide signal by another signal.
 
signals operator+ (const signals x) const
 Add two multi-channel signals together.
 
signals operator- (const signals x) const
 Subtract one multi-channel signal from another.
 
signals operator* (const signals x) const
 Multiply (modulate) two multi-channel signals.
 
signals operator/ (const signals x) const
 Divide one multi-channel signal by another.
 
signals operator+ (const signal x) const
 Return a copy of the multi-channel signal, adding a mono signal to each channel.
 
signals operator- (const signal x) const
 Return a copy of the multi-channel signal, subtracting a mono signal from each channel.
 
signals operator* (const signal x) const
 Return a copy of the multi-channel signal, multiplying (modulating) each channel by a mono signal.
 
signals operator/ (const signal x) const
 Return a copy of the multi-channel signal, dividing each channel by a mono signal.
 
signals operator+ (float x) const
 Return a copy of the signal with each channel offset by x.
 
signals operator- (float x) const
 Return a copy of the signal with each channel offset by -x.
 
signals operator* (float x) const
 Return a copy of the signal with each channel scaled by x.
 
signals operator/ (float x) const
 Return a copy of the signal with each channel divided by x.
 
signals operator+ (double x) const
 Return a copy of the signal with each channel offset by x.
 
signals operator- (double x) const
 Return a copy of the signal with each channel offset by -x.
 
signals operator* (double x) const
 Return a copy of the signal with each channel scaled by x.
 
signals operator/ (double x) const
 Return a copy of the signal with each channel divided by x.
 
signals operator+ (int x) const
 Return a copy of the signal with each channel offset by x.
 
signals operator- (int x) const
 Return a copy of the signal with each channel offset by -x.
 
signals operator* (int x) const
 Return a copy of the signal with each channel scaled by x.
 
signals operator/ (int x) const
 Return a copy of the signal with each channel divided by x.
 

Detailed Description

template<int CHANNELS = 2>
struct klang::signals< CHANNELS >

Definition at line 1278 of file klang.h.

Constructor & Destructor Documentation

◆ signals() [1/10]

template<int CHANNELS = 2>
klang::signals< CHANNELS >::signals ( float initial = 0.f)
inline

Definition at line 1292 of file klang.h.

1292{ for (int channel = 0; channel < CHANNELS; channel++) value[channel] = initial; }

◆ signals() [2/10]

template<int CHANNELS = 2>
klang::signals< CHANNELS >::signals ( double initial)
inline

Definition at line 1294 of file klang.h.

1294: signals((float)initial) {}
signals(float initial=0.f)
Create a multi-channel signal by broadcasting the given value.
Definition klang.h:1292

◆ signals() [3/10]

template<int CHANNELS = 2>
klang::signals< CHANNELS >::signals ( int initial)
inline

Definition at line 1296 of file klang.h.

1296: signals((float)initial) {}

◆ signals() [4/10]

template<int CHANNELS = 2>
klang::signals< CHANNELS >::signals ( const klang::signal & initial)
inline

Definition at line 1298 of file klang.h.

1298{ for (int channel = 0; channel < CHANNELS; channel++) value[channel] = initial; }

◆ signals() [5/10]

template<int CHANNELS = 2>
klang::signals< CHANNELS >::signals ( float left,
float right )
inline

Definition at line 1301 of file klang.h.

1301: signals(0.f) { l = left; r = right; }

◆ signals() [6/10]

template<int CHANNELS = 2>
klang::signals< CHANNELS >::signals ( double left,
double right )
inline

Definition at line 1303 of file klang.h.

1303: signals((float)left, (float)right) {}

◆ signals() [7/10]

template<int CHANNELS = 2>
klang::signals< CHANNELS >::signals ( int left,
int right )
inline

Definition at line 1305 of file klang.h.

1305: signals((float)left, (float)right) {}

◆ signals() [8/10]

template<int CHANNELS = 2>
template<typename... Args, typename = std::enable_if_t<sizeof...(Args) == CHANNELS && (std::is_convertible_v<Args, signal> && ...)>>
klang::signals< CHANNELS >::signals ( Args &... initial)
inline

Definition at line 1309 of file klang.h.

1309: value{ initial... } {}

◆ signals() [9/10]

template<int CHANNELS = 2>
template<typename... Args, typename = std::enable_if_t<sizeof...(Args) == CHANNELS && (std::is_scalar_v<Args> && ...)>>
klang::signals< CHANNELS >::signals ( Args... initial)
inline

Definition at line 1312 of file klang.h.

1312: value{ initial... } {}

◆ signals() [10/10]

template<int CHANNELS = 2>
template<typename TYPE , std::enable_if_t<!std::is_arithmetic_v< std::decay_t< TYPE > > &&!std::is_same_v< std::decay_t< TYPE >, klang::signal > &&std::is_convertible_v< TYPE &, klang::signal >, int > = 0>
klang::signals< CHANNELS >::signals ( TYPE & initial)
inline

Definition at line 1346 of file klang.h.

1346 {
1347 const klang::signal mono = initial;
1348 for (int channel = 0; channel < CHANNELS; channel++)
1349 value[channel] = mono;
1350 }
A mono audio signal (equivalent to a float).
Definition klang.h:1123
klang::signal mono() const
Return the default mono downmix: the arithmetic mean of all channels.
Definition klang.h:1364

Member Function Documentation

◆ average()

template<int CHANNELS = 2>
klang::signal klang::signals< CHANNELS >::average ( ) const
inline

Definition at line 1361 of file klang.h.

1361{ return sum() / float(CHANNELS); }
klang::signal sum() const
Return the sum of all channels.
Definition klang.h:1353

◆ channels()

template<int CHANNELS = 2>
int klang::signals< CHANNELS >::channels ( ) const
inline

Definition at line 1372 of file klang.h.

1372{ return CHANNELS; }

◆ mono()

template<int CHANNELS = 2>
klang::signal klang::signals< CHANNELS >::mono ( ) const
inline

Definition at line 1364 of file klang.h.

1364{ return average(); }
klang::signal average() const
Return the arithmetic mean of all channels.
Definition klang.h:1361

◆ operator*() [1/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator* ( const signal x) const
inline

Definition at line 1413 of file klang.h.

1413{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] *= x; return s; }

◆ operator*() [2/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator* ( const signals< CHANNELS > x) const
inline

Definition at line 1399 of file klang.h.

1399{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] *= x[v]; return s; }

◆ operator*() [3/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator* ( double x) const
inline

Definition at line 1431 of file klang.h.

1431{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] *= x; return s; }

◆ operator*() [4/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator* ( float x) const
inline

Definition at line 1422 of file klang.h.

1422{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] *= x; return s; }

◆ operator*() [5/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator* ( int x) const
inline

Definition at line 1440 of file klang.h.

1440{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] *= x; return s; }

◆ operator*=()

template<int CHANNELS = 2>
signals & klang::signals< CHANNELS >::operator*= ( const signals< CHANNELS > x)
inline

Definition at line 1390 of file klang.h.

1390{ for (int v = 0; v < CHANNELS; v++) value[v] *= x[v]; return *this; }

◆ operator+() [1/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator+ ( const signal x) const
inline

Definition at line 1409 of file klang.h.

1409{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] += x; return s; }

◆ operator+() [2/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator+ ( const signals< CHANNELS > x) const
inline

Definition at line 1395 of file klang.h.

1395{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] += x[v]; return s; }

◆ operator+() [3/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator+ ( double x) const
inline

Definition at line 1427 of file klang.h.

1427{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] += x; return s; }

◆ operator+() [4/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator+ ( float x) const
inline

Definition at line 1418 of file klang.h.

1418{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] += x; return s; }

◆ operator+() [5/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator+ ( int x) const
inline

Definition at line 1436 of file klang.h.

1436{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] += x; return s; }

◆ operator+=()

template<int CHANNELS = 2>
signals & klang::signals< CHANNELS >::operator+= ( const signals< CHANNELS > x)
inline

Definition at line 1386 of file klang.h.

1386{ for (int v = 0; v < CHANNELS; v++) value[v] += x[v]; return *this; }

◆ operator-() [1/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator- ( const signal x) const
inline

Definition at line 1411 of file klang.h.

1411{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] -= x; return s; }

◆ operator-() [2/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator- ( const signals< CHANNELS > x) const
inline

Definition at line 1397 of file klang.h.

1397{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] -= x[v]; return s; }

◆ operator-() [3/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator- ( double x) const
inline

Definition at line 1429 of file klang.h.

1429{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] -= x; return s; }

◆ operator-() [4/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator- ( float x) const
inline

Definition at line 1420 of file klang.h.

1420{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] -= x; return s; }

◆ operator-() [5/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator- ( int x) const
inline

Definition at line 1438 of file klang.h.

1438{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] -= x; return s; }

◆ operator-=()

template<int CHANNELS = 2>
signals & klang::signals< CHANNELS >::operator-= ( const signals< CHANNELS > x)
inline

Definition at line 1388 of file klang.h.

1388{ for (int v = 0; v < CHANNELS; v++) value[v] -= x[v]; return *this; }

◆ operator/() [1/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator/ ( const signal x) const
inline

Definition at line 1415 of file klang.h.

1415{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] /= x; return s; }

◆ operator/() [2/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator/ ( const signals< CHANNELS > x) const
inline

Definition at line 1401 of file klang.h.

1401{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] /= x[v]; return s; }

◆ operator/() [3/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator/ ( double x) const
inline

Definition at line 1433 of file klang.h.

1433{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] /= x; return s; }

◆ operator/() [4/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator/ ( float x) const
inline

Definition at line 1424 of file klang.h.

1424{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] /= x; return s; }

◆ operator/() [5/5]

template<int CHANNELS = 2>
signals klang::signals< CHANNELS >::operator/ ( int x) const
inline

Definition at line 1442 of file klang.h.

1442{ signals s = *this; for (int v = 0; v < CHANNELS; v++) s[v] /= x; return s; }

◆ operator/=()

template<int CHANNELS = 2>
signals & klang::signals< CHANNELS >::operator/= ( const signals< CHANNELS > x)
inline

Definition at line 1392 of file klang.h.

1392{ for (int v = 0; v < CHANNELS; v++) value[v] /= x[v]; return *this; }

◆ operator<<()

template<int CHANNELS = 2>
const signals & klang::signals< CHANNELS >::operator<< ( const signals< CHANNELS > & input)
inline

Definition at line 1375 of file klang.h.

1375 {
1376 return this->operator=(input);
1377 }

◆ operator>>()

template<int CHANNELS = 2>
signals & klang::signals< CHANNELS >::operator>> ( signals< CHANNELS > & destination) const
inline

Definition at line 1380 of file klang.h.

1380 {
1381 destination = *this;
1382 return destination;
1383 }

◆ operator[]() [1/2]

template<int CHANNELS = 2>
signal & klang::signals< CHANNELS >::operator[] ( int index)
inline

Definition at line 1367 of file klang.h.

1367{ return value[index]; }

◆ operator[]() [2/2]

template<int CHANNELS = 2>
const signal & klang::signals< CHANNELS >::operator[] ( int index) const
inline

Definition at line 1369 of file klang.h.

1369{ return value[index]; }

◆ sum()

template<int CHANNELS = 2>
klang::signal klang::signals< CHANNELS >::sum ( ) const
inline

Definition at line 1353 of file klang.h.

1353 {
1354 klang::signal result = 0;
1355 for (int channel = 0; channel < CHANNELS; channel++)
1356 result += value[channel];
1357 return result;
1358 }