class QAudioSink#

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

Synopsis#

Methods#

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

Signals#

def stateChanged()

Note

This documentation may contain snippets that were automatically translated from C++ to Python. We always welcome contributions to the snippet translation. If you see an issue with the translation, you can also let us know by creating a ticket on https:/bugreports.qt.io/projects/PYSIDE

Detailed Description#

Warning

This section contains snippets that were automatically translated from C++ to Python and may contain errors.

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:

QFile sourceFile # class member.
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(QMediaDevices.defaultAudioOutput())
if not info.isFormatSupported(format):
    qWarning() << "Raw audio format not supported by backend, cannot play audio."
    return

audio = QAudioSink(format, self)
audio.connect(QAudioSink::stateChanged, self.handleStateChanged)
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 stopAudioOutput(self):

    audio.stop()
    sourceFile.close()
    del audio

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 UnderrunError is encountered, the state changes to IdleState , when another error is encountered, the state changes to StoppedState . You can check for errors by connecting to the stateChanged() signal:

def handleStateChanged(self, newState):


        if newState == QAudio.IdleState:
            # Finished playing (no more data)
            AudioOutputExample::stopAudioOutput()
            break
        elif newState == QAudio.StoppedState:
            # Stopped for other reasons
            if audio.error() != QAudio.NoError:
                # Error handling

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