Class for handling the most basic audio needs. More...

#include <TAudioBuffer.hpp>

Inheritance diagram for tklb::AudioBufferTpl< T, STORAGE >:

Collaboration diagram for tklb::AudioBufferTpl< T, STORAGE >:

Public Types
using	Sample = T

using	Storage = STORAGE

using	uchar = unsigned char

using	ushort = unsigned short

using	uint = unsigned int

using	Size = typename Storage::Size

Public Member Functions
	AudioBufferTpl ()
	Empty buffer with no memory allocated yet. More...

	AudioBufferTpl (const Size length, const uchar channels)
	Buffer with memory allocated. More...

	~AudioBufferTpl ()

	AudioBufferTpl (AudioBufferTpl &&source)=default
	move contructor is implicitly deleted Don't know why More...

AudioBufferTpl &	operator= (AudioBufferTpl &&source)=default

AudioBufferTpl &	operator= (const AudioBufferTpl &)=delete

	AudioBufferTpl (const AudioBufferTpl &)=delete

	AudioBufferTpl (const AudioBufferTpl *)=delete

template<typename T2 >
void	set (const T2 *samples, Size length, const uchar channel=0, const Size offsetDst=0)
	Set a single channel from an array. More...

template<typename T2 >
void	set (T2 **const samples, const Size length, const uchar channels, const Size offsetSrc=0, const Size offsetDst=0)
	Set multiple channels from a 2D array. More...

template<typename T2 , class STORAGE2 >
void	set (const AudioBufferTpl< T2, STORAGE2 > &buffer, Size length=0, const Size offsetSrc=0, const Size offsetDst=0)
	Set from another buffer object, will not adjust size and channel count! Use clone() instead. More...

void	set (T value=0, Size length=0, const Size offsetDst=0)
	Set the entire buffer to a constant value. More...

template<typename T2 >
void	setFromInterleaved (const T2 *samples, Size length, const uchar channels, Size offsetSrc=0, const Size offsetDst=0)
	Set multiple channels from an interleaved array. More...

template<typename T2 , class STORAGE2 >
void	clone (const AudioBufferTpl< T2, STORAGE2 > &buffer)
	Match the size of the provided buffer and copy the contents. More...

bool	resize (const Size length, uchar channels)
	! Will not keep the contents! Resizes the buffer to the desired length and channel count. More...

void	resize (const Size length)
	Resize to the provided length and keep the channelcount. More...

template<typename T2 , class STORAGE2 >
void	resize (const AudioBufferTpl< T2, STORAGE2 > &buffer)
	Resize to match the provided buffer. More...

template<typename T2 , class STORAGE2 >
void	add (const AudioBufferTpl< T2, STORAGE2 > &buffer, Size length=0, Size offsetSrc=0, Size offsetDst=0)
	Add the provided buffer. More...

template<typename T2 , class STORAGE2 >
void	multiply (const AudioBufferTpl< T2, STORAGE2 > &buffer, Size length=0, Size offsetSrc=0, Size offsetDst=0)
	Multiply two buffers. More...

void	multiply (T value)
	Mutliplies the content of the buffer with a constant. More...

void	add (T value)
	Adds a constant to the contents of the buffer. More...

bool	inject (T *mem, const Size size, const uchar channels)
	Inject forgeign memory to be used by the buffer. More...

bool	inject (const T *mem, const Size size, const uchar channels)
	Inject const forgeign memory to be used by the buffer. More...

uchar	channels () const
	Returns the amount of channels. More...

Size	size () const
	Returns the allocated length of the buffer. More...

Size	validSize () const
	Returns the length of actually valid audio in the buffer. More...

void	setValidSize (const Size v)
	Set the amount of valid samples currently in the buffer This is mostly a convenience flag since the actual size of the buffer may be larger. More...

T *	get (const uchar channel)

const T *	get (const uchar channel) const

const T *	operator[] (const uchar channel) const

T *	operator[] (const uchar channel)

void	getRaw (T **put)
	Fills an 2d array of size maxChannels() with pointers to each channel. More...

void	getRaw (const T **put) const
	Fills an 2d array of size maxChannels() with pointers to each channel. More...

template<typename T2 >
Size	put (T2 *target, Size length=0, const uchar channel=0, const Size offset=0) const
	Fill the provided array with the contents of this buffer. More...

template<typename T2 >
Size	put (T2 **target, const Size length=0, uchar channels=0, const Size offset=0) const
	Fill the provided 2D array with the contents of this buffer. More...

