The Synthesis ToolKit in C++ (STK)

Home Information Classes Download Usage Mail List Requirements Links FAQ Tutorial

Classes | Public Types | Public Member Functions | Static Public Member Functions | List of all members
RtAudio Class Reference

Realtime audio i/o C++ classes. More...

`#include <RtAudio.h>`

## Classes
struct | DeviceInfo
| The public device information structure for returning queried values. More...
struct | StreamOptions
| The structure for specifying stream options. More...
struct | StreamParameters
| The structure for specifying input or output stream parameters. More...

## Public Types
enum | Api { UNSPECIFIED , MACOSX_CORE , LINUX_ALSA , UNIX_JACK , LINUX_PULSE , LINUX_OSS , WINDOWS_ASIO , WINDOWS_WASAPI , WINDOWS_DS , RTAUDIO_DUMMY , NUM_APIS }
| Audio API specifier arguments. More...

## Public Member Functions
| RtAudio (RtAudio::Api api=UNSPECIFIED, RtAudioErrorCallback &&errorCallback=0)
| The class constructor.
| ~RtAudio ()
| The destructor.
RtAudio::Api | getCurrentApi (void)
| Returns the audio API specifier for the current instance of RtAudio.
unsigned int | getDeviceCount (void)
| A public function that queries for the number of audio devices available.
std::vector< unsigned int > | getDeviceIds (void)
| A public function that returns a vector of audio device IDs.
std::vector< std::string > | getDeviceNames (void)
| A public function that returns a vector of audio device names.
RtAudio::DeviceInfo | getDeviceInfo (unsigned int deviceId)
| Return an RtAudio::DeviceInfo structure for a specified device ID.
unsigned int | getDefaultOutputDevice (void)
| A function that returns the ID of the default output device.
unsigned int | getDefaultInputDevice (void)
| A function that returns the ID of the default input device.
RtAudioErrorType | openStream (RtAudio::StreamParameters *outputParameters, RtAudio::StreamParameters *inputParameters, RtAudioFormat format, unsigned int sampleRate, unsigned int *bufferFrames, RtAudioCallback callback, void *userData=NULL, RtAudio::StreamOptions *options=NULL)
| A public function for opening a stream with the specified parameters.
void | closeStream (void)
| A function that closes a stream and frees any associated stream memory.
RtAudioErrorType | startStream (void)
| A function that starts a stream.
RtAudioErrorType | stopStream (void)
| Stop a stream, allowing any samples remaining in the output queue to be played.
RtAudioErrorType | abortStream (void)
| Stop a stream, discarding any samples remaining in the input/output queue.
const std::string | getErrorText (void)
| Retrieve the error message corresponding to the last error or warning condition.
bool | isStreamOpen (void) const
| Returns true if a stream is open and false if not.
bool | isStreamRunning (void) const
| Returns true if the stream is running and false if it is stopped or not open.
double | getStreamTime (void)
| Returns the number of seconds of processed data since the stream was started.
void | setStreamTime (double time)
| Set the stream time to a time in seconds greater than or equal to 0.0.
long | getStreamLatency (void)
| Returns the internal stream latency in sample frames.
unsigned int | getStreamSampleRate (void)
| Returns actual sample rate in use by the (open) stream.
void | setErrorCallback (RtAudioErrorCallback errorCallback)
| Set a client-defined function that will be invoked when an error or warning occurs.
void | showWarnings (bool value=true)
| Specify whether warning messages should be output or not.

## Static Public Member Functions
static std::string | getVersion (void)
| A static function to determine the current RtAudio version.
static void | getCompiledApi (std::vector< RtAudio::Api > &apis)
| A static function to determine the available compiled audio APIs.
static std::string | getApiName (RtAudio::Api api)
| Return the name of a specified compiled audio API.
static std::string | getApiDisplayName (RtAudio::Api api)
| Return the display name of a specified compiled audio API.
static RtAudio::Api | getCompiledApiByName (const std::string &name)
| Return the compiled audio API having the given name.
static RtAudio::Api | getCompiledApiByDisplayName (const std::string &name)
| Return the compiled audio API having the given display name.

## Detailed Description

Realtime audio i/o C++ classes.

RtAudio provides a common API (Application Programming Interface) for realtime audio input/output across Linux (native ALSA, Jack, and OSS), Macintosh OS X (CoreAudio and Jack), and Windows (DirectSound, ASIO and WASAPI) operating systems.

RtAudio GitHub site: https://github.com/thestk/rtaudio RtAudio WWW site: http://www.music.mcgill.ca/~gary/rtaudio/

