Qt Audio in Linux and Windows: different behaviour

[janK]

I have an application (SDR type) where the software generates a nice stream of PCM audiosamples and the output is made audible using QAudio to the soundcard of the PC
The current version runs with Qt5, and I am in the transition from Qt5 to Qt

I have a version that runs fine under Linux, but - it is cross compiled - under Windows it does not generate sound and does not give error messages either
It should be possible to have it run under Windows, the audioOutput example from the Qt sourcetree runs both under Linux and Windows fine

The structure of the class, driving the output, is basic, it is a class in which an AudioSink and a IODevice are created and the incoming samples are stored in a large ringbuffer
Part of the code that is executed on a (re)start, where newDeviceIndex is just in index is the vector ith device descriptions. the format is stored in m_settings:

if (newDeviceIndex < 0)
           return;
        QAudioDevice currentDevice
                        = outputDevices. at (newDeviceIndex);
        fprintf (stderr, "going for %s\n",
                          currentDevice. description (). toLatin1 (). data ());
        m_audioSink     = new QAudioSink (currentDevice, m_settings);
 
        m_audioSink     -> setBufferSize (8 * 32768);
        connect (m_audioSink, &QAudioSink::stateChanged,
                 this, &Qt_Audio::state_changed);
//
//      and run off
        theIODevice     -> close ();
        delete theIODevice;
        theIODevice     = new Qt_AudioDevice (mr, &tempBuffer);
        theIODevice     -> start ();
        m_audioSink     -> start (theIODevice);
 
        QtAudio::Error err = m_audioSink -> error ();
        fprintf (stderr, "Errorcode %d\n", (int)(err));

if (newDeviceIndex < 0)
           return;
        QAudioDevice currentDevice
                        = outputDevices. at (newDeviceIndex);
        fprintf (stderr, "going for %s\n",
                          currentDevice. description (). toLatin1 (). data ());
        m_audioSink     = new QAudioSink (currentDevice, m_settings);

        m_audioSink     -> setBufferSize (8 * 32768);
        connect (m_audioSink, &QAudioSink::stateChanged,
                 this, &Qt_Audio::state_changed);
//
//      and run off
        theIODevice     -> close ();
        delete theIODevice;
        theIODevice     = new Qt_AudioDevice (mr, &tempBuffer);
        theIODevice     -> start ();
        m_audioSink     -> start (theIODevice);

        QtAudio::Error err = m_audioSink -> error ();
        fprintf (stderr, "Errorcode %d\n", (int)(err));

To copy to clipboard, switch view to plain text mode 

And the IODevice is the most simple one one can imagine

void    Qt_AudioDevice::start () {
        if (running. load ())
           return;
        bool b = open (QIODevice::ReadOnly);
        fprintf (stderr, "Opening QIODevice %s\n", b ? "ok" : "error");
        running. store (true);
}
 
//      we always return "maxSize" bytes
qint64  Qt_AudioDevice::readData (char* buffer, qint64 maxSize) {
qint64  amount = 0;
//      "maxSize" is the requested size in bytes
//      "amount" is in uint8_t's
        amount = Buffer -> getDataFromBuffer (buffer, maxSize);
 
        if (amount < maxSize) {
           for (int i = amount; i < maxSize; i ++)
              buffer [i] = (char)(0);
        }
 
        totalBytes_l    += amount;
        missedBytes_l   += maxSize - amount;
        return maxSize;
}

void    Qt_AudioDevice::start () {
        if (running. load ())
           return;
        bool b = open (QIODevice::ReadOnly);
        fprintf (stderr, "Opening QIODevice %s\n", b ? "ok" : "error");
        running. store (true);
}

//      we always return "maxSize" bytes
qint64  Qt_AudioDevice::readData (char* buffer, qint64 maxSize) {
qint64  amount = 0;
//      "maxSize" is the requested size in bytes
//      "amount" is in uint8_t's
        amount = Buffer -> getDataFromBuffer (buffer, maxSize);

        if (amount < maxSize) {
           for (int i = amount; i < maxSize; i ++)
              buffer [i] = (char)(0);
        }

        totalBytes_l    += amount;
        missedBytes_l   += maxSize - amount;
        return maxSize;
}