template<typename T2 >
Size	putInterleaved (T2 *buffer, Size length=0, const Size offset=0) const
	Puts the interleaved contents in the target buffer. More...

Static Public Member Functions
template<typename T2 >
static constexpr bool	needsScaling ()
	Figure out if conversions between types like float -> int or int -> short need scaling applied. More...

template<typename T1 , typename T2 , typename Ratio = float>
static constexpr Ratio	getConversionScale ()
	calculate the scale factor needed between the types More...

Public Attributes
ushort	sampleRate = 0
	Only relevant for resampling and oversampling. More...

Static Public Attributes
static constexpr Size	Stride = xsimd::simd_type<T>::size

Private Member Functions
void	assertOnConstMem ()

Private Attributes
Storage	mBuffer

Size	mValidSize = 0

uchar	mChannels = 0

Detailed Description

template<typename T, class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>
class tklb::AudioBufferTpl< T, STORAGE >

Class for handling the most basic audio needs.

Does convenient type conversions TODO check if using a single buffer instead of one for each channel improves performance

Template Parameters

T	Sample type. Can be anything std::is_arithmetic
STORAGE	Storage type, tklb::HeapBuffer for now since there are a few things missing in a std::vector

Definition at line 36 of file TAudioBuffer.hpp.

Member Typedef Documentation

◆ Sample

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

using tklb::AudioBufferTpl< T, STORAGE >::Sample = T

Definition at line 39 of file TAudioBuffer.hpp.

◆ Size

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

using tklb::AudioBufferTpl< T, STORAGE >::Size = typename Storage::Size

Definition at line 44 of file TAudioBuffer.hpp.

◆ Storage

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

using tklb::AudioBufferTpl< T, STORAGE >::Storage = STORAGE

Definition at line 40 of file TAudioBuffer.hpp.

◆ uchar

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

using tklb::AudioBufferTpl< T, STORAGE >::uchar = unsigned char

Definition at line 41 of file TAudioBuffer.hpp.

◆ uint

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

using tklb::AudioBufferTpl< T, STORAGE >::uint = unsigned int

Definition at line 43 of file TAudioBuffer.hpp.

◆ ushort

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

using tklb::AudioBufferTpl< T, STORAGE >::ushort = unsigned short

Definition at line 42 of file TAudioBuffer.hpp.

Constructor & Destructor Documentation

◆ AudioBufferTpl() [1/5]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

tklb::AudioBufferTpl< T, STORAGE >::AudioBufferTpl ( )

inline

Empty buffer with no memory allocated yet.

Definition at line 65 of file TAudioBuffer.hpp.

65{ }

◆ AudioBufferTpl() [2/5]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

tklb::AudioBufferTpl< T, STORAGE >::AudioBufferTpl	(	const Size	length,
		const uchar	channels
	)

inline

Buffer with memory allocated.

Definition at line 70 of file TAudioBuffer.hpp.

                                                                {
            resize(length, channels);
        }

Here is the call graph for this function:

◆ ~AudioBufferTpl()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

tklb::AudioBufferTpl< T, STORAGE >::~AudioBufferTpl ( )

inline

Definition at line 74 of file TAudioBuffer.hpp.

                          {
            TKLB_ASSERT_STATE(mChannels = 0;)
            TKLB_ASSERT_STATE(mValidSize = 0;)
        }

◆ AudioBufferTpl() [3/5]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

tklb::AudioBufferTpl< T, STORAGE >::AudioBufferTpl ( AudioBufferTpl< T, STORAGE > && source )

default

move contructor is implicitly deleted Don't know why

◆ AudioBufferTpl() [4/5]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

tklb::AudioBufferTpl< T, STORAGE >::AudioBufferTpl ( const AudioBufferTpl< T, STORAGE > & )

delete

◆ AudioBufferTpl() [5/5]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

tklb::AudioBufferTpl< T, STORAGE >::AudioBufferTpl ( const AudioBufferTpl< T, STORAGE > * )

delete

Member Function Documentation