RtAudio: realtime audio i/o C++ classes Copyright (c) 2001-2023 Gary P. Scavone

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Any person wishing to distribute modifications to the Software is asked to send the modifications to the original developer so that they can be incorporated into the canonical version. This is, however, not a binding provision of this license.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

## Member Enumeration Documentation

## ◆ Api

enum RtAudio::Api

Audio API specifier arguments.

Enumerator
UNSPECIFIED | Search for a working compiled API.
MACOSX_CORE | Macintosh OS-X Core Audio API.
LINUX_ALSA | The Advanced Linux Sound Architecture API.
UNIX_JACK | The Jack Low-Latency Audio Server API.
LINUX_PULSE | The Linux PulseAudio API.
LINUX_OSS | The Linux Open Sound System API.
WINDOWS_ASIO | The Steinberg Audio Stream I/O API.
WINDOWS_WASAPI | The Microsoft WASAPI API.
WINDOWS_DS | The Microsoft DirectSound API.
RTAUDIO_DUMMY | A compilable but non-functional API.
NUM_APIS | Number of values in this enum.

272 {
273 UNSPECIFIED,
274 MACOSX_CORE,
275 LINUX_ALSA,
276 UNIX_JACK,
277 LINUX_PULSE,
278 LINUX_OSS,
279 WINDOWS_ASIO,
280 WINDOWS_WASAPI,
281 WINDOWS_DS,
282 RTAUDIO_DUMMY,
283 NUM_APIS
284 };
RtAudio::WINDOWS_ASIO
@ WINDOWS_ASIO
Definition RtAudio.h:279
RtAudio::WINDOWS_DS
@ WINDOWS_DS
Definition RtAudio.h:281
RtAudio::LINUX_OSS
@ LINUX_OSS
Definition RtAudio.h:278
RtAudio::UNIX_JACK
@ UNIX_JACK
Definition RtAudio.h:276
RtAudio::MACOSX_CORE
@ MACOSX_CORE
Definition RtAudio.h:274
RtAudio::UNSPECIFIED
@ UNSPECIFIED
Definition RtAudio.h:273
RtAudio::LINUX_ALSA
@ LINUX_ALSA
Definition RtAudio.h:275
RtAudio::NUM_APIS
@ NUM_APIS
Definition RtAudio.h:283
RtAudio::RTAUDIO_DUMMY
@ RTAUDIO_DUMMY
Definition RtAudio.h:282
RtAudio::WINDOWS_WASAPI
@ WINDOWS_WASAPI
Definition RtAudio.h:280
RtAudio::LINUX_PULSE
@ LINUX_PULSE
Definition RtAudio.h:277

## Constructor & Destructor Documentation

## ◆ RtAudio()

RtAudio::RtAudio | ( | RtAudio::Api | api = `UNSPECIFIED`,
|  | RtAudioErrorCallback && | errorCallback = `0`
| ) |  |

The class constructor.

The constructor attempts to create an RtApi instance.

If an API argument is specified but that API has not been compiled, a warning is issued and an instance of an available API is created. If no compiled API is found, the routine will abort (though this should be impossible because RtDummy is the default if no API-specific preprocessor definition is provided to the compiler). If no API argument is specified and multiple API support has been compiled, the default order of use is JACK, ALSA, OSS (Linux systems) and ASIO, DS (Windows systems).

An optional errorCallback function can be specified to subsequently receive warning and error messages.

## ◆ ~RtAudio()

RtAudio::~RtAudio | ( |  | ) |

The destructor.

If a stream is running or open, it will be stopped and closed automatically.

## Member Function Documentation

## ◆ getCompiledApi()

static void RtAudio::getCompiledApi | ( | std::vector< RtAudio::Api > & | apis | ) |
| static

A static function to determine the available compiled audio APIs.

The values returned in the std::vector can be compared against the enumerated list values. Note that there can be more than one API compiled for certain operating systems.

## ◆ getApiName()

static std::string RtAudio::getApiName | ( | RtAudio::Api | api | ) |
| static

Return the name of a specified compiled audio API.

This obtains a short lower-case name used for identification purposes. This value is guaranteed to remain identical across library versions. If the API is unknown, this function will return the empty string.

## ◆ getApiDisplayName()

static std::string RtAudio::getApiDisplayName | ( | RtAudio::Api | api | ) |
| static

Return the display name of a specified compiled audio API.

This obtains a long name used for display purposes. If the API is unknown, this function will return the empty string.

