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

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

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

**

** This file is part of the examples of the Qt Toolkit.

**

** $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 <QDebug>

#include <QAudioDeviceInfo>

#include "audiodevices.h"

AudioDevicesBase::AudioDevicesBase( QMainWindow *parent, Qt::WFlags f )

{

    Q_UNUSED(parent)

    Q_UNUSED(f)

    setupUi( this );

}

AudioDevicesBase::~AudioDevicesBase() {}

AudioTest::AudioTest( QMainWindow *parent, Qt::WFlags f )

    : AudioDevicesBase( parent, f )

{

    nearestFreq->setDisabled(true);

    nearestChannel->setDisabled(true);

    nearestCodec->setDisabled(true);

    nearestSampleSize->setDisabled(true);

    nearestSampleType->setDisabled(true);

    nearestEndian->setDisabled(true);

    logOutput->setDisabled(true);

    mode = QAudio::AudioOutput;

    modeBox->addItem("Input");

    modeBox->addItem("Output");

    connect(testButton,SIGNAL(clicked()),SLOT(test()));

    connect(modeBox,SIGNAL(activated(int)),SLOT(modeChanged(int)));

    connect(deviceBox,SIGNAL(activated(int)),SLOT(deviceChanged(int)));

    connect(frequencyBox,SIGNAL(activated(int)),SLOT(freqChanged(int)));

    connect(channelsBox,SIGNAL(activated(int)),SLOT(channelChanged(int)));

    connect(codecsBox,SIGNAL(activated(int)),SLOT(codecChanged(int)));

    connect(sampleSizesBox,SIGNAL(activated(int)),SLOT(sampleSizeChanged(int)));

    connect(sampleTypesBox,SIGNAL(activated(int)),SLOT(sampleTypeChanged(int)));

    connect(endianBox,SIGNAL(activated(int)),SLOT(endianChanged(int)));

    modeBox->setCurrentIndex(0);

    modeChanged(0);

    deviceBox->setCurrentIndex(0);

    deviceChanged(0);

}

AudioTest::~AudioTest()

{

}

void AudioTest::test()

{

    // tries to set all the settings picked.

    logOutput->clear();

    logOutput->append("NOTE: an invalid codec audio/test exists for testing, to get a fail condition.");

    if (!deviceInfo.isNull()) {

        if (deviceInfo.isFormatSupported(settings)) {

            logOutput->append("Success");

            nearestFreq->setText("");

            nearestChannel->setText("");

            nearestCodec->setText("");

            nearestSampleSize->setText("");

            nearestSampleType->setText("");

            nearestEndian->setText("");

        } else {

            QAudioFormat nearest = deviceInfo.nearestFormat(settings);

            logOutput->append(tr("Failed"));

            nearestFreq->setText(QString("%1").arg(nearest.frequency()));

            nearestChannel->setText(QString("%1").arg(nearest.channels()));

            nearestCodec->setText(nearest.codec());

            nearestSampleSize->setText(QString("%1").arg(nearest.sampleSize()));

            switch(nearest.sampleType()) {

                case QAudioFormat::SignedInt:

                    nearestSampleType->setText("SignedInt");

                    break;

                case QAudioFormat::UnSignedInt:

                    nearestSampleType->setText("UnSignedInt");

                    break;

                case QAudioFormat::Float:

                    nearestSampleType->setText("Float");

                    break;

                case QAudioFormat::Unknown:

                    nearestSampleType->setText("Unknown");

            }

            switch(nearest.byteOrder()) {

                case QAudioFormat::LittleEndian:

                    nearestEndian->setText("LittleEndian");

                    break;

                case QAudioFormat::BigEndian:

                    nearestEndian->setText("BigEndian");

            }

        }

    }

    else

        logOutput->append("No Device");

}

void AudioTest::modeChanged(int idx)

{

    // mode has changed

    if(idx == 0)

        mode=QAudio::AudioInput;

    else

        mode=QAudio::AudioOutput;

    deviceBox->clear();

    foreach (const QAudioDeviceInfo &deviceInfo, QAudioDeviceInfo::deviceList(mode))

        deviceBox->addItem(deviceInfo.deviceName(), qVariantFromValue(deviceInfo));

}

