/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <QDebug>

#include <qmediaobject.h>

#include <qmediacontrol.h>

#include <qmediaservice.h>

#include <qmediarecordercontrol.h>

#include <qmediarecorder.h>

#include <qaudioendpointselector.h>

#include <qaudioencodercontrol.h>

#include <qmediacontainercontrol.h>

#include <qvideoencodercontrol.h>

#include <QtMultimedia/qaudioformat.h>

QT_USE_NAMESPACE

class MockMediaContainerControl : public QMediaContainerControl

{

    Q_OBJECT

public:

    MockMediaContainerControl(QObject *parent):

        QMediaContainerControl(parent)

    {

        m_supportedContainers.append("wav");

        m_supportedContainers.append("mp3");

        m_supportedContainers.append("mov");

        m_descriptions.insert("wav", "WAV format");

        m_descriptions.insert("mp3", "MP3 format");

        m_descriptions.insert("mov", "MOV format");

    }

    virtual ~MockMediaContainerControl() {};

    QStringList supportedContainers() const

    {

        return m_supportedContainers;

    }

    QString containerMimeType() const

    {

        return m_format;

    }

    void setContainerMimeType(const QString &formatMimeType)

    {

        if (m_supportedContainers.contains(formatMimeType))

            m_format = formatMimeType;

    }

    QString containerDescription(const QString &formatMimeType) const

    {

        return m_descriptions.value(formatMimeType);

    }

private:

    QStringList m_supportedContainers;

    QMap<QString, QString> m_descriptions;

    QString m_format;

};

class MockVideoEncodeProvider : public QVideoEncoderControl

{

    Q_OBJECT

public:

    MockVideoEncodeProvider(QObject *parent):

        QVideoEncoderControl(parent)

    {

        m_supportedEncodeOptions.insert("video/3gpp", QStringList() << "quantizer" << "me");

        m_supportedEncodeOptions.insert("video/H264", QStringList() << "quantizer" << "me" << "bframes");

        m_videoCodecs << "video/3gpp" << "video/H264";

        m_sizes << QSize(320,240) << QSize(640,480);

        m_framerates << 30 << 15 << 1;

    }

    ~MockVideoEncodeProvider() {}

    QVideoEncoderSettings videoSettings() const { return m_videoSettings; }

    void setVideoSettings(const QVideoEncoderSettings &settings) { m_videoSettings = settings; };

    QList<QSize> supportedResolutions(const QVideoEncoderSettings & = QVideoEncoderSettings(),

                                      bool *continuous = 0) const

    {

        if (continuous)

            *continuous = true;

        return m_sizes;

    }

    QList<qreal> supportedFrameRates(const QVideoEncoderSettings & = QVideoEncoderSettings(),

                                     bool *continuous = 0) const

    {

        if (continuous)

            *continuous = false;

        return m_framerates;

    }

    QStringList supportedVideoCodecs() const { return m_videoCodecs; }

    QString videoCodecDescription(const QString &codecName) const { return codecName; }

    QStringList supportedEncodingOptions(const QString &codec) const

    {

        return m_supportedEncodeOptions.value(codec);

    }

    QVariant encodingOption(const QString &codec, const QString &name) const

    {

        return m_encodeOptions[codec].value(name);

    }

    void setEncodingOption(const QString &codec, const QString &name, const QVariant &value)

    {

        m_encodeOptions[codec][name] = value;

    }

private:

    QVideoEncoderSettings m_videoSettings;

    QMap<QString, QStringList> m_supportedEncodeOptions;

    QMap< QString, QMap<QString, QVariant> > m_encodeOptions;

    QStringList m_videoCodecs;

    QList<QSize> m_sizes;

    QList<qreal> m_framerates;

};

class MockAudioEncodeProvider : public QAudioEncoderControl

{

    Q_OBJECT

public:

    MockAudioEncodeProvider(QObject *parent):

        QAudioEncoderControl(parent)

    {

        m_codecs << "audio/pcm" << "audio/mpeg";

        m_supportedEncodeOptions.insert("audio/pcm", QStringList());

        m_supportedEncodeOptions.insert("audio/mpeg", QStringList() << "quality" << "bitrate" << "mode" << "vbr");

        m_audioSettings.setCodec("audio/pcm");

        m_audioSettings.setBitRate(128*1024);

    }

    ~MockAudioEncodeProvider() {}

    QAudioEncoderSettings audioSettings() const { return m_audioSettings; }

    void setAudioSettings(const QAudioEncoderSettings &settings) { m_audioSettings = settings; }

    QList<int> supportedSampleRates(const QAudioEncoderSettings & = QAudioEncoderSettings(), bool *continuous = 0) const

    {

        if (continuous)

            *continuous = false;

        return QList<int>() << 44100;

    }

    QStringList supportedAudioCodecs() const

    {

        return m_codecs;

    }

    QString codecDescription(const QString &codecName) const