## ◆ getCompiledApiByName()

static RtAudio::Api RtAudio::getCompiledApiByName | ( | const std::string & | name | ) |
| static

Return the compiled audio API having the given name.

A case insensitive comparison will check the specified name against the list of compiled APIs, and return the one that matches. On failure, the function returns UNSPECIFIED.

## ◆ getCompiledApiByDisplayName()

static RtAudio::Api RtAudio::getCompiledApiByDisplayName | ( | const std::string & | name | ) |
| static

Return the compiled audio API having the given display name.

A case sensitive comparison will check the specified display name against the list of compiled APIs, and return the one that matches. On failure, the function returns UNSPECIFIED.

## ◆ getDeviceCount()

unsigned int RtAudio::getDeviceCount | ( | void |  | ) |
| inline

A public function that queries for the number of audio devices available.

This function performs a system query of available devices each time it is called, thus supporting devices (dis)connected after instantiation. If a system error occurs during processing, a warning will be issued.

910{ return rtapi_->getDeviceCount(); }

## ◆ getDeviceIds()

std::vector< unsigned int > RtAudio::getDeviceIds | ( | void |  | ) |
| inline

A public function that returns a vector of audio device IDs.

The ID values returned by this function are used internally by RtAudio to identify a given device. The values themselves are arbitrary and do not correspond to device IDs used by the underlying API (nor are they index values). This function performs a system query of available devices each time it is called, thus supporting devices (dis)connected after instantiation. If no devices are available, the vector size will be zero. If a system error occurs during processing, a warning will be issued.

912{ return rtapi_->getDeviceIds(); }

## ◆ getDeviceNames()

std::vector< std::string > RtAudio::getDeviceNames | ( | void |  | ) |
| inline

A public function that returns a vector of audio device names.

This function performs a system query of available devices each time it is called, thus supporting devices (dis)connected after instantiation. If no devices are available, the vector size will be zero. If a system error occurs during processing, a warning will be issued.

913{ return rtapi_->getDeviceNames(); }

## ◆ getDeviceInfo()

RtAudio::DeviceInfo RtAudio::getDeviceInfo | ( | unsigned int | deviceId | ) |
| inline

Return an RtAudio::DeviceInfo structure for a specified device ID.

Any device ID returned by getDeviceIds() is valid, unless it has been removed between the call to getDevceIds() and this function. If an invalid argument is provided, an RTAUDIO_INVALID_USE will be passed to the user-provided errorCallback function (or otherwise printed to stderr) and all members of the returned RtAudio::DeviceInfo structure will be initialized to default, invalid values (ID = 0, empty name, ...). If the specified device is the current default input or output device, the corresponding "isDefault" member will have a value of "true".

911{ return rtapi_->getDeviceInfo( deviceId ); }

## ◆ getDefaultOutputDevice()

unsigned int RtAudio::getDefaultOutputDevice | ( | void |  | ) |
| inline

A function that returns the ID of the default output device.

If the underlying audio API does not provide a "default device", the first probed output device ID will be returned. If no devices are available, the return value will be 0 (which is an invalid device identifier).

915{ return rtapi_->getDefaultOutputDevice(); }

## ◆ getDefaultInputDevice()

unsigned int RtAudio::getDefaultInputDevice | ( | void |  | ) |
| inline

A function that returns the ID of the default input device.

If the underlying audio API does not provide a "default device", the first probed input device ID will be returned. If no devices are available, the return value will be 0 (which is an invalid device identifier).

914{ return rtapi_->getDefaultInputDevice(); }

## ◆ openStream()

RtAudioErrorType RtAudio::openStream | ( | RtAudio::StreamParameters * | outputParameters,
|  | RtAudio::StreamParameters * | inputParameters,
|  | RtAudioFormat | format,
|  | unsigned int | sampleRate,
|  | unsigned int * | bufferFrames,
|  | RtAudioCallback | callback,
|  | void * | userData = `NULL`,
|  | RtAudio::StreamOptions * | options = `NULL`
| ) |  |

A public function for opening a stream with the specified parameters.

An RTAUDIO_SYSTEM_ERROR is returned if a stream cannot be opened with the specified parameters or an error occurs during processing. An RTAUDIO_INVALID_USE is returned if a stream is already open or any invalid stream parameters are specified.

