1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 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 examples of the Qt Toolkit.

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

    43 #include <QVBoxLayout>

    44 

    45 #include <qaudiooutput.h>

    46 #include <qaudiodeviceinfo.h>

    47 #include <QtCore/qmath.h>

    48 #include <QtCore/qendian.h>

    49 #include "audiooutput.h"

    50 

    51 const QString AudioTest::PushModeLabel(tr("Enable push mode"));

    52 const QString AudioTest::PullModeLabel(tr("Enable pull mode"));

    53 const QString AudioTest::SuspendLabel(tr("Suspend playback"));

    54 const QString AudioTest::ResumeLabel(tr("Resume playback"));

    55 

    56 const int DurationSeconds = 1;

    57 const int ToneFrequencyHz = 600;

    58 const int DataFrequencyHz = 44100;

    59 const int BufferSize      = 32768;

    60 

    61 

    62 Generator::Generator(const QAudioFormat &format,

    63                      qint64 durationUs,

    64                      int frequency,

    65                      QObject *parent)

    66     :   QIODevice(parent)

    67     ,   m_pos(0)

    68 {

    69     generateData(format, durationUs, frequency);

    70 }

    71 

    72 Generator::~Generator()

    73 {

    74 

    75 }

    76 

    77 void Generator::start()

    78 {

    79     open(QIODevice::ReadOnly);

    80 }

    81 

    82 void Generator::stop()

    83 {

    84     m_pos = 0;

    85     close();

    86 }

    87 

    88 void Generator::generateData(const QAudioFormat &format, qint64 durationUs, int frequency)

    89 {

    90     const int channelBytes = format.sampleSize() / 8;

    91     const int sampleBytes = format.channels() * channelBytes;

    92 

    93     qint64 length = (format.frequency() * format.channels() * (format.sampleSize() / 8))

    94                         * durationUs / 100000;

    95 

    96     Q_ASSERT(length % sampleBytes == 0);

    97     Q_UNUSED(sampleBytes) // suppress warning in release builds

    98 

    99     m_buffer.resize(length);

   100     unsigned char *ptr = reinterpret_cast<unsigned char *>(m_buffer.data());

   101     int sampleIndex = 0;

   102 

   103     while (length) {

   104         const qreal x = qSin(2 * M_PI * frequency * qreal(sampleIndex % format.frequency()) / format.frequency());

   105         for (int i=0; i<format.channels(); ++i) {

   106             if (format.sampleSize() == 8 && format.sampleType() == QAudioFormat::UnSignedInt) {

   107                 const quint8 value = static_cast<quint8>((1.0 + x) / 2 * 255);

   108                 *reinterpret_cast<quint8*>(ptr) = value;

   109             } else if (format.sampleSize() == 8 && format.sampleType() == QAudioFormat::SignedInt) {

   110                 const qint8 value = static_cast<qint8>(x * 127);

   111                 *reinterpret_cast<quint8*>(ptr) = value;

   112             } else if (format.sampleSize() == 16 && format.sampleType() == QAudioFormat::UnSignedInt) {

   113                 quint16 value = static_cast<quint16>((1.0 + x) / 2 * 65535);

   114                 if (format.byteOrder() == QAudioFormat::LittleEndian)

   115                     qToLittleEndian<quint16>(value, ptr);

   116                 else

   117                     qToBigEndian<quint16>(value, ptr);

   118             } else if (format.sampleSize() == 16 && format.sampleType() == QAudioFormat::SignedInt) {

   119                 qint16 value = static_cast<qint16>(x * 32767);

   120                 if (format.byteOrder() == QAudioFormat::LittleEndian)

   121                     qToLittleEndian<qint16>(value, ptr);

   122                 else

   123                     qToBigEndian<qint16>(value, ptr);

   124             }

   125 

   126             ptr += channelBytes;

   127             length -= channelBytes;

   128         }

   129         ++sampleIndex;

   130     }

   131 }

   132 

   133 qint64 Generator::readData(char *data, qint64 len)

   134 {

   135     qint64 total = 0;

   136     while (len - total) {

   137         const qint64 chunk = qMin((m_buffer.size() - m_pos), len - total);

   138         memcpy(data, m_buffer.constData() + m_pos, chunk);

   139         m_pos = (m_pos + chunk) % m_buffer.size();

   140         total += chunk;

   141     }

   142     return total;

   143 }

   144 

   145 qint64 Generator::writeData(const char *data, qint64 len)

   146 {

   147     Q_UNUSED(data);

   148     Q_UNUSED(len);

   149 

   150     return 0;

   151 }

   152 

   153 qint64 Generator::bytesAvailable() const

   154 {

   155     return m_buffer.size() + QIODevice::bytesAvailable();

   156 }

   157 

   158 AudioTest::AudioTest()

   159     :   m_pullTimer(new QTimer(this))

   160     ,   m_modeButton(0)

   161     ,   m_suspendResumeButton(0)

   162     ,   m_deviceBox(0)

   163     ,   m_device(QAudioDeviceInfo::defaultOutputDevice())

   164     ,   m_generator(0)

   165     ,   m_audioOutput(0)

   166     ,   m_output(0)

   167     ,   m_buffer(BufferSize, 0)

   168 {

   169     initializeWindow();

   170     initializeAudio();

   171 }

   172 

   173 void AudioTest::initializeWindow()

   174 {

   175     QScopedPointer<QWidget> window(new QWidget);

   176     QScopedPointer<QVBoxLayout> layout(new QVBoxLayout);

   177 

   178     m_deviceBox = new QComboBox(this);

   179     foreach (const QAudioDeviceInfo &deviceInfo, QAudioDeviceInfo::availableDevices(QAudio::AudioOutput))

   180         m_deviceBox->addItem(deviceInfo.deviceName(), qVariantFromValue(deviceInfo));

   181     connect(m_deviceBox,SIGNAL(activated(int)),SLOT(deviceChanged(int)));

   182     layout->addWidget(m_deviceBox);

   183 

   184     m_modeButton = new QPushButton(this);

   185     m_modeButton->setText(PushModeLabel);

   186     connect(m_modeButton, SIGNAL(clicked()), SLOT(toggleMode()));

   187     layout->addWidget(m_modeButton);

   188 

   189     m_suspendResumeButton = new QPushButton(this);

   190     m_suspendResumeButton->setText(SuspendLabel);

   191     connect(m_suspendResumeButton, SIGNAL(clicked()), SLOT(toggleSuspendResume()));

   192     layout->addWidget(m_suspendResumeButton);

   193 

   194     window->setLayout(layout.data());

   195     layout.take(); // ownership transferred

   196 

   197     setCentralWidget(window.data());

   198     QWidget *const windowPtr = window.take(); // ownership transferred

   199     windowPtr->show();

   200 }

   201 

   202 void AudioTest::initializeAudio()

   203 {

   204     connect(m_pullTimer, SIGNAL(timeout()), SLOT(pullTimerExpired()));

   205 

   206     m_pullMode = true;

   207 

   208     m_format.setFrequency(DataFrequencyHz);

   209     m_format.setChannels(1);

   210     m_format.setSampleSize(16);

   211     m_format.setCodec("audio/pcm");

   212     m_format.setByteOrder(QAudioFormat::LittleEndian);

   213     m_format.setSampleType(QAudioFormat::SignedInt);

   214 

   215     QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());

   216     if (!info.isFormatSupported(m_format)) {

   217         qWarning() << "Default format not supported - trying to use nearest";

   218         m_format = info.nearestFormat(m_format);

   219     }

   220 

   221     m_generator = new Generator(m_format, DurationSeconds*1000000, ToneFrequencyHz, this);

   222 

   223     createAudioOutput();

   224 }

   225 

   226 void AudioTest::createAudioOutput()

   227 {

   228     delete m_audioOutput;

   229     m_audioOutput = 0;

   230     m_audioOutput = new QAudioOutput(m_device, m_format, this);

   231     connect(m_audioOutput, SIGNAL(notify()), SLOT(notified()));

   232     connect(m_audioOutput, SIGNAL(stateChanged(QAudio::State)), SLOT(stateChanged(QAudio::State)));

   233     m_generator->start();

   234     m_audioOutput->start(m_generator);

   235 }

   236 

   237 AudioTest::~AudioTest()

   238 {

   239 

   240 }

   241 

   242 void AudioTest::deviceChanged(int index)

   243 {

   244     m_pullTimer->stop();

   245     m_generator->stop();

   246     m_audioOutput->stop();

   247     m_audioOutput->disconnect(this);

   248     m_device = m_deviceBox->itemData(index).value<QAudioDeviceInfo>();

   249     createAudioOutput();

   250 }

   251 

   252 void AudioTest::notified()

   253 {

   254     qWarning() << "bytesFree = " << m_audioOutput->bytesFree()

   255                << ", " << "elapsedUSecs = " << m_audioOutput->elapsedUSecs()

   256                << ", " << "processedUSecs = " << m_audioOutput->processedUSecs();

   257 }

   258 

   259 void AudioTest::pullTimerExpired()

   260 {

   261     if (m_audioOutput && m_audioOutput->state() != QAudio::StoppedState) {

   262         int chunks = m_audioOutput->bytesFree()/m_audioOutput->periodSize();

   263         while (chunks) {

   264            const qint64 len = m_generator->read(m_buffer.data(), m_audioOutput->periodSize());

   265            if (len)

   266                m_output->write(m_buffer.data(), len);

   267            if (len != m_audioOutput->periodSize())

   268                break;

   269            --chunks;

   270         }

   271     }

   272 }

   273 

   274 void AudioTest::toggleMode()

   275 {

   276     m_pullTimer->stop();

   277     m_audioOutput->stop();

   278 

   279     if (m_pullMode) {

   280         m_modeButton->setText(PullModeLabel);

   281         m_output = m_audioOutput->start();

   282         m_pullMode = false;

   283         m_pullTimer->start(20);

   284     } else {

   285         m_modeButton->setText(PushModeLabel);

   286         m_pullMode = true;

   287         m_audioOutput->start(m_generator);

   288     }

   289 

   290     m_suspendResumeButton->setText(SuspendLabel);

   291 }

   292 

   293 void AudioTest::toggleSuspendResume()

   294 {

   295     if (m_audioOutput->state() == QAudio::SuspendedState) {

   296         qWarning() << "status: Suspended, resume()";

   297         m_audioOutput->resume();

   298         m_suspendResumeButton->setText(SuspendLabel);

   299     } else if (m_audioOutput->state() == QAudio::ActiveState) {

   300         qWarning() << "status: Active, suspend()";

   301         m_audioOutput->suspend();

   302         m_suspendResumeButton->setText(ResumeLabel);

   303     } else if (m_audioOutput->state() == QAudio::StoppedState) {

   304         qWarning() << "status: Stopped, resume()";

   305         m_audioOutput->resume();

   306         m_suspendResumeButton->setText(SuspendLabel);

   307     } else if (m_audioOutput->state() == QAudio::IdleState) {

   308         qWarning() << "status: IdleState";

   309     }

   310 }

   311 

   312 void AudioTest::stateChanged(QAudio::State state)

   313 {

   314     qWarning() << "state = " << state;

   315 }