tklb::wave Namespace Reference

Namespaces
namespace	_
	redirects malloc for drwav, not really needed since loading and saving wavs doesn't seem to allocate anything on the heap

Classes
struct	WaveOptions
	Small option struct to save wave files. More...

Functions
template<typename T , class Buffer = AudioBufferTpl<T>>
bool	load (const char *path, Buffer &out, typename Buffer::Size length=0)
	Decode wav from memory or file path. More...
template<typename T , class Buffer = AudioBufferTpl<T>>
bool	write (const Buffer &in, const char *path, const WaveOptions &&options={}, HeapBuffer< char > *out=nullptr)
	Write audiobuffer to file or memory. More...

Function Documentation

load()

template<typename T , class Buffer = AudioBufferTpl<T>>

bool tklb::wave::load	(	const char *	path,
		Buffer &	out,
		typename Buffer::Size	length = 0
	)

Decode wav from memory or file path.

Parameters

path	The path or the wav file buffer if length is non 0
out	The buffer to store the result in
length	The length of the wav file buffer if not reading from file

Definition at line 37 of file TWaveFile.hpp.

                                                                                 {
            drwav_allocation_callbacks drwaveCallbacks {
                nullptr,        // No userdata
                &_::drwaveMalloc,
                nullptr,        // TODO tklb test and add the realloc
                &_::drwaveFree
            };
 
            using Size = typename Buffer::Size;
            using uchar = unsigned char;
            using ushort = unsigned short;
 
            drwav wav;
            if (length == 0) {
            #ifndef TKLB_NO_STDIO
                if (!drwav_init_file(&wav, path, &drwaveCallbacks)) {
                    return false;
                }
            #else
                return false;
            #endif
            } else {
                if (!drwav_init_memory(&wav, path, length, &drwaveCallbacks)) {
                    return false;
                }
            }
            constexpr Size chunkSize = 128;
            Size read = 0;
            HeapBuffer<float> chunkBuffer;
            chunkBuffer.resize(chunkSize * wav.channels);
 
            out.sampleRate = wav.sampleRate;
            out.resize(Size(wav.totalPCMFrameCount), Size(wav.channels));
 
            while (read < wav.totalPCMFrameCount) {
                auto got = Size(drwav_read_pcm_frames_f32(&wav, chunkSize, chunkBuffer.data()));
                out.setFromInterleaved(chunkBuffer.data(), got, uchar(wav.channels), 0, read);
                read += got;
            }
 
            if (read == 0) {
                return false;
            }
 
            out.setValidSize(read);
            drwav_uninit(&wav);
            return true;
        }

Here is the call graph for this function:

write()

template<typename T , class Buffer = AudioBufferTpl<T>>

bool tklb::wave::write	(	const Buffer &	in,
		const char *	path,
		const WaveOptions &&	options = {},
		HeapBuffer< char > *	out = nullptr
	)

Write audiobuffer to file or memory.

Definition at line 114 of file TWaveFile.hpp.

                                          {},
            HeapBuffer<char>* out = nullptr
        ) {
            drwav_allocation_callbacks drwaveCallbacks {
                nullptr,        // No userdata
                &_::drwaveMalloc,
                nullptr,        // TODO tklb test and add the realloc
                &_::drwaveFree
            };
            drwav wav;
 
            using Size = typename Buffer::Size;
 
            drwav_data_format droptions;
            TKLB_ASSERT(in.sampleRate != 0) // Set a samplerate
            droptions.sampleRate = in.sampleRate;
            droptions.channels = in.channels();
            droptions.bitsPerSample = options.bitsPerSample;
            droptions.format = options.format;
            droptions.container = drwav_container(options.container);
 
            size_t outSize = 0;
            void* memory = nullptr;
            if (out == nullptr) { // write to file
            #ifndef TKLB_NO_STDIO
                if (!drwav_init_file_write(&wav, path, &droptions, &drwaveCallbacks)) {
                    return false;
                }
            #else
                return false;
            #endif
            } else {
                if (!drwav_init_memory_write(&wav, &memory, &outSize, &droptions, &drwaveCallbacks)) {
                    return false;
                }
            }
 
            Size written = 0;
            constexpr Size chunkSize = 128;
            const Size frames = in.validSize();
 
            switch (options.format) {
            case WaveOptions::Format::IEEE_FLOAT:
                {
                    // TODO benchmark against aligned heapbuffer
                    auto interleaved = new float[chunkSize * in.channels()];
                    while (written < frames) {
                        auto remaining = in.putInterleaved(interleaved, chunkSize, written);
                        written += Size(drwav_write_pcm_frames(&wav, remaining, interleaved));
                    }
                    delete[] interleaved;
                }
                break;
            case WaveOptions::Format::PCM:
                {
                    // TODO benchmark against aligned heapbuffer
                    auto interleaved = new short[chunkSize * in.channels()];
                    while (written < frames) {
                        auto read = in.putInterleaved(interleaved, chunkSize, written);
                        written += Size(drwav_write_pcm_frames(&wav, read, interleaved));
                    }
                    delete[] interleaved;
                }
                break;
            default:
                TKLB_ASSERT(false) return false;
            }
 
            drwav_uninit(&wav);
 
            if (out != nullptr) {
                out->set(reinterpret_cast<char*>(memory), Size(outSize));
            }
 
            return true;
        }