win32 backend for low-level audio doesn't pass new unit tests

New unit tests have identified issues with awin32 backend. These issues
need to be resolved before new unit tests are added.

  * stateChanged() signal should only be emitted on change of state
    currently signals can be emitted multiple times.
  * for output data is being lost when input can be read from
    QIODevice but cannot be written to audio sub system.

Task-number:QTBUG-8441
Reviewed-by:Dmytro Poplavskiy

2 files changed, 78 insertions, 26 deletions

diff --git a/src/multimedia/audio/qaudioinput_win32_p.cpp b/src/multimedia/audio/qaudioinput_win32_p.cpp
index 17e8bfbf4c..ec0359ac5d 100644
--- a/src/multimedia/audio/qaudioinput_win32_p.cpp
+++ b/src/multimedia/audio/qaudioinput_win32_p.cpp
@@ -192,9 +192,11 @@ QIODevice* QAudioInputPrivate::start(QIODevice* device)
         //set to pull mode
         pullMode = true;
         audioSource = device;
+        deviceState = QAudio::ActiveState;
     } else {
         //set to push mode
         pullMode = false;
+        deviceState = QAudio::IdleState;
         audioSource = new InputPrivate(this);
         audioSource->open(QIODevice::ReadOnly | QIODevice::Unbuffered);
     }
@@ -306,7 +308,6 @@ bool QAudioInputPrivate::open()
     elapsedTimeOffset = 0;
     totalTimeValue = 0;
     errorState  = QAudio::NoError;
-    deviceState = QAudio::ActiveState;
     return true;
 }
 
@@ -315,9 +316,9 @@ void QAudioInputPrivate::close()
     if(deviceState == QAudio::StoppedState)
         return;
 
+    deviceState = QAudio::StoppedState;
     waveInReset(hWaveIn);
     waveInClose(hWaveIn);
-    deviceState = QAudio::StoppedState;
 
     int count = 0;
     while(!finished && count < 500) {
@@ -352,7 +353,6 @@ qint64 QAudioInputPrivate::read(char* data, qint64 len)
     char*  p = data;
     qint64 l = 0;
     qint64 written = 0;
-
     while(!done) {
         // Read in some audio data
         if(waveBlocks[header].dwBytesRecorded > 0 && waveBlocks[header].dwFlags & WHDR_DONE) {
@@ -373,11 +373,12 @@ qint64 QAudioInputPrivate::read(char* data, qint64 len)
                     errorState = QAudio::IOError;
 
                 } else {
-                    totalTimeValue += waveBlocks[header].dwBytesRecorded
-                        /((settings.channels()*settings.sampleSize()/8))
-                        *10000/settings.frequency()*100;
+                    totalTimeValue += waveBlocks[header].dwBytesRecorded;
                     errorState = QAudio::NoError;
-                    deviceState = QAudio::ActiveState;
+                    if (deviceState != QAudio::ActiveState) {
+                        deviceState = QAudio::ActiveState;
+                        emit stateChanged(deviceState);
+                    }
 		    resuming = false;
                 }
             } else {
@@ -387,16 +388,17 @@ qint64 QAudioInputPrivate::read(char* data, qint64 len)
 #ifdef DEBUG_AUDIO
                 qDebug()<<"IN: "<<waveBlocks[header].dwBytesRecorded<<", OUT: "<<l;
 #endif
-                totalTimeValue += waveBlocks[header].dwBytesRecorded
-                    /((settings.channels()*settings.sampleSize()/8))
-                    *10000/settings.frequency()*100;
+                totalTimeValue += waveBlocks[header].dwBytesRecorded;
                 errorState = QAudio::NoError;
-                deviceState = QAudio::ActiveState;
+                if (deviceState != QAudio::ActiveState) {
+                    deviceState = QAudio::ActiveState;
+                    emit stateChanged(deviceState);
+                }
 		resuming = false;
             }
         } else {
             //no data, not ready yet, next time
-            return 0;
+            break;
         }
 
         waveInUnprepareHeader(hWaveIn,&waveBlocks[header], sizeof(WAVEHDR));
@@ -505,7 +507,13 @@ int QAudioInputPrivate::notifyInterval() const
 
 qint64 QAudioInputPrivate::processedUSecs() const
 {
-    return totalTimeValue;
+    if (deviceState == QAudio::StoppedState)
+        return 0;
+    qint64 result = qint64(1000000) * totalTimeValue /
+        (settings.channels()*(settings.sampleSize()/8)) /
+        settings.frequency();
+
+    return result;
 }
 
 void QAudioInputPrivate::suspend()
@@ -535,6 +543,9 @@ bool QAudioInputPrivate::deviceReady()
     QTime now(QTime::currentTime());
     qDebug()<<now.second()<<"s "<<now.msec()<<"ms :deviceReady() INPUT";
 #endif
+    if(deviceState != QAudio::ActiveState && deviceState != QAudio::IdleState)
+        return true;
+
     if(pullMode) {
         // reads some audio data and writes it to QIODevice
         read(0,0);
@@ -543,8 +554,6 @@ bool QAudioInputPrivate::deviceReady()
 	InputPrivate* a = qobject_cast<InputPrivate*>(audioSource);
 	a->trigger();
     }
