Windows-4.7.4/src/multimedia/audio/qaudioinput_win32_p.cpp - platform/external/qt - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtMultimedia module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** GNU Lesser General Public License Usage
 ** This file may be used under the terms of the GNU Lesser General Public
 ** License version 2.1 as published by the Free Software Foundation and
 ** appearing in the file LICENSE.LGPL included in the packaging of this
 ** file. Please review the following information to ensure the GNU Lesser
 ** General Public License version 2.1 requirements will be met:
 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights. These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU General
 ** Public License version 3.0 as published by the Free Software Foundation
 ** and appearing in the file LICENSE.GPL included in the packaging of this
 ** file. Please review the following information to ensure the GNU General
 ** Public License version 3.0 requirements will be met:
 ** http://www.gnu.org/copyleft/gpl.html.
 **
 ** Other Usage
 ** Alternatively, this file may be used in accordance with the terms and
 ** conditions contained in a signed written agreement between you and Nokia.
 **
 **
 **
 **
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 //
 //  W A R N I N G
 //  -------------
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of other Qt classes.  This header file may change from version to
 // version without notice, or even be removed.
 //
 // We mean it.
 //


 #include "qaudioinput_win32_p.h"

 QT_BEGIN_NAMESPACE

 //#define DEBUG_AUDIO 1

 QAudioInputPrivate::QAudioInputPrivate(const QByteArray &device, const QAudioFormat& audioFormat):
     settings(audioFormat)
 {
     bytesAvailable = 0;
     buffer_size = 0;
     period_size = 0;
     m_device = device;
     totalTimeValue = 0;
     intervalTime = 1000;
     errorState = QAudio::NoError;
     deviceState = QAudio::StoppedState;
     audioSource = 0;
     pullMode = true;
     resuming = false;
     finished = false;
 }

 QAudioInputPrivate::~QAudioInputPrivate()
 {
     stop();
 }

 void QT_WIN_CALLBACK QAudioInputPrivate::waveInProc( HWAVEIN hWaveIn, UINT uMsg,
         DWORD dwInstance, DWORD dwParam1, DWORD dwParam2 )
 {
     Q_UNUSED(dwParam1)
     Q_UNUSED(dwParam2)
     Q_UNUSED(hWaveIn)

     QAudioInputPrivate* qAudio;
     qAudio = (QAudioInputPrivate*)(dwInstance);
     if(!qAudio)
         return;

     QMutexLocker(&qAudio->mutex);

     switch(uMsg) {
         case WIM_OPEN:
             break;
         case WIM_DATA:
             if(qAudio->waveFreeBlockCount > 0)
                 qAudio->waveFreeBlockCount--;
             qAudio->feedback();
             break;
         case WIM_CLOSE:
             qAudio->finished = true;
             break;
         default:
             return;
     }
 }

 WAVEHDR* QAudioInputPrivate::allocateBlocks(int size, int count)
 {
     int i;
     unsigned char* buffer;
     WAVEHDR* blocks;
     DWORD totalBufferSize = (size + sizeof(WAVEHDR))*count;

     if((buffer=(unsigned char*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
                     totalBufferSize)) == 0) {
         qWarning("QAudioInput: Memory allocation error");
         return 0;
     }
     blocks = (WAVEHDR*)buffer;
     buffer += sizeof(WAVEHDR)*count;
     for(i = 0; i < count; i++) {
         blocks[i].dwBufferLength = size;
         blocks[i].lpData = (LPSTR)buffer;
         blocks[i].dwBytesRecorded=0;
         blocks[i].dwUser = 0L;
         blocks[i].dwFlags = 0L;
         blocks[i].dwLoops = 0L;
         result = waveInPrepareHeader(hWaveIn,&blocks[i], sizeof(WAVEHDR));
         if(result != MMSYSERR_NOERROR) {
             qWarning("QAudioInput: Can't prepare block %d",i);
             return 0;
         }
         buffer += size;
     }
     return blocks;
 }

 void QAudioInputPrivate::freeBlocks(WAVEHDR* blockArray)
 {
     WAVEHDR* blocks = blockArray;

     int count = buffer_size/period_size;

     for(int i = 0; i < count; i++) {
         waveInUnprepareHeader(hWaveIn,blocks, sizeof(WAVEHDR));
         blocks++;
     }
     HeapFree(GetProcessHeap(), 0, blockArray);
 }

 QAudio::Error QAudioInputPrivate::error() const
 {
     return errorState;
 }

 QAudio::State QAudioInputPrivate::state() const
 {
     return deviceState;
 }

 QAudioFormat QAudioInputPrivate::format() const
 {
     return settings;
 }

 QIODevice* QAudioInputPrivate::start(QIODevice* device)
 {
     if(deviceState != QAudio::StoppedState)
         close();

     if(!pullMode && audioSource) {
         delete audioSource;
     }

     if(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);
     }

     if( !open() )
         return 0;

     emit stateChanged(deviceState);

     return audioSource;
 }

 void QAudioInputPrivate::stop()
 {
     if(deviceState == QAudio::StoppedState)
         return;

     close();
     emit stateChanged(deviceState);
 }

 bool QAudioInputPrivate::open()
 {
 #ifdef DEBUG_AUDIO
     QTime now(QTime::currentTime());
     qDebug()<<now.second()<<"s "<<now.msec()<<"ms :open()";
 #endif
     header = 0;
     period_size = 0;

     if (!settings.isValid()) {
         qWarning("QAudioInput: open error, invalid format.");
     } else if (settings.channels() <= 0) {
         qWarning("QAudioInput: open error, invalid number of channels (%d).",
                  settings.channels());
     } else if (settings.sampleSize() <= 0) {
         qWarning("QAudioInput: open error, invalid sample size (%d).",
                  settings.sampleSize());
     } else if (settings.frequency() < 8000 || settings.frequency() > 48000) {
         qWarning("QAudioInput: open error, frequency out of range (%d).", settings.frequency());
     } else if (buffer_size == 0) {

         buffer_size
                 = (settings.frequency()
                 * settings.channels()
                 * settings.sampleSize()
 #ifndef Q_OS_WINCE  // Default buffer size, 200ms, default period size is 40ms
                 + 39) / 40;
         period_size = buffer_size / 5;
     } else {
         period_size = buffer_size / 5;
 #else               // For wince reduce size to 40ms for buffer size and 20ms period
                 + 199) / 200;
         period_size = buffer_size / 2;
     } else {
         period_size = buffer_size / 2;
 #endif
     }

     if (period_size == 0) {
         errorState = QAudio::OpenError;
         deviceState = QAudio::StoppedState;
         emit stateChanged(deviceState);
         return false;
     }

     timeStamp.restart();
     elapsedTimeOffset = 0;
     wfx.nSamplesPerSec = settings.frequency();
     wfx.wBitsPerSample = settings.sampleSize();
     wfx.nChannels = settings.channels();
     wfx.cbSize = 0;

     wfx.wFormatTag = WAVE_FORMAT_PCM;
     wfx.nBlockAlign = (wfx.wBitsPerSample >> 3) * wfx.nChannels;
     wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;

     UINT_PTR devId = WAVE_MAPPER;

     WAVEINCAPS wic;
     unsigned long iNumDevs,ii;
     iNumDevs = waveInGetNumDevs();
     for(ii=0;ii<iNumDevs;ii++) {
         if(waveInGetDevCaps(ii, &wic, sizeof(WAVEINCAPS))
 	    == MMSYSERR_NOERROR) {
 	    QString tmp;
 	    tmp = QString((const QChar *)wic.szPname);
 	    if(tmp.compare(QLatin1String(m_device)) == 0) {
 	        devId = ii;
 		break;
 	    }
 	}
     }

     if(waveInOpen(&hWaveIn, devId, &wfx,
                 (DWORD_PTR)&waveInProc,
                 (DWORD_PTR) this,
                 CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {
         errorState = QAudio::OpenError;
         deviceState = QAudio::StoppedState;
         emit stateChanged(deviceState);
         qWarning("QAudioInput: failed to open audio device");
         return false;
     }
     waveBlocks = allocateBlocks(period_size, buffer_size/period_size);

     if(waveBlocks == 0) {
         errorState = QAudio::OpenError;
         deviceState = QAudio::StoppedState;
         emit stateChanged(deviceState);
         qWarning("QAudioInput: failed to allocate blocks. open failed");
         return false;
     }

     mutex.lock();
     waveFreeBlockCount = buffer_size/period_size;
     mutex.unlock();

     waveCurrentBlock = 0;

     for(int i=0; i<buffer_size/period_size; i++) {
         result = waveInAddBuffer(hWaveIn, &waveBlocks[i], sizeof(WAVEHDR));
         if(result != MMSYSERR_NOERROR) {
             qWarning("QAudioInput: failed to setup block %d,err=%d",i,result);
             errorState = QAudio::OpenError;
             deviceState = QAudio::StoppedState;
             emit stateChanged(deviceState);
             return false;
         }
     }
     result = waveInStart(hWaveIn);
     if(result) {
         qWarning("QAudioInput: failed to start audio input");
         errorState = QAudio::OpenError;
         deviceState = QAudio::StoppedState;
         emit stateChanged(deviceState);
         return false;
     }
     timeStampOpened.restart();
     elapsedTimeOffset = 0;
     totalTimeValue = 0;
     errorState  = QAudio::NoError;
     return true;
 }

 void QAudioInputPrivate::close()
 {
     if(deviceState == QAudio::StoppedState)
         return;

     deviceState = QAudio::StoppedState;
     waveInReset(hWaveIn);
     waveInClose(hWaveIn);

     int count = 0;
     while(!finished && count < 500) {
         count++;
         Sleep(10);
     }

     mutex.lock();
     for(int i=0; i<waveFreeBlockCount; i++)
         waveInUnprepareHeader(hWaveIn,&waveBlocks[i],sizeof(WAVEHDR));
     freeBlocks(waveBlocks);
     mutex.unlock();
 }

 int QAudioInputPrivate::bytesReady() const
 {
     if(period_size == 0 || buffer_size == 0)
         return 0;

     int buf = ((buffer_size/period_size)-waveFreeBlockCount)*period_size;
     if(buf < 0)
         buf = 0;
     return buf;
 }

 qint64 QAudioInputPrivate::read(char* data, qint64 len)
 {
     bool done = false;

     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) {
             if(pullMode) {
                 l = audioSource->write(waveBlocks[header].lpData,
                         waveBlocks[header].dwBytesRecorded);
 #ifdef DEBUG_AUDIO
                 qDebug()<<"IN: "<<waveBlocks[header].dwBytesRecorded<<", OUT: "<<l;
 #endif
                 if(l < 0) {
                     // error
                     qWarning("QAudioInput: IOError");
                     errorState = QAudio::IOError;

                 } else if(l == 0) {
                     // cant write to IODevice
                     qWarning("QAudioInput: IOError, can't write to QIODevice");
                     errorState = QAudio::IOError;

                 } else {
                     totalTimeValue += waveBlocks[header].dwBytesRecorded;
                     errorState = QAudio::NoError;
                     if (deviceState != QAudio::ActiveState) {
                         deviceState = QAudio::ActiveState;
                         emit stateChanged(deviceState);
                     }
 		    resuming = false;
                 }
             } else {
                 l = qMin<qint64>(len, waveBlocks[header].dwBytesRecorded);
                 // push mode
                 memcpy(p, waveBlocks[header].lpData, l);

                 len -= l;

 #ifdef DEBUG_AUDIO
                 qDebug()<<"IN: "<<waveBlocks[header].dwBytesRecorded<<", OUT: "<<l;
 #endif
                 totalTimeValue += waveBlocks[header].dwBytesRecorded;
                 errorState = QAudio::NoError;
                 if (deviceState != QAudio::ActiveState) {
                     deviceState = QAudio::ActiveState;
                     emit stateChanged(deviceState);
                 }
 		resuming = false;
             }
         } else {
             //no data, not ready yet, next time
             break;
         }

         waveInUnprepareHeader(hWaveIn,&waveBlocks[header], sizeof(WAVEHDR));

         mutex.lock();
         waveFreeBlockCount++;
         mutex.unlock();

         waveBlocks[header].dwBytesRecorded=0;
         waveBlocks[header].dwFlags = 0L;
         result = waveInPrepareHeader(hWaveIn,&waveBlocks[header], sizeof(WAVEHDR));
         if(result != MMSYSERR_NOERROR) {
             result = waveInPrepareHeader(hWaveIn,&waveBlocks[header], sizeof(WAVEHDR));
             qWarning("QAudioInput: failed to prepare block %d,err=%d",header,result);
             errorState = QAudio::IOError;

             mutex.lock();
             waveFreeBlockCount--;
             mutex.unlock();

             return 0;
         }
         result = waveInAddBuffer(hWaveIn, &waveBlocks[header], sizeof(WAVEHDR));
         if(result != MMSYSERR_NOERROR) {
             qWarning("QAudioInput: failed to setup block %d,err=%d",header,result);
             errorState = QAudio::IOError;

             mutex.lock();
             waveFreeBlockCount--;
             mutex.unlock();

             return 0;
         }
         header++;
         if(header >= buffer_size/period_size)
             header = 0;
         p+=l;

         mutex.lock();
         if(!pullMode) {
             if(len < period_size || waveFreeBlockCount == buffer_size/period_size)
 	        done = true;
 	} else {
 	    if(waveFreeBlockCount == buffer_size/period_size)
 	        done = true;
 	}
         mutex.unlock();

 	written+=l;
     }
 #ifdef DEBUG_AUDIO
     qDebug()<<"read in len="<<written;
 #endif
     return written;
 }

 void QAudioInputPrivate::resume()
 {
     if(deviceState == QAudio::SuspendedState) {
         deviceState = QAudio::ActiveState;
         for(int i=0; i<buffer_size/period_size; i++) {
             result = waveInAddBuffer(hWaveIn, &waveBlocks[i], sizeof(WAVEHDR));
             if(result != MMSYSERR_NOERROR) {
                 qWarning("QAudioInput: failed to setup block %d,err=%d",i,result);
                 errorState = QAudio::OpenError;
                 deviceState = QAudio::StoppedState;
                 emit stateChanged(deviceState);
                 return;
             }
         }

         mutex.lock();
         waveFreeBlockCount = buffer_size/period_size;
         mutex.unlock();

         waveCurrentBlock = 0;
         header = 0;
 	resuming = true;
         waveInStart(hWaveIn);
         QTimer::singleShot(20,this,SLOT(feedback()));
         emit stateChanged(deviceState);
     }
 }

 void QAudioInputPrivate::setBufferSize(int value)
 {
     buffer_size = value;
 }

 int QAudioInputPrivate::bufferSize() const
 {
     return buffer_size;
 }

 int QAudioInputPrivate::periodSize() const
 {
     return period_size;
 }

 void QAudioInputPrivate::setNotifyInterval(int ms)
 {
     intervalTime = qMax(0, ms);
 }

 int QAudioInputPrivate::notifyInterval() const
 {
     return intervalTime;
 }

 qint64 QAudioInputPrivate::processedUSecs() const
 {
     if (deviceState == QAudio::StoppedState)
         return 0;
     qint64 result = qint64(1000000) * totalTimeValue /
         (settings.channels()*(settings.sampleSize()/8)) /
         settings.frequency();

     return result;
 }

 void QAudioInputPrivate::suspend()
 {
     if(deviceState == QAudio::ActiveState) {
         waveInReset(hWaveIn);
         deviceState = QAudio::SuspendedState;
         emit stateChanged(deviceState);
     }
 }

 void QAudioInputPrivate::feedback()
 {
 #ifdef DEBUG_AUDIO
     QTime now(QTime::currentTime());
     qDebug()<<now.second()<<"s "<<now.msec()<<"ms :feedback() INPUT "<<this;
 #endif
     if(!(deviceState==QAudio::StoppedState||deviceState==QAudio::SuspendedState))
         QMetaObject::invokeMethod(this, "deviceReady", Qt::QueuedConnection);
 }

 bool QAudioInputPrivate::deviceReady()
 {
     bytesAvailable = bytesReady();
 #ifdef DEBUG_AUDIO
     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, buffer_size);
     } else {
         // emits readyRead() so user will call read() on QIODevice to get some audio data
 	InputPrivate* a = qobject_cast<InputPrivate*>(audioSource);
 	a->trigger();
     }

     if(intervalTime && (timeStamp.elapsed() + elapsedTimeOffset) > intervalTime) {
         emit notify();
         elapsedTimeOffset = timeStamp.elapsed() + elapsedTimeOffset - intervalTime;
         timeStamp.restart();
     }
     return true;
 }

 qint64 QAudioInputPrivate::elapsedUSecs() const
 {
     if (deviceState == QAudio::StoppedState)
         return 0;

     return timeStampOpened.elapsed()*1000;
 }

 void QAudioInputPrivate::reset()
 {
     close();
 }

 InputPrivate::InputPrivate(QAudioInputPrivate* audio)
 {
     audioDevice = qobject_cast<QAudioInputPrivate*>(audio);
 }

 InputPrivate::~InputPrivate() {}

 qint64 InputPrivate::readData( char* data, qint64 len)
 {
     // push mode, user read() called
     if(audioDevice->deviceState != QAudio::ActiveState &&
             audioDevice->deviceState != QAudio::IdleState)
         return 0;
     // Read in some audio data
     return audioDevice->read(data,len);
 }

 qint64 InputPrivate::writeData(const char* data, qint64 len)
 {
     Q_UNUSED(data)
     Q_UNUSED(len)

     emit readyRead();
     return 0;
 }

 void InputPrivate::trigger()
 {
     emit readyRead();
 }

 QT_END_NAMESPACE
	/****************************************************************************
	**
	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
	** All rights reserved.
	** Contact: Nokia Corporation (qt-info@nokia.com)
	**
	** This file is part of the QtMultimedia module of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:LGPL$
	** GNU Lesser General Public License Usage
	** This file may be used under the terms of the GNU Lesser General Public
	** License version 2.1 as published by the Free Software Foundation and
	** appearing in the file LICENSE.LGPL included in the packaging of this
	** file. Please review the following information to ensure the GNU Lesser
	** General Public License version 2.1 requirements will be met:
	** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
	**
	** In addition, as a special exception, Nokia gives you certain additional
	** rights. These rights are described in the Nokia Qt LGPL Exception
	** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
	**
	** GNU General Public License Usage
	** Alternatively, this file may be used under the terms of the GNU General
	** Public License version 3.0 as published by the Free Software Foundation
	** and appearing in the file LICENSE.GPL included in the packaging of this
	** file. Please review the following information to ensure the GNU General
	** Public License version 3.0 requirements will be met:
	** http://www.gnu.org/copyleft/gpl.html.
	**
	** Other Usage
	** Alternatively, this file may be used in accordance with the terms and
	** conditions contained in a signed written agreement between you and Nokia.
	**
	**
	**
	**
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	//
	// W A R N I N G
	// -------------
	//
	// This file is not part of the Qt API. It exists for the convenience
	// of other Qt classes. This header file may change from version to
	// version without notice, or even be removed.
	//
	// We mean it.
	//


	#include "qaudioinput_win32_p.h"

	QT_BEGIN_NAMESPACE

	//#define DEBUG_AUDIO 1

	QAudioInputPrivate::QAudioInputPrivate(const QByteArray &device, const QAudioFormat& audioFormat):
	settings(audioFormat)
	{
	bytesAvailable = 0;
	buffer_size = 0;
	period_size = 0;
	m_device = device;
	totalTimeValue = 0;
	intervalTime = 1000;
	errorState = QAudio::NoError;
	deviceState = QAudio::StoppedState;
	audioSource = 0;
	pullMode = true;
	resuming = false;
	finished = false;
	}

	QAudioInputPrivate::~QAudioInputPrivate()
	{
	stop();
	}

	void QT_WIN_CALLBACK QAudioInputPrivate::waveInProc( HWAVEIN hWaveIn, UINT uMsg,
	DWORD dwInstance, DWORD dwParam1, DWORD dwParam2 )
	{
	Q_UNUSED(dwParam1)
	Q_UNUSED(dwParam2)
	Q_UNUSED(hWaveIn)

	QAudioInputPrivate* qAudio;
	qAudio = (QAudioInputPrivate*)(dwInstance);
	if(!qAudio)
	return;

	QMutexLocker(&qAudio->mutex);

	switch(uMsg) {
	case WIM_OPEN:
	break;
	case WIM_DATA:
	if(qAudio->waveFreeBlockCount > 0)
	qAudio->waveFreeBlockCount--;
	qAudio->feedback();
	break;
	case WIM_CLOSE:
	qAudio->finished = true;
	break;
	default:
	return;
	}
	}

	WAVEHDR* QAudioInputPrivate::allocateBlocks(int size, int count)
	{
	int i;
	unsigned char* buffer;
	WAVEHDR* blocks;
	DWORD totalBufferSize = (size + sizeof(WAVEHDR))*count;

	if((buffer=(unsigned char*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
	totalBufferSize)) == 0) {
	qWarning("QAudioInput: Memory allocation error");
	return 0;
	}
	blocks = (WAVEHDR*)buffer;
	buffer += sizeof(WAVEHDR)*count;
	for(i = 0; i < count; i++) {
	blocks[i].dwBufferLength = size;
	blocks[i].lpData = (LPSTR)buffer;
	blocks[i].dwBytesRecorded=0;
	blocks[i].dwUser = 0L;
	blocks[i].dwFlags = 0L;
	blocks[i].dwLoops = 0L;
	result = waveInPrepareHeader(hWaveIn,&blocks[i], sizeof(WAVEHDR));
	if(result != MMSYSERR_NOERROR) {
	qWarning("QAudioInput: Can't prepare block %d",i);
	return 0;
	}
	buffer += size;
	}
	return blocks;
	}

	void QAudioInputPrivate::freeBlocks(WAVEHDR* blockArray)
	{
	WAVEHDR* blocks = blockArray;

	int count = buffer_size/period_size;

	for(int i = 0; i < count; i++) {
	waveInUnprepareHeader(hWaveIn,blocks, sizeof(WAVEHDR));
	blocks++;
	}
	HeapFree(GetProcessHeap(), 0, blockArray);
	}

	QAudio::Error QAudioInputPrivate::error() const
	{
	return errorState;
	}

	QAudio::State QAudioInputPrivate::state() const
	{
	return deviceState;
	}

	QAudioFormat QAudioInputPrivate::format() const
	{
	return settings;
	}

	QIODevice* QAudioInputPrivate::start(QIODevice* device)
	{
	if(deviceState != QAudio::StoppedState)
	close();

	if(!pullMode && audioSource) {
	delete audioSource;
	}

	if(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);
	}

	if( !open() )
	return 0;

	emit stateChanged(deviceState);

	return audioSource;
	}

	void QAudioInputPrivate::stop()
	{
	if(deviceState == QAudio::StoppedState)
	return;

	close();
	emit stateChanged(deviceState);
	}

	bool QAudioInputPrivate::open()
	{
	#ifdef DEBUG_AUDIO
	QTime now(QTime::currentTime());
	qDebug()<<now.second()<<"s "<<now.msec()<<"ms :open()";
	#endif
	header = 0;
	period_size = 0;

	if (!settings.isValid()) {
	qWarning("QAudioInput: open error, invalid format.");
	} else if (settings.channels() <= 0) {
	qWarning("QAudioInput: open error, invalid number of channels (%d).",
	settings.channels());
	} else if (settings.sampleSize() <= 0) {
	qWarning("QAudioInput: open error, invalid sample size (%d).",
	settings.sampleSize());
	} else if (settings.frequency() < 8000 \|\| settings.frequency() > 48000) {
	qWarning("QAudioInput: open error, frequency out of range (%d).", settings.frequency());
	} else if (buffer_size == 0) {

	buffer_size
	= (settings.frequency()
	* settings.channels()
	* settings.sampleSize()
	#ifndef Q_OS_WINCE // Default buffer size, 200ms, default period size is 40ms
	+ 39) / 40;
	period_size = buffer_size / 5;
	} else {
	period_size = buffer_size / 5;
	#else // For wince reduce size to 40ms for buffer size and 20ms period
	+ 199) / 200;
	period_size = buffer_size / 2;
	} else {
	period_size = buffer_size / 2;
	#endif
	}

	if (period_size == 0) {
	errorState = QAudio::OpenError;
	deviceState = QAudio::StoppedState;
	emit stateChanged(deviceState);
	return false;
	}

	timeStamp.restart();
	elapsedTimeOffset = 0;
	wfx.nSamplesPerSec = settings.frequency();
	wfx.wBitsPerSample = settings.sampleSize();
	wfx.nChannels = settings.channels();
	wfx.cbSize = 0;

	wfx.wFormatTag = WAVE_FORMAT_PCM;
	wfx.nBlockAlign = (wfx.wBitsPerSample >> 3) * wfx.nChannels;
	wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;

	UINT_PTR devId = WAVE_MAPPER;

	WAVEINCAPS wic;
	unsigned long iNumDevs,ii;
	iNumDevs = waveInGetNumDevs();
	for(ii=0;ii<iNumDevs;ii++) {
	if(waveInGetDevCaps(ii, &wic, sizeof(WAVEINCAPS))
	== MMSYSERR_NOERROR) {
	QString tmp;
	tmp = QString((const QChar *)wic.szPname);
	if(tmp.compare(QLatin1String(m_device)) == 0) {
	devId = ii;
	break;
	}
	}
	}

	if(waveInOpen(&hWaveIn, devId, &wfx,
	(DWORD_PTR)&waveInProc,
	(DWORD_PTR) this,
	CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {
	errorState = QAudio::OpenError;
	deviceState = QAudio::StoppedState;
	emit stateChanged(deviceState);
	qWarning("QAudioInput: failed to open audio device");
	return false;
	}
	waveBlocks = allocateBlocks(period_size, buffer_size/period_size);

	if(waveBlocks == 0) {
	errorState = QAudio::OpenError;
	deviceState = QAudio::StoppedState;
	emit stateChanged(deviceState);
	qWarning("QAudioInput: failed to allocate blocks. open failed");
	return false;
	}

	mutex.lock();
	waveFreeBlockCount = buffer_size/period_size;
	mutex.unlock();

	waveCurrentBlock = 0;

	for(int i=0; i<buffer_size/period_size; i++) {
	result = waveInAddBuffer(hWaveIn, &waveBlocks[i], sizeof(WAVEHDR));
	if(result != MMSYSERR_NOERROR) {
	qWarning("QAudioInput: failed to setup block %d,err=%d",i,result);
	errorState = QAudio::OpenError;
	deviceState = QAudio::StoppedState;
	emit stateChanged(deviceState);
	return false;
	}
	}
	result = waveInStart(hWaveIn);
	if(result) {
	qWarning("QAudioInput: failed to start audio input");
	errorState = QAudio::OpenError;
	deviceState = QAudio::StoppedState;
	emit stateChanged(deviceState);
	return false;
	}
	timeStampOpened.restart();
	elapsedTimeOffset = 0;
	totalTimeValue = 0;
	errorState = QAudio::NoError;
	return true;
	}

	void QAudioInputPrivate::close()
	{
	if(deviceState == QAudio::StoppedState)
	return;

	deviceState = QAudio::StoppedState;
	waveInReset(hWaveIn);
	waveInClose(hWaveIn);

	int count = 0;
	while(!finished && count < 500) {
	count++;
	Sleep(10);
	}

	mutex.lock();
	for(int i=0; i<waveFreeBlockCount; i++)
	waveInUnprepareHeader(hWaveIn,&waveBlocks[i],sizeof(WAVEHDR));
	freeBlocks(waveBlocks);
	mutex.unlock();
	}

	int QAudioInputPrivate::bytesReady() const
	{
	if(period_size == 0 \|\| buffer_size == 0)
	return 0;

	int buf = ((buffer_size/period_size)-waveFreeBlockCount)*period_size;
	if(buf < 0)
	buf = 0;
	return buf;
	}

	qint64 QAudioInputPrivate::read(char* data, qint64 len)
	{
	bool done = false;

	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) {
	if(pullMode) {
	l = audioSource->write(waveBlocks[header].lpData,
	waveBlocks[header].dwBytesRecorded);
	#ifdef DEBUG_AUDIO
	qDebug()<<"IN: "<<waveBlocks[header].dwBytesRecorded<<", OUT: "<<l;
	#endif
	if(l < 0) {
	// error
	qWarning("QAudioInput: IOError");
	errorState = QAudio::IOError;

	} else if(l == 0) {
	// cant write to IODevice
	qWarning("QAudioInput: IOError, can't write to QIODevice");
	errorState = QAudio::IOError;

	} else {
	totalTimeValue += waveBlocks[header].dwBytesRecorded;
	errorState = QAudio::NoError;
	if (deviceState != QAudio::ActiveState) {
	deviceState = QAudio::ActiveState;
	emit stateChanged(deviceState);
	}
	resuming = false;
	}
	} else {
	l = qMin<qint64>(len, waveBlocks[header].dwBytesRecorded);
	// push mode
	memcpy(p, waveBlocks[header].lpData, l);

	len -= l;

	#ifdef DEBUG_AUDIO
	qDebug()<<"IN: "<<waveBlocks[header].dwBytesRecorded<<", OUT: "<<l;
	#endif
	totalTimeValue += waveBlocks[header].dwBytesRecorded;
	errorState = QAudio::NoError;
	if (deviceState != QAudio::ActiveState) {
	deviceState = QAudio::ActiveState;
	emit stateChanged(deviceState);
	}
	resuming = false;
	}
	} else {
	//no data, not ready yet, next time
	break;
	}

	waveInUnprepareHeader(hWaveIn,&waveBlocks[header], sizeof(WAVEHDR));

	mutex.lock();
	waveFreeBlockCount++;
	mutex.unlock();

	waveBlocks[header].dwBytesRecorded=0;
	waveBlocks[header].dwFlags = 0L;
	result = waveInPrepareHeader(hWaveIn,&waveBlocks[header], sizeof(WAVEHDR));
	if(result != MMSYSERR_NOERROR) {
	result = waveInPrepareHeader(hWaveIn,&waveBlocks[header], sizeof(WAVEHDR));
	qWarning("QAudioInput: failed to prepare block %d,err=%d",header,result);
	errorState = QAudio::IOError;

	mutex.lock();
	waveFreeBlockCount--;
	mutex.unlock();

	return 0;
	}
	result = waveInAddBuffer(hWaveIn, &waveBlocks[header], sizeof(WAVEHDR));
	if(result != MMSYSERR_NOERROR) {
	qWarning("QAudioInput: failed to setup block %d,err=%d",header,result);
	errorState = QAudio::IOError;

	mutex.lock();
	waveFreeBlockCount--;
	mutex.unlock();

	return 0;
	}
	header++;
	if(header >= buffer_size/period_size)
	header = 0;
	p+=l;

	mutex.lock();
	if(!pullMode) {
	if(len < period_size \|\| waveFreeBlockCount == buffer_size/period_size)
	done = true;
	} else {
	if(waveFreeBlockCount == buffer_size/period_size)
	done = true;
	}
	mutex.unlock();

	written+=l;
	}
	#ifdef DEBUG_AUDIO
	qDebug()<<"read in len="<<written;
	#endif
	return written;
	}

	void QAudioInputPrivate::resume()
	{
	if(deviceState == QAudio::SuspendedState) {
	deviceState = QAudio::ActiveState;
	for(int i=0; i<buffer_size/period_size; i++) {
	result = waveInAddBuffer(hWaveIn, &waveBlocks[i], sizeof(WAVEHDR));
	if(result != MMSYSERR_NOERROR) {
	qWarning("QAudioInput: failed to setup block %d,err=%d",i,result);
	errorState = QAudio::OpenError;
	deviceState = QAudio::StoppedState;
	emit stateChanged(deviceState);
	return;
	}
	}

	mutex.lock();
	waveFreeBlockCount = buffer_size/period_size;
	mutex.unlock();

	waveCurrentBlock = 0;
	header = 0;
	resuming = true;
	waveInStart(hWaveIn);
	QTimer::singleShot(20,this,SLOT(feedback()));
	emit stateChanged(deviceState);
	}
	}

	void QAudioInputPrivate::setBufferSize(int value)
	{
	buffer_size = value;
	}

	int QAudioInputPrivate::bufferSize() const
	{
	return buffer_size;
	}

	int QAudioInputPrivate::periodSize() const
	{
	return period_size;
	}

	void QAudioInputPrivate::setNotifyInterval(int ms)
	{
	intervalTime = qMax(0, ms);
	}

	int QAudioInputPrivate::notifyInterval() const
	{
	return intervalTime;
	}

	qint64 QAudioInputPrivate::processedUSecs() const
	{
	if (deviceState == QAudio::StoppedState)
	return 0;
	qint64 result = qint64(1000000) * totalTimeValue /
	(settings.channels()*(settings.sampleSize()/8)) /
	settings.frequency();

	return result;
	}

	void QAudioInputPrivate::suspend()
	{
	if(deviceState == QAudio::ActiveState) {
	waveInReset(hWaveIn);
	deviceState = QAudio::SuspendedState;
	emit stateChanged(deviceState);
	}
	}

	void QAudioInputPrivate::feedback()
	{
	#ifdef DEBUG_AUDIO
	QTime now(QTime::currentTime());
	qDebug()<<now.second()<<"s "<<now.msec()<<"ms :feedback() INPUT "<<this;
	#endif
	if(!(deviceState==QAudio::StoppedState\|\|deviceState==QAudio::SuspendedState))
	QMetaObject::invokeMethod(this, "deviceReady", Qt::QueuedConnection);
	}

	bool QAudioInputPrivate::deviceReady()
	{
	bytesAvailable = bytesReady();
	#ifdef DEBUG_AUDIO
	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, buffer_size);
	} else {
	// emits readyRead() so user will call read() on QIODevice to get some audio data
	InputPrivate* a = qobject_cast<InputPrivate*>(audioSource);
	a->trigger();
	}

	if(intervalTime && (timeStamp.elapsed() + elapsedTimeOffset) > intervalTime) {
	emit notify();
	elapsedTimeOffset = timeStamp.elapsed() + elapsedTimeOffset - intervalTime;
	timeStamp.restart();
	}
	return true;
	}

	qint64 QAudioInputPrivate::elapsedUSecs() const
	{
	if (deviceState == QAudio::StoppedState)
	return 0;

	return timeStampOpened.elapsed()*1000;
	}

	void QAudioInputPrivate::reset()
	{
	close();
	}

	InputPrivate::InputPrivate(QAudioInputPrivate* audio)
	{
	audioDevice = qobject_cast<QAudioInputPrivate*>(audio);
	}

	InputPrivate::~InputPrivate() {}

	qint64 InputPrivate::readData( char* data, qint64 len)
	{
	// push mode, user read() called
	if(audioDevice->deviceState != QAudio::ActiveState &&
	audioDevice->deviceState != QAudio::IdleState)
	return 0;
	// Read in some audio data
	return audioDevice->read(data,len);
	}

	qint64 InputPrivate::writeData(const char* data, qint64 len)
	{
	Q_UNUSED(data)
	Q_UNUSED(len)

	emit readyRead();
	return 0;
	}

	void InputPrivate::trigger()
	{
	emit readyRead();
	}

	QT_END_NAMESPACE