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

    46 {

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

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

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

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

    51     audiocapture->record();

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

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

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

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

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

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

    58     audiocapture->pause();

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

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

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

    62     audiocapture->stop();

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

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

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

    66 }

    67 

    68 void tst_QMediaRecorder::testAudioWavSr8kHz()

    69 {

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

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

    72     QAudioEncoderSettings audioSettings;

    73     audioSettings.setCodec("pcm");

    74     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

    75     audioSettings.setSampleRate(8000);

    76     QVideoEncoderSettings videoSettings;

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

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

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

    80     audiocapture->record();

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

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

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

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

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

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

    87     audiocapture->pause();

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

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

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

    91     audiocapture->stop();

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

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

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

    95 }

    96 

    97 void tst_QMediaRecorder::testAudioWavSr16kHz()

    98 {

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

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

   101     QAudioEncoderSettings audioSettings;

   102     audioSettings.setCodec("pcm");

   103     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   104     audioSettings.setSampleRate(16000);

   105     QVideoEncoderSettings videoSettings;

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

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

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

   109     audiocapture->record();

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

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

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

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

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

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

   116     audiocapture->pause();

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

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

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

   120     audiocapture->stop();

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

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

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

   124 }

   125 

   126 void tst_QMediaRecorder::testAudioWavSr32kHz()

   127 {

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

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

   130     QAudioEncoderSettings audioSettings;

   131     audioSettings.setCodec("pcm");

   132     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   133     audioSettings.setSampleRate(32000);

   134     QVideoEncoderSettings videoSettings;

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

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

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

   138     audiocapture->record();

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

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

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

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

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

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

   145     audiocapture->pause();

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

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

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

   149     audiocapture->stop();

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

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

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

   153 }

   154 

   155 void tst_QMediaRecorder::testAudioWavSr96kHz()

   156 {

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

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

   159     QAudioEncoderSettings audioSettings;

   160     audioSettings.setCodec("pcm");

   161     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   162     audioSettings.setSampleRate(96000);

   163     QVideoEncoderSettings videoSettings;

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

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

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

   167     audiocapture->record();

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

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

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

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

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

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

   174     audiocapture->pause();

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

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

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

   178     audiocapture->stop();

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

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

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

   182 }

   183 

   184 void tst_QMediaRecorder::testAudioWavSr8kHzStereo()

   185 {

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

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

   188     QAudioEncoderSettings audioSettings;

   189     audioSettings.setCodec("pcm");

   190     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   191     audioSettings.setSampleRate(8000);

   192     audioSettings.setChannelCount(2);

   193     QVideoEncoderSettings videoSettings;

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

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

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

   197     audiocapture->record();

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

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

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

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

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

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

   204     audiocapture->pause();

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

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

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

   208     audiocapture->stop();

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

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

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

   212 }

   213 

   214 void tst_QMediaRecorder::testAudioWavSr16kHzStereo()

   215 {

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

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

   218     QAudioEncoderSettings audioSettings;

   219     audioSettings.setCodec("pcm");

   220     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   221     audioSettings.setSampleRate(16000);

   222     audioSettings.setChannelCount(2);

   223     QVideoEncoderSettings videoSettings;

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

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

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

   227     audiocapture->record();

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

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

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

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

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

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

   234     audiocapture->pause();

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

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

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

   238     audiocapture->stop();

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

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

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

   242 }

   243 

   244 void tst_QMediaRecorder::testAudioWavSr32kHzStereo()

   245 {

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

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

   248     QAudioEncoderSettings audioSettings;

   249     audioSettings.setCodec("pcm");

   250     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   251     audioSettings.setSampleRate(32000);

   252     audioSettings.setChannelCount(2);

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

   275 {

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

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

   278     QAudioEncoderSettings audioSettings;

   279     audioSettings.setCodec("pcm");

   280     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   281     audioSettings.setSampleRate(96000);

   282     audioSettings.setChannelCount(2);

   283     QVideoEncoderSettings videoSettings;

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

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

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

   287     audiocapture->record();

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

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

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

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

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

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

   294     audiocapture->pause();

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

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

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

   298     audiocapture->stop();

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

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

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

   302 }

   303 

   304 void tst_QMediaRecorder::testAudioWavQualityVeryLow()

   305 {

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

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

   308     QAudioEncoderSettings audioSettings;

   309     audioSettings.setCodec("pcm");

   310     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   311     audioSettings.setQuality(QtMultimedia::VeryLowQuality);

   312     QVideoEncoderSettings videoSettings;

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

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

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

   316     audiocapture->record();

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

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

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

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

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

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

   323     audiocapture->pause();

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

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

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

   327     audiocapture->stop();

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

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

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

   331 }

   332 

   333 void tst_QMediaRecorder::testAudioWavQualityLow()

   334 {

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

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

   337     QAudioEncoderSettings audioSettings;

   338     audioSettings.setCodec("pcm");

   339     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   340     audioSettings.setQuality(QtMultimedia::LowQuality);

   341     QVideoEncoderSettings videoSettings;

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

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

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

   345     audiocapture->record();

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

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

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

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

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

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

   352     audiocapture->pause();

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

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

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

   356     audiocapture->stop();

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

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

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

   360 }

   361 

   362 void tst_QMediaRecorder::testAudioWavQualityNormal()

   363 {

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

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

   366     QAudioEncoderSettings audioSettings;

   367     audioSettings.setCodec("pcm");

   368     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   369     audioSettings.setQuality(QtMultimedia::NormalQuality);

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

   392 {

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

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

   395     QAudioEncoderSettings audioSettings;

   396     audioSettings.setCodec("pcm");

   397     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   398     audioSettings.setQuality(QtMultimedia::HighQuality);

   399     QVideoEncoderSettings videoSettings;

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

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

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

   403     audiocapture->record();

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

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

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

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

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

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

   410     audiocapture->pause();

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

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

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

   414     audiocapture->stop();

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

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

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

   418 }

   419 

   420 void tst_QMediaRecorder::testAudioWavQualityVeryHigh()

   421 {

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

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

   424     QAudioEncoderSettings audioSettings;

   425     audioSettings.setCodec("pcm");

   426     audioSettings.setEncodingMode(QtMultimedia::ConstantQualityEncoding);

   427     audioSettings.setQuality(QtMultimedia::VeryHighQuality);

   428     QVideoEncoderSettings videoSettings;

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

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

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

   432     audiocapture->record();

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

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

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

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

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

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

   439     audiocapture->pause();

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

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

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

   443     audiocapture->stop();

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

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

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

   447 }

   448 

   449 void tst_QMediaRecorder::testAudioWavSr4kHz()

   450 {

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

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

   453     QAudioEncoderSettings audioSettings;

   454     audioSettings.setCodec("pcm");

   455     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   456     audioSettings.setSampleRate(4000);

   457     QVideoEncoderSettings videoSettings;

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

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

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

   461     audiocapture->record();

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

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

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

   465 }

   466 

   467 void tst_QMediaRecorder::testAudioWavSr8kHz5Channel()

   468 {

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

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

   471     QAudioEncoderSettings audioSettings;

   472     audioSettings.setCodec("pcm");

   473     audioSettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);

   474     audioSettings.setSampleRate(8000);

   475     audioSettings.setChannelCount(6);

   476     QVideoEncoderSettings videoSettings;

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

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

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

   480     audiocapture->record();

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

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

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

   484 }