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 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 #include <QtTest/QtTest>

    43 #include <QDebug>

    44 #include <qmediaobject.h>

    45 #include <qmediacontrol.h>

    46 #include <qmediaservice.h>

    47 #include <qmediarecordercontrol.h>

    48 #include <qmediarecorder.h>

    49 #include <qaudioendpointselector.h>

    50 #include <qaudioencodercontrol.h>

    51 #include <qmediacontainercontrol.h>

    52 #include <QtMultimedia/qaudioformat.h>

    53 #include <qaudiocapturesource.h>

    54 

    55 #define QTRY_COMPARE(a,e)                       \

    56     for (int _i = 0; _i < 5000; _i += 100) {    \

    57         if ((a) == (e)) break;                  \

    58         QTest::qWait(100);                      \

    59     }                                           \

    60     QCOMPARE(a, e)

    61 

    62 #define QTRY_VERIFY(a)                       \

    63     for (int _i = 0; _i < 5000; _i += 100) {    \

    64         if (a) break;                  \

    65         QTest::qWait(100);                      \

    66     }                                           \

    67     QVERIFY(a)

    68 

    69 QT_USE_NAMESPACE

    70 class tst_QMediaRecorder: public QObject

    71 {

    72     Q_OBJECT

    73 

    74 public slots:

    75     void initTestCase();

    76     void cleanupTestCase();

    77 

    78 private slots:

    79 

    80     // Positive test cases

    81     void testMediaRecorderObject();

    82     void testAudioSink();

    83     void testAudioEndPointSelector();

    84     void testDefaultAudioEncodingSettings();

    85     void testAudioWav();

    86     void testAudioWavSr8kHz();

    87     void testAudioWavSr16kHz();

    88     void testAudioWavSr32kHz();

    89     void testAudioWavSr96kHz();

    90     void testAudioWavSr8kHzStereo();

    91     void testAudioWavSr16kHzStereo();

    92     void testAudioWavSr32kHzStereo();

    93     void testAudioWavSr96kHzStereo();

    94     void testAudioWavQualityVeryLow();

    95     void testAudioWavQualityLow();

    96     void testAudioWavQualityNormal();

    97     void testAudioWavQualityHigh();

    98     void testAudioWavQualityVeryHigh();

    99     // Negetive test cases

   100     void testAudioWavSr4kHz();

   101     void testAudioWavSr8kHz5Channel();

   102 

   103     // Positive test cases

   104     void testAudioAmr();

   105     void testAudioAmrBr4750bps();

   106     void testAudioAmrBr5150bps();

   107     void testAudioAmrBr5900bps();

   108     void testAudioAmrBr6700bps();

   109     void testAudioAmrBr7400bps();

   110     void testAudioAmrBr7950bps();

   111     void testAudioAmrBr10200bps();

   112     void testAudioAmrBr12200bps();

   113     void testAudioAmrQualityVeryLow();

   114     void testAudioAmrQualityLow();

   115     void testAudioAmrQualityNormal();

   116     void testAudioAmrQualityHigh();

   117     void testAudioAmrQualityVeryHigh();

   118     // Negetive test cases

   119     void testAudioAmrSr8kHzMono();

   120     void testAudioAmrStereo();

   121     void testAudioAmrSr16kHz();

   122 

   123     // Positive test cases

   124     void testAudioMpeg();

   125     void testAudioMpegBr32kSr8kHz();

   126     void testAudioMpegBr32kbpsSr8kHzStereo();

   127     void testAudioMpegBr128kbpsSr16kHz();

   128     void testAudioMpegBr128kbpsSr16kHzStereo();

   129     void testAudioMpegBr256kbpsSr48kHz();

   130     void testAudioMpegBr256kbpsSr48kHzStereo();

   131     void testAudioMpegQualityVeryLow();

   132     void testAudioMpegQualityLow();

   133     void testAudioMpegQualityNormal();

   134     void testAudioMpegQualityHigh();

   135     void testAudioMpegQualityVeryHigh();

   136     // Negetive test cases

   137     void testAudioMpegBr16kSr8kHz();

   138 

   139 

   140 private:

   141 

   142     QUrl nextFileName(QDir outputDir, QString appendName, QString ext);

   143 

   144     QAudioEncoderControl *audioEncoder;

   145     QAudioEndpointSelector *audioEndpoint;

   146     QMediaRecorder  *audiocapture;

   147     QAudioCaptureSource *captureSource;

   148 };

   149 

   150 void tst_QMediaRecorder::initTestCase()

   151 {

   152     qRegisterMetaType<QMediaRecorder::State>("QMediaRecorder::State");

   153     qRegisterMetaType<QMediaRecorder::Error>("QMediaRecorder::Error");

   154 

   155     captureSource = new QAudioCaptureSource;

   156     audiocapture = new QMediaRecorder(captureSource);

   157 

   158     audioEndpoint = qobject_cast<QAudioEndpointSelector*>(audiocapture->service()->control(QAudioEndpointSelector_iid));

   159     audioEncoder = qobject_cast<QAudioEncoderControl*>(audiocapture->service()->control(QAudioEncoderControl_iid));

   160 }

   161 

   162 void tst_QMediaRecorder::cleanupTestCase()

   163 {

   164     delete audiocapture;

   165     delete captureSource;

   166 }

   167 

   168 void tst_QMediaRecorder::testMediaRecorderObject()

   169 {

   170     //audioocontainer types

   171     QCOMPARE(audiocapture->audioCodecDescription("pcm"), QString("pcm"));

   172     QCOMPARE(audiocapture->audioCodecDescription("amr"), QString("amr"));

   173     QCOMPARE(audiocapture->audioCodecDescription("aac"), QString("aac"));

   174     QCOMPARE(audiocapture->containerDescription("audio/wav"), QString("wav container"));

   175     QCOMPARE(audiocapture->containerDescription("audio/amr"), QString("amr File format"));

   176     QCOMPARE(audiocapture->containerDescription("audio/mpeg"), QString("mpeg container"));

   177     QCOMPARE(audiocapture->containerMimeType(), QString("audio/wav"));

   178     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   179     QCOMPARE(audiocapture->errorString(), QString());

   180     QCOMPARE(audiocapture->outputLocation().toLocalFile(), QString());

   181     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   182     QCOMPARE(audiocapture->supportedAudioCodecs().count(), 3); // "pcm", "amr", "aac");

   183     QAudioEncoderSettings settings;

   184     settings.setCodec("pcm");

   185     QCOMPARE(audiocapture->supportedAudioSampleRates(settings).count(), 12);

   186     bool isContinuous;

   187     audiocapture->supportedAudioSampleRates(settings, &isContinuous);

   188     QCOMPARE(isContinuous, false);

   189     QCOMPARE(audiocapture->supportedContainers().count(), 3); // "audio/wav", "audio/amr", "audio/mpeg");

   190 }

   191 

   192 void tst_QMediaRecorder::testAudioSink()

   193 {

   194     audiocapture->setOutputLocation(QUrl("test.wav"));

   195     QUrl s = audiocapture->outputLocation();

   196     QCOMPARE(s.toString(), QString("test.wav"));

   197 }

   198 

   199 void tst_QMediaRecorder::testAudioEndPointSelector()

   200 {

   201     QSignalSpy audioSignal(audioEndpoint,SIGNAL(activeEndpointChanged(QString)));

   202     QVERIFY(audioEndpoint->availableEndpoints().count() == 1);

   203     QVERIFY(audioEndpoint->defaultEndpoint().compare("Default Mic") == 0);

   204     audioEndpoint->setActiveEndpoint("Default Mic");

   205     QVERIFY(audioEndpoint->activeEndpoint().compare("Default Mic") == 0);

   206     QVERIFY(audioSignal.count() == 1);

   207     QVERIFY(audioEndpoint->endpointDescription("Default Mic").compare("Default Mic") == 0);

   208 }

   209 

   210 void tst_QMediaRecorder::testDefaultAudioEncodingSettings()

   211 {

   212     QAudioEncoderSettings audioSettings = audiocapture->audioSettings();

   213     QCOMPARE(audioSettings.codec(), QString("pcm"));

   214     QCOMPARE(audiocapture->containerMimeType(), QString("audio/wav"));

   215     QCOMPARE(audioSettings.bitRate(), 0);

   216     QCOMPARE(audioSettings.channelCount(), 1);

   217     QCOMPARE(audioSettings.encodingMode(), QtMultimedia::ConstantQualityEncoding);

   218     QCOMPARE(audioSettings.quality(), QtMultimedia::VeryLowQuality);

   219     QCOMPARE(audioSettings.sampleRate(), 8000);

   220 }

   221 

   222 void tst_QMediaRecorder::testAudioWav()

   223 {

   224     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   225     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   226     QTest::qWait(500);  // wait for recorder to initialize itself

   227     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "", "wav"));

   228     audiocapture->record();

   229     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   230     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   231     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   232     QCOMPARE(audiocapture->errorString(), QString());

   233     QCOMPARE(stateSignal.count(), 1);

   234     QTest::qWait(5000);  // wait for 5 seconds

   235     audiocapture->pause();

   236     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   237     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   238     QCOMPARE(stateSignal.count(), 2);

   239     audiocapture->stop();

   240     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   241     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   242     QCOMPARE(stateSignal.count(), 3);

   243 }

   244 

   245 void tst_QMediaRecorder::testAudioWavSr8kHz()

   246 {

   247     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   248     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr8kHz", "wav"));

   249     QAudioEncoderSettings audioSettings;

   250     audioSettings.setCodec("pcm");

   251     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   252     audioSettings.setSampleRate(8000);

   253     QVideoEncoderSettings videoSettings;

   254     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   255     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   256     QTest::qWait(500);  // wait for recorder to initialize itself

   257     audiocapture->record();

   258     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   259     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   260     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   261     QCOMPARE(audiocapture->errorString(), QString());

   262     QCOMPARE(stateSignal.count(), 1);

   263     QTest::qWait(5000);  // wait for 5 seconds

   264     audiocapture->pause();

   265     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   266     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   267     QCOMPARE(stateSignal.count(), 2);

   268     audiocapture->stop();

   269     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   270     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   271     QCOMPARE(stateSignal.count(), 3);

   272 }

   273 

   274 void tst_QMediaRecorder::testAudioWavSr16kHz()

   275 {

   276     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   277     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr16kHz", "wav"));

   278     QAudioEncoderSettings audioSettings;

   279     audioSettings.setCodec("pcm");

   280     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   281     audioSettings.setSampleRate(16000);

   282     QVideoEncoderSettings videoSettings;

   283     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   284     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   285     QTest::qWait(500);  // wait for recorder to initialize itself

   286     audiocapture->record();

   287     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   288     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   289     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   290     QCOMPARE(audiocapture->errorString(), QString());

   291     QCOMPARE(stateSignal.count(), 1);

   292     QTest::qWait(5000);  // wait for 5 seconds

   293     audiocapture->pause();

   294     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   295     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   296     QCOMPARE(stateSignal.count(), 2);

   297     audiocapture->stop();

   298     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   299     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   300     QCOMPARE(stateSignal.count(), 3);

   301 }

   302 

   303 void tst_QMediaRecorder::testAudioWavSr32kHz()

   304 {

   305     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   306     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr32kHz", "wav"));

   307     QAudioEncoderSettings audioSettings;

   308     audioSettings.setCodec("pcm");

   309     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   310     audioSettings.setSampleRate(32000);

   311     QVideoEncoderSettings videoSettings;

   312     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   313     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   314     QTest::qWait(500);  // wait for recorder to initialize itself

   315     audiocapture->record();

   316     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   317     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   318     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   319     QCOMPARE(audiocapture->errorString(), QString());

   320     QCOMPARE(stateSignal.count(), 1);

   321     QTest::qWait(5000);  // wait for 5 seconds

   322     audiocapture->pause();

   323     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   324     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   325     QCOMPARE(stateSignal.count(), 2);

   326     audiocapture->stop();

   327     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   328     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   329     QCOMPARE(stateSignal.count(), 3);

   330 }

   331 

   332 void tst_QMediaRecorder::testAudioWavSr96kHz()

   333 {

   334     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   335     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr32kHz", "wav"));

   336     QAudioEncoderSettings audioSettings;

   337     audioSettings.setCodec("pcm");

   338     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   339     audioSettings.setSampleRate(96000);

   340     QVideoEncoderSettings videoSettings;

   341     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   342     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   343     QTest::qWait(500);  // wait for recorder to initialize itself

   344     audiocapture->record();

   345     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   346     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   347     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   348     QCOMPARE(audiocapture->errorString(), QString());

   349     QCOMPARE(stateSignal.count(), 1);

   350     QTest::qWait(5000);  // wait for 5 seconds

   351     audiocapture->pause();

   352     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   353     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   354     QCOMPARE(stateSignal.count(), 2);

   355     audiocapture->stop();

   356     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   357     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   358     QCOMPARE(stateSignal.count(), 3);

   359 }

   360 

   361 void tst_QMediaRecorder::testAudioWavSr8kHzStereo()

   362 {

   363     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   364     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr8kHzStereo", "wav"));

   365     QAudioEncoderSettings audioSettings;

   366     audioSettings.setCodec("pcm");

   367     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   368     audioSettings.setSampleRate(8000);

   369     audioSettings.setChannelCount(2);

   370     QVideoEncoderSettings videoSettings;

   371     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   372     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   373     QTest::qWait(500);  // wait for recorder to initialize itself

   374     audiocapture->record();

   375     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   376     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   377     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   378     QCOMPARE(audiocapture->errorString(), QString());

   379     QCOMPARE(stateSignal.count(), 1);

   380     QTest::qWait(5000);  // wait for 5 seconds

   381     audiocapture->pause();

   382     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   383     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   384     QCOMPARE(stateSignal.count(), 2);

   385     audiocapture->stop();

   386     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   387     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   388     QCOMPARE(stateSignal.count(), 3);

   389 }

   390 

   391 void tst_QMediaRecorder::testAudioWavSr16kHzStereo()

   392 {

   393     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   394     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr16kHzStereo", "wav"));

   395     QAudioEncoderSettings audioSettings;

   396     audioSettings.setCodec("pcm");

   397     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   398     audioSettings.setSampleRate(16000);

   399     audioSettings.setChannelCount(2);

   400     QVideoEncoderSettings videoSettings;

   401     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   402     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   403     QTest::qWait(500);  // wait for recorder to initialize itself

   404     audiocapture->record();

   405     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   406     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   407     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   408     QCOMPARE(audiocapture->errorString(), QString());

   409     QCOMPARE(stateSignal.count(), 1);

   410     QTest::qWait(5000);  // wait for 5 seconds

   411     audiocapture->pause();

   412     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   413     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   414     QCOMPARE(stateSignal.count(), 2);

   415     audiocapture->stop();

   416     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   417     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   418     QCOMPARE(stateSignal.count(), 3);

   419 }

   420 

   421 void tst_QMediaRecorder::testAudioWavSr32kHzStereo()

   422 {

   423     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   424     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr32kHzStereo", "wav"));

   425     QAudioEncoderSettings audioSettings;

   426     audioSettings.setCodec("pcm");

   427     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   428     audioSettings.setSampleRate(32000);

   429     audioSettings.setChannelCount(2);

   430     QVideoEncoderSettings videoSettings;

   431     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   432     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   433     QTest::qWait(500);  // wait for recorder to initialize itself

   434     audiocapture->record();

   435     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   436     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   437     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   438     QCOMPARE(audiocapture->errorString(), QString());

   439     QCOMPARE(stateSignal.count(), 1);

   440     QTest::qWait(5000);  // wait for 5 seconds

   441     audiocapture->pause();

   442     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   443     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   444     QCOMPARE(stateSignal.count(), 2);

   445     audiocapture->stop();

   446     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   447     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   448     QCOMPARE(stateSignal.count(), 3);

   449 }

   450 

   451 void tst_QMediaRecorder::testAudioWavSr96kHzStereo()

   452 {

   453     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   454     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr32kHzStereo", "wav"));

   455     QAudioEncoderSettings audioSettings;

   456     audioSettings.setCodec("pcm");

   457     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   458     audioSettings.setSampleRate(96000);

   459     audioSettings.setChannelCount(2);

   460     QVideoEncoderSettings videoSettings;

   461     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   462     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   463     QTest::qWait(500);  // wait for recorder to initialize itself

   464     audiocapture->record();

   465     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   466     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   467     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   468     QCOMPARE(audiocapture->errorString(), QString());

   469     QCOMPARE(stateSignal.count(), 1);

   470     QTest::qWait(5000);  // wait for 5 seconds

   471     audiocapture->pause();

   472     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   473     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   474     QCOMPARE(stateSignal.count(), 2);

   475     audiocapture->stop();

   476     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   477     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   478     QCOMPARE(stateSignal.count(), 3);

   479 }

   480 

   481 void tst_QMediaRecorder::testAudioWavQualityVeryLow()

   482 {

   483     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   484     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "VeryLowQuality", "wav"));

   485     QAudioEncoderSettings audioSettings;

   486     audioSettings.setCodec("pcm");

   487     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   488     audioSettings.setQuality(QtMultimedia::VeryLowQuality);

   489     QVideoEncoderSettings videoSettings;

   490     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   491     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   492     QTest::qWait(500);  // wait for recorder to initialize itself

   493     audiocapture->record();

   494     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   495     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   496     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   497     QCOMPARE(audiocapture->errorString(), QString());

   498     QCOMPARE(stateSignal.count(), 1);

   499     QTest::qWait(5000);  // wait for 5 seconds

   500     audiocapture->pause();

   501     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   502     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   503     QCOMPARE(stateSignal.count(), 2);

   504     audiocapture->stop();

   505     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   506     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   507     QCOMPARE(stateSignal.count(), 3);

   508 }

   509 

   510 void tst_QMediaRecorder::testAudioWavQualityLow()

   511 {

   512     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   513     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "LowQuality", "wav"));

   514     QAudioEncoderSettings audioSettings;

   515     audioSettings.setCodec("pcm");

   516     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   517     audioSettings.setQuality(QtMultimedia::LowQuality);

   518     QVideoEncoderSettings videoSettings;

   519     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   520     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   521     QTest::qWait(500);  // wait for recorder to initialize itself

   522     audiocapture->record();

   523     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   524     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   525     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   526     QCOMPARE(audiocapture->errorString(), QString());

   527     QCOMPARE(stateSignal.count(), 1);

   528     QTest::qWait(5000);  // wait for 5 seconds

   529     audiocapture->pause();

   530     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   531     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   532     QCOMPARE(stateSignal.count(), 2);

   533     audiocapture->stop();

   534     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   535     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   536     QCOMPARE(stateSignal.count(), 3);

   537 }

   538 

   539 void tst_QMediaRecorder::testAudioWavQualityNormal()

   540 {

   541     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   542     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "NormalQuality", "wav"));

   543     QAudioEncoderSettings audioSettings;

   544     audioSettings.setCodec("pcm");

   545     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   546     audioSettings.setQuality(QtMultimedia::NormalQuality);

   547     QVideoEncoderSettings videoSettings;

   548     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   549     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   550     QTest::qWait(500);  // wait for recorder to initialize itself

   551     audiocapture->record();

   552     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   553     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   554     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   555     QCOMPARE(audiocapture->errorString(), QString());

   556     QCOMPARE(stateSignal.count(), 1);

   557     QTest::qWait(5000);  // wait for 5 seconds

   558     audiocapture->pause();

   559     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   560     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   561     QCOMPARE(stateSignal.count(), 2);

   562     audiocapture->stop();

   563     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   564     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   565     QCOMPARE(stateSignal.count(), 3);

   566 }

   567 

   568 void tst_QMediaRecorder::testAudioWavQualityHigh()

   569 {

   570     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   571     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "HighQuality", "wav"));

   572     QAudioEncoderSettings audioSettings;

   573     audioSettings.setCodec("pcm");

   574     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   575     audioSettings.setQuality(QtMultimedia::HighQuality);

   576     QVideoEncoderSettings videoSettings;

   577     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   578     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   579     QTest::qWait(500);  // wait for recorder to initialize itself

   580     audiocapture->record();

   581     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   582     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   583     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   584     QCOMPARE(audiocapture->errorString(), QString());

   585     QCOMPARE(stateSignal.count(), 1);

   586     QTest::qWait(5000);  // wait for 5 seconds

   587     audiocapture->pause();

   588     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   589     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   590     QCOMPARE(stateSignal.count(), 2);

   591     audiocapture->stop();

   592     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   593     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   594     QCOMPARE(stateSignal.count(), 3);

   595 }

   596 

   597 void tst_QMediaRecorder::testAudioWavQualityVeryHigh()

   598 {

   599     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   600     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "VeryHighQuality", "wav"));

   601     QAudioEncoderSettings audioSettings;

   602     audioSettings.setCodec("pcm");

   603     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   604     audioSettings.setQuality(QtMultimedia::VeryHighQuality);

   605     QVideoEncoderSettings videoSettings;

   606     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   607     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   608     QTest::qWait(500);  // wait for recorder to initialize itself

   609     audiocapture->record();

   610     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   611     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   612     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   613     QCOMPARE(audiocapture->errorString(), QString());

   614     QCOMPARE(stateSignal.count(), 1);

   615     QTest::qWait(5000);  // wait for 5 seconds

   616     audiocapture->pause();

   617     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   618     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   619     QCOMPARE(stateSignal.count(), 2);

   620     audiocapture->stop();

   621     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   622     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   623     QCOMPARE(stateSignal.count(), 3);

   624 }

   625 

   626 void tst_QMediaRecorder::testAudioWavSr4kHz()

   627 {

   628     QSignalSpy errorSignal(audiocapture,SIGNAL(error(QMediaRecorder::Error)));

   629     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr441kHz", "wav"));

   630     QAudioEncoderSettings audioSettings;

   631     audioSettings.setCodec("pcm");

   632     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   633     audioSettings.setSampleRate(4000);

   634     QVideoEncoderSettings videoSettings;

   635     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   636     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   637     QTest::qWait(500);  // wait for recorder to initialize itself

   638     audiocapture->record();

   639     QTRY_COMPARE(errorSignal.count(), 1); // wait for callbacks to complete in symbian API

   640     QCOMPARE(audiocapture->error(), QMediaRecorder::ResourceError);

   641     QCOMPARE(audiocapture->errorString(), QString("Generic error"));

   642 }

   643 

   644 void tst_QMediaRecorder::testAudioWavSr8kHz5Channel()

   645 {

   646     QSignalSpy errorSignal(audiocapture,SIGNAL(error(QMediaRecorder::Error)));

   647     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr441kHz", "wav"));

   648     QAudioEncoderSettings audioSettings;

   649     audioSettings.setCodec("pcm");

   650     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   651     audioSettings.setSampleRate(8000);

   652     audioSettings.setChannelCount(6);

   653     QVideoEncoderSettings videoSettings;

   654     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/wav"));

   655     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   656     QTest::qWait(500);  // wait for recorder to initialize itself

   657     audiocapture->record();

   658     QTRY_COMPARE(errorSignal.count(), 1); // wait for callbacks to complete in symbian API

   659     QCOMPARE(audiocapture->error(), QMediaRecorder::ResourceError);

   660     QCOMPARE(audiocapture->errorString(), QString("Generic error"));

   661 }

   662 

   663 void tst_QMediaRecorder::testAudioAmr()

   664 {

   665     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   666     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "", "amr"));

   667     QAudioEncoderSettings audioSettings;

   668     audioSettings.setCodec("amr");

   669     audioSettings.setSampleRate(-1);

   670     QVideoEncoderSettings videoSettings;

   671     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   672     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   673     QTest::qWait(500);  // wait for recorder to initialize itself

   674     audiocapture->record();

   675     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   676     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   677     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   678     QCOMPARE(audiocapture->errorString(), QString());

   679     QCOMPARE(stateSignal.count(), 1);

   680     QTest::qWait(5000);  // wait for 5 seconds

   681     audiocapture->pause();

   682     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   683     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   684     QCOMPARE(stateSignal.count(), 2);

   685     audiocapture->stop();

   686     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   687     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   688     QCOMPARE(stateSignal.count(), 3);

   689 }

   690 

   691 void tst_QMediaRecorder::testAudioAmrBr4750bps()

   692 {

   693     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   694     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br4750bps", "amr"));

   695     QAudioEncoderSettings audioSettings;

   696     audioSettings.setCodec("amr");

   697     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   698     audioSettings.setBitRate(4750);

   699     QVideoEncoderSettings videoSettings;

   700     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   701     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   702     QTest::qWait(500);  // wait for recorder to initialize itself

   703     audiocapture->record();

   704     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   705     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   706     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   707     QCOMPARE(audiocapture->errorString(), QString());

   708     QCOMPARE(stateSignal.count(), 1);

   709     QTest::qWait(5000);  // wait for 5 seconds

   710     audiocapture->pause();

   711     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   712     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   713     QCOMPARE(stateSignal.count(), 2);

   714     audiocapture->stop();

   715     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   716     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   717     QCOMPARE(stateSignal.count(), 3);

   718 }

   719 

   720 void tst_QMediaRecorder::testAudioAmrBr5150bps()

   721 {

   722     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   723     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br4750bps", "amr"));

   724     QAudioEncoderSettings audioSettings;

   725     audioSettings.setCodec("amr");

   726     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   727     audioSettings.setBitRate(5150);

   728     QVideoEncoderSettings videoSettings;

   729     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   730     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   731     QTest::qWait(500);  // wait for recorder to initialize itself

   732     audiocapture->record();

   733     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   734     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   735     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   736     QCOMPARE(audiocapture->errorString(), QString());

   737     QCOMPARE(stateSignal.count(), 1);

   738     QTest::qWait(5000);  // wait for 5 seconds

   739     audiocapture->pause();

   740     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   741     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   742     QCOMPARE(stateSignal.count(), 2);

   743     audiocapture->stop();

   744     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   745     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   746     QCOMPARE(stateSignal.count(), 3);

   747 }

   748 

   749 void tst_QMediaRecorder::testAudioAmrBr5900bps()

   750 {

   751     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   752     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br4750bps", "amr"));

   753     QAudioEncoderSettings audioSettings;

   754     audioSettings.setCodec("amr");

   755     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   756     audioSettings.setBitRate(5900);

   757     QVideoEncoderSettings videoSettings;

   758     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   759     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   760     QTest::qWait(500);  // wait for recorder to initialize itself

   761     audiocapture->record();

   762     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   763     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   764     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   765     QCOMPARE(audiocapture->errorString(), QString());

   766     QCOMPARE(stateSignal.count(), 1);

   767     QTest::qWait(5000);  // wait for 5 seconds

   768     audiocapture->pause();

   769     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   770     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   771     QCOMPARE(stateSignal.count(), 2);

   772     audiocapture->stop();

   773     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   774     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   775     QCOMPARE(stateSignal.count(), 3);

   776 }

   777 

   778 void tst_QMediaRecorder::testAudioAmrBr6700bps()

   779 {

   780     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   781     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br4750bps", "amr"));

   782     QAudioEncoderSettings audioSettings;

   783     audioSettings.setCodec("amr");

   784     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   785     audioSettings.setBitRate(6700);

   786     QVideoEncoderSettings videoSettings;

   787     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   788     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   789     QTest::qWait(500);  // wait for recorder to initialize itself

   790     audiocapture->record();

   791     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   792     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   793     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   794     QCOMPARE(audiocapture->errorString(), QString());

   795     QCOMPARE(stateSignal.count(), 1);

   796     QTest::qWait(5000);  // wait for 5 seconds

   797     audiocapture->pause();

   798     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   799     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   800     QCOMPARE(stateSignal.count(), 2);

   801     audiocapture->stop();

   802     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   803     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   804     QCOMPARE(stateSignal.count(), 3);

   805 }

   806 

   807 void tst_QMediaRecorder::testAudioAmrBr7400bps()

   808 {

   809     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   810     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br4750bps", "amr"));

   811     QAudioEncoderSettings audioSettings;

   812     audioSettings.setCodec("amr");

   813     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   814     audioSettings.setBitRate(7400);

   815     QVideoEncoderSettings videoSettings;

   816     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   817     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   818     QTest::qWait(500);  // wait for recorder to initialize itself

   819     audiocapture->record();

   820     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   821     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   822     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   823     QCOMPARE(audiocapture->errorString(), QString());

   824     QCOMPARE(stateSignal.count(), 1);

   825     QTest::qWait(5000);  // wait for 5 seconds

   826     audiocapture->pause();

   827     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   828     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   829     QCOMPARE(stateSignal.count(), 2);

   830     audiocapture->stop();

   831     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   832     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   833     QCOMPARE(stateSignal.count(), 3);

   834 }

   835 

   836 void tst_QMediaRecorder::testAudioAmrBr7950bps()

   837 {

   838     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   839     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br4750bps", "amr"));

   840     QAudioEncoderSettings audioSettings;

   841     audioSettings.setCodec("amr");

   842     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   843     audioSettings.setBitRate(7950);

   844     QVideoEncoderSettings videoSettings;

   845     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   846     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   847     QTest::qWait(500);  // wait for recorder to initialize itself

   848     audiocapture->record();

   849     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   850     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   851     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   852     QCOMPARE(audiocapture->errorString(), QString());

   853     QCOMPARE(stateSignal.count(), 1);

   854     QTest::qWait(5000);  // wait for 5 seconds

   855     audiocapture->pause();

   856     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   857     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   858     QCOMPARE(stateSignal.count(), 2);

   859     audiocapture->stop();

   860     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   861     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   862     QCOMPARE(stateSignal.count(), 3);

   863 }

   864 

   865 void tst_QMediaRecorder::testAudioAmrBr10200bps()

   866 {

   867     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   868     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br4750bps", "amr"));

   869     QAudioEncoderSettings audioSettings;

   870     audioSettings.setCodec("amr");

   871     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   872     audioSettings.setBitRate(10200);

   873     QVideoEncoderSettings videoSettings;

   874     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   875     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   876     QTest::qWait(500);  // wait for recorder to initialize itself

   877     audiocapture->record();

   878     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   879     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   880     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   881     QCOMPARE(audiocapture->errorString(), QString());

   882     QCOMPARE(stateSignal.count(), 1);

   883     QTest::qWait(5000);  // wait for 5 seconds

   884     audiocapture->pause();

   885     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   886     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   887     QCOMPARE(stateSignal.count(), 2);

   888     audiocapture->stop();

   889     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   890     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   891     QCOMPARE(stateSignal.count(), 3);

   892 }

   893 

   894 void tst_QMediaRecorder::testAudioAmrBr12200bps()

   895 {

   896     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   897     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br4750bps", "amr"));

   898     QAudioEncoderSettings audioSettings;

   899     audioSettings.setCodec("amr");

   900     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   901     audioSettings.setBitRate(12200);

   902     QVideoEncoderSettings videoSettings;

   903     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   904     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   905     QTest::qWait(500);  // wait for recorder to initialize itself

   906     audiocapture->record();

   907     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   908     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   909     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   910     QCOMPARE(audiocapture->errorString(), QString());

   911     QCOMPARE(stateSignal.count(), 1);

   912     QTest::qWait(5000);  // wait for 5 seconds

   913     audiocapture->pause();

   914     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   915     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   916     QCOMPARE(stateSignal.count(), 2);

   917     audiocapture->stop();

   918     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   919     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   920     QCOMPARE(stateSignal.count(), 3);

   921 }

   922 

   923 void tst_QMediaRecorder::testAudioAmrQualityVeryLow()

   924 {

   925     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   926     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "VeryLowQuality", "amr"));

   927     QAudioEncoderSettings audioSettings;

   928     audioSettings.setCodec("amr");

   929     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   930     audioSettings.setQuality(QtMultimedia::VeryLowQuality);

   931     QVideoEncoderSettings videoSettings;

   932     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   933     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   934     QTest::qWait(500);  // wait for recorder to initialize itself

   935     audiocapture->record();

   936     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   937     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   938     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   939     QCOMPARE(audiocapture->errorString(), QString());

   940     QCOMPARE(stateSignal.count(), 1);

   941     QTest::qWait(5000);  // wait for 5 seconds

   942     audiocapture->pause();

   943     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   944     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   945     QCOMPARE(stateSignal.count(), 2);

   946     audiocapture->stop();

   947     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   948     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   949     QCOMPARE(stateSignal.count(), 3);

   950 }

   951 

   952 void tst_QMediaRecorder::testAudioAmrQualityLow()

   953 {

   954     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   955     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "LowQuality", "amr"));

   956     QAudioEncoderSettings audioSettings;

   957     audioSettings.setCodec("amr");

   958     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   959     audioSettings.setQuality(QtMultimedia::LowQuality);

   960     QVideoEncoderSettings videoSettings;

   961     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   962     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   963     QTest::qWait(500);  // wait for recorder to initialize itself

   964     audiocapture->record();

   965     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   966     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   967     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   968     QCOMPARE(audiocapture->errorString(), QString());

   969     QCOMPARE(stateSignal.count(), 1);

   970     QTest::qWait(5000);  // wait for 5 seconds

   971     audiocapture->pause();

   972     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

   973     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

   974     QCOMPARE(stateSignal.count(), 2);

   975     audiocapture->stop();

   976     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

   977     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   978     QCOMPARE(stateSignal.count(), 3);

   979 }

   980 

   981 void tst_QMediaRecorder::testAudioAmrQualityNormal()

   982 {

   983     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

   984     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "NormalQuality", "amr"));

   985     QAudioEncoderSettings audioSettings;

   986     audioSettings.setCodec("amr");

   987     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   988     audioSettings.setQuality(QtMultimedia::NormalQuality);

   989     QVideoEncoderSettings videoSettings;

   990     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

   991     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

   992     QTest::qWait(500);  // wait for recorder to initialize itself

   993     audiocapture->record();

   994     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

   995     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

   996     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

   997     QCOMPARE(audiocapture->errorString(), QString());

   998     QCOMPARE(stateSignal.count(), 1);

   999     QTest::qWait(5000);  // wait for 5 seconds

  1000     audiocapture->pause();

  1001     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

  1002     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

  1003     QCOMPARE(stateSignal.count(), 2);

  1004     audiocapture->stop();

  1005     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

  1006     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

  1007     QCOMPARE(stateSignal.count(), 3);

  1008 }

  1009 

  1010 void tst_QMediaRecorder::testAudioAmrQualityHigh()

  1011 {

  1012     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

  1013     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "HighQuality", "amr"));

  1014     QAudioEncoderSettings audioSettings;

  1015     audioSettings.setCodec("amr");

  1016     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

  1017     audioSettings.setQuality(QtMultimedia::HighQuality);

  1018     QVideoEncoderSettings videoSettings;

  1019     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

  1020     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

  1021     QTest::qWait(500);  // wait for recorder to initialize itself

  1022     audiocapture->record();

  1023     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

  1024     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

  1025     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

  1026     QCOMPARE(audiocapture->errorString(), QString());

  1027     QCOMPARE(stateSignal.count(), 1);

  1028     QTest::qWait(5000);  // wait for 5 seconds

  1029     audiocapture->pause();

  1030     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

  1031     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

  1032     QCOMPARE(stateSignal.count(), 2);

  1033     audiocapture->stop();

  1034     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

  1035     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

  1036     QCOMPARE(stateSignal.count(), 3);

  1037 }

  1038 

  1039 void tst_QMediaRecorder::testAudioAmrQualityVeryHigh()

  1040 {

  1041     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

  1042     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "LowQuality", "amr"));

  1043     QAudioEncoderSettings audioSettings;

  1044     audioSettings.setCodec("amr");

  1045     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

  1046     audioSettings.setQuality(QtMultimedia::VeryHighQuality);

  1047     QVideoEncoderSettings videoSettings;

  1048     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

  1049     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

  1050     QTest::qWait(500);  // wait for recorder to initialize itself

  1051     audiocapture->record();

  1052     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

  1053     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

  1054     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

  1055     QCOMPARE(audiocapture->errorString(), QString());

  1056     QCOMPARE(stateSignal.count(), 1);

  1057     QTest::qWait(5000);  // wait for 5 seconds

  1058     audiocapture->pause();

  1059     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

  1060     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

  1061     QCOMPARE(stateSignal.count(), 2);

  1062     audiocapture->stop();

  1063     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

  1064     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

  1065     QCOMPARE(stateSignal.count(), 3);

  1066 }

  1067 

  1068 void tst_QMediaRecorder::testAudioAmrSr8kHzMono()

  1069 {

  1070     QSignalSpy stateSignal(audiocapture,SIGNAL(stateChanged(QMediaRecorder::State)));

  1071     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr8kHzMono", "amr"));

  1072     QAudioEncoderSettings audioSettings;

  1073     audioSettings.setCodec("amr");

  1074     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

  1075     audioSettings.setSampleRate(8000);

  1076     audioSettings.setChannelCount(1);

  1077     QVideoEncoderSettings videoSettings;

  1078     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

  1079     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

  1080     QTest::qWait(500);  // wait for recorder to initialize itself

  1081     audiocapture->record();

  1082     QTRY_COMPARE(stateSignal.count(), 1); // wait for callbacks to complete in symbian API

  1083     QCOMPARE(audiocapture->state(), QMediaRecorder::RecordingState);

  1084     QCOMPARE(audiocapture->error(), QMediaRecorder::NoError);

  1085     QCOMPARE(audiocapture->errorString(), QString());

  1086     QCOMPARE(stateSignal.count(), 1);

  1087     QTest::qWait(5000);  // wait for 5 seconds

  1088     audiocapture->pause();

  1089     QTRY_COMPARE(stateSignal.count(), 2); // wait for callbacks to complete in symbian API

  1090     QCOMPARE(audiocapture->state(), QMediaRecorder::PausedState);

  1091     QCOMPARE(stateSignal.count(), 2);

  1092     audiocapture->stop();

  1093     QTRY_COMPARE(stateSignal.count(), 3); // wait for callbacks to complete in symbian API

  1094     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

  1095     QCOMPARE(stateSignal.count(), 3);

  1096 }

  1097 

  1098 void tst_QMediaRecorder::testAudioAmrStereo()

  1099 {

  1100     QSignalSpy errorSignal(audiocapture,SIGNAL(error(QMediaRecorder::Error)));

  1101     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Stereo", "amr"));

  1102     QAudioEncoderSettings audioSettings;

  1103     audioSettings.setCodec("amr");

  1104     audioSettings.setSampleRate(-1);

  1105     audioSettings.setChannelCount(2);

  1106     QVideoEncoderSettings videoSettings;

  1107     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

  1108     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

  1109     QTest::qWait(500);  // wait for recorder to initialize itself

  1110     audiocapture->record();

  1111     QTRY_COMPARE(errorSignal.count(), 1); // wait for callbacks to complete in symbian API

  1112     QCOMPARE(audiocapture->error(), QMediaRecorder::ResourceError);

  1113     QCOMPARE(audiocapture->errorString(), QString("Generic error"));

  1114 }

  1115 

  1116 void tst_QMediaRecorder::testAudioAmrSr16kHz()

  1117 {

  1118     QSignalSpy errorSignal(audiocapture,SIGNAL(error(QMediaRecorder::Error)));

  1119     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Sr16kHz", "amr"));

  1120     QAudioEncoderSettings audioSettings;

  1121     audioSettings.setCodec("amr");

  1122     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

  1123     audioSettings.setSampleRate(16000);

  1124     QVideoEncoderSettings videoSettings;

  1125     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/amr"));

  1126     QCOMPARE(audiocapture->state(), QMediaRecorder::StoppedState);

  1127     QTest::qWait(500);  // wait for recorder to initialize itself

  1128     audiocapture->record();

  1129     QTRY_COMPARE(errorSignal.count(), 1); // wait for callbacks to complete in symbian API

  1130     QCOMPARE(audiocapture->error(), QMediaRecorder::ResourceError);

  1131     QCOMPARE(audiocapture->errorString(), QString("Generic error"));

  1132 }

  1133 

  1134 void tst_QMediaRecorder::testAudioMpeg()