◆ add() [1/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 , class STORAGE2 >

void tklb::AudioBufferTpl< T, STORAGE >::add	(	const AudioBufferTpl< T2, STORAGE2 > &	buffer,
		Size	length = `0`,
		Size	offsetSrc = `0`,
		Size	offsetDst = `0`
	)

inline

Add the provided buffer.

Parameters

buffer	Source buffer object
length	Samples to add from the source buffer
offsetSrc	Start offset in the source buffer
offsetDst	Start offset in the target buffer

Definition at line 318 of file TAudioBuffer.hpp.

          {
            TKLB_ASSERT(validSize() >= offsetDst)
            TKLB_ASSERT(buffer.validSize() >= offsetSrc)
            length = length == 0 ? buffer.validSize() - offsetSrc : length;
            length = std::min(buffer.validSize() - offsetSrc, validSize() - offsetDst);
            const uchar channelCount = std::min(buffer.channels(), channels());
 
            #ifndef TKLB_NO_SIMD
                if (std::is_same<T2, T>::value) {
                    const Size vectorize = length - (length % Stride);
                    for (uchar c = 0; c < channelCount; c++) {
                        T* out = get(c) + offsetDst;
                        const T* in = reinterpret_cast<const T*>(buffer[c]) + offsetSrc;
                        for(Size i = 0; i < vectorize; i += Stride) {
                            xsimd::simd_type<T> a = xsimd::load_aligned(in + i);
                            xsimd::simd_type<T> b = xsimd::load_aligned(out + i);
                            xsimd::store_aligned(out + i, (a + b));
                        }
                        for(Size i = vectorize; i < length; i++) {
                            out[i] += in[i];
                        }
                    }
                    return;
                }
            #endif
 
            // If the type doen't match or simd is diabled
            for (uchar c = 0; c < channelCount; c++) {
                T* out = get(c) + offsetDst;
                const T2* in = buffer[c] + offsetSrc;
                for(Size i = 0; i < length; i++) {
                    out[i] += in[i];
                }
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add() [2/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

void tklb::AudioBufferTpl< T, STORAGE >::add ( T value )

inline

Adds a constant to the contents of the buffer.

Parameters

value

Definition at line 441 of file TAudioBuffer.hpp.

                          {
            const Size length = validSize();
 
            #ifndef TKLB_NO_SIMD
                const Size vectorize = length - (length % Stride);
                for (uchar c = 0; c < channels(); c++) {
                    T* out = get(c);
                    for(Size i = 0; i < vectorize; i += Stride) {
                        xsimd::simd_type<T> b = xsimd::load_aligned(out + i);
                        xsimd::store_aligned(out + i, (b + value));
                    }
                    for(Size i = vectorize; i < length; i++) {
                        out[i] += value;
                    }
                }
            #else
                for (uchar c = 0; c < channels(); c++) {
                    T* out = get(c);
                    for(Size i = 0; i < length; i++) {
                        out[i] += value;
                    }
                }
            #endif
        }

Here is the call graph for this function:

◆ assertOnConstMem()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

void tklb::AudioBufferTpl< T, STORAGE >::assertOnConstMem ( )

inlineprivate

Definition at line 667 of file TAudioBuffer.hpp.

667{ T* data = mBuffer.data(); }

tklb::AudioBufferTpl::mBuffer

Storage mBuffer

Definition: TAudioBuffer.hpp:51

Here is the caller graph for this function:

◆ channels()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

uchar tklb::AudioBufferTpl< T, STORAGE >::channels ( ) const

inline

Returns the amount of channels.

Definition at line 505 of file TAudioBuffer.hpp.

505{ return mChannels; }

Here is the caller graph for this function:

◆ clone()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 , class STORAGE2 >

void tklb::AudioBufferTpl< T, STORAGE >::clone ( const AudioBufferTpl< T2, STORAGE2 > & buffer )

inline

Match the size of the provided buffer and copy the contents.

Definition at line 264 of file TAudioBuffer.hpp.

                                                               {
            resize(buffer);
            set(buffer);
        }

Here is the call graph for this function:

◆ get() [1/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

T * tklb::AudioBufferTpl< T, STORAGE >::get ( const uchar channel )

inline

Definition at line 529 of file TAudioBuffer.hpp.

                                           {
            TKLB_ASSERT(channel < mChannels)
            // We use the size of the buffer itself since this will result in aligned addresses
            return mBuffer.data() + (channel * (mBuffer.size() / mChannels));
        };

Here is the caller graph for this function:

◆ get() [2/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

const T * tklb::AudioBufferTpl< T, STORAGE >::get ( const uchar channel ) const

inline

Definition at line 535 of file TAudioBuffer.hpp.

                                                       {
            TKLB_ASSERT(channel < mChannels)
            return mBuffer.data() + (channel * (mBuffer.size() / mChannels));
        };

◆ getConversionScale()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T1 , typename T2 , typename Ratio = float>

static constexpr Ratio tklb::AudioBufferTpl< T, STORAGE >::getConversionScale ( )

inlinestaticconstexpr

calculate the scale factor needed between the types

Template Parameters

T1	Source type
T2	target type
Ratio	Floating point type since the value can be smaller than 1

Returns: constexpr Ratio

Definition at line 114 of file TAudioBuffer.hpp.

                                                    {
            const Ratio maxt = std::is_floating_point<T2>::value ?
                Ratio(1.0) : Ratio(std::numeric_limits<T2>::max()) - Ratio(1);
            const Ratio maxt2 = std::is_floating_point<T1>::value ?
                Ratio(1.0) : Ratio(std::numeric_limits<T1>::max()) - Ratio(1);
            return maxt / maxt2;
        }

Here is the call graph for this function:

◆ getRaw() [1/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

void tklb::AudioBufferTpl< T, STORAGE >::getRaw ( const T ** put ) const

inline

Fills an 2d array of size maxChannels() with pointers to each channel.

Parameters

put	Pointers go here

Definition at line 559 of file TAudioBuffer.hpp.

                                         {
            for (uchar c = 0; c < mChannels; c++) {
                put[c] = get(c);
            }
        }

Here is the call graph for this function:

◆ getRaw() [2/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

void tklb::AudioBufferTpl< T, STORAGE >::getRaw ( T ** put )

inline

Fills an 2d array of size maxChannels() with pointers to each channel.

Parameters

put	Pointers go here

Definition at line 548 of file TAudioBuffer.hpp.

                             {
            TKLB_ASSERT_STATE(assertOnConstMem())
            for (uchar c = 0; c < mChannels; c++) {
                put[c] = get(c);
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inject() [1/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

bool tklb::AudioBufferTpl< T, STORAGE >::inject	(	const T *	mem,
		const Size	size,
		const uchar	channels
	)

inline

Inject const forgeign memory to be used by the buffer.

Potentially dangerous but useful when splitting up channels for processing

Parameters

mem	Const memory (No type conversions here)
size	Size of the entire buffer
channels	How many channels are contained in mem

Definition at line 491 of file TAudioBuffer.hpp.

                                                                         {
            if (!mBuffer.isAligned(mem)) {
                TKLB_ASSERT(false)
                return false;
            }
            TKLB_ASSERT(size % channels == 0)
            mBuffer.inject(mem, size);
            mValidSize = size / channels;
            mChannels = channels;
        }

Here is the call graph for this function:

◆ inject() [2/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

bool tklb::AudioBufferTpl< T, STORAGE >::inject	(	T *	mem,
		const Size	size,
		const uchar	channels
	)

inline

Inject forgeign memory to be used by the buffer.

Potentially dangerous but useful when splitting up channels for processing

Parameters

mem	Modifiable memory (No type conversions here)
size	Size of the entire buffer
channels	How many channels are contained in mem

Definition at line 473 of file TAudioBuffer.hpp.

                                                                   {
            if (!mBuffer.isAligned(mem)) {
                TKLB_ASSERT(false)
                return false;
            }
            TKLB_ASSERT(size % channels == 0)
            mBuffer.inject(mem, size);
            mValidSize = size / channels;
            mChannels = channels;
        }

Here is the call graph for this function:

◆ multiply() [1/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 , class STORAGE2 >

void tklb::AudioBufferTpl< T, STORAGE >::multiply	(	const AudioBufferTpl< T2, STORAGE2 > &	buffer,
		Size	length = `0`,
		Size	offsetSrc = `0`,
		Size	offsetDst = `0`
	)

inline

Multiply two buffers.

Parameters

buffer	Source buffer object
length	Samples to multiply from the source buffer
offsetIn	Start offset in the source buffer
offset	Start offset in the target buffer

Definition at line 367 of file TAudioBuffer.hpp.

          {
            TKLB_ASSERT(validSize() >= offsetDst)
            TKLB_ASSERT(buffer.validSize() >= offsetSrc)
            length = length == 0 ? buffer.validSize() - offsetSrc : length;
            length = std::min(buffer.validSize() - offsetSrc, validSize() - offsetDst);
            const uchar channelsCount = std::min(buffer.channels(), channels());
 
            #ifndef TKLB_NO_SIMD
                if (std::is_same<T2, T>::value) {
                    const Size vectorize = length - (length % Stride);
                    for (uchar c = 0; c < channelsCount; c++) {
                        T* out = get(c) + offsetDst;
                        const T* in = reinterpret_cast<const T*>(buffer[c]) + offsetSrc;
                        for(Size i = 0; i < vectorize; i += Stride) {
                            xsimd::simd_type<T> a = xsimd::load_aligned(in + i);
                            xsimd::simd_type<T> b = xsimd::load_aligned(out + i);
                            xsimd::store_aligned(out + i, (a * b));
                        }
                        for(Size i = vectorize; i < length; i++) {
                            out[i] *= in[i];
                        }
                    }
                    return;
                }
            #endif
 
            // If the type doen't match or simd is diabled
            for (uchar c = 0; c < channelsCount; c++) {
                T* out = get(c) + offsetDst;
                const T2* in = buffer[c] + offsetSrc;
                for(Size i = 0; i < length; i++) {
                    out[i] *= in[i];
                }
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ multiply() [2/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

void tklb::AudioBufferTpl< T, STORAGE >::multiply ( T value )

inline

Mutliplies the content of the buffer with a constant.

Parameters

value Constant to multiply the buffer with

Definition at line 412 of file TAudioBuffer.hpp.

                               {
            const Size length = validSize();
 
            #ifndef TKLB_NO_SIMD
                const Size vectorize = length - (length % Stride);
                for (uchar c = 0; c < channels(); c++) {
                    T* out = get(c);
                    for(Size i = 0; i < vectorize; i += Stride) {
                        xsimd::simd_type<T> b = xsimd::load_aligned(out + i);
                        xsimd::store_aligned(out + i, (b * value));
                    }
                    for(Size i = vectorize; i < length; i++) {
                        out[i] *= value;
                    }
                }
            #else
                for (uchar c = 0; c < channels(); c++) {
                    T* out = get(c);
                    for(Size i = 0; i < length; i++) {
                        out[i] *= value;
                    }
                }
            #endif
        }

Here is the call graph for this function:

◆ needsScaling()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 >

static constexpr bool tklb::AudioBufferTpl< T, STORAGE >::needsScaling ( )

inlinestaticconstexpr

Figure out if conversions between types like float -> int or int -> short need scaling applied.

Template Parameters

T2	Other type compared to own type

Returns: true Scaling needs to be applied; false No scaling needs to be applied

See also: getConversionScale

Definition at line 99 of file TAudioBuffer.hpp.

                                             {
            if (std::is_floating_point<T>::value && std::is_floating_point<T2>::value) {
                return false;
            }
            return std::numeric_limits<T>::max() != std::numeric_limits<T2>::max();
        }

Here is the call graph for this function:

◆ operator=() [1/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

AudioBufferTpl & tklb::AudioBufferTpl< T, STORAGE >::operator= ( AudioBufferTpl< T, STORAGE > && source )

default

◆ operator=() [2/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

AudioBufferTpl & tklb::AudioBufferTpl< T, STORAGE >::operator= ( const AudioBufferTpl< T, STORAGE > & )

delete

◆ operator[]() [1/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

T * tklb::AudioBufferTpl< T, STORAGE >::operator[] ( const uchar channel )

inline

Definition at line 542 of file TAudioBuffer.hpp.

542{ return get(channel); }

Here is the call graph for this function:

◆ operator[]() [2/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

const T * tklb::AudioBufferTpl< T, STORAGE >::operator[] ( const uchar channel ) const

inline

Definition at line 540 of file TAudioBuffer.hpp.

540{ return get(channel); }

Here is the call graph for this function:

◆ put() [1/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 >

Size tklb::AudioBufferTpl< T, STORAGE >::put	(	T2 **	target,
		const Size	length = `0`,
		uchar	channels = `0`,
		const Size	offset = `0`
	)		const

inline

Fill the provided 2D array with the contents of this buffer.

Parameters

target	The array to fill
channels	How many channels there are in the target buffer
length	The length of the output

Returns: The amount of samples written, might be less than requested

Definition at line 612 of file TAudioBuffer.hpp.

                {
            static_assert(std::is_arithmetic<T2>::value, "Need arithmetic type.");
            Size res = 0;
            channels = (channels == 0) ? mChannels : channels;
            for (uchar c = 0; c < channels; c++) {
                res = put(target[c], length, c, offset);
            }
            return res;
        }

Here is the call graph for this function:

◆ put() [2/2]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 >

Size tklb::AudioBufferTpl< T, STORAGE >::put	(	T2 *	target,
		Size	length = `0`,
		const uchar	channel = `0`,
		const Size	offset = `0`
	)		const

inline

Fill the provided array with the contents of this buffer.

Parameters

target	The arry to fill
channel	Which source channel to use
length	The length of the output
offset	Start offset in the source (this) buffer

Returns: The amount of samples written, might be less than requested

Definition at line 574 of file TAudioBuffer.hpp.

                {
            static_assert(std::is_arithmetic<T2>::value, "Need arithmetic type.");
            if (mChannels <= channel) { return 0; }
            const Size valid = validSize();
            TKLB_ASSERT(offset <= valid)
            length = length == 0 ? valid : length;
            length = std::min(length, valid - offset);
            const T2* source = get(channel) + offset;
            if (std::is_same<T2, T>::value) {
                memory::copy(target, source, sizeof(T) * length);
            } else {
                if (!needsScaling<T2>()) {
                    for (Size i = 0; i < length; i++) {
                        target[i] = T2(source[i]);
                    }
                } else {
                    constexpr auto scale = getConversionScale<T, T2>();
                    for (Size i = 0; i < length; i++) {
                        target[i] = T2(source[i] * scale);
                    }
                }
            }
            return length;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ putInterleaved()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 >

Size tklb::AudioBufferTpl< T, STORAGE >::putInterleaved	(	T2 *	buffer,
		Size	length = `0`,
		const Size	offset = `0`
	)		const

inline

Puts the interleaved contents in the target buffer.

Parameters

buffer	The array to fill with interleaved audio
length	Number of frames to interleave (not the length of the interleaved buffer)
offset	Offset for the sourcebuffer (this)

Returns: Number of frames emitted

Definition at line 634 of file TAudioBuffer.hpp.

                {
            static_assert(std::is_arithmetic<T2>::value, "Need arithmetic type.");
            const Size valid = validSize();
            TKLB_ASSERT(offset <= valid)
            const uchar chan = channels();
            length = (length == 0) ? valid : length;
            length = std::min(valid - offset, length);
            Size out = 0;
            for (uchar c = 0; c < chan; c++) {
                Size j = c;
                const T* data = get(c);
                if (!needsScaling<T2>()) {
                    for (Size i = 0; i < length; i++) {
                        buffer[j] = T2(data[i + offset]);
                        j += chan;
                    }
                } else {
                    constexpr auto scale = getConversionScale<T, T2>();
                    for (Size i = 0; i < length; i++) {
                        buffer[j] = T2(data[i + offset] * scale);
                        j += chan;
                    }
                }
                out += length;
            }
            return out / Size(channels());
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resize() [1/3]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 , class STORAGE2 >

void tklb::AudioBufferTpl< T, STORAGE >::resize ( const AudioBufferTpl< T2, STORAGE2 > & buffer )

inline

Resize to match the provided buffer.

Definition at line 306 of file TAudioBuffer.hpp.

                                                                {
            resize(buffer.size(), buffer.channels());
        }

Here is the call graph for this function:

◆ resize() [2/3]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

void tklb::AudioBufferTpl< T, STORAGE >::resize ( const Size length )

inline

Resize to the provided length and keep the channelcount.

If the channel count was 0 it will assume 1 channel instead.

Parameters

length The desired length in samples. 0 will deallocate.

Definition at line 298 of file TAudioBuffer.hpp.

                                       {
            resize(length, std::max(uchar(1), mChannels));
        }

Here is the call graph for this function:

◆ resize() [3/3]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

bool tklb::AudioBufferTpl< T, STORAGE >::resize	(	const Size	length,
		uchar	channels
	)

inline

! Will not keep the contents! Resizes the buffer to the desired length and channel count.

If the validSize = 0 it will be set to the new size for convenience. The size reported back when calling size is can be larger if the data is aligned

Parameters

length	The desired length in Samples. 0 will deallocate.
channels	Desired channel count. 0 will deallocate.

Definition at line 276 of file TAudioBuffer.hpp.

                                                       {
            if (channels == mChannels && size() == length) { return true; }
            // We need to ensure each channel is aligned so we add some padding after each channel
            const auto elementAlign = mBuffer.closestChunkSize(length, mBuffer.Alignment / sizeof(T));
            mBuffer.resize(0); // deallocate so we don't copy old misaligned signal over
            mBuffer.resize(channels * elementAlign);
 
            mChannels = channels;
 
            if (mValidSize == 0) {
                mValidSize = length;
            } else {
                mValidSize = std::min(mValidSize, length);
            }
            return true;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set() [1/4]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 , class STORAGE2 >

void tklb::AudioBufferTpl< T, STORAGE >::set	(	const AudioBufferTpl< T2, STORAGE2 > &	buffer,
		Size	length = `0`,
		const Size	offsetSrc = `0`,
		const Size	offsetDst = `0`
	)

inline

Set from another buffer object, will not adjust size and channel count! Use clone() instead.

e.g. offset=10 and length=15 will copy 15 samples into the buffer starting at the 10th sample

Parameters

buffer	Source buffer object
length	Samples to copy in
offsetSrc	Start offset in the source buffer
offsetDst	Start offset in the target buffer

Definition at line 193 of file TAudioBuffer.hpp.

          {
            length = length == 0 ? buffer.validSize() : length;
            for (uchar c = 0; c < buffer.channels(); c++) {
                set(buffer[c] + offsetSrc, length, c, offsetDst);
            }
        }

Here is the call graph for this function:

◆ set() [2/4]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 >

void tklb::AudioBufferTpl< T, STORAGE >::set	(	const T2 *	samples,
		Size	length,
		const uchar	channel = `0`,
		const Size	offsetDst = `0`
	)

inline

Set a single channel from an array.

Parameters

samples	An Array containing the audio samples
length	Amount of sample to copy
channel	Channel index
offsetDst	The offset for the destination buffer (this)

Definition at line 130 of file TAudioBuffer.hpp.

          {
            static_assert(std::is_arithmetic<T2>::value, "Need arithmetic type.");
            if (mChannels <= channel) { return; }
            TKLB_ASSERT(size() >= offsetDst)
            length = std::min(length, size() - offsetDst);
            T* out = get(channel);
            if (std::is_same<T2, T>::value) {
                // Types are identical
                memory::copy(out + offsetDst, samples, sizeof(T) * length);
            } else {
                if (!needsScaling<T2>()) {
                    // Both floats means they need to be converted but not scaled
                    for (Size i = 0; i < length; i++) {
                        out[i + offsetDst] = static_cast<T>(samples[i]);
                    }
                } else {
                    // We also need to scale
                    // float -> int, int -> float, short -> int
                    constexpr auto scale = getConversionScale<T2, T>();
                    for (Size i = 0; i < length; i++) {
                        out[i + offsetDst] = static_cast<T>(samples[i] * scale);
                    }
                }
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set() [3/4]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

void tklb::AudioBufferTpl< T, STORAGE >::set	(	T	value = `0`,
		Size	length = `0`,
		const Size	offsetDst = `0`
	)

inline

Set the entire buffer to a constant value.

Parameters

value	Value to fill the buffer with
length	Samples to set. 0 Sets all
offsetDst	Start offset in the target buffer

Definition at line 211 of file TAudioBuffer.hpp.

          {
            TKLB_ASSERT(size() >= offsetDst)
            length = std::min(size() - offsetDst, length ? length : size());
            for (uchar c = 0; c < channels(); c++) {
                std::fill_n(get(c) + offsetDst, length, value);
            }
        }

Here is the call graph for this function:

◆ set() [4/4]

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 >

void tklb::AudioBufferTpl< T, STORAGE >::set	(	T2 **const	samples,
		const Size	length,
		const uchar	channels,
		const Size	offsetSrc = `0`,
		const Size	offsetDst = `0`
	)

inline

Set multiple channels from a 2D array.

Parameters

samples	A 2D Array containing the audio samples (float or double)
length	Samples to copy in (single channel)
channels	Channel count
offsetSrc	Offset in the source buffer
offsetDst	Offset in the destination buffer

Definition at line 170 of file TAudioBuffer.hpp.

          {
            static_assert(std::is_arithmetic<T2>::value, "Need arithmetic type.");
            for (uchar c = 0; c < channels; c++) {
                set(samples[c] + offsetSrc, length, c, offsetDst);
            }
        }

Here is the call graph for this function:

◆ setFromInterleaved()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

template<typename T2 >

void tklb::AudioBufferTpl< T, STORAGE >::setFromInterleaved	(	const T2 *	samples,
		Size	length,
		const uchar	channels,
		Size	offsetSrc = `0`,
		const Size	offsetDst = `0`
	)

inline

Set multiple channels from an interleaved array.

Parameters

samples	A 1D Array containing the interleaved audio samples (float or double)
length	The length of a single channel
channels	Channel count
offsetSrc	Start offset in the source buffer
offsetDst	Start offset in the target buffer

Definition at line 232 of file TAudioBuffer.hpp.

          {
            static_assert(std::is_arithmetic<T2>::value, "Need arithmetic type.");
            TKLB_ASSERT(size() >= offsetDst)
            length = std::min(size() - offsetDst, length);
            offsetSrc *= channels;
            for (uchar c = 0; c < std::min(channels, mChannels); c++) {
                T* out = get(c);
                if (!needsScaling<T2>()) {
                    for(Size i = 0, j = c + offsetSrc; i < length; i++, j+= channels) {
                        out[i + offsetDst] = static_cast<T>(samples[j]);
                    }
                } else {
                    constexpr auto scale = getConversionScale<T2, T>();
                    for(Size i = 0, j = c + offsetSrc; i < length; i++, j+= channels) {
                        out[i + offsetDst] = static_cast<T>(samples[j] * scale);
                    }
                }
            }
            mValidSize = length;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setValidSize()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

void tklb::AudioBufferTpl< T, STORAGE >::setValidSize ( const Size v )

inline

Set the amount of valid samples currently in the buffer This is mostly a convenience flag since the actual size of the buffer may be larger.

Definition at line 524 of file TAudioBuffer.hpp.

                                        {
            TKLB_ASSERT(v <= size());
            mValidSize = std::min(size(), v);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ size()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

Size tklb::AudioBufferTpl< T, STORAGE >::size ( ) const

inline

Returns the allocated length of the buffer.

Definition at line 510 of file TAudioBuffer.hpp.

                                 {
            return mBuffer.empty() ? 0 : mBuffer.size() / mChannels;
        }

Here is the caller graph for this function:

◆ validSize()

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

Size tklb::AudioBufferTpl< T, STORAGE >::validSize ( ) const

inline

Returns the length of actually valid audio in the buffer.

TODO tklb make sure this is used consistently

Definition at line 518 of file TAudioBuffer.hpp.

518{ return mValidSize; }

Here is the caller graph for this function:

Member Data Documentation

◆ mBuffer

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

Storage tklb::AudioBufferTpl< T, STORAGE >::mBuffer

private

Definition at line 51 of file TAudioBuffer.hpp.

◆ mChannels

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

uchar tklb::AudioBufferTpl< T, STORAGE >::mChannels = 0

private

Definition at line 53 of file TAudioBuffer.hpp.

◆ mValidSize

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

Size tklb::AudioBufferTpl< T, STORAGE >::mValidSize = 0

private

Definition at line 52 of file TAudioBuffer.hpp.

◆ sampleRate

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

ushort tklb::AudioBufferTpl< T, STORAGE >::sampleRate = 0

Only relevant for resampling and oversampling.

TODO higher sample rates wont work, maybe use enum

Definition at line 60 of file TAudioBuffer.hpp.

◆ Stride

template<typename T , class STORAGE = HeapBuffer<T, DEFAULT_ALIGNMENT>>

constexpr Size tklb::AudioBufferTpl< T, STORAGE >::Stride = xsimd::simd_type<T>::size

staticconstexpr

Definition at line 47 of file TAudioBuffer.hpp.

The documentation for this class was generated from the following file:

TAudioBuffer.hpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Sample

◆ Size

◆ Storage

◆ uchar

◆ uint

◆ ushort

Constructor & Destructor Documentation

◆ AudioBufferTpl() [1/5]

◆ AudioBufferTpl() [2/5]

◆ ~AudioBufferTpl()

◆ AudioBufferTpl() [3/5]

◆ AudioBufferTpl() [4/5]

◆ AudioBufferTpl() [5/5]

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ assertOnConstMem()

◆ channels()

◆ clone()

◆ get() [1/2]

◆ get() [2/2]

◆ getConversionScale()

◆ getRaw() [1/2]

◆ getRaw() [2/2]

◆ inject() [1/2]

◆ inject() [2/2]

◆ multiply() [1/2]

◆ multiply() [2/2]

◆ needsScaling()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ put() [1/2]

◆ put() [2/2]

◆ putInterleaved()

◆ resize() [1/3]

◆ resize() [2/3]

◆ resize() [3/3]

◆ set() [1/4]

◆ set() [2/4]

◆ set() [3/4]

◆ set() [4/4]

◆ setFromInterleaved()

◆ setValidSize()

◆ size()

◆ validSize()

Member Data Documentation

◆ mBuffer

◆ mChannels

◆ mValidSize

◆ sampleRate

◆ Stride