Parameters

  outputParameters | Specifies output stream parameters to use when opening a stream, including a device ID, number of channels, and starting channel number. For input-only streams, this argument should be NULL. The device ID is a value returned by getDeviceIds().
  inputParameters | Specifies input stream parameters to use when opening a stream, including a device ID, number of channels, and starting channel number. For output-only streams, this argument should be NULL. The device ID is a value returned by getDeviceIds().
  format | An RtAudioFormat specifying the desired sample data format.
  sampleRate | The desired sample rate (sample frames per second).
  bufferFrames | A pointer to a value indicating the desired internal buffer size in sample frames. The actual value used by the device is returned via the same pointer. A value of zero can be specified, in which case the lowest allowable value is determined.
  callback | A client-defined function that will be invoked when input data is available and/or output data is needed.
  userData | An optional pointer to data that can be accessed from within the callback function.
  options | An optional pointer to a structure containing various global stream options, including a list of OR'ed RtAudioStreamFlags and a suggested number of stream buffers that can be used to control stream latency. More buffers typically result in more robust performance, though at a cost of greater latency. If a value of zero is specified, a system-specific median value is chosen. If the RTAUDIO_MINIMIZE_LATENCY flag bit is set, the lowest allowable value is used. The actual value used is returned via the structure argument. The parameter is API dependent.

## ◆ closeStream()

void RtAudio::closeStream | ( | void |  | ) |
| inline

A function that closes a stream and frees any associated stream memory.

If a stream is not open, an RTAUDIO_WARNING will be passed to the user-provided errorCallback function (or otherwise printed to stderr).

916{ return rtapi_->closeStream(); }

## ◆ startStream()

RtAudioErrorType RtAudio::startStream | ( | void |  | ) |
| inline

A function that starts a stream.

An RTAUDIO_SYSTEM_ERROR is returned if an error occurs during processing. An RTAUDIO_WARNING is returned if a stream is not open or is already running.

917{ return rtapi_->startStream(); }

## ◆ stopStream()

RtAudioErrorType RtAudio::stopStream | ( | void |  | ) |
| inline

Stop a stream, allowing any samples remaining in the output queue to be played.

An RTAUDIO_SYSTEM_ERROR is returned if an error occurs during processing. An RTAUDIO_WARNING is returned if a stream is not open or is already stopped.

918{ return rtapi_->stopStream(); }

## ◆ abortStream()

RtAudioErrorType RtAudio::abortStream | ( | void |  | ) |
| inline

Stop a stream, discarding any samples remaining in the input/output queue.

An RTAUDIO_SYSTEM_ERROR is returned if an error occurs during processing. An RTAUDIO_WARNING is returned if a stream is not open or is already stopped.

919{ return rtapi_->abortStream(); }

## ◆ getErrorText()

const std::string RtAudio::getErrorText | ( | void |  | ) |
| inline

Retrieve the error message corresponding to the last error or warning condition.

This function can be used to get a detailed error message when a non-zero RtAudioErrorType is returned by a function. This is the same message sent to the user-provided errorCallback function.

920{ return rtapi_->getErrorText(); }

## ◆ getStreamTime()

double RtAudio::getStreamTime | ( | void |  | ) |
| inline

Returns the number of seconds of processed data since the stream was started.

The stream time is calculated from the number of sample frames processed by the underlying audio system, which will increment by units of the audio buffer size. It is not an absolute running time. If a stream is not open, the returned value may not be valid.

925{ return rtapi_->getStreamTime(); }

## ◆ getStreamLatency()

long RtAudio::getStreamLatency | ( | void |  | ) |
| inline

Returns the internal stream latency in sample frames.

The stream latency refers to delay in audio input and/or output caused by internal buffering by the audio system and/or hardware. For duplex streams, the returned value will represent the sum of the input and output latencies. If a stream is not open, the returned value will be invalid. If the API does not report latency, the return value will be zero.

923{ return rtapi_->getStreamLatency(); }

## ◆ getStreamSampleRate()

unsigned int RtAudio::getStreamSampleRate | ( | void |  | ) |
| inline

Returns actual sample rate in use by the (open) stream.

On some systems, the sample rate used may be slightly different than that specified in the stream parameters. If a stream is not open, a value of zero is returned.

924{ return rtapi_->getStreamSampleRate(); }

## ◆ showWarnings()

void RtAudio::showWarnings | ( | bool | value = `true` | ) |
| inline

Specify whether warning messages should be output or not.

The default behaviour is for warning messages to be output, either to a client-defined error callback function (if specified) or to stderr.

928{ rtapi_->showWarnings( value ); }

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

- RtAudio.h

The Synthesis ToolKit in C++ (STK)
©1995--2023 Perry R. Cook and Gary P. Scavone. All Rights Reserved.