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

    46 {

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

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

    49     QAudioEncoderSettings audioSettings;

    50     audioSettings.setCodec("aac");

    51     audioSettings.setSampleRate(-1);

    52     QVideoEncoderSettings videoSettings;

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

    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->stop();

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

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

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

    67 }

    68 

    69 void tst_QMediaRecorder::testAudioMpegBr32kSr8kHz()

    70 {

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

    72     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br32kSr8kHz", "mp4"));

    73     QAudioEncoderSettings audioSettings;

    74     audioSettings.setCodec("aac");

    75     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

    76     audioSettings.setBitRate(32000);

    77     audioSettings.setSampleRate(8000);

    78     audioSettings.setChannelCount(1);

    79     QVideoEncoderSettings videoSettings;

    80     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

    83     audiocapture->record();

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

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

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

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

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

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

    90     audiocapture->stop();

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

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

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

    94 }

    95 

    96 void tst_QMediaRecorder::testAudioMpegBr32kbpsSr8kHzStereo()

    97 {

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

    99     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br32kSr8kHzStereo", "mp4"));

   100     QAudioEncoderSettings audioSettings;

   101     audioSettings.setCodec("aac");

   102     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   103     audioSettings.setBitRate(32000);

   104     audioSettings.setSampleRate(8000);

   105     audioSettings.setChannelCount(2);

   106     QVideoEncoderSettings videoSettings;

   107     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   110     audiocapture->record();

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

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

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

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

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

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

   117     audiocapture->stop();

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

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

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

   121 }

   122 

   123 void tst_QMediaRecorder::testAudioMpegBr128kbpsSr16kHz()

   124 {

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

   126     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br128kSr16kHz", "mp4"));

   127     QAudioEncoderSettings audioSettings;

   128     audioSettings.setCodec("aac");

   129     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   130     audioSettings.setBitRate(128000);

   131     audioSettings.setSampleRate(16000);

   132     audioSettings.setChannelCount(1);

   133     QVideoEncoderSettings videoSettings;

   134     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   137     audiocapture->record();

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

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

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

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

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

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

   144     audiocapture->stop();

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

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

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

   148 }

   149 

   150 void tst_QMediaRecorder::testAudioMpegBr128kbpsSr16kHzStereo()

   151 {

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

   153     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br128kSr16kHzStereo", "mp4"));

   154     QAudioEncoderSettings audioSettings;

   155     audioSettings.setCodec("aac");

   156     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   157     audioSettings.setBitRate(128000);

   158     audioSettings.setSampleRate(16000);

   159     audioSettings.setChannelCount(2);

   160     QVideoEncoderSettings videoSettings;

   161     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   164     audiocapture->record();

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

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

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

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

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

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

   171     audiocapture->stop();

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

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

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

   175 }

   176 

   177 void tst_QMediaRecorder::testAudioMpegBr192kbpsSr32kHz()

   178 {

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

   180     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br192kSr32kHz", "mp4"));

   181     QAudioEncoderSettings audioSettings;

   182     audioSettings.setCodec("aac");

   183     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   184     audioSettings.setBitRate(192000);

   185     audioSettings.setSampleRate(32000);

   186     audioSettings.setChannelCount(1);

   187     QVideoEncoderSettings videoSettings;

   188     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   191     audiocapture->record();

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

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

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

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

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

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

   198     audiocapture->stop();

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

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

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

   202 }

   203 

   204 void tst_QMediaRecorder::testAudioMpegBr192kbpsSr32kHzStereo()

   205 {

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

   207     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br192kSr32kHzStereo", "mp4"));

   208     QAudioEncoderSettings audioSettings;

   209     audioSettings.setCodec("aac");

   210     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   211     audioSettings.setBitRate(192000);

   212     audioSettings.setSampleRate(32000);

   213     audioSettings.setChannelCount(2);

   214     QVideoEncoderSettings videoSettings;

   215     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   218     audiocapture->record();

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

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

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

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

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

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

   225     audiocapture->stop();

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

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

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

   229 }

   230 

   231 void tst_QMediaRecorder::testAudioMpegBr256kbpsSr48kHz()

   232 {

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

   234     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br256kSr48kHz", "mp4"));

   235     QAudioEncoderSettings audioSettings;

   236     audioSettings.setCodec("aac");

   237     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   238     audioSettings.setBitRate(256000);

   239     audioSettings.setSampleRate(48000);

   240     audioSettings.setChannelCount(1);

   241     QVideoEncoderSettings videoSettings;

   242     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   245     audiocapture->record();

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

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

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

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

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

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

   252     audiocapture->stop();

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

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

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

   256 }

   257 

   258 void tst_QMediaRecorder::testAudioMpegBr256kbpsSr48kHzStereo()

   259 {

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

   261     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br256kSr48kHzStereo", "mp4"));

   262     QAudioEncoderSettings audioSettings;

   263     audioSettings.setCodec("aac");

   264     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   265     audioSettings.setBitRate(256000);

   266     audioSettings.setSampleRate(48000);

   267     audioSettings.setChannelCount(2);

   268     QVideoEncoderSettings videoSettings;

   269     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   272     audiocapture->record();

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

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

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

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

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

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

   279     audiocapture->stop();

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

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

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

   283 }

   284 

   285 void tst_QMediaRecorder::testAudioMpegQualityVeryLow()

   286 {

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

   288     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "VeryLowQuality", "mp4"));

   289     QAudioEncoderSettings audioSettings;

   290     audioSettings.setCodec("aac");

   291     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   292     audioSettings.setQuality(QtMultimedia::VeryLowQuality);

   293     QVideoEncoderSettings videoSettings;

   294     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   297     audiocapture->record();

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

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

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

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

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

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

   304     audiocapture->stop();

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

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

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

   308 }

   309 

   310 void tst_QMediaRecorder::testAudioMpegQualityLow()

   311 {

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

   313     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "LowQuality", "mp4"));

   314     QAudioEncoderSettings audioSettings;

   315     audioSettings.setCodec("aac");

   316     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   317     audioSettings.setQuality(QtMultimedia::LowQuality);

   318     QVideoEncoderSettings videoSettings;

   319     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   322     audiocapture->record();

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

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

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

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

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

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

   329     audiocapture->stop();

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

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

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

   333 }

   334 

   335 void tst_QMediaRecorder::testAudioMpegQualityNormal()

   336 {

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

   338     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "NormalQuality", "mp4"));

   339     QAudioEncoderSettings audioSettings;

   340     audioSettings.setCodec("aac");

   341     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   342     audioSettings.setQuality(QtMultimedia::NormalQuality);

   343     QVideoEncoderSettings videoSettings;

   344     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   347     audiocapture->record();

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

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

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

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

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

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

   354     audiocapture->stop();

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

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

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

   358 }

   359 

   360 void tst_QMediaRecorder::testAudioMpegQualityHigh()

   361 {

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

   363     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "HighQuality", "mp4"));

   364     QAudioEncoderSettings audioSettings;

   365     audioSettings.setCodec("aac");

   366     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   367     audioSettings.setQuality(QtMultimedia::HighQuality);

   368     QVideoEncoderSettings videoSettings;

   369     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   372     audiocapture->record();

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

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

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

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

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

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

   379     audiocapture->stop();

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

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

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

   383 }

   384 

   385 void tst_QMediaRecorder::testAudioMpegQualityVeryHigh()

   386 {

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

   388     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "VeryHighQuality", "mp4"));

   389     QAudioEncoderSettings audioSettings;

   390     audioSettings.setCodec("aac");

   391     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   392     audioSettings.setQuality(QtMultimedia::VeryHighQuality);

   393     QVideoEncoderSettings videoSettings;

   394     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   397     audiocapture->record();

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

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

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

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

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

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

   404     audiocapture->stop();

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

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

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

   408 }

   409 

   410 void tst_QMediaRecorder::testAudioMpegBr16kSr8kHz()

   411 {

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

   413     audiocapture->setOutputLocation(nextFileName(QDir::rootPath(), "Br16kHzSr8kHz", "mp4"));

   414     QAudioEncoderSettings audioSettings;

   415     audioSettings.setCodec("aac");

   416     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   417     audioSettings.setBitRate(16000);

   418     audioSettings.setSampleRate(8000);

   419     QVideoEncoderSettings videoSettings;

   420     audiocapture->setEncodingSettings(audioSettings, videoSettings, QString("audio/mpeg"));

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

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

   423     audiocapture->record();

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

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

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

   427 }