tklb::ogg Namespace Reference

Functions
template<typename T , class Buffer = AudioBufferTpl<T>>
bool	load (const char *path, Buffer &out, typename Buffer::Size length=0)
	Decode ogg/vorbis from memory or file path. More...

Function Documentation

load()

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

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

Decode ogg/vorbis 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 28 of file TOggFile.hpp.

                                                                                 {
            using Size = typename Buffer::Size;
            using uchar = unsigned char;
            using ushort = unsigned short;
 
            stb_vorbis* vorbis;
            int error = 0;
            if (length == 0) {
            #ifndef TKLB_NO_STDIO
                vorbis = stb_vorbis_open_filename(path, &error, nullptr);
            #else
                return false;
            #endif
            } else {
                vorbis = stb_vorbis_open_memory(
                    reinterpret_cast<const unsigned char*>(path), length, &error, nullptr
                );
            }
 
            if (error != VORBIS__no_error) {
                stb_vorbis_close(vorbis);
                return false;
            }
 
            const stb_vorbis_info info = stb_vorbis_get_info(vorbis);
            const Size streamLength = stb_vorbis_stream_length_in_samples(vorbis);
 
 
            out.sampleRate = info.sample_rate;
            out.resize(streamLength, Size(info.channels)); // will fail at channels higher than allowed
 
            if (std::is_same<float, T>::value) {
                HeapBuffer<T*> buffer;
                buffer.resize(info.channels);
                out.getRaw(buffer.data());
                // seems evil but where only here if it's alredy a float**
                float** fbuf = reinterpret_cast<float**>(buffer.data());
                Size got = stb_vorbis_get_samples_float(
                    vorbis, info.channels, fbuf, streamLength
                );
                out.setValidSize(got);
                stb_vorbis_close(vorbis);
                return got == streamLength;
            }
 
            Size read = 0;
 
            int channels = info.channels;
            float** bufferPtr = nullptr;
            while (read < streamLength) {
                Size got = stb_vorbis_get_frame_float(vorbis, &channels, &bufferPtr);
                out.set(bufferPtr, got, channels, 0, read);
                read += got;
            }
 
            out.setValidSize(read);
 
            stb_vorbis_close(vorbis);
 
            if (read == 0) {
                return false;
            }
 
            return true;
        }

Here is the call graph for this function: