path: root/demos/mobile/guitartuner/src/guitartuner.cpp

/****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
**   * Redistributions of source code must retain the above copyright
**     notice, this list of conditions and the following disclaimer.
**   * Redistributions in binary form must reproduce the above copyright
**     notice, this list of conditions and the following disclaimer in
**     the documentation and/or other materials provided with the
**     distribution.
**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
**     the names of its contributors may be used to endorse or promote
**     products derived from this software without specific prior written
**     permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
** $QT_END_LICENSE$
**
****************************************************************************/

#include "guitartuner.h"

#ifdef Q_OS_SYMBIAN
#include <SoundDevice.h>
#endif // Q_OS_SYMBIAN

#if defined(Q_OS_SYMBIAN) && defined(ORIENTATIONLOCK)
#include <eikenv.h>
#include <eikappui.h>
#include <aknenv.h>
#include <aknappui.h>
#endif // Q_OS_SYMBIAN && ORIENTATIONLOCK

GuitarTuner::GuitarTuner(QWidget *parent) :
    QMainWindow(parent)
{

    // Set up the QML.
    m_guitarTunerUI = new QDeclarativeView(QUrl("qrc:/src/application.qml"), this);
    setCentralWidget(m_guitarTunerUI);
    m_guitarTunerUI->setResizeMode(QDeclarativeView::SizeRootObjectToView);
    qmlObject = m_guitarTunerUI->rootObject();

    // Init audio output and input.
    initAudioOutput();
    initAudioInput();

    // Connect the quit signal of m_guitarTunerUI
    // into the close slot of this.
    connect(m_guitarTunerUI->engine(), SIGNAL(quit()), SLOT(close()));

    // Connect the signals from qmlObject into proper slots
    // of this and m_voicegenerator.
    connect(qmlObject, SIGNAL(muteStateChanged(bool)),
            SLOT(muteStateChanged(bool)));
    connect(qmlObject, SIGNAL(volumeChanged(qreal)),
            m_voicegenerator, SLOT(setAmplitude(qreal)));
    connect(qmlObject, SIGNAL(volumeChanged(qreal)),
            SLOT(setMaxVolumeLevel(qreal)));

    // Connect the modeChanged signal from qmlObject
    // into modeChanged slot of this class.
    connect(qmlObject, SIGNAL(modeChanged(bool)),
            SLOT(modeChanged(bool)));

    // Connect the microphoneSensitivityChanged signal from
    // m_guitarTunerUI into setCutOffPercentage slot of m_analyzer class.
    connect(qmlObject, SIGNAL(microphoneSensitivityChanged(qreal)),
            m_analyzer, SLOT(setCutOffPercentage(qreal)));

    // Connect the signals from m_analyzer into slots of qmlObject.
    connect(m_analyzer, SIGNAL(lowVoice()),
            qmlObject, SLOT(lowVoice()));
    connect(m_analyzer, SIGNAL(correctFrequency()),
            qmlObject, SLOT(correctFrequencyObtained()));
    connect(m_analyzer, SIGNAL(voiceDifference(QVariant)),
            qmlObject, SLOT(voiceDifferenceChanged(QVariant)));

    // Initialise the MaximumVoiceDifference
    // value of qmlObject with the value obtained from m_analyzer.
    qmlObject->setProperty("maxVoiceDifference",
                           m_analyzer->getMaximumVoiceDifference());

    // Connect the targetFrequencyChanged signal of qmlObject
    // into targetFrequencyChanged slot of this class.
    connect(qmlObject, SIGNAL(targetFrequencyChanged(qreal)),
            SLOT(targetFrequencyChanged(qreal)));

    // Start voice output or input by using the modeChanged function,
    // depending of the current mode.
    modeChanged(qmlObject->property("isInput").toBool());

}

/**
  * Inits audio output.
  */