    {

        if (codecName == "audio/pcm")

            return QString("Pulse Code Modulation");

        if (codecName == "audio/mpeg")

            return QString("MP3 audio format");

        return QString();

    }

    QStringList supportedEncodingOptions(const QString &codec) const

    {

        return m_supportedEncodeOptions.value(codec);

    }

    QVariant encodingOption(const QString &codec, const QString &name) const

    {

        return m_encodeOptions[codec].value(name);

    }

    void setEncodingOption(const QString &codec, const QString &name, const QVariant &value)

    {

        m_encodeOptions[codec][name] = value;

    }

private:

    QAudioEncoderSettings m_audioSettings;

    QStringList  m_codecs;

    QStringList  m_codecsDesc;

    QMap<QString, QStringList> m_supportedEncodeOptions;

    QMap< QString, QMap<QString, QVariant> > m_encodeOptions;

};

class MockAudioEndpointSelectorProvider : public QAudioEndpointSelector

{

    Q_OBJECT

public:

    MockAudioEndpointSelectorProvider(QObject *parent):

        QAudioEndpointSelector(parent)

    {

        m_names << "device1" << "device2" << "device3";

        m_descriptions << "dev1 comment" << "dev2 comment" << "dev3 comment";

        emit availableEndpointsChanged();

    }

    ~MockAudioEndpointSelectorProvider() {};

    QList<QString> availableEndpoints() const

    {

        return m_names;

    }

    QString endpointDescription(const QString& name) const

    {

        QString desc;

        for(int i = 0; i < m_names.count(); i++) {

            if (m_names.at(i).compare(name) == 0) {

                desc = m_descriptions.at(i);

                break;

            }

        }

        return desc;

    }

    QString defaultEndpoint() const

    {

        return m_names.at(0);

    }

    QString activeEndpoint() const

    {

        return m_audioInput;

    }

public Q_SLOTS:

    void setActiveEndpoint(const QString& name)

    {

        m_audioInput = name;

        emit activeEndpointChanged(name);

    }

private:

    QString         m_audioInput;

    QList<QString>  m_names;

    QList<QString>  m_descriptions;

};

class MockProvider : public QMediaRecorderControl

{

    Q_OBJECT

public:

    MockProvider(QObject *parent):

        QMediaRecorderControl(parent),

    m_state(QMediaRecorder::StoppedState),

    m_position(0) {}

    QUrl outputLocation() const

    {

        return m_sink;

    }

    bool setOutputLocation(const QUrl &sink)

    {

        m_sink = sink;

        return true;

    }

    QMediaRecorder::State state() const

    {

        return m_state;

    }

    qint64 duration() const

    {

        return m_position;

    }

    void applySettings() {}

    using QMediaRecorderControl::error;

public slots:

    void record()

    {

        m_state = QMediaRecorder::RecordingState;

        m_position=1;

        emit stateChanged(m_state);

        emit durationChanged(m_position);

    }

    void pause()

    {

        m_state = QMediaRecorder::PausedState;

        emit stateChanged(m_state);

    }

    void stop()

    {

        m_position=0;

        m_state = QMediaRecorder::StoppedState;

        emit stateChanged(m_state);

    }

public:

    QUrl       m_sink;

    QMediaRecorder::State m_state;

    qint64     m_position;

};

class MockService : public QMediaService

{

    Q_OBJECT

public:

    MockService(QObject *parent, QMediaControl *control):

        QMediaService(parent),

        mockControl(control),

        hasControls(true)

    {

        mockAudioEndpointSelector = new MockAudioEndpointSelectorProvider(parent);

        mockAudioEncodeControl = new MockAudioEncodeProvider(parent);

        mockFormatControl = new MockMediaContainerControl(parent);

        mockVideoEncodeControl = new MockVideoEncodeProvider(parent);

    }

    QMediaControl* control(const char *name) const

    {

        if(hasControls && qstrcmp(name,QAudioEncoderControl_iid) == 0)

            return mockAudioEncodeControl;

        if(hasControls && qstrcmp(name,QAudioEndpointSelector_iid) == 0)

            return mockAudioEndpointSelector;

        if(hasControls && qstrcmp(name,QMediaRecorderControl_iid) == 0)

            return mockControl;

        if(hasControls && qstrcmp(name,QMediaContainerControl_iid) == 0)

            return mockFormatControl;

        if(hasControls && qstrcmp(name,QVideoEncoderControl_iid) == 0)

            return mockVideoEncodeControl;

        return 0;

    }

    QMediaControl   *mockControl;

    QAudioEndpointSelector  *mockAudioEndpointSelector;

    QAudioEncoderControl    *mockAudioEncodeControl;

    QMediaContainerControl     *mockFormatControl;

    QVideoEncoderControl    *mockVideoEncodeControl;

    bool hasControls;

};

class MockObject : public QMediaObject

{

    Q_OBJECT

public:

    MockObject(QObject *parent, MockService *service):

        QMediaObject(parent, service)

    {

    }

};

class tst_QMediaRecorder: public QObject

{

    Q_OBJECT

public slots:

