vae::core::DeviceRtaudio Class Reference

#include <vae_rtaudio.hpp>

Inheritance diagram for vae::core::DeviceRtaudio:

Collaboration diagram for vae::core::DeviceRtaudio:

Public Member Functions
	DeviceRtaudio (Backend &backend, const EngineConfig &config)
	~DeviceRtaudio ()
bool	openDevice (DeviceInfo &device) override
	Opens a specific audio device. More...
bool	closeDevice () override
	Closes the currently open device. More...
Public Member Functions inherited from vae::core::Device
	Device (Backend &backend, const EngineConfig &config)
	Only a Backend can construct a Device. More...
virtual	~Device ()
void	setCallback (Callback callback)
virtual bool	openDevice (bool input=false)
	Tries to open the default audio device whith desired in out channels. More...
Size	push (const ScratchBuffer &buffer)
	Push samples to the audio device. More...
Size	canPush () const
	Return amount of audio frames which can be pushed in buffer ! this is an estimate when resampling ! More...
void	pop (ScratchBuffer &buffer)
	Get samples form audio device. More...
Size	canPop () const
Size	getChannelsOut () const
Size	getChannelsIn () const
Size	getSampleRate () const
	Get the sample rate. More...
Size	getRealSampleRate () const
	Get the Real Sample Rate before resampling. More...
size_t	getStreamTime () const
Size	getOverruns () const
Size	getUnderruns () const

Private Member Functions
bool	cleanUp ()

Static Private Member Functions
static int	AudioCallback (void *out, void *in, unsigned int frames, double streamTime, RtAudioStreamStatus status, void *data)
	Function called from the RtAudio thread. More...

Private Attributes
RtAudio	mAudio

Additional Inherited Members
Public Types inherited from vae::core::Device
using	Resampler = tklb::ResamplerTpl< Sample, ScratchBuffer >
Protected Types inherited from vae::core::Device
using	Callback = tklb::Delegate< void(Device *)>
Protected Member Functions inherited from vae::core::Device
void	init (Size sampleRate, Uchar channelsIn, Uchar channelsOut, Size bufferSize)
	initializes buffers, queues and resamplers if needed Has to be called in openDevice once the samplerate and channel config is known More...
void	postInit ()
Protected Attributes inherited from vae::core::Device
Backend &	mBackend
const EngineConfig &	mConfig
Size	mSampleRate = 0
Size	mRealSampleRate = 0
Size	mOverruns = 0
Size	mUnderruns = 0
Resampler	mResamplerToDevice
ScratchBuffer	mResamplerBufferToDevice
AudioThreadWorker	mWorker
Static Protected Attributes inherited from vae::core::Device
static constexpr int	_VAE_WORKER_SIZE = sizeof(AudioThreadWorker)

Detailed Description

Definition at line 12 of file vae_rtaudio.hpp.

Constructor & Destructor Documentation

DeviceRtaudio()

vae::core::DeviceRtaudio::DeviceRtaudio ( Backend &  backend, const EngineConfig &  config  )

inline

Definition at line 50 of file vae_rtaudio.hpp.

          : Device(backend, config) { };

~DeviceRtaudio()

vae::core::DeviceRtaudio::~DeviceRtaudio ( )

inline

Definition at line 54 of file vae_rtaudio.hpp.

                         {
            cleanUp();
        }

Here is the call graph for this function:

Member Function Documentation

AudioCallback()

static int vae::core::DeviceRtaudio::AudioCallback ( void *  out, void *  in, unsigned int  frames, double  streamTime, RtAudioStreamStatus  status, void *  data  )

inlinestaticprivate

Function called from the RtAudio thread.

Definition at line 35 of file vae_rtaudio.hpp.

          {
            (void) streamTime;  // Prevent unused variable warnings.
            (void) status;      // Prevent unused variable warnings.
            auto inFloat = static_cast<const float*>(in);
            auto outFloat = static_cast<float*>(out);
            static_cast<AudioThreadWorker*>(data)
                ->swapBufferInterleaved(inFloat, outFloat, frames);
            return 0;
        }

