You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
rosegarden/src/base/SegmentPerformanceHelper.cpp

473 lines
13 KiB

// -*- c-basic-offset: 4 -*-
/*
Rosegarden
A sequencer and musical notation editor.
This program is Copyright 2000-2008
Guillaume Laurent <glaurent@telegraph-road.org>,
Chris Cannam <cannam@all-day-breakfast.com>,
Richard Bown <bownie@bownie.com>
The moral right of the authors to claim authorship of this work
has been asserted.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version. See the file
COPYING included with this distribution for more information.
*/
#include "SegmentPerformanceHelper.h"
#include "BaseProperties.h"
#include <iostream>
namespace Rosegarden
{
using std::endl;
using std::string;
using namespace BaseProperties;
SegmentPerformanceHelper::~SegmentPerformanceHelper() { }
SegmentPerformanceHelper::iteratorcontainer
SegmentPerformanceHelper::getTiedNotes(iterator i)
{
iteratorcontainer c;
c.push_back(i);
Event *e = *i;
if (!e->isa(Note::EventType)) return c;
Segment::iterator j(i);
bool tiedBack = false, tiedForward = false;
e->get<Bool>(TIED_BACKWARD, tiedBack);
e->get<Bool>(TIED_FORWARD, tiedForward);
timeT d = e->getNotationDuration();
timeT t = e->getNotationAbsoluteTime();
if (!e->has(PITCH)) return c;
int pitch = e->get<Int>(PITCH);
bool valid = false;
if (tiedBack) {
// #1171463: If we can find no preceding TIED_FORWARD event,
// then we remove this property
while (j != begin()) {
--j;
if (!(*j)->isa(Note::EventType)) continue;
e = *j; // can reuse e because this branch always returns
timeT t2 = e->getNotationAbsoluteTime() + e->getNotationDuration();
if (t2 < t) break;
if (t2 > t || !e->has(PITCH) ||
e->get<Int>(PITCH) != pitch) continue;
bool prevTiedForward = false;
if (!e->get<Bool>(TIED_FORWARD, prevTiedForward) ||
!prevTiedForward) break;
valid = true;
break;
}
if (valid) {
return iteratorcontainer();
} else {
(*i)->unset(TIED_BACKWARD);
return c;
}
}
else if (!tiedForward) return c;
for (;;) {
while (++j != end() && !(*j)->isa(Note::EventType));
if (j == end()) return c;
e = *j;
timeT t2 = e->getNotationAbsoluteTime();
if (t2 > t + d) break;
else if (t2 < t + d || !e->has(PITCH) ||
e->get<Int>(PITCH) != pitch) continue;
if (!e->get<Bool>(TIED_BACKWARD, tiedBack) ||
!tiedBack) break;
d += e->getNotationDuration();
c.push_back(j);
valid = true;
if (!e->get<Bool>(TIED_FORWARD, tiedForward) ||
!tiedForward) return c;
}
if (!valid) {
// Related to #1171463: If we can find no following
// TIED_BACKWARD event, then we remove this property
(*i)->unset(TIED_FORWARD);
}
return c;
}
bool
SegmentPerformanceHelper::getGraceAndHostNotes(iterator i,
iteratorcontainer &graceNotes,
iteratorcontainer &hostNotes,
bool &isHostNote)
{
if (i == end() || !(*i)->isa(Note::EventType)) return false;
Segment::iterator j = i;
Segment::iterator firstGraceNote = i;
Segment::iterator firstHostNote = i;
if ((*i)->has(IS_GRACE_NOTE) && (*i)->get<Bool>(IS_GRACE_NOTE)) {
// i is a grace note. Find the first host note following it
j = i;
while (++j != end()) {
if ((*j)->getNotationAbsoluteTime() >
(*i)->getNotationAbsoluteTime()) break;
if ((*j)->getSubOrdering() < 0) continue;
if ((*j)->isa(Note::EventType)) {
firstHostNote = j;
break;
}
}
if (firstHostNote == i) {
std::cerr << "SegmentPerformanceHelper::getGraceAndHostNotes: REMARK: Grace note at " << (*i)->getAbsoluteTime() << " has no host note" << std::endl;
return false;
}
} else {
// i is a host note, but we need to ensure we have the first
// one, not just any one
j = i;
while (j != begin()) {
--j;
if ((*j)->getNotationAbsoluteTime() <
(*i)->getNotationAbsoluteTime()) break;
if ((*j)->getSubOrdering() <
(*i)->getSubOrdering()) break;
if ((*j)->isa(Note::EventType)) {
firstHostNote = j;
break;
}
}
}
// firstHostNote now points to the first host note, which is
// either the first non-grace note after i (if i was a grace note)
// or the first note with the same time and subordering as i (if i
// was not a grace note).
if ((*firstHostNote)->getSubOrdering() < 0) {
std::cerr << "SegmentPerformanceHelper::getGraceAndHostNotes: WARNING: Note at " << (*firstHostNote)->getAbsoluteTime() << " has subordering " << (*i)->getSubOrdering() << " but is not a grace note" << std::endl;
return false;
}
j = firstHostNote;
while (j != begin()) {
--j;
if ((*j)->getNotationAbsoluteTime() <
(*firstHostNote)->getNotationAbsoluteTime()) break;
if ((*j)->getSubOrdering() >= 0) continue;
if (!(*j)->isa(Note::EventType)) continue;
if (!(*j)->has(IS_GRACE_NOTE) || !(*j)->get<Bool>(IS_GRACE_NOTE)) {
std::cerr << "SegmentPerformanceHelper::getGraceAndHostNotes: WARNING: Note at " << (*j)->getAbsoluteTime() << " (in trackback) has subordering " << (*j)->getSubOrdering() << " but is not a grace note" << std::endl;
break;
}
firstGraceNote = j;
}
if (firstGraceNote == firstHostNote) {
std::cerr << "SegmentPerformanceHelper::getGraceAndHostNotes: REMARK: Note at " << (*firstHostNote)->getAbsoluteTime() << " has no grace notes" << std::endl;
return false;
}
j = firstGraceNote;
// push all of the grace notes, and notes with the same time as
// the first host note, onto the container
isHostNote = false;
while (j != end()) {
if ((*j)->isa(Note::EventType)) {
if ((*j)->getSubOrdering() < 0) {
if ((*j)->has(IS_GRACE_NOTE) && (*j)->get<Bool>(IS_GRACE_NOTE)) {
graceNotes.push_back(j);
}
} else {
hostNotes.push_back(j);
if (j == i) isHostNote = true;
}
}
if ((*j)->getNotationAbsoluteTime() >
(*firstHostNote)->getNotationAbsoluteTime()) break;
++j;
}
return true;
}
timeT
SegmentPerformanceHelper::getSoundingAbsoluteTime(iterator i)
{
timeT t = 0;
timeT discard;
// std::cerr << "SegmentPerformanceHelper::getSoundingAbsoluteTime at " << (*i)->getAbsoluteTime() << std::endl;
if ((*i)->has(IS_GRACE_NOTE)) {
// std::cerr << "it's a grace note" << std::endl;
if (getGraceNoteTimeAndDuration(false, i, t, discard)) return t;
}
if ((*i)->has(MAY_HAVE_GRACE_NOTES)) {
// std::cerr << "it's a candidate host note" << std::endl;
if (getGraceNoteTimeAndDuration(true, i, t, discard)) return t;
}
return (*i)->getAbsoluteTime();
}
timeT
SegmentPerformanceHelper::getSoundingDuration(iterator i)
{
timeT d = 0;
timeT discard;
// std::cerr << "SegmentPerformanceHelper::getSoundingDuration at " << (*i)->getAbsoluteTime() << std::endl;
if ((*i)->has(IS_GRACE_NOTE)) {
// std::cerr << "it's a grace note" << std::endl;
if (getGraceNoteTimeAndDuration(false, i, discard, d)) return d;
}
if ((*i)->has(MAY_HAVE_GRACE_NOTES)) {
// std::cerr << "it's a candidate host note" << std::endl;
if (getGraceNoteTimeAndDuration(true, i, discard, d)) return d;
}
if ((*i)->has(TIED_BACKWARD)) {
// Formerly we just returned d in this case, but now we check
// with getTiedNotes so as to remove any bogus backward ties
// that have no corresponding forward tie. Unfortunately this
// is quite a bit slower.
//!!! optimize. at least we should add a marker property to
//anything we've already processed from this helper this time
//around.
iteratorcontainer c(getTiedNotes(i));
if (c.empty()) { // the tie back is valid
return 0;
}
}
if (!(*i)->has(TIED_FORWARD) || !(*i)->isa(Note::EventType)) {
d = (*i)->getDuration();
} else {
// tied forward but not back
iteratorcontainer c(getTiedNotes(i));
for (iteratorcontainer::iterator ci = c.begin();
ci != c.end(); ++ci) {
d += (**ci)->getDuration();
}
}
return d;
}
// In theory we can do better with tuplets, because real time has
// finer precision than timeT time. With a timeT resolution of 960ppq
// however the difference is probably not audible
RealTime
SegmentPerformanceHelper::getRealAbsoluteTime(iterator i)
{
return segment().getComposition()->getElapsedRealTime
(getSoundingAbsoluteTime(i));
}
// In theory we can do better with tuplets, because real time has
// finer precision than timeT time. With a timeT resolution of 960ppq
// however the difference is probably not audible
//
// (If we did want to do this, it'd help to have abstime->realtime
// conversion methods that accept double args in Composition)
RealTime
SegmentPerformanceHelper::getRealSoundingDuration(iterator i)
{
timeT t0 = getSoundingAbsoluteTime(i);
timeT t1 = t0 + getSoundingDuration(i);
if (t1 > segment().getEndMarkerTime()) {
t1 = segment().getEndMarkerTime();
}
return segment().getComposition()->getRealTimeDifference(t0, t1);
}
bool
SegmentPerformanceHelper::getGraceNoteTimeAndDuration(bool host, iterator i,
timeT &t, timeT &d)
{
// [This code currently assumes appoggiatura. Acciaccatura later.]
// For our present purposes, we will assume that grace notes start
// at the same time as their host note was intended to, and
// "steal" a proportion of the duration of their host note. This
// causes the host note to start later, and be shorter, by that
// same proportion.
// If a host note has more than one (consecutive) grace note, they
// should take a single cut from the grace note and divide it
// amongst themselves.
// To begin with we will set the proportion to 1/4, but we will
// probably want it to be (a) something different [because I don't
// really know what I'm doing], (b) adaptive [e.g. shorter host
// note or more grace notes = longer proportion], (c)
// configurable, or (d) all of the above.
// Of course we also ought to be taking into account the notated
// duration of the grace notes -- though in my working examples it
// generally doesn't seem to be the case that we can always just
// follow those. I wonder if we can always use the grace notes'
// notated duration if the ratio of grace note duration to host
// note duration is less than some value? Whatever we do, we
// should be dividing the grace note duration up in proportion to
// the durations of the grace notes, in situations where we have
// more than one grace note consecutively of different durations;
// that isn't handled at all here.
if (i == end()) return false;
iteratorcontainer graceNotes, hostNotes;
bool isHostNote;
if (!getGraceAndHostNotes(i, graceNotes, hostNotes, isHostNote)) {
std::cerr << "SegmentPerformanceHelper::getGraceNoteTimeAndDuration: REMARK: Note at " << (*i)->getAbsoluteTime() << " is not a grace note, or has no grace notes" << std::endl;
return false;
}
if (!isHostNote) {
if (!(*i)->has(IS_GRACE_NOTE) || !(*i)->get<Bool>(IS_GRACE_NOTE)) {
std::cerr << "SegmentPerformanceHelper::getGraceNoteTimeAndDuration: WARNING: Note at " << (*i)->getAbsoluteTime() << " is neither grace nor host note, but was reported as suitable by getGraceAndHostNotes" << std::endl;
return false;
}
}
if (hostNotes.empty()) {
std::cerr << "SegmentPerformanceHelper::getGraceNoteTimeAndDuration: REMARK: Grace note at " << (*i)->getAbsoluteTime() << " has no host note" << std::endl;
return false;
}
if (graceNotes.empty()) {
std::cerr << "SegmentPerformanceHelper::getGraceNoteTimeAndDuration: REMARK: Note at " << (*i)->getAbsoluteTime() << " has no grace notes" << std::endl;
return false;
}
timeT hostNoteEarliestTime = 0;
timeT hostNoteShortestDuration = 0;
timeT hostNoteNotationDuration = 0;
for (iteratorcontainer::iterator j = hostNotes.begin();
j != hostNotes.end(); ++j) {
if (j == hostNotes.begin() ||
(**j)->getAbsoluteTime() < hostNoteEarliestTime) {
hostNoteEarliestTime = (**j)->getAbsoluteTime();
}
if (j == hostNotes.begin() ||
(**j)->getDuration() < hostNoteShortestDuration) {
hostNoteShortestDuration = (**j)->getDuration();
}
if (j == hostNotes.begin() ||
(**j)->getNotationDuration() > hostNoteNotationDuration) {
hostNoteNotationDuration = (**j)->getNotationDuration();
}
(**j)->set<Bool>(MAY_HAVE_GRACE_NOTES, true);
}
timeT graceNoteTime = hostNoteEarliestTime;
timeT graceNoteDuration = hostNoteNotationDuration / 4;
if (graceNoteDuration > hostNoteShortestDuration / 2) {
graceNoteDuration = hostNoteShortestDuration / 2;
}
if (isHostNote) {
t = (*i)->getAbsoluteTime() + graceNoteDuration;
d = (*i)->getDuration() - graceNoteDuration;
} else {
int count = 0, index = 0;
bool found = false;
int prevSubOrdering = 0;
for (iteratorcontainer::iterator j = graceNotes.begin();
j != graceNotes.end(); ++j) {
bool newChord = false;
if ((**j)->getSubOrdering() != prevSubOrdering) {
newChord = true;
prevSubOrdering = (**j)->getSubOrdering();
}
if (newChord) ++count;
if (*j == i) found = true;
if (!found) {
if (newChord) ++index;
}
}
if (index == count) index = 0;
if (count == 0) count = 1; // should not happen
d = graceNoteDuration / count;
t = hostNoteEarliestTime + d * index;
}
return true;
}
}