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

     2 **

     3 ** Copyright (C) 2009 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 QtMultimedia module of the Qt Toolkit.

     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 

    56 QT_BEGIN_NAMESPACE

    57 

    58 //#define DEBUG_AUDIO 1

    59 

    60 static const int minimumIntervalTime = 50;

    61 

    62 QAudioInputPrivate::QAudioInputPrivate(const QByteArray &device, const QAudioFormat& audioFormat):

    63     settings(audioFormat)

    64 {

    65     bytesAvailable = 0;

    66     handle = 0;

    67     ahandler = 0;

    68     access = SND_PCM_ACCESS_RW_INTERLEAVED;

    69     pcmformat = SND_PCM_FORMAT_S16;

    70     buffer_size = 0;

    71     period_size = 0;

    72     buffer_time = 100000;

    73     period_time = 20000;

    74     totalTimeValue = 0;

    75     intervalTime = 1000;

    76     audioBuffer = 0;

    77     errorState = QAudio::NoError;

    78     deviceState = QAudio::StopState;

    79     audioSource = 0;

    80     pullMode = true;

    81     resuming = false;

    82 

    83     QStringList list1 = QString(QLatin1String(device)).split(QLatin1String(":"));

    84     m_device = QByteArray(list1.at(0).toLocal8Bit().constData());

    85 

    86     timer = new QTimer(this);

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

    88 }

    89 

    90 QAudioInputPrivate::~QAudioInputPrivate()

    91 {

    92     close();

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

    94     QCoreApplication::processEvents();

    95     delete timer;

    96 }

    97 

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

    99 {

   100     return errorState;

   101 }

   102 

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

   104 {

   105     return deviceState;

   106 }

   107 

   108 

   109 QAudioFormat QAudioInputPrivate::format() const

   110 {

   111     return settings;

   112 }

   113 

   114 int QAudioInputPrivate::xrun_recovery(int err)

   115 {

   116     int  count = 0;

   117     bool reset = false;

   118 

   119     if(err == -EPIPE) {

   120         errorState = QAudio::UnderrunError;

   121         err = snd_pcm_prepare(handle);

   122         if(err < 0)

   123             reset = true;

   124 

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

   126         errorState = QAudio::IOError;

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

   128             usleep(100);

   129             count++;

   130             if(count > 5) {

   131                 reset = true;

   132                 break;

   133             }

   134         }

   135         if(err < 0) {

   136             err = snd_pcm_prepare(handle);

   137             if(err < 0)

   138                 reset = true;

   139         }

   140     }

   141     if(reset) {

   142         close();

   143         open();

   144         snd_pcm_prepare(handle);

   145         return 0;

   146     }

   147     return err;

   148 }

   149 

   150 int QAudioInputPrivate::setFormat()

   151 {

   152     snd_pcm_format_t format = SND_PCM_FORMAT_S16;

   153 

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

   155         format = SND_PCM_FORMAT_U8;

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

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

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

   159                 format = SND_PCM_FORMAT_S16_LE;

   160             else

   161                 format = SND_PCM_FORMAT_S16_BE;

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

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

   164                 format = SND_PCM_FORMAT_U16_LE;

   165             else

   166                 format = SND_PCM_FORMAT_U16_BE;

   167         }

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

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

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

   171                 format = SND_PCM_FORMAT_S24_LE;

   172             else

   173                 format = SND_PCM_FORMAT_S24_BE;

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

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

   176                 format = SND_PCM_FORMAT_U24_LE;

   177             else

   178                 format = SND_PCM_FORMAT_U24_BE;

   179         }

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

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

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

   183                 format = SND_PCM_FORMAT_S32_LE;

   184             else

   185                 format = SND_PCM_FORMAT_S32_BE;

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

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

   188                 format = SND_PCM_FORMAT_U32_LE;

   189             else

   190                 format = SND_PCM_FORMAT_U32_BE;

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

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

   193                 format = SND_PCM_FORMAT_FLOAT_LE;

   194             else

   195                 format = SND_PCM_FORMAT_FLOAT_BE;

   196         }

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

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

   199             format = SND_PCM_FORMAT_FLOAT64_LE;

   200         else

   201             format = SND_PCM_FORMAT_FLOAT64_BE;

   202     }

   203 

   204     return snd_pcm_hw_params_set_format( handle, hwparams, format);

   205 }

   206 

   207 QIODevice* QAudioInputPrivate::start(QIODevice* device)

   208 {

   209     if(deviceState != QAudio::StopState)

   210         close();

   211 

   212     if(!pullMode && audioSource) {

   213         delete audioSource;

   214     }

   215 

   216     if(device) {

   217         //set to pull mode

   218         pullMode = true;

   219         audioSource = device;

   220     } else {

   221         //set to push mode

   222         pullMode = false;

   223         audioSource = new InputPrivate(this);

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

   225     }

   226 

   227     if( !open() )

   228         return 0;

   229 

   230     emit stateChanged(deviceState);

   231 

   232     return audioSource;

   233 }

   234 

   235 void QAudioInputPrivate::stop()

   236 {

   237     if(deviceState == QAudio::StopState)

   238         return;

   239 

   240     deviceState = QAudio::StopState;

   241 

   242     close();

   243     emit stateChanged(deviceState);

   244 }

   245 

   246 bool QAudioInputPrivate::open()

   247 {

   248 #ifdef DEBUG_AUDIO

   249     QTime now(QTime::currentTime());

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

   251 #endif

   252     clockStamp.restart();

   253     timeStamp.restart();

   254     elapsedTimeOffset = 0;

   255 

   256     int dir;

   257     int err=-1;

   258     int count=0;

   259     unsigned int freakuency=settings.frequency();

   260 

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

   262     if(!dev.contains(QLatin1String("default"))) {

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

   264         dev = QString(QLatin1String("default:CARD=%1")).arg(QLatin1String(m_device.constData()));

   265 #else

   266         int idx = 0;

   267         char *name;

   268 

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

   270             if(m_device.contains(name))

   271                 break;

   272             idx++;

   273         }

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

   275 #endif

   276     }

   277     

   278     // Step 1: try and open the device

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

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

   281         if(err < 0)

   282             count++;

   283     }

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

   285         errorState = QAudio::OpenError;

   286         deviceState = QAudio::StopState;

   287         emit stateChanged(deviceState);

   288         return false;

   289     }

   290     snd_pcm_nonblock( handle, 0 );

   291 

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

   293     snd_pcm_hw_params_alloca( &hwparams );

   294 

   295     bool fatal = false;

   296     QString errMessage;

   297     unsigned int chunks = 8;

   298 

   299     err = snd_pcm_hw_params_any( handle, hwparams );

   300     if ( err < 0 ) {

   301         fatal = true;

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

   303     }

   304     if ( !fatal ) {

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

   306         if ( err < 0 ) {

   307             fatal = true;

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

   309         }

   310     }

   311     if ( !fatal ) {

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

   313         if ( err < 0 ) {

   314             fatal = true;

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

   316         }

   317     }

   318     if ( !fatal ) {

   319         err = setFormat();

   320         if ( err < 0 ) {

   321             fatal = true;

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

   323         }

   324     }

   325     if ( !fatal ) {

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

   327         if ( err < 0 ) {

   328             fatal = true;

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

   330         }

   331     }

   332     if ( !fatal ) {

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

   334         if ( err < 0 ) {

   335             fatal = true;

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

   337         }

   338     }

   339     if ( !fatal ) {

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

   341         if ( err < 0 ) {

   342             fatal = true;

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

   344         }

   345     }

   346     if ( !fatal ) {

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

   348         if ( err < 0 ) {

   349             fatal = true;

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

   351         }

   352     }

   353     if ( !fatal ) {

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

   355         if ( err < 0 ) {

   356             fatal = true;

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

   358         }

   359     }

   360     if ( !fatal ) {

   361         err = snd_pcm_hw_params(handle, hwparams);

   362         if ( err < 0 ) {

   363             fatal = true;

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

   365         }

   366     }

   367     if( err < 0) {

   368         qWarning()<<errMessage;

   369         errorState = QAudio::OpenError;

   370         deviceState = QAudio::StopState;

   371         emit stateChanged(deviceState);

   372         return false;

   373     }

   374     snd_pcm_hw_params_get_buffer_size(hwparams,&buffer_frames);

   375     buffer_size = snd_pcm_frames_to_bytes(handle,buffer_frames);

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

   377     period_size = snd_pcm_frames_to_bytes(handle,period_frames);

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

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

   380 

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

   382     snd_pcm_sw_params_t *swparams;

   383     snd_pcm_sw_params_alloca(&swparams);

   384     snd_pcm_sw_params_current(handle, swparams);

   385     snd_pcm_sw_params_set_start_threshold(handle,swparams,period_frames);

   386     snd_pcm_sw_params_set_stop_threshold(handle,swparams,buffer_frames);

   387     snd_pcm_sw_params_set_avail_min(handle, swparams,period_frames);

   388     snd_pcm_sw_params(handle, swparams);

   389 

   390     // Step 4: Prepare audio

   391     if(audioBuffer == 0)

   392         audioBuffer = new char[buffer_size];

   393     snd_pcm_prepare( handle );

   394     snd_pcm_start(handle);

   395 

   396     // Step 5: Setup timer

   397     bytesAvailable = bytesReady();

   398 

   399     if(pullMode)

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

   401 

   402     // Step 6: Start audio processing

   403     chunks = buffer_size/period_size;

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

   405 

   406     errorState  = QAudio::NoError;

   407     deviceState = QAudio::ActiveState;

   408 

   409     totalTimeValue = 0;

   410 

   411     return true;

   412 }

   413 

   414 void QAudioInputPrivate::close()

   415 {

   416     deviceState = QAudio::StopState;

   417     timer->stop();

   418 

   419     if ( handle ) {

   420         snd_pcm_drop( handle );

   421         snd_pcm_close( handle );

   422         handle = 0;

   423         delete [] audioBuffer;

   424         audioBuffer=0;

   425     }

   426 }

   427 

   428 int QAudioInputPrivate::bytesReady() const

   429 {

   430     if(resuming)

   431         return period_size;

   432 

   433     if(deviceState != QAudio::ActiveState)

   434         return 0;

   435     int frames = snd_pcm_avail_update(handle);

   436     if((int)frames > (int)buffer_frames)

   437         frames = buffer_frames;

   438 

   439     return snd_pcm_frames_to_bytes(handle, frames);

   440 }

   441 

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

   443 {

   444     Q_UNUSED(data)

   445     Q_UNUSED(len)

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

   447     if ( !handle )

   448         return 0;

   449 

   450     bytesAvailable = bytesReady();

   451 

   452     int count=0, err = 0;

   453     while(count < 5) {

   454         int chunks = bytesAvailable/period_size;

   455         int frames = chunks*period_frames;

   456         if(frames > (int)buffer_frames)

   457             frames = buffer_frames;

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

   459         if (readFrames >= 0) {

   460             err = snd_pcm_frames_to_bytes(handle, readFrames);

   461 #ifdef DEBUG_AUDIO

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

   463 #endif

   464             break;

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

   466             errorState = QAudio::IOError;

   467             err = 0;

   468             break;

   469         } else {

   470             if(readFrames == -EPIPE) {

   471                 errorState = QAudio::UnderrunError;

   472                 err = snd_pcm_prepare(handle);

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

   474                 err = snd_pcm_prepare(handle);

   475             }

   476             if(err != 0) break;

   477         }

   478         count++;

   479     }

   480     if(err > 0) {

   481         // got some send it onward

   482 #ifdef DEBUG_AUDIO

   483         qDebug()<<"PULL: frames to write to QIODevice = "<<

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

   485 #endif

   486         if(deviceState != QAudio::ActiveState)

   487             return 0;

   488 

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

   490         if(l < 0) {

   491             close();

   492             errorState = QAudio::IOError;

   493             deviceState = QAudio::StopState;

   494             emit stateChanged(deviceState);

   495         } else if(l == 0) {

   496             errorState = QAudio::NoError;

   497             deviceState = QAudio::IdleState;

   498         } else {

   499             totalTimeValue += snd_pcm_bytes_to_frames(handle, err)*1000000/settings.frequency();

   500             resuming = false;

   501             errorState = QAudio::NoError;

   502             deviceState = QAudio::ActiveState;

   503         }

   504         return l;

   505     }

   506     return 0;

   507 }

   508 

   509 void QAudioInputPrivate::resume()

   510 {

   511     if(deviceState == QAudio::SuspendState) {

   512         int err = 0;

   513 

   514         if(handle) {

   515             err = snd_pcm_prepare( handle );

   516             if(err < 0)

   517                 xrun_recovery(err);

   518 

   519             err = snd_pcm_start(handle);

   520             if(err < 0)

   521                 xrun_recovery(err);

   522 

   523             bytesAvailable = buffer_size;

   524         }

   525         resuming = true;

   526         deviceState = QAudio::ActiveState;

   527         int chunks = buffer_size/period_size;

   528         timer->start(buffer_time*chunks/2000);

   529         emit stateChanged(deviceState);

   530     }

   531 }

   532 

   533 void QAudioInputPrivate::setBufferSize(int value)

   534 {

   535     buffer_size = value;

   536 }

   537 

   538 int QAudioInputPrivate::bufferSize() const

   539 {

   540     return buffer_size;

   541 }

   542 

   543 int QAudioInputPrivate::periodSize() const

   544 {

   545     return period_size;

   546 }

   547 

   548 void QAudioInputPrivate::setNotifyInterval(int ms)

   549 {

   550     if(ms >= minimumIntervalTime)

   551         intervalTime = ms;

   552     else

   553         intervalTime = minimumIntervalTime;

   554 }

   555 

   556 int QAudioInputPrivate::notifyInterval() const

   557 {

   558     return intervalTime;

   559 }

   560 

   561 qint64 QAudioInputPrivate::totalTime() const

   562 {

   563     return totalTimeValue;

   564 }

   565 

   566 void QAudioInputPrivate::suspend()

   567 {

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

   569         timer->stop();

   570         deviceState = QAudio::SuspendState;

   571         emit stateChanged(deviceState);

   572     }

   573 }

   574 

   575 void QAudioInputPrivate::userFeed()

   576 {

   577     if(deviceState == QAudio::StopState || deviceState == QAudio::SuspendState)

   578         return;

   579 #ifdef DEBUG_AUDIO

   580     QTime now(QTime::currentTime());

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

   582 #endif

   583     deviceReady();

   584 }

   585 

   586 bool QAudioInputPrivate::deviceReady()

   587 {

   588     if(pullMode) {

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

   590         read(0,0);

   591     } else {

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

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

   594         a->trigger();

   595     }

   596     bytesAvailable = bytesReady();

   597 

   598     if(deviceState != QAudio::ActiveState)

   599         return true;

   600 

   601     if((timeStamp.elapsed() + elapsedTimeOffset) > intervalTime) {

   602         emit notify();

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

   604         timeStamp.restart();

   605     }

   606     return true;

   607 }

   608 

   609 qint64 QAudioInputPrivate::clock() const

   610 {

   611     if(!handle)

   612         return 0;

   613 

   614     if (deviceState == QAudio::StopState)

   615         return 0;

   616 

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

   618     snd_pcm_status_t* status;

   619     snd_pcm_status_alloca(&status);

   620 

   621     snd_timestamp_t t1,t2;

   622     if( snd_pcm_status(handle, status) >= 0) {

   623         snd_pcm_status_get_tstamp(status,&t1);

   624         snd_pcm_status_get_trigger_tstamp(status,&t2);

   625         t1.tv_sec-=t2.tv_sec;

   626 

   627         signed long l = (signed long)t1.tv_usec - (signed long)t2.tv_usec;

   628         if(l < 0) {

   629             t1.tv_sec--;

   630             l = -l;

   631             l %= 1000000;

   632         }

   633         return ((t1.tv_sec * 1000000)+l);

   634     } else

   635         return 0;

   636 #else

   637     return clockStamp.elapsed()*1000;

   638 #endif

   639 }

   640 

   641 void QAudioInputPrivate::reset()

   642 {

   643     if(handle)

   644         snd_pcm_reset(handle);

   645 }

   646 

   647 void QAudioInputPrivate::drain()

   648 {

   649     if(handle)

   650         snd_pcm_drain(handle);

   651 }

   652 

   653 InputPrivate::InputPrivate(QAudioInputPrivate* audio)

   654 {

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

   656 }

   657 

   658 InputPrivate::~InputPrivate()

   659 {

   660 }

   661 

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

   663 {

   664     // push mode, user read() called

   665     if((audioDevice->state() != QAudio::ActiveState) && !audioDevice->resuming)

   666         return 0;

   667 

   668     int readFrames;

   669     int count=0, err = 0;

   670 

   671     while(count < 5) {

   672         int frames = snd_pcm_bytes_to_frames(audioDevice->handle, len);

   673         readFrames = snd_pcm_readi(audioDevice->handle, data, frames);

   674         if (readFrames >= 0) {

   675             err = snd_pcm_frames_to_bytes(audioDevice->handle, readFrames);

   676 #ifdef DEBUG_AUDIO

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

   678 #endif

   679             break;

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

   681             audioDevice->errorState = QAudio::IOError;

   682             err = 0;

   683             break;

   684         } else {

   685             if(readFrames == -EPIPE) {

   686                 audioDevice->errorState = QAudio::UnderrunError;

   687                 err = snd_pcm_prepare(audioDevice->handle);

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

   689                 err = snd_pcm_prepare(audioDevice->handle);

   690             }

   691             if(err != 0) break;

   692         }

   693         count++;

   694     }

   695     if(err > 0 && readFrames > 0) {

   696         audioDevice->totalTimeValue += readFrames*1000/audioDevice->settings.frequency()*1000;

   697         audioDevice->deviceState = QAudio::ActiveState;

   698         return err;

   699     }

   700     return 0;

   701 }

   702 

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

   704 {

   705     Q_UNUSED(data)

   706     Q_UNUSED(len)

   707     return 0;

   708 }

   709 

   710 void InputPrivate::trigger()

   711 {

   712     emit readyRead();

   713 }

   714 

   715 QT_END_NAMESPACE