To copy to clipboard, switch view to plain text mode 

On a state change I print the state,
On Linux, the message is - after opening the device "activeState"
On windows, the message with opening is that opening was successfull and the state is "Idle"

Format is 48000, 2 channels and floats (bit I tried Int16 as well with the same result)

Any help would really be appreciated

Jan

[janK]

I simplified the code and made it into a small example with the same behaviour,
The "start" function now only reads

const QAudioDevice &defaultDevice =
                               QMediaDevices::defaultAudioOutput ();
        m_audioSink     = new QAudioSink (defaultDevice, m_settings);
        connect (m_audioSink, &QAudioSink::stateChanged,
                 this, &Qt_Audio::state_changed);
        theIODevice. start ();
        m_audioSink     -> start (&theIODevice);
        QtAudio::Error err = m_audioSink -> error ();
        fprintf (stderr, "Errorcode %d\n", (int)(err));

const QAudioDevice &defaultDevice =
                               QMediaDevices::defaultAudioOutput ();
        m_audioSink     = new QAudioSink (defaultDevice, m_settings);
        connect (m_audioSink, &QAudioSink::stateChanged,
                 this, &Qt_Audio::state_changed);
        theIODevice. start ();
        m_audioSink     -> start (&theIODevice);
        QtAudio::Error err = m_audioSink -> error ();
        fprintf (stderr, "Errorcode %d\n", (int)(err));

To copy to clipboard, switch view to plain text mode 

The behaviour is the same, in the example I just generate a tone of 600 Hz, and add per 100 msec a buffer
Under Linux the tone is OK, the status report tells the the AudioSink is active
Under Windows no errors, state is Idle, and the read function is NOT called

void    Qt_AudioDevice::start () {
        bool b = open (QIODevice::ReadOnly);
}
 
//      we always return "maxSize" bytes
qint64  Qt_AudioDevice::readData (char* buffer, qint64 maxSize) {
qint64  amount = 0;
static int64_t teller = 0;
        amount = Buffer -> getDataFromBuffer (buffer, maxSize);
        if (amount < maxSize) {
           for (int i = amount; i < maxSize; i ++)
              buffer [i] = (char)(0);
        }
 
        return maxSize;
}

void    Qt_AudioDevice::start () {
        bool b = open (QIODevice::ReadOnly);
}

//      we always return "maxSize" bytes
qint64  Qt_AudioDevice::readData (char* buffer, qint64 maxSize) {
qint64  amount = 0;
static int64_t teller = 0;
        amount = Buffer -> getDataFromBuffer (buffer, maxSize);
        if (amount < maxSize) {
           for (int i = amount; i < maxSize; i ++)
              buffer [i] = (char)(0);
        }

        return maxSize;
}

To copy to clipboard, switch view to plain text mode 

Fot me the question is, why is the state "Idle" in Windows, when in Linux it is "Active"

suggestions?

best
jan

[d_stranz]

I am wondering whether you need to tell Windows to give your program permission to use the audio device? Or whether you need to run your program as Administrator? I know that for things like Zoom, you must give permission for it to use the camera, microphone, and speakers.

[janK]

Rgabjs,
But the audiooutput example from the the examples in the Qt sources works just fine.
I merely copied the code, the difference being that they use as QIOdevice a program that generates the data by itsellf
Anyway, thanks for the effort

[d_stranz]

Something else that comes to mind: Is the endianess (byte order) different between linux and Windows? In the audiooutput example, the bytes are internally generated so the byte order is consistent. In your case, I get the idea that you are connecting to an external SDR stream where the byte order could be different.

[janK]

That is true, but that does not explain why the Audiosink opens without error and then goes into state Idle. especially when the QIODevice reports that opening is fine, The result is that in the end no bytes are read.
If I understand the documentation, then the Audiosink goes into state Idle if there is no input, but I ensured that a buffer is filled, and then no element of the buffer is read
And again, using Linux, it works fine, so either the Windows version should have worked, or the Linux version works while it should not