    void initTestCase();

    void cleanupTestCase();

private slots:

    void testNullService();

    void testNullControls();

    void testError();

    void testSink();

    void testRecord();

    void testAudioDeviceControl();

    void testAudioEncodeControl();

    void testMediaFormatsControl();

    void testVideoEncodeControl();

    void testEncodingSettings();

    void testAudioSettings();

    void testVideoSettings();

private:

    QAudioEncoderControl* encode;

    QAudioEndpointSelector* audio;

    MockObject      *object;

    MockService		*service;

    MockProvider    *mock;

    QMediaRecorder  *capture;

    QVideoEncoderControl* videoEncode;

};

void tst_QMediaRecorder::initTestCase()

{

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

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

    mock = new MockProvider(this);

    service = new MockService(this, mock);

    object = new MockObject(this, service);

    capture = new QMediaRecorder(object);

    capture->setNotifyInterval(100);

    audio = qobject_cast<QAudioEndpointSelector*>(capture->service()->control(QAudioEndpointSelector_iid));

    encode = qobject_cast<QAudioEncoderControl*>(capture->service()->control(QAudioEncoderControl_iid));

    videoEncode = qobject_cast<QVideoEncoderControl*>(capture->service()->control(QVideoEncoderControl_iid));

}

void tst_QMediaRecorder::cleanupTestCase()

{

    delete capture;

    delete object;

    delete service;

    delete mock;

}

void tst_QMediaRecorder::testNullService()

{

    const QString id(QLatin1String("application/x-format"));

    MockObject object(0, 0);

    QMediaRecorder recorder(&object);

    QCOMPARE(recorder.outputLocation(), QUrl());

    QCOMPARE(recorder.state(), QMediaRecorder::StoppedState);

    QCOMPARE(recorder.error(), QMediaRecorder::NoError);

    QCOMPARE(recorder.duration(), qint64(0));

    QCOMPARE(recorder.supportedContainers(), QStringList());

    QCOMPARE(recorder.containerDescription(id), QString());

    QCOMPARE(recorder.supportedAudioCodecs(), QStringList());

    QCOMPARE(recorder.audioCodecDescription(id), QString());

    QCOMPARE(recorder.supportedAudioSampleRates(), QList<int>());

    QCOMPARE(recorder.supportedVideoCodecs(), QStringList());

    QCOMPARE(recorder.videoCodecDescription(id), QString());

    bool continuous = true;

    QCOMPARE(recorder.supportedResolutions(QVideoEncoderSettings(), &continuous), QList<QSize>());

    QCOMPARE(continuous, false);

    continuous = true;

    QCOMPARE(recorder.supportedFrameRates(QVideoEncoderSettings(), &continuous), QList<qreal>());

    QCOMPARE(continuous, false);

    QCOMPARE(recorder.audioSettings(), QAudioEncoderSettings());

    QCOMPARE(recorder.videoSettings(), QVideoEncoderSettings());

    QCOMPARE(recorder.containerMimeType(), QString());

}

void tst_QMediaRecorder::testNullControls()

{

    const QString id(QLatin1String("application/x-format"));

    MockService service(0, 0);

    service.hasControls = false;

    MockObject object(0, &service);

    QMediaRecorder recorder(&object);

    QCOMPARE(recorder.outputLocation(), QUrl());

    QCOMPARE(recorder.state(), QMediaRecorder::StoppedState);

    QCOMPARE(recorder.error(), QMediaRecorder::NoError);

    QCOMPARE(recorder.duration(), qint64(0));

    QCOMPARE(recorder.supportedContainers(), QStringList());

    QCOMPARE(recorder.containerDescription(id), QString());

    QCOMPARE(recorder.supportedAudioCodecs(), QStringList());

    QCOMPARE(recorder.audioCodecDescription(id), QString());

    QCOMPARE(recorder.supportedAudioSampleRates(), QList<int>());

    QCOMPARE(recorder.supportedVideoCodecs(), QStringList());

    QCOMPARE(recorder.videoCodecDescription(id), QString());

    bool continuous = true;

    QCOMPARE(recorder.supportedResolutions(QVideoEncoderSettings(), &continuous), QList<QSize>());

    QCOMPARE(continuous, false);

    continuous = true;

    QCOMPARE(recorder.supportedFrameRates(QVideoEncoderSettings(), &continuous), QList<qreal>());

    QCOMPARE(continuous, false);

    QCOMPARE(recorder.audioSettings(), QAudioEncoderSettings());

    QCOMPARE(recorder.videoSettings(), QVideoEncoderSettings());

    QCOMPARE(recorder.containerMimeType(), QString());

    recorder.setOutputLocation(QUrl("file://test/save/file.mp4"));

    QCOMPARE(recorder.outputLocation(), QUrl());

    QAudioEncoderSettings audio;

    audio.setCodec(id);

    audio.setQuality(QtMediaServices::LowQuality);

    QVideoEncoderSettings video;

    video.setCodec(id);