voiceanalyzer.cpp Example File

demos/mobile/guitartuner/src/voiceanalyzer.cpp
 /****************************************************************************
 **
 ** Copyright (C) 2011 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 "voiceanalyzer.h"

 /**
   * Constant used to scale the cut-off density for the fft helper.
   */
 const static float CutOffScaler = 0.05;

 /**
   * Force the precision to be "1/PrecisionPerNote" notes
   * near the target frequency.
   */
 const static int PrecisionPerNote = 4;

 /**
   * TargetFrequencyParameter is a constant which implies the index at
   * which corresponds to the target frequency.
   * 0.5 * N * 1/TargetFrequencyParameter is (about) the index which
   * corresponds to the given target frequency.
   * Effectively TargetFrequencyParameter = 2^z, and the z*TargetFrequency
   * is the maximum frequency that can be noticed.
   */
 const static int TargetFrequencyParameter = 4;

 VoiceAnalyzer::VoiceAnalyzer(const QAudioFormat &format, QObject *parent):
     QIODevice(parent),
     m_format(format),
     m_frequency(0),
     m_position(0),
     m_fftHelper(new FastFourierTransformer(this))
 {
     Q_ASSERT(qFuzzyCompare(M_SAMPLE_COUNT_MULTIPLIER,
                            float(2)/(M_TWELTH_ROOT_OF_2 -1.0)));
     m_totalSampleCount = qRound(qreal(PrecisionPerNote)
                                 *TargetFrequencyParameter
                                 *M_SAMPLE_COUNT_MULTIPLIER);
     m_samples.reserve(m_totalSampleCount);
     int i = 2;
     int j = 1;
     for (; i < TargetFrequencyParameter; i *= 2) {
         j++;
     }
     m_maximumVoiceDifference = j*12;

     setCutOffPercentage(CutOffScaler);
 }

 /**
   * Opens the parent QIODevice. Sets up the analysation parameters.
   */
 void VoiceAnalyzer::start(qreal frequency)
 {
     m_stepSize = (qreal) 1.0 * m_format.sampleRate()
                          / (TargetFrequencyParameter*2*frequency);
     m_frequency = frequency;
     open(QIODevice::WriteOnly);
 }

 /**
   * Closes the parent QIODevice, thus the voice is not analysed anymore.
   * Resets the m_samples QList.
   */
 void VoiceAnalyzer::stop()
 {
     m_samples.clear();
     m_samples.reserve(m_totalSampleCount);
     close();
 }

 /**
   * Called when data is obtained. Stores each m_stepSize sample
   * into a QList to be analysed.
   */
 qint64 VoiceAnalyzer::writeData(const char *data, qint64 maxlen)
 {
     const int channelBytes = m_format.sampleSize() / 8;
     int sampleSize = m_format.channels() * channelBytes;
     int m_stepSizeInBytes = m_stepSize*sampleSize;
     // assert that each sample fits fully into the data
     Q_ASSERT((m_position % sampleSize)==0);
     const uchar *ptr = reinterpret_cast<const uchar *>(data);
     while (m_position < maxlen) {
         if (m_samples.size() < m_totalSampleCount) {
             m_samples.append(getValueInt16(ptr+m_position));
         }
         else {
             analyzeVoice();
             m_samples.clear();
             m_samples.reserve(m_totalSampleCount);
             // fast forward position to the first position after maxlen or to the maxlen
             m_position += ((m_stepSizeInBytes - 1 + maxlen - m_position) /
                            m_stepSizeInBytes) * m_stepSizeInBytes;
             break;
         }
         m_position += m_stepSizeInBytes;
     }
     m_position -= maxlen;
     return maxlen;
 }

 /**
   * Interprets ptr as a pointer to int value and returns it.
   */
 qint16 VoiceAnalyzer::getValueInt16(const uchar *ptr)
 {
     qint16 realValue = 0;
     if (m_format.sampleSize() == 8)
     {
         const qint16 value = *reinterpret_cast<const quint8*>(ptr);
         if (m_format.sampleType() == QAudioFormat::UnSignedInt) {
             realValue = value - M_MAX_AMPLITUDE_8BIT_SIGNED - 1;
         } else if (m_format.sampleType() == QAudioFormat::SignedInt) {
             realValue = value;
         }
     } else if (m_format.sampleSize() == 16) {
         qint16 value = 0;
         if (m_format.byteOrder() == QAudioFormat::LittleEndian)
             value = qFromLittleEndian<quint16>(ptr);
         else
             value = qFromBigEndian<quint16>(ptr);

         if (m_format.sampleType() == QAudioFormat::UnSignedInt) {
             realValue = value - M_MAX_AMPLITUDE_16BIT_SIGNED;
         } else if (m_format.sampleType() == QAudioFormat::SignedInt) {
             realValue = value;
         }
     }
     return realValue;
 }

 /**
   * Takes a number between 0 and 1, scales it with CutOffScaler,
   * multiplies it with maximum density, and then gives it
   * to the fft helper.
   */
 void VoiceAnalyzer::setCutOffPercentage(qreal cutoff)
 {
     cutoff = CutOffScaler*cutoff;
     if (m_format.sampleSize() == 8) {
         float t = cutoff*m_totalSampleCount*M_MAX_AMPLITUDE_8BIT_SIGNED;
         m_fftHelper->setCutOffForDensity(t);
     }
     else if (m_format.sampleSize() == 16) {
         float t = cutoff*m_totalSampleCount*M_MAX_AMPLITUDE_16BIT_SIGNED;
         m_fftHelper->setCutOffForDensity(t);
     }
 }

 /**
   * Returns the current target frequency.
   */
 qreal VoiceAnalyzer::frequency()
 {
     return m_frequency;
 }

 /**
   * Returns the maximum absolute value sent by
   * the voiceDifference() signal.
   */
 int VoiceAnalyzer::getMaximumVoiceDifference()
 {
     return m_maximumVoiceDifference;
 }

 /**
   * Returns the maximum precision per note
   * near the target frequency.
   */
 int VoiceAnalyzer::getMaximumPrecisionPerNote()
 {
     return PrecisionPerNote;
 }

 /**
   * Analyzes the voice frequency and emits appropriate signals.
   */
 void VoiceAnalyzer::analyzeVoice()
 {
     m_fftHelper->calculateFFT(m_samples);
     int index = m_fftHelper->getMaximumDensityIndex();

     // If index == -1
     if (index == -1) {
         // The voice is to be filtered away.
         // Emit the lowVoice signal and return.
         emit lowVoice();
         qDebug() << "low voice";
         return;
     }
     // Else, continue

     // Let the correctIndex to be
     // the nearest index corresponding to the correct frequency.
     qreal stepSizeInFrequency = (qreal)m_format.sampleRate()
             / (m_totalSampleCount * m_stepSize);
     qreal newFrequency = qreal(index) * stepSizeInFrequency;
     // Calculate the nearest index corresponding to the correct frequency.
     int correctIndex = qRound(m_frequency / stepSizeInFrequency);
     qreal value = 0;

     // If the obtained frequency is more than
     // log_2(TargetFrequencyParameter) octaves less than the m_frequency:

     // Note:
     // Instead of m_frequency/TargetFrequencyParameter > newFrequency,
     // the comparison is done without a div instructions by
     // m_frequency > newFrequency * TargetFrequencyParameter.

     if (m_frequency > newFrequency * TargetFrequencyParameter) {
         // Set the difference value to be -m_maximumVoiceDifference.
         qDebug() << "compare" << "low" << newFrequency << m_frequency - stepSizeInFrequency * correctIndex << (m_frequency - stepSizeInFrequency * correctIndex) / stepSizeInFrequency;
         value = -m_maximumVoiceDifference;
     }
     // Else, if the obtained frequency is more than
     // log_2(TargetFrequencyParameter) octaves more than the m_frequency:
     else if (m_frequency*TargetFrequencyParameter < newFrequency) {
         // Set the difference value to be m_maximumVoiceDifference.
         qDebug() << "compare" << "high" << newFrequency << m_frequency - stepSizeInFrequency * correctIndex << (m_frequency - stepSizeInFrequency * correctIndex) / stepSizeInFrequency;
         value = m_maximumVoiceDifference;
     }
     // Else:
     else {
         // Calculate the difference between the obtained and the correct
         // frequency in tones.
         // Use stepSizeInFrequency * correctIndex instead of
         // m_frequency so that the value is zero when there is correct
         // voice obtained. Set the difference value to be
         // log(frequency / target frequency) * 12 / log(2).
         value = log(newFrequency / (stepSizeInFrequency * correctIndex))
                 * 12 / M_LN2;
         qDebug() << "compare" << value << newFrequency << m_frequency - stepSizeInFrequency * correctIndex << (m_frequency - stepSizeInFrequency * correctIndex) / stepSizeInFrequency;
     }

     // Emit voiceDifference signal.
     QVariant valueVar(value); //Has to be QVariant for QML
     emit voiceDifference(valueVar);

     // If the correctIndex is index, emit the correctFrequency signal.
     if (correctIndex == index) {
         emit(correctFrequency());
     }
 }

 /**
   * Empty implementation for readData, since no data is provided
   * by the VoiceAnalyzer class.
   */
 qint64 VoiceAnalyzer::readData(char *data, qint64 maxlen)
 {
     Q_UNUSED(data);
     Q_UNUSED(maxlen);

     return 0;
 }