1 #include "tst_qmediarecorder_mmf.h"

     2 

     3 QT_USE_NAMESPACE

     4 

     5 void tst_QMediaRecorder_mmf::initTestCase()

     6 {

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

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

     9 

    10     captureSource = new QAudioCaptureSource;

    11     audiocapture = new QMediaRecorder(captureSource);

    12 

    13     audioEndpoint = qobject_cast<QAudioEndpointSelector*>(captureSource->service()->requestControl(QAudioEndpointSelector_iid));

    14     audioEncoder = qobject_cast<QAudioEncoderControl*>(captureSource->service()->requestControl(QAudioEncoderControl_iid));

    15 }

    16 

    17 void tst_QMediaRecorder_mmf::cleanupTestCase()

    18 {

    19     delete audiocapture;

    20     delete captureSource;

    21 }

    22 

    23 QUrl tst_QMediaRecorder_mmf::recordPathAudio(QDir outputDir)

    24 {

    25     int lastImage = 0;

    26     int fileCount = 0;

    27     foreach( QString fileName, outputDir.entryList(QStringList() << "testclip_*.amr") ) {

    28         int imgNumber = fileName.mid(5, fileName.size()-9).toInt();

    29         lastImage = qMax(lastImage, imgNumber);

    30         if (outputDir.exists(fileName))

    31             fileCount+=1;

    32     }

    33     lastImage+=fileCount;

    34 

    35     QUrl location(QDir::toNativeSeparators(outputDir.canonicalPath()+QString("/testclip_%1.amr").arg(lastImage+1,4,10,QLatin1Char('0'))));

    36     return location;

    37 }

    38 

    39 void tst_QMediaRecorder_mmf::testAudioSink()

    40 {

    41     audiocapture->setOutputLocation(QUrl("test.tmp"));

    42     QUrl s = audiocapture->outputLocation();

    43     QCOMPARE(s.toString(), QString("test.tmp"));

    44 }

    45 

    46 void tst_QMediaRecorder_mmf::testAudioRecord()

    47 {

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

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

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

    51     audiocapture->setOutputLocation(recordPathAudio(QDir::rootPath()));

    52     audiocapture->record();

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

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

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

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

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

    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_mmf::testAudioRecordWithAMR()

    69 {

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

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

    72     audiocapture->setOutputLocation(recordPathAudio(QDir::rootPath()));

    73     QAudioEncoderSettings audioSettings;

    74     QVideoEncoderSettings videoSettings;

    75     audioSettings.setCodec("AMR");

    76     QString format = audiocapture->containerMimeType();

    77     format = QString("audio/amr");

    78     audiocapture->setEncodingSettings(audioSettings,videoSettings,format);

    79     audiocapture->record();

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

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

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

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

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

    85     audiocapture->pause();

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

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

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

    89     audiocapture->stop();

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

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

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

    93 }

    94 

    95 void tst_QMediaRecorder_mmf::testAudioEndPointSelector()

    96 {

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

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

    99     QVERIFY(audioEndpoint->defaultEndpoint().compare("") == 0);

   100     audioEndpoint->setActiveEndpoint("device2");

   101     QVERIFY(audioEndpoint->activeEndpoint().compare("device2") == 0);

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

   103     QVERIFY(audioEndpoint->endpointDescription("device2").compare("") == 0);

   104 }

   105 

   106 void tst_QMediaRecorder_mmf::testAudioEncoderControl()

   107 {

   108     QStringList codecs = audiocapture->supportedAudioCodecs();

   109     QVERIFY(codecs.count() == 2);

   110     QVERIFY(audiocapture->audioCodecDescription("PCM") == "Pulse code modulation");

   111     QStringList options = audioEncoder->supportedEncodingOptions("PCM");

   112     QCOMPARE(options.count(), 3);

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

   114     audioEncoder->setEncodingOption("PCM", "channels", QVariant(2));

   115     QCOMPARE(audioEncoder->encodingOption("PCM","channels").toInt(), 2);

   116     audioEncoder->setEncodingOption("PCM", "quality", QVariant(int(QtMultimediaKit::NormalQuality)));

   117     QCOMPARE(audioEncoder->encodingOption("PCM","quality").toInt(), int(QtMultimediaKit::NormalQuality));

   118     audioEncoder->setEncodingOption("PCM", "samplerate", QVariant(44100));

   119     QCOMPARE(audioEncoder->encodingOption("PCM","samplerate").toInt(), 44100);

   120 }

   121 

   122 void tst_QMediaRecorder_mmf::testMediaFormatsControl()

   123 {

   124     //audioocontainer types

   125     QCOMPARE(audiocapture->supportedContainers(), QStringList() << "audio/wav" << "audio/amr");

   126     QCOMPARE(audiocapture->containerDescription("audio/wav"), QString("WAV Write Format"));

   127     QCOMPARE(audiocapture->containerDescription("audio/amr"), QString("AMR Write Format"));

   128 }

   129 

   130 void tst_QMediaRecorder_mmf::testDefaultAudioEncodingSettings()

   131 {

   132     QAudioEncoderSettings audioSettings = audiocapture->audioSettings();

   133     QCOMPARE(audioSettings.codec(), QString("AMR"));

   134     QString format = audiocapture->containerMimeType();

   135     QCOMPARE(format, QString("audio/amr"));

   136 }