Here is the caller graph for this function:

cleanUp()

bool vae::core::DeviceRtaudio::cleanUp ( )

inlineprivate

Definition at line 15 of file vae_rtaudio.hpp.

                       {
            VAE_PROFILER_SCOPE_NAMED("Cleanup RtAudio")
            if (mAudio.isStreamRunning()) {
                VAE_PROFILER_SCOPE_NAMED("Stop RtAudio Stream")
                auto result = mAudio.stopStream();
                if (result != RTAUDIO_NO_ERROR) {
                    VAE_ASSERT(false)
                    return false;
                }
            }
            if (mAudio.isStreamOpen()) {
                VAE_PROFILER_SCOPE_NAMED("Close RtAudio Stream")
                mAudio.closeStream();
            }
            return true;
        }

Here is the caller graph for this function:

closeDevice()

bool vae::core::DeviceRtaudio::closeDevice ( )

inlineoverridevirtual

Closes the currently open device.

Otherwise does nothing.

Implements vae::core::Device.

Definition at line 114 of file vae_rtaudio.hpp.

{ return cleanUp(); }

Here is the call graph for this function:

openDevice()

bool vae::core::DeviceRtaudio::openDevice ( DeviceInfo &  device )

inlineoverridevirtual

Opens a specific audio device.

The device struct may be altered to match the actual hardware. (sampleRate, bufferSize and channel count)

Implements vae::core::Device.

Definition at line 58 of file vae_rtaudio.hpp.

                                                     {
            if (mBackend.getDeviceCount() < Size(device.id)) {
                VAE_ERROR("Failed to open deivce with index out of bounds")
                return false;
            }
            device.channelsIn = tklb::clamp<int>(device.channelsIn, 0, StaticConfig::MaxChannels);
            device.channelsOut = tklb::clamp<int>(device.channelsOut, 0, StaticConfig::MaxChannels);
            RtAudio::StreamParameters inParams, outParams;
            inParams.deviceId = device.id;
            inParams.nChannels = device.channelsIn;
            outParams.deviceId = device.id;
            outParams.nChannels = device.channelsOut;
            if (device.bufferSize == 0) {
                device.bufferSize = mConfig.preferredBufferSize;
            }
 
            RtAudioErrorType result;
            {
                VAE_PROFILER_SCOPE_NAMED("Open RtAudio stream")
                result = mAudio.openStream(
                    outParams.nChannels ? &outParams : nullptr,
                    inParams.nChannels  ? &inParams  : nullptr,
                    RTAUDIO_FLOAT32, device.sampleRate,
                    &device.bufferSize, &AudioCallback, &mWorker
                );
            }
 
            if (result != RTAUDIO_NO_ERROR) {
                VAE_ERROR("Failed to open RtAudio device with code %i", result)
                return false;
            }
 
            device.sampleRate = mAudio.getStreamSampleRate();
            device.channelsIn = inParams.nChannels;
            device.channelsOut = outParams.nChannels;
 
            init(
                device.sampleRate, device.channelsIn, device.channelsOut,
                device.bufferSize // RtAudio writes back to this on openStream
            );
            {
                VAE_PROFILER_SCOPE_NAMED("Start RtAudio stream")
                result = mAudio.startStream();
            }
 
            if (result != RTAUDIO_NO_ERROR) {
                VAE_ERROR("Failed to open RtAudio device with code %i", result)
                cleanUp();
                return false;
            }
 
            postInit();
 
            return true;
        }

Here is the call graph for this function:

Member Data Documentation

mAudio

RtAudio vae::core::DeviceRtaudio::mAudio

private

Definition at line 13 of file vae_rtaudio.hpp.

---

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

• vae_rtaudio.hpp