1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 //

    43 //  W A R N I N G

    44 //  -------------

    45 //

    46 // This file is not part of the Qt API.  It exists for the convenience

    47 // of other Qt classes.  This header file may change from version to

    48 // version without notice, or even be removed.

    49 //

    50 // We mean it.

    51 //

    52 

    53 #include <QtCore/qcoreapplication.h>

    54 #include "qaudioinput_alsa_p.h"

    55 #include "qaudiodeviceinfo_alsa_p.h"

    56 

    57 QT_BEGIN_NAMESPACE

    58 

    59 //#define DEBUG_AUDIO 1

    60 

    61 QAudioInputPrivate::QAudioInputPrivate(const QByteArray &device)

    62 {

    63     bytesAvailable = 0;

    64     handle = 0;

    65     ahandler = 0;

    66     access = SND_PCM_ACCESS_RW_INTERLEAVED;

    67     pcmformat = SND_PCM_FORMAT_S16;

    68     buffer_size = 0;

    69     period_size = 0;

    70     buffer_time = 100000;

    71     period_time = 20000;

    72     totalTimeValue = 0;

    73     intervalTime = 1000;

    74     audioBuffer = 0;

    75     errorState = QAudio::NoError;

    76     deviceState = QAudio::StoppedState;

    77     audioSource = 0;

    78     pullMode = true;

    79     resuming = false;

    80 

    81     m_device = device;

    82 

    83     timer = new QTimer(this);

    84     connect(timer,SIGNAL(timeout()),SLOT(userFeed()));

    85 }

    86 

    87 QAudioInputPrivate::~QAudioInputPrivate()

    88 {

    89     close();

    90     disconnect(timer, SIGNAL(timeout()));

    91     QCoreApplication::processEvents();

    92     delete timer;

    93 }

    94 

    95 QAudio::Error QAudioInputPrivate::error() const

    96 {

    97     return errorState;

    98 }

    99 

   100 QAudio::State QAudioInputPrivate::state() const

   101 {

   102     return deviceState;

   103 }

   104 

   105 void QAudioInputPrivate::setFormat(const QAudioFormat& fmt)

   106 {

   107     if (deviceState == QAudio::StoppedState)

   108         settings = fmt;

   109 }

   110 

   111 QAudioFormat QAudioInputPrivate::format() const

   112 {

   113     return settings;

   114 }

   115 

   116 int QAudioInputPrivate::xrun_recovery(int err)

   117 {

   118     int  count = 0;

   119     bool reset = false;

   120 

   121     if(err == -EPIPE) {

   122         errorState = QAudio::UnderrunError;

   123         err = snd_pcm_prepare(handle);

   124         if(err < 0)

   125             reset = true;

   126         else {

   127             bytesAvailable = bytesReady();

   128             if (bytesAvailable <= 0)

   129                 reset = true;

   130         }

   131 

   132     } else if((err == -ESTRPIPE)||(err == -EIO)) {

   133         errorState = QAudio::IOError;

   134         while((err = snd_pcm_resume(handle)) == -EAGAIN){

   135             usleep(100);

   136             count++;

   137             if(count > 5) {

   138                 reset = true;

   139                 break;

   140             }

   141         }

   142         if(err < 0) {

   143             err = snd_pcm_prepare(handle);

   144             if(err < 0)

   145                 reset = true;

   146         }

   147     }

   148     if(reset) {

   149         close();

   150         open();

   151         snd_pcm_prepare(handle);

   152         return 0;

   153     }

   154     return err;

   155 }

   156 

   157 int QAudioInputPrivate::setFormat()

   158 {

   159     snd_pcm_format_t format = SND_PCM_FORMAT_S16;

   160 

   161     if(settings.sampleSize() == 8) {

   162         format = SND_PCM_FORMAT_U8;

   163     } else if(settings.sampleSize() == 16) {

   164         if(settings.sampleType() == QAudioFormat::SignedInt) {

   165             if(settings.byteOrder() == QAudioFormat::LittleEndian)

   166                 format = SND_PCM_FORMAT_S16_LE;

   167             else

   168                 format = SND_PCM_FORMAT_S16_BE;

   169         } else if(settings.sampleType() == QAudioFormat::UnSignedInt) {

   170             if(settings.byteOrder() == QAudioFormat::LittleEndian)

   171                 format = SND_PCM_FORMAT_U16_LE;

   172             else

   173                 format = SND_PCM_FORMAT_U16_BE;

   174         }

   175     } else if(settings.sampleSize() == 24) {

   176         if(settings.sampleType() == QAudioFormat::SignedInt) {

   177             if(settings.byteOrder() == QAudioFormat::LittleEndian)

   178                 format = SND_PCM_FORMAT_S24_LE;

   179             else

   180                 format = SND_PCM_FORMAT_S24_BE;

   181         } else if(settings.sampleType() == QAudioFormat::UnSignedInt) {

   182             if(settings.byteOrder() == QAudioFormat::LittleEndian)

   183                 format = SND_PCM_FORMAT_U24_LE;

   184             else

   185                 format = SND_PCM_FORMAT_U24_BE;

   186         }

   187     } else if(settings.sampleSize() == 32) {

   188         if(settings.sampleType() == QAudioFormat::SignedInt) {

   189             if(settings.byteOrder() == QAudioFormat::LittleEndian)

   190                 format = SND_PCM_FORMAT_S32_LE;

   191             else

   192                 format = SND_PCM_FORMAT_S32_BE;

   193         } else if(settings.sampleType() == QAudioFormat::UnSignedInt) {

   194             if(settings.byteOrder() == QAudioFormat::LittleEndian)

   195                 format = SND_PCM_FORMAT_U32_LE;

   196             else

   197                 format = SND_PCM_FORMAT_U32_BE;

   198         } else if(settings.sampleType() == QAudioFormat::Float) {

   199             if(settings.byteOrder() == QAudioFormat::LittleEndian)

   200                 format = SND_PCM_FORMAT_FLOAT_LE;

   201             else

   202                 format = SND_PCM_FORMAT_FLOAT_BE;

   203         }

   204     } else if(settings.sampleSize() == 64) {

   205         if(settings.byteOrder() == QAudioFormat::LittleEndian)

   206             format = SND_PCM_FORMAT_FLOAT64_LE;

   207         else

   208             format = SND_PCM_FORMAT_FLOAT64_BE;

   209     }

   210 

   211     return snd_pcm_hw_params_set_format( handle, hwparams, format);

   212 }

   213 

   214 void QAudioInputPrivate::start(QIODevice* device)

   215 {

   216     if(deviceState != QAudio::StoppedState)

   217         close();

   218 

   219     if(!pullMode && audioSource)

   220         delete audioSource;

   221 

   222     pullMode = true;

   223     audioSource = device;

   224 

   225     deviceState = QAudio::ActiveState;

   226 

   227     if( !open() )

   228         return;

   229 

   230     emit stateChanged(deviceState);

   231 }

   232 

   233 QIODevice* QAudioInputPrivate::start()

   234 {

   235     if(deviceState != QAudio::StoppedState)

   236         close();

   237 

   238     if(!pullMode && audioSource)

   239         delete audioSource;

   240 

   241     pullMode = false;

   242     audioSource = new InputPrivate(this);

   243     audioSource->open(QIODevice::ReadOnly | QIODevice::Unbuffered);

   244 

   245     deviceState = QAudio::IdleState;

   246 

   247     if( !open() )

   248         return 0;

   249 

   250     emit stateChanged(deviceState);

   251 

   252     return audioSource;

   253 }

   254 

   255 void QAudioInputPrivate::stop()

   256 {

   257     if(deviceState == QAudio::StoppedState)

   258         return;

   259 

   260     deviceState = QAudio::StoppedState;

   261 

   262     close();

   263     emit stateChanged(deviceState);

   264 }

   265 

   266 bool QAudioInputPrivate::open()

   267 {

   268 #ifdef DEBUG_AUDIO

   269     QTime now(QTime::currentTime());

   270     qDebug()<<now.second()<<"s "<<now.msec()<<"ms :open()";

   271 #endif

   272     clockStamp.restart();

   273     timeStamp.restart();

   274     elapsedTimeOffset = 0;

   275 

   276     int dir;

   277     int err=-1;

   278     int count=0;

   279     unsigned int freakuency=settings.frequency();

   280 

   281     QString dev = QString(QLatin1String(m_device.constData()));

   282     QList<QByteArray> devices = QAudioDeviceInfoInternal::availableDevices(QAudio::AudioInput);

   283     if(dev.compare(QLatin1String("default")) == 0) {

   284 #if(SND_LIB_MAJOR == 1 && SND_LIB_MINOR == 0 && SND_LIB_SUBMINOR >= 14)

   285         dev = QLatin1String(devices.first());

   286 #else

   287         dev = QLatin1String("hw:0,0");

   288 #endif

   289     } else {

   290 #if(SND_LIB_MAJOR == 1 && SND_LIB_MINOR == 0 && SND_LIB_SUBMINOR >= 14)

   291         dev = QLatin1String(m_device);

   292 #else

   293         int idx = 0;

   294         char *name;

   295 

   296         QString shortName = QLatin1String(m_device.mid(m_device.indexOf('=',0)+1).constData());

   297 

   298         while(snd_card_get_name(idx,&name) == 0) {

   299             if(qstrncmp(shortName.toLocal8Bit().constData(),name,shortName.length()) == 0)

   300                 break;

   301             idx++;

   302         }

   303         dev = QString(QLatin1String("hw:%1,0")).arg(idx);

   304 #endif

   305     }

   306 

   307     // Step 1: try and open the device

   308     while((count < 5) && (err < 0)) {

   309         err=snd_pcm_open(&handle,dev.toLocal8Bit().constData(),SND_PCM_STREAM_CAPTURE,0);

   310         if(err < 0)

   311             count++;

   312     }

   313     if (( err < 0)||(handle == 0)) {

   314         errorState = QAudio::OpenError;

   315         deviceState = QAudio::StoppedState;

   316         emit stateChanged(deviceState);

   317         return false;

   318     }

   319     snd_pcm_nonblock( handle, 0 );

   320 

   321     // Step 2: Set the desired HW parameters.

   322     snd_pcm_hw_params_alloca( &hwparams );

   323 

   324     bool fatal = false;

   325     QString errMessage;

   326     unsigned int chunks = 8;

   327 

   328     err = snd_pcm_hw_params_any( handle, hwparams );

   329     if ( err < 0 ) {

   330         fatal = true;

   331         errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_any: err = %1").arg(err);

   332     }

   333     if ( !fatal ) {

   334         err = snd_pcm_hw_params_set_rate_resample( handle, hwparams, 1 );

   335         if ( err < 0 ) {

   336             fatal = true;

   337             errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_rate_resample: err = %1").arg(err);

   338         }

   339     }

   340     if ( !fatal ) {

   341         err = snd_pcm_hw_params_set_access( handle, hwparams, access );

   342         if ( err < 0 ) {

   343             fatal = true;

   344             errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_access: err = %1").arg(err);

   345         }

   346     }

   347     if ( !fatal ) {

   348         err = setFormat();

   349         if ( err < 0 ) {

   350             fatal = true;

   351             errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_format: err = %1").arg(err);

   352         }

   353     }

   354     if ( !fatal ) {

   355         err = snd_pcm_hw_params_set_channels( handle, hwparams, (unsigned int)settings.channels() );

   356         if ( err < 0 ) {

   357             fatal = true;

   358             errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_channels: err = %1").arg(err);

   359         }

   360     }

   361     if ( !fatal ) {

   362         err = snd_pcm_hw_params_set_rate_near( handle, hwparams, &freakuency, 0 );

   363         if ( err < 0 ) {

   364             fatal = true;

   365             errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_rate_near: err = %1").arg(err);

   366         }

   367     }

   368     if ( !fatal ) {

   369         err = snd_pcm_hw_params_set_buffer_time_near(handle, hwparams, &buffer_time, &dir);

   370         if ( err < 0 ) {

   371             fatal = true;

   372             errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_buffer_time_near: err = %1").arg(err);

   373         }

   374     }

   375     if ( !fatal ) {

   376         err = snd_pcm_hw_params_set_period_time_near(handle, hwparams, &period_time, &dir);

   377         if ( err < 0 ) {

   378             fatal = true;

   379             errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_period_time_near: err = %1").arg(err);

   380         }

   381     }

   382     if ( !fatal ) {

   383         err = snd_pcm_hw_params_set_periods_near(handle, hwparams, &chunks, &dir);

   384         if ( err < 0 ) {

   385             fatal = true;

   386             errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params_set_periods_near: err = %1").arg(err);

   387         }

   388     }

   389     if ( !fatal ) {

   390         err = snd_pcm_hw_params(handle, hwparams);

   391         if ( err < 0 ) {

   392             fatal = true;

   393             errMessage = QString::fromLatin1("QAudioInput: snd_pcm_hw_params: err = %1").arg(err);

   394         }

   395     }

   396     if( err < 0) {

   397         qWarning()<<errMessage;

   398         errorState = QAudio::OpenError;

   399         deviceState = QAudio::StoppedState;

   400         emit stateChanged(deviceState);

   401         return false;

   402     }

   403     snd_pcm_hw_params_get_buffer_size(hwparams,&buffer_frames);

   404     buffer_size = snd_pcm_frames_to_bytes(handle,buffer_frames);

   405     snd_pcm_hw_params_get_period_size(hwparams,&period_frames, &dir);

   406     period_size = snd_pcm_frames_to_bytes(handle,period_frames);

   407     snd_pcm_hw_params_get_buffer_time(hwparams,&buffer_time, &dir);

   408     snd_pcm_hw_params_get_period_time(hwparams,&period_time, &dir);

   409 

   410     // Step 3: Set the desired SW parameters.

   411     snd_pcm_sw_params_t *swparams;

   412     snd_pcm_sw_params_alloca(&swparams);

   413     snd_pcm_sw_params_current(handle, swparams);

   414     snd_pcm_sw_params_set_start_threshold(handle,swparams,period_frames);

   415     snd_pcm_sw_params_set_stop_threshold(handle,swparams,buffer_frames);

   416     snd_pcm_sw_params_set_avail_min(handle, swparams,period_frames);

   417     snd_pcm_sw_params(handle, swparams);

   418 

   419     // Step 4: Prepare audio

   420     if(audioBuffer == 0)

   421         audioBuffer = new char[buffer_size];

   422     snd_pcm_prepare( handle );

   423     snd_pcm_start(handle);

   424 

   425     // Step 5: Setup timer

   426     bytesAvailable = bytesReady();

   427 

   428     if(pullMode)

   429         connect(audioSource,SIGNAL(readyRead()),this,SLOT(userFeed()));

   430 

   431     // Step 6: Start audio processing

   432     chunks = buffer_size/period_size;

   433     timer->start(period_time*chunks/2000);

   434 

   435     errorState  = QAudio::NoError;

   436 

   437     totalTimeValue = 0;

   438 

   439     return true;

   440 }

   441 

   442 void QAudioInputPrivate::close()

   443 {

   444     timer->stop();

   445 

   446     if ( handle ) {

   447         snd_pcm_drop( handle );

   448         snd_pcm_close( handle );

   449         handle = 0;

   450         delete [] audioBuffer;

   451         audioBuffer=0;

   452     }

   453 }

   454 

   455 int QAudioInputPrivate::bytesReady() const

   456 {

   457     if(resuming)

   458         return period_size;

   459 

   460     if(deviceState != QAudio::ActiveState && deviceState != QAudio::IdleState)

   461         return 0;

   462     int frames = snd_pcm_avail_update(handle);

   463     if (frames < 0) return frames;

   464     if((int)frames > (int)buffer_frames)

   465         frames = buffer_frames;

   466 

   467     return snd_pcm_frames_to_bytes(handle, frames);

   468 }

   469 

   470 qint64 QAudioInputPrivate::read(char* data, qint64 len)

   471 {

   472     Q_UNUSED(len)

   473 

   474     // Read in some audio data and write it to QIODevice, pull mode

   475     if ( !handle )

   476         return 0;

   477 

   478     bytesAvailable = bytesReady();

   479 

   480     if (bytesAvailable < 0) {

   481         // bytesAvailable as negative is error code, try to recover from it.

   482         xrun_recovery(bytesAvailable);

   483         bytesAvailable = bytesReady();

   484         if (bytesAvailable < 0) {

   485             // recovery failed must stop and set error.

   486             close();

   487             errorState = QAudio::IOError;

   488             deviceState = QAudio::StoppedState;

   489             emit stateChanged(deviceState);

   490             return 0;

   491         }

   492     }

   493 

   494     int count=0, err = 0;

   495     while(count < 5) {

   496         int chunks = bytesAvailable/period_size;

   497         int frames = chunks*period_frames;

   498         if(frames > (int)buffer_frames)

   499             frames = buffer_frames;

   500         int readFrames = snd_pcm_readi(handle, audioBuffer, frames);

   501         if (readFrames >= 0) {

   502             err = snd_pcm_frames_to_bytes(handle, readFrames);

   503 #ifdef DEBUG_AUDIO

   504             qDebug()<<QString::fromLatin1("read in bytes = %1 (frames=%2)").arg(err).arg(readFrames).toLatin1().constData();

   505 #endif

   506             break;

   507         } else if((readFrames == -EAGAIN) || (readFrames == -EINTR)) {

   508             errorState = QAudio::IOError;

   509             err = 0;

   510             break;

   511         } else {

   512             if(readFrames == -EPIPE) {

   513                 errorState = QAudio::UnderrunError;

   514                 err = snd_pcm_prepare(handle);

   515             } else if(readFrames == -ESTRPIPE) {

   516                 err = snd_pcm_prepare(handle);

   517             }

   518             if(err != 0) break;

   519         }

   520         count++;

   521     }

   522     if(err > 0) {

   523         // got some send it onward

   524 #ifdef DEBUG_AUDIO

   525         qDebug()<<"frames to write to QIODevice = "<<

   526             snd_pcm_bytes_to_frames( handle, (int)err )<<" ("<<err<<") bytes";

   527 #endif

   528         if(deviceState != QAudio::ActiveState && deviceState != QAudio::IdleState)

   529             return 0;

   530         if (pullMode) {

   531             qint64 l = audioSource->write(audioBuffer,err);

   532             if(l < 0) {

   533                 close();

   534                 errorState = QAudio::IOError;

   535                 deviceState = QAudio::StoppedState;

   536                 emit stateChanged(deviceState);

   537             } else if(l == 0) {

   538                 if (deviceState != QAudio::IdleState) {

   539                     errorState = QAudio::NoError;

   540                     deviceState = QAudio::IdleState;

   541                     emit stateChanged(deviceState);

   542                 }

   543             } else {

   544                 totalTimeValue += err;

   545                 resuming = false;

   546                 if (deviceState != QAudio::ActiveState) {

   547                     errorState = QAudio::NoError;

   548                     deviceState = QAudio::ActiveState;

   549                     emit stateChanged(deviceState);

   550                 }

   551             }

   552             return l;

   553 

   554         } else {

   555             memcpy(data,audioBuffer,err);

   556             totalTimeValue += err;

   557             resuming = false;

   558             if (deviceState != QAudio::ActiveState) {

   559                 errorState = QAudio::NoError;

   560                 deviceState = QAudio::ActiveState;

   561                 emit stateChanged(deviceState);

   562             }

   563             return err;

   564         }

   565     }

   566     return 0;

   567 }

   568 

   569 void QAudioInputPrivate::resume()

   570 {

   571     if(deviceState == QAudio::SuspendedState) {

   572         int err = 0;

   573 

   574         if(handle) {

   575             err = snd_pcm_prepare( handle );

   576             if(err < 0)

   577                 xrun_recovery(err);

   578 

   579             err = snd_pcm_start(handle);

   580             if(err < 0)

   581                 xrun_recovery(err);

   582 

   583             bytesAvailable = buffer_size;

   584         }

   585         resuming = true;

   586         deviceState = QAudio::ActiveState;

   587         int chunks = buffer_size/period_size;

   588         timer->start(period_time*chunks/2000);

   589         emit stateChanged(deviceState);

   590     }

   591 }

   592 

   593 void QAudioInputPrivate::setBufferSize(int value)

   594 {

   595     buffer_size = value;

   596 }

   597 

   598 int QAudioInputPrivate::bufferSize() const

   599 {

   600     return buffer_size;

   601 }

   602 

   603 int QAudioInputPrivate::periodSize() const

   604 {

   605     return period_size;

   606 }

   607 

   608 void QAudioInputPrivate::setNotifyInterval(int ms)

   609 {

   610     intervalTime = qMax(0, ms);

   611 }

   612 

   613 int QAudioInputPrivate::notifyInterval() const

   614 {

   615     return intervalTime;

   616 }

   617 

   618 qint64 QAudioInputPrivate::processedUSecs() const

   619 {

   620     qint64 result = qint64(1000000) * totalTimeValue /

   621         (settings.channels()*(settings.sampleSize()/8)) /

   622         settings.frequency();

   623 

   624     return result;

   625 }

   626 

   627 void QAudioInputPrivate::suspend()

   628 {

   629     if(deviceState == QAudio::ActiveState||resuming) {

   630         timer->stop();

   631         deviceState = QAudio::SuspendedState;

   632         emit stateChanged(deviceState);

   633     }

   634 }

   635 

   636 void QAudioInputPrivate::userFeed()

   637 {

   638     if(deviceState == QAudio::StoppedState || deviceState == QAudio::SuspendedState)

   639         return;

   640 #ifdef DEBUG_AUDIO

   641     QTime now(QTime::currentTime());

   642     qDebug()<<now.second()<<"s "<<now.msec()<<"ms :userFeed() IN";

   643 #endif

   644     deviceReady();

   645 }

   646 

   647 bool QAudioInputPrivate::deviceReady()

   648 {

   649     if(pullMode) {

   650         // reads some audio data and writes it to QIODevice

   651         read(0,0);

   652     } else {

   653         // emits readyRead() so user will call read() on QIODevice to get some audio data

   654         InputPrivate* a = qobject_cast<InputPrivate*>(audioSource);

   655         a->trigger();

   656     }

   657     bytesAvailable = bytesReady();

   658 

   659     if(deviceState != QAudio::ActiveState)

   660         return true;

   661 

   662     if(intervalTime && (timeStamp.elapsed() + elapsedTimeOffset) > intervalTime) {

   663         emit notify();

   664         elapsedTimeOffset = timeStamp.elapsed() + elapsedTimeOffset - intervalTime;

   665         timeStamp.restart();

   666     }

   667     return true;

   668 }

   669 

   670 qint64 QAudioInputPrivate::elapsedUSecs() const

   671 {

   672     if (deviceState == QAudio::StoppedState)

   673         return 0;

   674 

   675     return clockStamp.elapsed()*1000;

   676 }

   677 

   678 void QAudioInputPrivate::reset()

   679 {

   680     if(handle)

   681         snd_pcm_reset(handle);

   682 }

   683 

   684 void QAudioInputPrivate::drain()

   685 {

   686     if(handle)

   687         snd_pcm_drain(handle);

   688 }

   689 

   690 InputPrivate::InputPrivate(QAudioInputPrivate* audio)

   691 {

   692     audioDevice = qobject_cast<QAudioInputPrivate*>(audio);

   693 }

   694 

   695 InputPrivate::~InputPrivate()

   696 {

   697 }

   698 

   699 qint64 InputPrivate::readData( char* data, qint64 len)

   700 {

   701     return audioDevice->read(data,len);

   702 }

   703 

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

   705 {

   706     Q_UNUSED(data)

   707     Q_UNUSED(len)

   708     return 0;

   709 }

   710 

   711 void InputPrivate::trigger()

   712 {

   713     emit readyRead();

   714 }

   715 

   716 QT_END_NAMESPACE