trunk/synthesis/Vocoder.cpp

/*
 *
 *    Vocoder.cpp
 *                                    (c) HAL@shurabaP 2012-
 *
 *  This class provides the interface to synthesize wave
 * by Vocoder system.
 *
 * These files are distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 */
#include "Vocoder.h"

#include "SequenceModel.h"
#include "SynthesizerExpression.h"
#include "SynthesizerTrack.h"
#include "SynthesizerNote.h"
#include "SynthesizerPhrase.h"
#include "AbstractCorpus.h"

#include "audio/AudioChunk.h"

#include "../configure.h"
#include "Utility.h"

using namespace stand::synthesis;
using namespace stand::model;

Vocoder::Vocoder(AbstractVocoderEngine *engine, AbstractCorpus *corpus, QObject *parent) :
    AbstractSynthesizer(parent)
{
    setEngine(engine);
    setCorpus(corpus);
}

Vocoder::~Vocoder()
{
}

bool Vocoder::synthesize(stand::io::audio::AudioChunk *dst, SynthesizerPhrase *phrase)
{
    if(!_engine || !_corpus || !dst || !dst->format().isValid())
    {
        return false;
    }

    double msCurrent = phrase->msBegin();
    dst->setMsLength(phrase->msEnd() - phrase->msBegin());
    dst->clearBufferToZero();

    const QVector<SynthesizerNote *> &notes = phrase->track()->notes();

    for(int i = 0; i < notes.size(); i++)
    {
        if(notes[i]->msBegin() < phrase->msBegin())
        {
            continue;
        }
        if(notes[i]->msBegin() >= phrase->msEnd())
        {
            break;
        }

        if(_corpus->contains(AbstractCorpus::Key(notes[i], 0)))
        {
            // ������������������������������
            SynthesizerNote *thisNote = notes[i];
            SynthesizerNote *nextNote = (i + 1 < notes.size()) ? notes[i+1] : NULL;

            msCurrent = qMax(msCurrent, thisNote->msBegin() - _corpus->msPreutterance(AbstractCorpus::Key(thisNote, 0.0)));

            // ���������������������������������������������������������������������
            if(nextNote)
            {
                msCurrent = _synthesizeOneNote(dst, msCurrent, thisNote, nextNote, phrase);
            }
            else
            {
                msCurrent = _synthesizeOneNote(dst, msCurrent, thisNote, phrase);
            }
        }
        else
        {
            msCurrent = notes[i]->msEnd();
        }
    }
    dst->setReadiness(true);

    return true;
}

double Vocoder::_synthesizeOneNote(stand::io::audio::AudioChunk *dst, double msCurrent, SynthesizerNote *current, SynthesizerNote *next, SynthesizerPhrase *phrase)
{
    VocoderFrame currentFrame(_engine->info()), nextFrame(_engine->info());

    QVector<QPair<VocoderFrame *, double> > frames;
    frames.resize(2);
    frames[0].first = &currentFrame;
    frames[1].first = &nextFrame;

    double currentActualMs = current->msBegin() - _corpus->msPreutterance(AbstractCorpus::Key(current, 0));
    double nextActualMs = next->msBegin() - _corpus->msPreutterance(AbstractCorpus::Key(next, 0));
    double begin = qMax(currentActualMs, nextActualMs);
    double length = current->msEnd() - begin;
    if(length <= 0.0)
    {
        return _synthesizeOneNote(dst, msCurrent, current, phrase);
    }

    while(msCurrent < phrase->msEnd() && msCurrent < current->msEnd())
    {
        double f0 = phrase->track()->f0At(msCurrent);
        if(f0 == 0.0)
        {
            f0 = stand::DefaultF0Value;
        }

        AbstractCorpus::Key currentKey(current, msCurrent - current->msBegin());
        AbstractCorpus::Key nextKey(next, msCurrent - next->msBegin());

        // ���������������������������������������
        frames[0].second = qMax(0.0, qMin(1.0, 1.0 - (msCurrent - begin) / length));
        frames[1].second = 1.0 - frames[0].second;

        // ���������������������������������������������������
        if(frames[0].second == 0.0)
        {
            _corpus->find(&currentFrame, nextKey, _engine);
        }
        else if(frames[0].second == 1.0)
        {
            _corpus->find(&currentFrame, currentKey, _engine);
        }
        else
        {
            _corpus->find(&currentFrame, currentKey, _engine);
            _corpus->find(&nextFrame, nextKey, _engine);
            _engine->morph(&currentFrame, frames);
        }

        _engine->synthesize(dst, &currentFrame, dst->samplesAtMsec(msCurrent));
        msCurrent += 1000.0 / f0;//_engine->samplesForF0(f0);
    }
    return msCurrent;
}

double Vocoder::_synthesizeOneNote(stand::io::audio::AudioChunk *dst, double msCurrent, SynthesizerNote *current, SynthesizerPhrase *phrase)
{
    VocoderFrame currentFrame(_engine->info());
    while(msCurrent < phrase->msEnd() && msCurrent < current->msEnd())
    {
        double f0 = phrase->track()->f0At(msCurrent);
        if(f0 < stand::utility::NoteFrequency(0) || f0 > stand::utility::NoteFrequency(128))
        {
            f0 = stand::DefaultF0Value;
        }
        AbstractCorpus::Key key(current, msCurrent - current->msBegin());
        _corpus->find(&currentFrame, key, _engine);
        _engine->synthesize(dst, &currentFrame, dst->samplesAtMsec(msCurrent));
        msCurrent += 1000.0 / f0;//_engine->samplesForF0(f0) / (double)_engine->info().sampleRate() * 1000.0;
    }
    return msCurrent;
}