[janK]

That is true, but that does not explain why the Audiosink opens without error and then goes into state Idle. especially when the QIODevice reports that opening is fine, The result is that in the end no bytes are read.
If I understand the documentation, then the Audiosink goes into state Idle if there is no input, but I ensured that a buffer is filled, and then no element of the buffer is read
And again, using Linux, it works fine, so either the Windows version should have worked, or the Linux version works while it should not

I think the basic quesiton is
if the creation of a QIODevice and the creation of an QAudioSink is also without errors,
under what conditions changes the AudioSink the state to "Idle"

I checked again btw that while sthe "start" of the QIODevice is - according to the QIODevice = without problems, the "readData" function
is not called at all. So, it seems that the AudioSink does not see that the readData function can be called

Anyway, in the documentation I do not find any clue of why this behavious happens under Windows

[janK]

Implementing the (virtual) bytesAvailable function for the derives QUIDevice class did the trick. It remains a mystery why the Linux implementation apaprently does not require that and rhe windows ine does
(Both are 6.8.1)

[d_stranz]

Implementing the (virtual) bytesAvailable function for the derives QUIDevice class did the trick.

I assume you meant QIODevice. It would be nice if you could post your code for that to help others who might experience the same problem in the future and come across this thread looking for an answer.

[janK]

I assume you meant QIODevice. It would be nice if you could post your code for that to help others who might experience the same problem in the future and come across this thread looking for an answer.

The siruation was roughly as sketched below, a derived class from QIODevice was used and sound was output under Linux and silence was output under Windows
Under windows, the AudioSink that was use to embed the derived QIODevice class gave state Idle under Window and Active under Linux
The read function implemented in the derived QIOdevice class always gives the required amount of bytes back, taken from abuffer and a shortage, if appearing, filled with o bytes.
The original version differs from the one given below by not having impmented the "bytesAvailable" function and the "sze" function.
After implementing the bytesAvailable function itworked fine. Appparently the Windows version of AudioSink - when started- first looks at the bytesAvailable function, while the
same class in the Linux version does not.

The amount returned by the bytesAvailable function did not matter, as long as the (virtual) function is reimplemented and returns a value > 0 it works fine (again, given that the read function always returns the
requested amount

In both cases it was version 6.8.1.

Qt_AudioDevice::~Qt_AudioDevice () {
        close ();
}
 
void    Qt_AudioDevice::start () {
        bool b = open (QIODevice::ReadOnly);
}
 
//      we always return "maxSize" bytes
qint64  Qt_AudioDevice::readData (char* buffer, qint64 maxSize) {
//      "maxSize" is the requested size in bytes
//      "amount" is in uint8_t's
        amount = Buffer -> getDataFromBuffer (buffer, maxSize);
        if (amount < maxSize) {
           for (int i = amount; i < maxSize; i ++)
              buffer [i] = (char)(0);
        }
}
 
//      usused here
qint64  Qt_AudioDevice::writeData (const char* data, qint64 len) {
        Q_UNUSED (data);
        Q_UNUSED (len);
        return 0;
}
 
 
qint64  Qt_AudioDevice::bytesAvailable  () const {
        return  32768;
}

Qt_AudioDevice::~Qt_AudioDevice () {
        close ();
}

void    Qt_AudioDevice::start () {
        bool b = open (QIODevice::ReadOnly);
}

//      we always return "maxSize" bytes
qint64  Qt_AudioDevice::readData (char* buffer, qint64 maxSize) {
//      "maxSize" is the requested size in bytes
//      "amount" is in uint8_t's
        amount = Buffer -> getDataFromBuffer (buffer, maxSize);
        if (amount < maxSize) {
           for (int i = amount; i < maxSize; i ++)
              buffer [i] = (char)(0);
        }
}

//      usused here
qint64  Qt_AudioDevice::writeData (const char* data, qint64 len) {
        Q_UNUSED (data);
        Q_UNUSED (len);
        return 0;
}


qint64  Qt_AudioDevice::bytesAvailable  () const {
        return  32768;
}

To copy to clipboard, switch view to plain text mode