void AudioTest::deviceChanged(int idx)

{

    if (deviceBox->count() == 0)

        return;

    // device has changed

    deviceInfo = deviceBox->itemData(idx).value<QAudioDeviceInfo>();

    frequencyBox->clear();

    QList<int> freqz = deviceInfo.supportedFrequencies();

    for(int i = 0; i < freqz.size(); ++i)

        frequencyBox->addItem(QString("%1").arg(freqz.at(i)));

    if(freqz.size())

        settings.setFrequency(freqz.at(0));

    channelsBox->clear();

    QList<int> chz = deviceInfo.supportedChannels();

    for(int i = 0; i < chz.size(); ++i)

        channelsBox->addItem(QString("%1").arg(chz.at(i)));

    if(chz.size())

        settings.setChannels(chz.at(0));

    codecsBox->clear();

    QStringList codecz = deviceInfo.supportedCodecs();

    for(int i = 0; i < codecz.size(); ++i)

        codecsBox->addItem(QString("%1").arg(codecz.at(i)));

    if(codecz.size())

        settings.setCodec(codecz.at(0));

    // Add false to create failed condition!

    codecsBox->addItem("audio/test");

    sampleSizesBox->clear();

    QList<int> sampleSizez = deviceInfo.supportedSampleSizes();

    for(int i = 0; i < sampleSizez.size(); ++i)

        sampleSizesBox->addItem(QString("%1").arg(sampleSizez.at(i)));

    if(sampleSizez.size())

        settings.setSampleSize(sampleSizez.at(0));

    sampleTypesBox->clear();

    QList<QAudioFormat::SampleType> sampleTypez = deviceInfo.supportedSampleTypes();

    for(int i = 0; i < sampleTypez.size(); ++i) {

        switch(sampleTypez.at(i)) {

            case QAudioFormat::SignedInt:

                sampleTypesBox->addItem("SignedInt");

                break;

            case QAudioFormat::UnSignedInt:

                sampleTypesBox->addItem("UnSignedInt");

                break;

            case QAudioFormat::Float:

                sampleTypesBox->addItem("Float");

                break;

            case QAudioFormat::Unknown:

                sampleTypesBox->addItem("Unknown");

        }

	if(sampleTypez.size())

            settings.setSampleType(sampleTypez.at(0));

    }

    endianBox->clear();

    QList<QAudioFormat::Endian> endianz = deviceInfo.supportedByteOrders();

    for(int i = 0; i < endianz.size(); ++i) {

        switch(endianz.at(i)) {

            case QAudioFormat::LittleEndian:

                endianBox->addItem("Little Endian");

                break;

            case QAudioFormat::BigEndian:

                endianBox->addItem("Big Endian");

                break;

        }

    }

    if(endianz.size())

        settings.setByteOrder(endianz.at(0));

}

void AudioTest::freqChanged(int idx)

{

    // freq has changed

    settings.setFrequency(frequencyBox->itemText(idx).toInt());

}

void AudioTest::channelChanged(int idx)

{

    settings.setChannels(channelsBox->itemText(idx).toInt());

}

void AudioTest::codecChanged(int idx)

{

    settings.setCodec(codecsBox->itemText(idx));

}

void AudioTest::sampleSizeChanged(int idx)

{

    settings.setSampleSize(sampleSizesBox->itemText(idx).toInt());

}

void AudioTest::sampleTypeChanged(int idx)

{

    switch(sampleTypesBox->itemText(idx).toInt()) {

        case QAudioFormat::SignedInt:

            settings.setSampleType(QAudioFormat::SignedInt);

            break;

        case QAudioFormat::UnSignedInt:

            settings.setSampleType(QAudioFormat::UnSignedInt);

            break;

        case QAudioFormat::Float:

            settings.setSampleType(QAudioFormat::Float);

    }

}

void AudioTest::endianChanged(int idx)

{

    switch(endianBox->itemText(idx).toInt()) {

        case QAudioFormat::LittleEndian:

            settings.setByteOrder(QAudioFormat::LittleEndian);

            break;

        case QAudioFormat::BigEndian:

            settings.setByteOrder(QAudioFormat::BigEndian);

    }

}