void GuitarTuner::initAudioOutput()
{
    // Set up the output format.
    m_format_output.setFrequency(DataFrequencyHzOutput);
    m_format_output.setCodec("audio/pcm");
    m_format_output.setSampleSize(16);
    m_format_output.setChannels(1);
    m_format_output.setByteOrder(QAudioFormat::LittleEndian);
    m_format_output.setSampleType(QAudioFormat::SignedInt);

    // Obtain a default output device, and if the format is not
    // supported, find the nearest format available.
    QAudioDeviceInfo outputDeviceInfo(
                QAudioDeviceInfo::defaultOutputDevice());
    if (!outputDeviceInfo.isFormatSupported(m_format_output)) {
        m_format_output = outputDeviceInfo.nearestFormat(m_format_output);
    }

    // Create new QAudioOutput and VoiceGenerator instances, and store
    // them in m_audioOutput and m_voicegenerator, respectively.
    m_audioOutput = new QAudioOutput(outputDeviceInfo,
                                     m_format_output, this);
    m_voicegenerator = new VoiceGenerator(m_format_output,
                                          qmlObject->property("frequency").toReal(),
                                          qmlObject->property("volume").toReal(),
                                          this);

    // Connect m_audioOutput stateChanged signal to outputStateChanged.
    connect(m_audioOutput, SIGNAL(stateChanged(QAudio::State)),
            SLOT(outputStateChanged(QAudio::State)));
}

/**
  * Inits audio input.
  */
void GuitarTuner::initAudioInput()
{
    // Set up the input format.
    m_format_input.setFrequency(DataFrequencyHzInput);
    m_format_input.setCodec("audio/pcm");
    m_format_input.setSampleSize(16);
    m_format_input.setChannels(1);
    m_format_input.setByteOrder(QAudioFormat::LittleEndian);
    m_format_input.setSampleType(QAudioFormat::SignedInt);

    // Obtain a default input device, and if the format is not
    // supported, find the nearest format available.
    QAudioDeviceInfo inputDeviceInfo(
                QAudioDeviceInfo::defaultInputDevice());
    if (!inputDeviceInfo.isFormatSupported(m_format_input)) {
        m_format_input = inputDeviceInfo.nearestFormat(m_format_input);
    }

    // Create new QAudioInput and VoiceAnalyzer instances, and store
    // them in m_audioInput and m_analyzer, respectively.
    // Remember to set the cut-off percentage for voice analyzer.
    m_audioInput = new QAudioInput(inputDeviceInfo, m_format_input, this);
    m_analyzer = new VoiceAnalyzer(m_format_input, this);
    m_analyzer->setCutOffPercentage(qmlObject->property("sensitivity").toReal());

}

/**
  * Receives a mode changed signal.
  */
void GuitarTuner::modeChanged(bool isInput)
{



    // If the mode must be changed to input mode:
    if (isInput) {

        // Stop audio output and audio generator.
        m_audioOutput->stop();
        m_voicegenerator->stop();
        // Start the audio analyzer and then the audio input.
        m_analyzer->start(qmlObject->property("frequency").toReal());
        m_audioInput->start(m_analyzer);

    }
    // Else:
    else {

        // Stop audio input and audio analyzer.
        m_audioInput->stop();
        m_analyzer->stop();

        // Set up the audio output.

        // If the current frequency of voice generator
        // is not the same as the target frequency selected in the UI,
        // update voice generator's frequency.
        if (m_voicegenerator->frequency() != qmlObject->property("frequency").toReal()) {
            m_voicegenerator->setFrequency(qmlObject->property("frequency").toReal());
        }

        // Start the voice generator and then the audio output.
        m_voicegenerator->start();
        m_audioOutput->start(m_voicegenerator);
        // Call setMaxVolumeLevel(1) to set the maximum volume louder.
        setMaxVolumeLevel(qmlObject->property("volume").toReal());

        // If the voice is muted, the voice is suspended
        // in the outputStateChanged slot.

    }
}

/**
  * Receives a output state changed signal.
  * Suspends the audio output, if the state is ActiveState
  * and the voice is muted.
  */
void GuitarTuner::outputStateChanged(QAudio::State state)
{
    if (QAudio::ActiveState == state && qmlObject->property("isMuted").toBool()) {
        // If the voice is muted, suspend the voice.
        m_audioOutput->suspend();
    }
}

