--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qtmobility/examples/audiodevices/audiodevices.cpp Wed Jun 23 19:08:38 2010 +0300
@@ -0,0 +1,313 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 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 <qaudiodeviceinfo.h>
+
+#include "audiodevices.h"
+
+// Utility functions for converting QAudioFormat fields into text
+
+QString toString(QAudioFormat::SampleType sampleType)
+{
+ QString result("Unknown");
+ switch (sampleType) {
+ case QAudioFormat::SignedInt:
+ result = "SignedInt";
+ break;
+ case QAudioFormat::UnSignedInt:
+ result = "UnSignedInt";
+ break;
+ case QAudioFormat::Float:
+ result = "Float";
+ break;
+ }
+ return result;
+}
+
+QString toString(QAudioFormat::Endian endian)
+{
+ QString result("Unknown");
+ switch (endian) {
+ case QAudioFormat::LittleEndian:
+ result = "LittleEndian";
+ break;
+ case QAudioFormat::BigEndian:
+ result = "BigEndian";
+ break;
+ }
+ return result;
+}
+
+
+AudioDevicesBase::AudioDevicesBase(QWidget *parent, Qt::WFlags f)
+ : QMainWindow(parent, f)
+{
+ setupUi(this);
+}
+
+AudioDevicesBase::~AudioDevicesBase() {}
+
+
+AudioTest::AudioTest(QWidget *parent, Qt::WFlags f)
+ : AudioDevicesBase(parent, f)
+{
+ mode = QAudio::AudioOutput;
+
+ 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)));
+ connect(populateTableButton, SIGNAL(clicked()), SLOT(populateTable()));
+
+ modeBox->setCurrentIndex(0);
+ modeChanged(0);
+ deviceBox->setCurrentIndex(0);
+ deviceChanged(0);
+}
+
+AudioTest::~AudioTest()
+{
+}
+
+void AudioTest::test()
+{
+ // tries to set all the settings picked.
+ testResult->clear();
+
+ if (!deviceInfo.isNull()) {
+ if (deviceInfo.isFormatSupported(settings)) {
+ testResult->setText(tr("Success"));
+ nearestFreq->setText("");
+ nearestChannel->setText("");
+ nearestCodec->setText("");
+ nearestSampleSize->setText("");
+ nearestSampleType->setText("");
+ nearestEndian->setText("");
+ } else {
+ QAudioFormat nearest = deviceInfo.nearestFormat(settings);
+ testResult->setText(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()));
+ nearestSampleType->setText(toString(nearest.sampleType()));
+ nearestEndian->setText(toString(nearest.byteOrder()));
+ }
+ }
+ else
+ testResult->setText(tr("No Device"));
+}
+
+void AudioTest::modeChanged(int idx)
+{
+ testResult->clear();
+
+ // mode has changed
+ if (idx == 0)
+ mode = QAudio::AudioInput;
+ else
+ mode = QAudio::AudioOutput;
+
+ deviceBox->clear();
+ foreach (const QAudioDeviceInfo &deviceInfo, QAudioDeviceInfo::availableDevices(mode))
+ deviceBox->addItem(deviceInfo.deviceName(), qVariantFromValue(deviceInfo));
+
+ deviceBox->setCurrentIndex(0);
+ deviceChanged(0);
+}
+
+void AudioTest::deviceChanged(int idx)
+{
+ testResult->clear();
+
+ 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)
+ sampleTypesBox->addItem(toString(sampleTypez.at(i)));
+ if (sampleTypez.size())
+ settings.setSampleType(sampleTypez.at(0));
+
+ endianBox->clear();
+ QList<QAudioFormat::Endian> endianz = deviceInfo.supportedByteOrders();
+ for (int i = 0; i < endianz.size(); ++i)
+ endianBox->addItem(toString(endianz.at(i)));
+ if (endianz.size())
+ settings.setByteOrder(endianz.at(0));
+
+ allFormatsTable->clearContents();
+}
+
+void AudioTest::populateTable()
+{
+ int row = 0;
+
+ QAudioFormat format;
+ foreach (QString codec, deviceInfo.supportedCodecs()) {
+ format.setCodec(codec);
+ foreach (int frequency, deviceInfo.supportedFrequencies()) {
+ format.setFrequency(frequency);
+ foreach (int channels, deviceInfo.supportedChannels()) {
+ format.setChannels(channels);
+ foreach (QAudioFormat::SampleType sampleType, deviceInfo.supportedSampleTypes()) {
+ format.setSampleType(sampleType);
+ foreach (int sampleSize, deviceInfo.supportedSampleSizes()) {
+ format.setSampleSize(sampleSize);
+ foreach (QAudioFormat::Endian endian, deviceInfo.supportedByteOrders()) {
+ format.setByteOrder(endian);
+ if (deviceInfo.isFormatSupported(format)) {
+ allFormatsTable->setRowCount(row + 1);
+
+ QTableWidgetItem *codecItem = new QTableWidgetItem(format.codec());
+ allFormatsTable->setItem(row, 0, codecItem);
+
+ QTableWidgetItem *frequencyItem = new QTableWidgetItem(QString("%1").arg(format.frequency()));
+ allFormatsTable->setItem(row, 1, frequencyItem);
+
+ QTableWidgetItem *channelsItem = new QTableWidgetItem(QString("%1").arg(format.channels()));
+ allFormatsTable->setItem(row, 2, channelsItem);
+
+ QTableWidgetItem *sampleTypeItem = new QTableWidgetItem(toString(format.sampleType()));
+ allFormatsTable->setItem(row, 3, sampleTypeItem);
+
+ QTableWidgetItem *sampleSizeItem = new QTableWidgetItem(QString("%1").arg(format.sampleSize()));
+ allFormatsTable->setItem(row, 4, sampleSizeItem);
+
+ QTableWidgetItem *byteOrderItem = new QTableWidgetItem(toString(format.byteOrder()));
+ allFormatsTable->setItem(row, 5, byteOrderItem);
+
+ ++row;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+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);
+ }
+}