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 "tst_qmediarecorder_xa.h"

    43 #include "tst_qmediarecorder_xa_macros.h"

    44 

    45 void tst_QMediaRecorder::testAudioAmr()

    46 {

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

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

    49     QAudioEncoderSettings audioSettings;

    50     audioSettings.setCodec("amr");

    51     audioSettings.setSampleRate(-1);

    52     QVideoEncoderSettings videoSettings;

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

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

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

    56     audiocapture->record();

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

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

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

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

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

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

    63     audiocapture->pause();

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

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

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

    67     audiocapture->stop();

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

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

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

    71 }

    72 

    73 void tst_QMediaRecorder::testAudioAmrBr4750bps()

    74 {

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

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

    77     QAudioEncoderSettings audioSettings;

    78     audioSettings.setCodec("amr");

    79     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

    80     audioSettings.setBitRate(4750);

    81     QVideoEncoderSettings videoSettings;

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

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

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

    85     audiocapture->record();

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

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

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

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

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

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

    92     audiocapture->pause();

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

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

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

    96     audiocapture->stop();

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

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

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

   100 }

   101 

   102 void tst_QMediaRecorder::testAudioAmrBr5150bps()

   103 {

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

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

   106     QAudioEncoderSettings audioSettings;

   107     audioSettings.setCodec("amr");

   108     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   109     audioSettings.setBitRate(5150);

   110     QVideoEncoderSettings videoSettings;

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

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

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

   114     audiocapture->record();

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

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

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

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

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

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

   121     audiocapture->pause();

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

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

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

   125     audiocapture->stop();

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

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

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

   129 }

   130 

   131 void tst_QMediaRecorder::testAudioAmrBr5900bps()

   132 {

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

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

   135     QAudioEncoderSettings audioSettings;

   136     audioSettings.setCodec("amr");

   137     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   138     audioSettings.setBitRate(5900);

   139     QVideoEncoderSettings videoSettings;

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

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

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

   143     audiocapture->record();

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

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

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

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

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

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

   150     audiocapture->pause();

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

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

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

   154     audiocapture->stop();

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

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

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

   158 }

   159 

   160 void tst_QMediaRecorder::testAudioAmrBr6700bps()

   161 {

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

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

   164     QAudioEncoderSettings audioSettings;

   165     audioSettings.setCodec("amr");

   166     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   167     audioSettings.setBitRate(6700);

   168     QVideoEncoderSettings videoSettings;

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

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

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

   172     audiocapture->record();

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

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

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

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

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

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

   179     audiocapture->pause();

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

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

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

   183     audiocapture->stop();

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

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

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

   187 }

   188 

   189 void tst_QMediaRecorder::testAudioAmrBr7400bps()

   190 {

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

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

   193     QAudioEncoderSettings audioSettings;

   194     audioSettings.setCodec("amr");

   195     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   196     audioSettings.setBitRate(7400);

   197     QVideoEncoderSettings videoSettings;

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

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

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

   201     audiocapture->record();

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

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

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

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

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

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

   208     audiocapture->pause();

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

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

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

   212     audiocapture->stop();

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

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

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

   216 }

   217 

   218 void tst_QMediaRecorder::testAudioAmrBr7950bps()

   219 {

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

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

   222     QAudioEncoderSettings audioSettings;

   223     audioSettings.setCodec("amr");

   224     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   225     audioSettings.setBitRate(7950);

   226     QVideoEncoderSettings videoSettings;

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

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

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

   230     audiocapture->record();

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

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

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

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

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

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

   237     audiocapture->pause();

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

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

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

   241     audiocapture->stop();

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

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

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

   245 }

   246 

   247 void tst_QMediaRecorder::testAudioAmrBr10200bps()

   248 {

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

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

   251     QAudioEncoderSettings audioSettings;

   252     audioSettings.setCodec("amr");

   253     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   254     audioSettings.setBitRate(10200);

   255     QVideoEncoderSettings videoSettings;

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

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

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

   259     audiocapture->record();

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

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

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

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

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

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

   266     audiocapture->pause();

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

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

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

   270     audiocapture->stop();

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

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

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

   274 }

   275 

   276 void tst_QMediaRecorder::testAudioAmrBr12200bps()

   277 {

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

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

   280     QAudioEncoderSettings audioSettings;

   281     audioSettings.setCodec("amr");

   282     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   283     audioSettings.setBitRate(12200);

   284     QVideoEncoderSettings videoSettings;

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

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

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

   288     audiocapture->record();

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

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

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

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

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

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

   295     audiocapture->pause();

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

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

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

   299     audiocapture->stop();

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

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

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

   303 }

   304 

   305 void tst_QMediaRecorder::testAudioAmrQualityVeryLow()

   306 {

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

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

   309     QAudioEncoderSettings audioSettings;

   310     audioSettings.setCodec("amr");

   311     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   312     audioSettings.setQuality(QtMultimedia::VeryLowQuality);

   313     QVideoEncoderSettings videoSettings;

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

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

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

   317     audiocapture->record();

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

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

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

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

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

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

   324     audiocapture->pause();

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

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

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

   328     audiocapture->stop();

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

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

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

   332 }

   333 

   334 void tst_QMediaRecorder::testAudioAmrQualityLow()

   335 {

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

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

   338     QAudioEncoderSettings audioSettings;

   339     audioSettings.setCodec("amr");

   340     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   341     audioSettings.setQuality(QtMultimedia::LowQuality);

   342     QVideoEncoderSettings videoSettings;

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

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

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

   346     audiocapture->record();

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

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

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

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

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

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

   353     audiocapture->pause();

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

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

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

   357     audiocapture->stop();

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

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

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

   361 }

   362 

   363 void tst_QMediaRecorder::testAudioAmrQualityNormal()

   364 {

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

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

   367     QAudioEncoderSettings audioSettings;

   368     audioSettings.setCodec("amr");

   369     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   370     audioSettings.setQuality(QtMultimedia::NormalQuality);

   371     QVideoEncoderSettings videoSettings;

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

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

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

   375     audiocapture->record();

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

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

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

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

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

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

   382     audiocapture->pause();

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

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

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

   386     audiocapture->stop();

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

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

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

   390 }

   391 

   392 void tst_QMediaRecorder::testAudioAmrQualityHigh()

   393 {

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

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

   396     QAudioEncoderSettings audioSettings;

   397     audioSettings.setCodec("amr");

   398     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   399     audioSettings.setQuality(QtMultimedia::HighQuality);

   400     QVideoEncoderSettings videoSettings;

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

   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::testAudioAmrQualityVeryHigh()

   422 {

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

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

   425     QAudioEncoderSettings audioSettings;

   426     audioSettings.setCodec("amr");

   427     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   428     audioSettings.setQuality(QtMultimedia::VeryHighQuality);

   429     QVideoEncoderSettings videoSettings;

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

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

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

   433     audiocapture->record();

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

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

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

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

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

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

   440     audiocapture->pause();

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

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

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

   444     audiocapture->stop();

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

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

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

   448 }

   449 

   450 void tst_QMediaRecorder::testAudioAmrSr8kHzMono()

   451 {

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

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

   454     QAudioEncoderSettings audioSettings;

   455     audioSettings.setCodec("amr");

   456     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   457     audioSettings.setSampleRate(8000);

   458     audioSettings.setChannelCount(1);

   459     QVideoEncoderSettings videoSettings;

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

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

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

   463     audiocapture->record();

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

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

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

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

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

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

   470     audiocapture->pause();

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

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

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

   474     audiocapture->stop();

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

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

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

   478 }

   479 

   480 void tst_QMediaRecorder::testAudioAmrStereo()

   481 {

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

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

   484     QAudioEncoderSettings audioSettings;

   485     audioSettings.setCodec("amr");

   486     audioSettings.setSampleRate(-1);

   487     audioSettings.setChannelCount(2);

   488     QVideoEncoderSettings videoSettings;

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

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

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

   492     audiocapture->record();

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

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

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

   496 }

   497 

   498 void tst_QMediaRecorder::testAudioAmrSr16kHz()

   499 {

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

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

   502     QAudioEncoderSettings audioSettings;

   503     audioSettings.setCodec("amr");

   504     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   505     audioSettings.setSampleRate(16000);

   506     QVideoEncoderSettings videoSettings;

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

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

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

   510     audiocapture->record();

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

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

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

   514 }