/**
  * Receives a mute state changed signal.
  * Suspends the audio output or resumes it, depending of the
  * isMuted parameter.
  */
void GuitarTuner::muteStateChanged(bool isMuted)
{
    if (isMuted) {
        m_audioOutput->suspend();
    }
    else {
        m_audioOutput->resume();
    }
}

/**
  * Receives a target frequency signal.
  */
void GuitarTuner::targetFrequencyChanged(qreal targetFrequency)
{
    // If the output mode is active:
    if (!qmlObject->property("isInput").toBool()) {
        // Stop the audio output and voice generator.
        m_audioOutput->stop();
        m_voicegenerator->stop();
        // Set the voice generator's frequency to the target frequency.
        m_voicegenerator->setFrequency(targetFrequency);
        // Start the voice generator and audio output.
        m_voicegenerator->start();
        m_audioOutput->start(m_voicegenerator);
        // Call setMaxVolumeLevel(1) to set the maximum volume louder.
        setMaxVolumeLevel(qmlObject->property("volume").toReal());

        // If the voice is muted, the voice is suspended
        // in the outputStateChanged slot.

    }
    // Else:
    else {

        // Stop the audio input and voice analyzer.
        m_audioInput->stop();
        m_analyzer->stop();
        // Start the voice analyzer with new frequency and audio input.
        m_analyzer->start(targetFrequency);
        m_audioInput->start(m_analyzer);

    }
}

/**
  * This method provides a hack to set the maximum volume level in
  * Symbian.
  */
void GuitarTuner::setMaxVolumeLevel(qreal percent)
{
    if (percent >= 1.0) {
        percent = 1.0;
    }
    else if (percent <= 0.0) {
        percent = 0.0;
    }
    percent = percent*0.5 + 0.5;
    // Warning! This is a hack, which can break when the QtMobility
    // changes. Use at your own risk.
#ifdef Q_OS_SYMBIAN
    unsigned int *pointer_to_abstract_audio
            = (unsigned int*)( (unsigned char*)m_audioOutput + 8 );
    unsigned int *dev_sound_wrapper
            = (unsigned int*)(*pointer_to_abstract_audio) + 16;
    unsigned int *temp
            = ((unsigned int*)(*dev_sound_wrapper) + 6);
    CMMFDevSound *dev_sound = (CMMFDevSound*)(*temp);
    dev_sound->SetVolume((unsigned int)
                         (percent*(float)dev_sound->MaxVolume()));
#endif
}

/**
  * A function used to lock the orientation.
  */
void GuitarTuner::setOrientation(Orientation orientation)
{
#ifdef Q_OS_SYMBIAN
    if (orientation != Auto) {
#if defined(ORIENTATIONLOCK)
        const CAknAppUiBase::TAppUiOrientation uiOrientation =
                (orientation == LockPortrait)
                    ? CAknAppUi::EAppUiOrientationPortrait
                    : CAknAppUi::EAppUiOrientationLandscape;
        CAknAppUi* appUi = dynamic_cast<CAknAppUi*>
                (CEikonEnv::Static()->AppUi());
        TRAPD(error,
            if (appUi)
                appUi->SetOrientationL(uiOrientation);
        );
#else // ORIENTATIONLOCK
        qWarning(QString("'ORIENTATIONLOCK' needs to be defined on")
                 +QString(" Symbian when locking the orientation."));
#endif // ORIENTATIONLOCK
    }
#elif defined(Q_WS_MAEMO_5)
    Qt::WidgetAttribute attribute;
    switch (orientation) {
    case LockPortrait:
        attribute = Qt::WA_Maemo5PortraitOrientation;
        break;
    case LockLandscape:
        attribute = Qt::WA_Maemo5LandscapeOrientation;
        break;
    case Auto:
    default:
        attribute = Qt::WA_Maemo5AutoOrientation;
        break;
    }
    setAttribute(attribute, true);
#else // Q_OS_SYMBIAN
    Q_UNUSED(orientation);
#endif // Q_OS_SYMBIAN
}