Mercurial Mercurial > oss > MCL > sf > mw > qt / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/multimedia/audio/qaudioinput_win32_p.cpp
branchRCL_3
changeset 7 3f74d0d4af4c
parent 4 3b1da2848fc7
child 13 c0432d11811c
equal deleted inserted replaced
6:dee5afe5301f 7:3f74d0d4af4c 
   190 
   190 
   191     if(device) {
 
   191     if(device) {
 
   192         //set to pull mode
 
   192         //set to pull mode
 
   193         pullMode = true;
 
   193         pullMode = true;
 
   194         audioSource = device;
 
   194         audioSource = device;
 
       
   195         deviceState = QAudio::ActiveState;
 
   195     } else {
 
   196     } else {
 
   196         //set to push mode
 
   197         //set to push mode
 
   197         pullMode = false;
 
   198         pullMode = false;
 
       
   199         deviceState = QAudio::IdleState;
 
   198         audioSource = new InputPrivate(this);
 
   200         audioSource = new InputPrivate(this);
 
   199         audioSource->open(QIODevice::ReadOnly | QIODevice::Unbuffered);
 
   201         audioSource->open(QIODevice::ReadOnly | QIODevice::Unbuffered);
 
   200     }
 
   202     }
 
   201 
   203 
   202     if( !open() )
 
   204     if( !open() )
 
   304     }
 
   306     }
 
   305     timeStampOpened.restart();
 
   307     timeStampOpened.restart();
 
   306     elapsedTimeOffset = 0;
 
   308     elapsedTimeOffset = 0;
 
   307     totalTimeValue = 0;
 
   309     totalTimeValue = 0;
 
   308     errorState  = QAudio::NoError;
 
   310     errorState  = QAudio::NoError;
 
   309     deviceState = QAudio::ActiveState;
 
       
   310     return true;
 
   311     return true;
 
   311 }
 
   312 }
 
   312 
   313 
   313 void QAudioInputPrivate::close()
 
   314 void QAudioInputPrivate::close()
 
   314 {
 
   315 {
 
   315     if(deviceState == QAudio::StoppedState)
 
   316     if(deviceState == QAudio::StoppedState)
 
   316         return;
 
   317         return;
 
   317 
   318 
       
   319     deviceState = QAudio::StoppedState;
 
   318     waveInReset(hWaveIn);
 
   320     waveInReset(hWaveIn);
 
   319     waveInClose(hWaveIn);
 
   321     waveInClose(hWaveIn);
 
   320     deviceState = QAudio::StoppedState;
 
       
   321 
   322 
   322     int count = 0;
 
   323     int count = 0;
 
   323     while(!finished && count < 500) {
 
   324     while(!finished && count < 500) {
 
   324         count++;
 
   325         count++;
 
   325         Sleep(10);
 
   326         Sleep(10);
 
   350     bool done = false;
 
   351     bool done = false;
 
   351 
   352 
   352     char*  p = data;
 
   353     char*  p = data;
 
   353     qint64 l = 0;
 
   354     qint64 l = 0;
 
   354     qint64 written = 0;
 
   355     qint64 written = 0;
 
   355 
       
   356     while(!done) {
 
   356     while(!done) {
 
   357         // Read in some audio data
 
   357         // Read in some audio data
 
   358         if(waveBlocks[header].dwBytesRecorded > 0 && waveBlocks[header].dwFlags & WHDR_DONE) {
 
   358         if(waveBlocks[header].dwBytesRecorded > 0 && waveBlocks[header].dwFlags & WHDR_DONE) {
 
   359             if(pullMode) {
 
   359             if(pullMode) {
 
   360                 l = audioSource->write(waveBlocks[header].lpData,
 
   360                 l = audioSource->write(waveBlocks[header].lpData,
 
   371                     // cant write to IODevice
 
   371                     // cant write to IODevice
 
   372                     qWarning("QAudioInput: IOError, can't write to QIODevice");
 
   372                     qWarning("QAudioInput: IOError, can't write to QIODevice");
 
   373                     errorState = QAudio::IOError;
 
   373                     errorState = QAudio::IOError;
 
   374 
   374 
   375                 } else {
 
   375                 } else {
 
   376                     totalTimeValue += waveBlocks[header].dwBytesRecorded
 
   376                     totalTimeValue += waveBlocks[header].dwBytesRecorded;
 
   377                         /((settings.channels()*settings.sampleSize()/8))
 
       
   378                         *10000/settings.frequency()*100;
 
       
   379                     errorState = QAudio::NoError;
 
   377                     errorState = QAudio::NoError;
 
   380                     deviceState = QAudio::ActiveState;
 
   378                     if (deviceState != QAudio::ActiveState) {
 
       
   379                         deviceState = QAudio::ActiveState;
 
       
   380                         emit stateChanged(deviceState);
 
       
   381                     }
 
   381 		    resuming = false;
 
   382 		    resuming = false;
 
   382                 }
 
   383                 }
 
   383             } else {
 
   384             } else {
 
   384                 // push mode
 
   385                 // push mode
 
   385                 memcpy(p,waveBlocks[header].lpData,waveBlocks[header].dwBytesRecorded);
 
   386                 memcpy(p,waveBlocks[header].lpData,waveBlocks[header].dwBytesRecorded);
 
   386                 l = waveBlocks[header].dwBytesRecorded;
 
   387                 l = waveBlocks[header].dwBytesRecorded;
 
   387 #ifdef DEBUG_AUDIO
 
   388 #ifdef DEBUG_AUDIO
 
   388                 qDebug()<<"IN: "<<waveBlocks[header].dwBytesRecorded<<", OUT: "<<l;
 
   389                 qDebug()<<"IN: "<<waveBlocks[header].dwBytesRecorded<<", OUT: "<<l;
 
   389 #endif
 
   390 #endif
 
   390                 totalTimeValue += waveBlocks[header].dwBytesRecorded
 
   391                 totalTimeValue += waveBlocks[header].dwBytesRecorded;
 
   391                     /((settings.channels()*settings.sampleSize()/8))
 
       
   392                     *10000/settings.frequency()*100;
 
       
   393                 errorState = QAudio::NoError;
 
   392                 errorState = QAudio::NoError;
 
   394                 deviceState = QAudio::ActiveState;
 
   393                 if (deviceState != QAudio::ActiveState) {
 
       
   394                     deviceState = QAudio::ActiveState;
 
       
   395                     emit stateChanged(deviceState);
 
       
   396                 }
 
   395 		resuming = false;
 
   397 		resuming = false;
 
   396             }
 
   398             }
 
   397         } else {
 
   399         } else {
 
   398             //no data, not ready yet, next time
 
   400             //no data, not ready yet, next time
 
   399             return 0;
 
   401             break;
 
   400         }
 
   402         }
 
   401 
   403 
   402         waveInUnprepareHeader(hWaveIn,&waveBlocks[header], sizeof(WAVEHDR));
 
   404         waveInUnprepareHeader(hWaveIn,&waveBlocks[header], sizeof(WAVEHDR));
 
   403 
   405 
   404         EnterCriticalSection(&waveInCriticalSection);
 
   406         EnterCriticalSection(&waveInCriticalSection);
 
   503     return intervalTime;
 
   505     return intervalTime;
 
   504 }
 
   506 }
 
   505 
   507 
   506 qint64 QAudioInputPrivate::processedUSecs() const
 
   508 qint64 QAudioInputPrivate::processedUSecs() const
 
   507 {
 
   509 {
 
   508     return totalTimeValue;
 
   510     if (deviceState == QAudio::StoppedState)
 
       
   511         return 0;
 
       
   512     qint64 result = qint64(1000000) * totalTimeValue /
 
       
   513         (settings.channels()*(settings.sampleSize()/8)) /
 
       
   514         settings.frequency();
 
       
   515 
       
   516     return result;
 
   509 }
 
   517 }
 
   510 
   518 
   511 void QAudioInputPrivate::suspend()
 
   519 void QAudioInputPrivate::suspend()
 
   512 {
 
   520 {
 
   513     if(deviceState == QAudio::ActiveState) {
 
   521     if(deviceState == QAudio::ActiveState) {
 
   533 {
 
   541 {
 
   534 #ifdef DEBUG_AUDIO
 
   542 #ifdef DEBUG_AUDIO
 
   535     QTime now(QTime::currentTime());
 
   543     QTime now(QTime::currentTime());
 
   536     qDebug()<<now.second()<<"s "<<now.msec()<<"ms :deviceReady() INPUT";
 
   544     qDebug()<<now.second()<<"s "<<now.msec()<<"ms :deviceReady() INPUT";
 
   537 #endif
 
   545 #endif
 
       
   546     if(deviceState != QAudio::ActiveState && deviceState != QAudio::IdleState)
 
       
   547         return true;
 
       
   548 
   538     if(pullMode) {
 
   549     if(pullMode) {
 
   539         // reads some audio data and writes it to QIODevice
 
   550         // reads some audio data and writes it to QIODevice
 
   540         read(0,0);
 
   551         read(0,0);
 
   541     } else {
 
   552     } else {
 
   542         // emits readyRead() so user will call read() on QIODevice to get some audio data
 
   553         // emits readyRead() so user will call read() on QIODevice to get some audio data
 
   543 	InputPrivate* a = qobject_cast<InputPrivate*>(audioSource);
 
   554 	InputPrivate* a = qobject_cast<InputPrivate*>(audioSource);
 
   544 	a->trigger();
 
   555 	a->trigger();
 
   545     }
 
   556     }
 
   546     if(deviceState != QAudio::ActiveState)
 
       
   547         return true;
 
       
   548 
   557 
   549     if((timeStamp.elapsed() + elapsedTimeOffset) > intervalTime) {
 
   558     if((timeStamp.elapsed() + elapsedTimeOffset) > intervalTime) {
 
   550         emit notify();
 
   559         emit notify();
 
   551         elapsedTimeOffset = timeStamp.elapsed() + elapsedTimeOffset - intervalTime;
 
   560         elapsedTimeOffset = timeStamp.elapsed() + elapsedTimeOffset - intervalTime;
 
   552         timeStamp.restart();
 
   561         timeStamp.restart();
 
   575 InputPrivate::~InputPrivate() {}
 
   584 InputPrivate::~InputPrivate() {}
 
   576 
   585 
   577 qint64 InputPrivate::readData( char* data, qint64 len)
 
   586 qint64 InputPrivate::readData( char* data, qint64 len)
 
   578 {
 
   587 {
 
   579     // push mode, user read() called
 
   588     // push mode, user read() called
 
   580     if(audioDevice->deviceState != QAudio::ActiveState)
 
   589     if(audioDevice->deviceState != QAudio::ActiveState &&
 
       
   590             audioDevice->deviceState != QAudio::IdleState)
 
   581         return 0;
 
   591         return 0;
 
   582     // Read in some audio data
 
   592     // Read in some audio data
 
   583     return audioDevice->read(data,len);
 
   593     return audioDevice->read(data,len);
 
   584 }
 
   594 }
 
   585 
   595
MCL/sf/mw/qt