QAudioSink¶

The QAudioSink class provides an interface for sending audio data to an audio output device. More…

Synopsis¶

Functions¶

def bufferSize ()
def bytesFree ()
def elapsedUSecs ()
def error ()
def format ()
def isNull ()
def processedUSecs ()
def reset ()
def resume ()
def setBufferSize (bytes)
def setVolume (arg__1)
def start ()
def start (device)
def state ()
def stop ()
def suspend ()
def volume ()

Signals¶

def stateChanged (state)

Detailed Description¶

You can construct an audio output with the system’s default audio output device. It is also possible to create QAudioSink with a specific QAudioDevice . When you create the audio output, you should also send in the QAudioFormat to be used for the playback (see the QAudioFormat class description for details).

To play a file:

Starting to play an audio stream is simply a matter of calling start() with a QIODevice . QAudioSink will then fetch the data it needs from the io device. So playing back an audio file is as simple as:

sourceFile = QFile()
QAudioSink* audio # class member.        sourceFile.setFileName("/tmp/test.raw")
sourceFile.open(QIODevice.ReadOnly)
format = QAudioFormat()
# Set up the format, eg.
format.setSampleRate(8000)
format.setChannelCount(1)
format.setSampleFormat(QAudioFormat.UInt8)
info = QAudioDevice(QAudioDevice.defaultOutputDevice())
if (not info.isFormatSupported(format)) {
    qWarning() << "Raw audio format not supported by backend, cannot play audio."
    return

audio = QAudioSink(format, self)
connect(audio, SIGNAL(stateChanged(QAudio.State)), self, SLOT(handleStateChanged(QAudio.State)))
audio.start(sourceFile)

The file will start playing assuming that the audio system and output device support it. If you run out of luck, check what’s up with the error() function.

After the file has finished playing, we need to stop the device:

def handleStateChanged(self, newState):

    switch (newState) {
        QAudio.IdleState: = case()
            # Finished playing (no more data)
            audio.stop()
            sourceFile.close()
            del audio
            break
        QAudio.StoppedState: = case()
            # Stopped for other reasons
            if (audio.error() != QAudio.NoError) {
                # Error handling

            break
        default:
            # ... other cases as appropriate
            break

At any given time, the QAudioSink will be in one of four states: active, suspended, stopped, or idle. These states are described by the State enum. State changes are reported through the stateChanged() signal. You can use this signal to, for instance, update the GUI of the application; the mundane example here being changing the state of a play/pause button. You request a state change directly with suspend() , stop() , reset() , resume() , and start() .

If an error occurs, you can fetch the error type with the error() function. Please see the Error enum for a description of the possible errors that are reported. When an error is encountered, the state changes to StoppedState . You can check for errors by connecting to the stateChanged() signal:

def handleStateChanged(self, newState):

    switch (newState) {
        QAudio.IdleState: = case()
            # Finished playing (no more data)
            audio.stop()
            sourceFile.close()
            del audio
            break
        QAudio.StoppedState: = case()
            # Stopped for other reasons
            if (audio.error() != QAudio.NoError) {
                # Error handling

            break
        default:
            # ... other cases as appropriate
            break

Table of Contents

Previous topic

Next topic