-    if(deviceState != QAudio::ActiveState)
-        return true;
 
     if((timeStamp.elapsed() + elapsedTimeOffset) > intervalTime) {
         emit notify();
@@ -577,7 +586,8 @@ InputPrivate::~InputPrivate() {}
 qint64 InputPrivate::readData( char* data, qint64 len)
 {
     // push mode, user read() called
-    if(audioDevice->deviceState != QAudio::ActiveState)
+    if(audioDevice->deviceState != QAudio::ActiveState &&
+            audioDevice->deviceState != QAudio::IdleState)
         return 0;
     // Read in some audio data
     return audioDevice->read(data,len);
diff --git a/src/multimedia/audio/qaudiooutput_win32_p.cpp b/src/multimedia/audio/qaudiooutput_win32_p.cpp
index c31e04841a..c5792b631c 100644
--- a/src/multimedia/audio/qaudiooutput_win32_p.cpp
+++ b/src/multimedia/audio/qaudiooutput_win32_p.cpp
@@ -211,6 +211,13 @@ bool QAudioOutputPrivate::open()
     QTime now(QTime::currentTime());
     qDebug()<<now.second()<<"s "<<now.msec()<<"ms :open()";
 #endif
+    if (!(settings.frequency() >= 8000 && settings.frequency() <= 48000)) {
+        errorState = QAudio::OpenError;
+        deviceState = QAudio::StoppedState;
+        emit stateChanged(deviceState);
+        qWarning("QAudioOutput: open error, frequency out of range.");
+        return false;
+    }
     if(buffer_size == 0) {
         // Default buffer size, 200ms, default period size is 40ms
         buffer_size = settings.frequency()*settings.channels()*(settings.sampleSize()/8)*0.2;
@@ -289,6 +296,7 @@ void QAudioOutputPrivate::close()
         return;
 
     deviceState = QAudio::StoppedState;
+    errorState = QAudio::NoError;
     int delay = (buffer_size-bytesFree())*1000/(settings.frequency()
                   *settings.channels()*(settings.sampleSize()/8));
     waveOutReset(hWaveOut);
@@ -340,12 +348,20 @@ int QAudioOutputPrivate::notifyInterval() const
 
 qint64 QAudioOutputPrivate::processedUSecs() const
 {
-    return totalTimeValue;
+    if (deviceState == QAudio::StoppedState)
+        return 0;
+    qint64 result = qint64(1000000) * totalTimeValue /
+        (settings.channels()*(settings.sampleSize()/8)) /
+        settings.frequency();
+
+    return result;
 }
 
 qint64 QAudioOutputPrivate::write( const char *data, qint64 len )
 {
     // Write out some audio data
+    if (deviceState != QAudio::ActiveState && deviceState != QAudio::IdleState)
+        return 0;
 
     char* p = (char*)data;
     int l = (int)len;
@@ -385,13 +401,16 @@ qint64 QAudioOutputPrivate::write( const char *data, qint64 len )
                 current->dwBufferLength,waveFreeBlockCount);
         LeaveCriticalSection(&waveOutCriticalSection);
 #endif
-        totalTimeValue += current->dwBufferLength
-            /(settings.channels()*(settings.sampleSize()/8))
-            *1000000/settings.frequency();;
+        totalTimeValue += current->dwBufferLength;
         waveCurrentBlock++;
         waveCurrentBlock %= buffer_size/period_size;
         current = &waveBlocks[waveCurrentBlock];
         current->dwUser = 0;
+        errorState = QAudio::NoError;
+        if (deviceState != QAudio::ActiveState) {
+            deviceState = QAudio::ActiveState;
+            emit stateChanged(deviceState);
+        }
     }
     return (len-l);
 }
@@ -409,8 +428,11 @@ void QAudioOutputPrivate::resume()
 
 void QAudioOutputPrivate::suspend()
 {
-    if(deviceState == QAudio::ActiveState) {
+    if(deviceState == QAudio::ActiveState || deviceState == QAudio::IdleState) {
+        int delay = (buffer_size-bytesFree())*1000/(settings.frequency()
+                *settings.channels()*(settings.sampleSize()/8));
         waveOutPause(hWaveOut);
+        Sleep(delay+10);
         deviceState = QAudio::SuspendedState;
         errorState = QAudio::NoError;
         emit stateChanged(deviceState);
@@ -465,8 +487,16 @@ bool QAudioOutputPrivate::deviceReady()
         int l = audioSource->read(audioBuffer,input);
         if(l > 0) {
             int out= write(audioBuffer,l);
-            if(out > 0)
-                deviceState = QAudio::ActiveState;
+            if(out > 0) {
+                if (deviceState != QAudio::ActiveState) {
+                    deviceState = QAudio::ActiveState;
+                    emit stateChanged(deviceState);
+                }
+            }
+            if ( out < l) {
+                // Didnt write all data
+                audioSource->seek(audioSource->pos()-(l-out));
+            }
 	    if(startup)
 	        waveOutRestart(hWaveOut);
         } else if(l == 0) {
@@ -478,16 +508,28 @@ bool QAudioOutputPrivate::deviceReady()
             LeaveCriticalSection(&waveOutCriticalSection);
             if(check == buffer_size/period_size) {
                 errorState = QAudio::UnderrunError;
-                deviceState = QAudio::IdleState;
-                emit stateChanged(deviceState);
+                if (deviceState != QAudio::IdleState) {
+                    deviceState = QAudio::IdleState;
+                    emit stateChanged(deviceState);
+                }
             }
 
         } else if(l < 0) {
             bytesAvailable = bytesFree();
             errorState = QAudio::IOError;
         }
+    } else {
+        int buffered;
+	EnterCriticalSection(&waveOutCriticalSection);
+	buffered = waveFreeBlockCount;
+	LeaveCriticalSection(&waveOutCriticalSection);
+        errorState = QAudio::UnderrunError;
+        if (buffered >= buffer_size/period_size && deviceState == QAudio::ActiveState) {
+            deviceState = QAudio::IdleState;
+            emit stateChanged(deviceState);
+        }
     }
-    if(deviceState != QAudio::ActiveState)
+    if(deviceState != QAudio::ActiveState && deviceState != QAudio::IdleState)
         return true;
 
     if((timeStamp.elapsed() + elapsedTimeOffset) > intervalTime) {