trunk/echoes/EchoesStyleGenerator.cpp

#include <qmath.h>
#include <cmath>
#include "helper/ControlCommand.h"
#include "EchoesAnalysis.h"
#include "EchoesSegment.h"
#include "EchoesStyleModel.h"
#include "SequenceModel.h"
#include "ControlItem.h"
#include "TrackItem.h"
#include "envelope/Envelope.h"
#include "Utility.h"

#include "EchoesStyleGenerator.h"

using namespace stand::echoes;

EchoesStyleGenerator::EchoesStyleGenerator(EchoesStyleModel *style)
{
    setStyle(style);
}

EchoesStyleGenerator::~EchoesStyleGenerator()
{
}

EchoesStyleModel *EchoesStyleGenerator::style()
{
    return _style;
}

void EchoesStyleGenerator::setStyle(EchoesStyleModel *style)
{
    _style = style;
}

stand::view::helper::ControlCommand *EchoesStyleGenerator::styleCommand(stand::model::SequenceModel *sequence, int trackId, int tickBegin, int tickEnd, int tickResolution, double msFramePeriod)
{
    if(!sequence)
    {
        qDebug("EchoesStyleGenerator::styleCommand(); // invalid args.");
        return NULL;
    }
    QList<EchoesPhrase> phrases = EchoesAnalysis::phraseFromSequence(sequence, trackId, tickBegin, tickEnd);

    if(phrases.empty())
    {
        qDebug("EchoesStyleGenerator::styleCommand(); // Range(%d to %d) has no data.", tickBegin, tickEnd);
        return NULL;
    }

    // 'segments' is the list of corresponding segments to phrases.
    QList<EchoesSegment> segments;
    for(int i = 0; i < phrases.size(); i++)
    {
        segments.append(_style->findNearest(phrases.at(i)));
    }

    stand::view::helper::ControlCommand *parent = new stand::view::helper::ControlCommand;
    for(int i = 0; i < phrases.size(); i++)
    {
        _calculatePhrase(phrases[i], segments[i], sequence, trackId, tickResolution, msFramePeriod, parent);
    }
    return parent;
}

stand::view::helper::ControlCommand *EchoesStyleGenerator::_calculatePhrase(const EchoesPhrase &phrase, const EchoesSegment &source, stand::model::SequenceModel *sequence, int trackId, int tickResolution, double framePeriod, stand::view::helper::ControlCommand *parent)
{
    stand::view::helper::ControlCommand *pitch = new stand::view::helper::ControlCommand(parent);
    stand::view::helper::ControlCommand *volume = new stand::view::helper::ControlCommand(parent);
    stand::model::TrackItem *track = sequence->track(trackId);
    stand::model::ControlItem *pitchControl = track->control(track->data(track->PitchControlId, 0).toInt());
    stand::model::ControlItem *volumeControl = track->control(track->data(track->VolumeControlId, 0).toInt());

    pitch->control = pitchControl;
    volume->control = volumeControl;
    int tickBegin = sequence->tick(phrase.notes().first().msPosition());
    int tickEnd = sequence->tick(phrase.notes().last().msPosition() + phrase.notes().last().msLength());
    pitch->oldP = pitchControl->contour(tickBegin, tickEnd);
    volume->oldP = volumeControl->contour(tickBegin ,tickEnd);

    int firstIndex = 0, lastIndex = 0;
    QList<_Data> data;
    while(lastIndex < phrase.notes().size())
    {
        const EchoesNote &first = phrase.notes().at(firstIndex);
        const EchoesNote &last = phrase.notes().at(lastIndex);

        // ������������������������������
        if(first.msPosition() + first.msLength() + 20.0 < last.msPosition())
        {
            firstIndex++;
            continue;
        }
        QPair<EchoesNote, EchoesNote> pair = source.phrase()->find(first, last);
        _Data d = {QPair<EchoesNote, EchoesNote>(first, last), pair, pair.first.noteNumber(), pair.second.noteNumber() - pair.first.noteNumber(), source.pitch(), source.volume()};
        data.append(d);
        firstIndex = lastIndex;
        lastIndex++;
    }

    _morph(pitch, volume, data, tickResolution, framePeriod, sequence);

    return pitch;
}

void EchoesStyleGenerator::_morph(stand::view::helper::ControlCommand *pitch, stand::view::helper::ControlCommand *volume, QList<_Data> &data, int tickResolution, double framePeriod, stand::model::SequenceModel * sequence)
{
    int size = (data.last().target.second.msPosition() + data.last().target.second.msLength() - data.first().target.first.msPosition()) / framePeriod + 0.5;

    double *pitchContour = new double[size];
    double *volumeContour = new double[size];

    for(int i = 0; i < size; i++)
    {
        pitchContour[i] = 0;
        volumeContour[i] = -24.0;
    }

    for(int i = 0; i < data.size(); i++)
    {
        for(double ms = data[i].target.first.msPosition(); ms < data[i].target.second.msPosition(); ms += framePeriod)
        {
            int index = ms / framePeriod + 0.5;
            double rate = (ms - data[i].target.first.msPosition()) / (data[i].target.second.msPosition() - data[i].target.first.msPosition());
            double localMs = rate * (data[i].source.second.msPosition() - data[i].source.first.msPosition()) + data[i].source.first.msPosition();
            index = qMax(0, qMin(index, size - 1));
            pitchContour[index] += rate * data[i].pitch->at(localMs) / stand::utility::NoteFrequency(data[i].source.first.noteNumber()) * stand::utility::NoteFrequency(data[i].target.first.noteNumber());
            volumeContour[index] += rate * data[i].volume->at(localMs);
        }

        for(double ms = data[i].target.second.msPosition(); ms <= data[i].target.second.msPosition() + data[i].target.second.msLength(); ms += framePeriod)
        {
            int index = ms / framePeriod + 0.5;
            double rate = 1.0 - (ms - data[i].target.second.msPosition())/ data[i].target.second.msLength();
            double localMs = (1.0 - rate) * data[i].source.second.msLength() + data[i].source.second.msPosition();
            index = qMax(0, qMin(index, size - 1));
            pitchContour[index] += rate * data[i].pitch->at(localMs) / stand::utility::NoteFrequency(data[i].source.second.noteNumber()) * stand::utility::NoteFrequency(data[i].target.second.noteNumber());
            volumeContour[index] += rate * data[i].volume->at(localMs);
        }
    }

    stand::utility::envelope::Envelope pitchEnvelope(pitchContour, size, framePeriod, true);
    stand::utility::envelope::Envelope volumeEnvelope(volumeContour, size, framePeriod, true);

    int tickBegin = sequence->tick(data.first().target.first.msPosition());
    int tickEnd = sequence->tick(data.last().target.second.msPosition() + data.last().target.second.msLength());
    for(int tick = tickBegin / tickResolution * tickResolution; tick <= tickEnd; tick += tickResolution)
    {
        double ms = sequence->ms(tick) - data.first().target.first.msPosition();
        double f0 = pitchEnvelope.at(ms);
        double vol = volumeEnvelope.at(ms);
        pitch->newP.append(stand::utility::ControlPoint(tick, f0));
        volume->newP.append(stand::utility::ControlPoint(tick, vol));
    }

}
