MuseScore/libmscore/repeatlist.cpp
luz.paz f31624d746 fix various typos
* Found via `codespell -q 3 -S ./share/locale,./thirdparty -L ba,cann,clas,dur,foto,iff,nd,ois,ot,pres,possibile,snaped,strack,tage,te,uint,thru,valu`  
* Some revisions made per feedback given during review.
* Follow-up typos for review  
* Add revisions per feedback
2019-12-19 06:13:30 -05:00

840 lines
38 KiB
C++

//=============================================================================
// MuseScore
// Music Composition & Notation
//
// Copyright (C) 2009-2011 Werner Schweer
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation and appearing in
// the file LICENCE.GPL
//=============================================================================
#include "repeatlist.h"
#include "score.h"
#include "measure.h"
#include "tempo.h"
#include "volta.h"
#include "segment.h"
#include "marker.h"
#include "jump.h"
namespace Ms {
//---------------------------------------------------------
// searchLabel
// @param startMeasure From this measure, if nullptr from firstMeasure
// @param endMeasure Up to and including this measure, if nullptr till end of score
//---------------------------------------------------------
Measure* Score::searchLabel(const QString& s, Measure* startMeasure, Measure* endMeasure)
{
if (nullptr == startMeasure)
startMeasure = firstMeasure();
if (nullptr == endMeasure)
endMeasure = lastMeasure();
if (s == "start")
return startMeasure;
else if (s == "end")
return endMeasure;
endMeasure = endMeasure->nextMeasure(); // stop comparison needs measure one past the last one to check
for (Measure* m = startMeasure; m && (m != endMeasure); m = m->nextMeasure()) {
for (auto e : m->el()) {
if ( (e->isMarker())
&& (toMarker(e)->label() == s)) {
return m;
}
}
}
return nullptr;
}
//---------------------------------------------------------
// searchLabelWithinSectionFirst
//---------------------------------------------------------
Measure* Score::searchLabelWithinSectionFirst(const QString& s, Measure* sectionStartMeasure, Measure* sectionEndMeasure)
{
Measure* result = searchLabel(s, sectionStartMeasure, sectionEndMeasure);
if ((nullptr == result) && (sectionStartMeasure != firstMeasure())) { // not found, expand to the front
result = searchLabel(s, nullptr, sectionStartMeasure->prevMeasure());
}
if ((nullptr == result) && (sectionEndMeasure != lastMeasure())) { // not found, expand to the end
result = searchLabel(s, sectionEndMeasure->nextMeasure(), nullptr);
}
return result;
}
//---------------------------------------------------------
// RepeatSegment
//---------------------------------------------------------
RepeatSegment::RepeatSegment()
{
tick = 0;
utick = 0;
utime = 0.0;
timeOffset = 0.0;
}
RepeatSegment::RepeatSegment(RepeatSegment * const rs, Measure * const fromMeasure, Measure * const untilMeasure)
{
tick = 0;
utick = 0;
utime = 0.0;
timeOffset = 0.0;
//copy the measure list
auto it = rs->measureList.cbegin();
if (nullptr != fromMeasure) {
//skip until fromMeasure
while ((it->first != fromMeasure) && ((++it) != rs->measureList.cend()));
}
while (it != rs->measureList.cend()) {
if ((nullptr != untilMeasure) && (it->first->no() > untilMeasure->no())) {
break;
}
measureList.push_back(std::make_pair(it->first, it->second));
++it;
}
if (!measureList.empty()) {
tick = measureList.cbegin()->first->tick().ticks();
}
}
void RepeatSegment::addMeasure(Measure * const m)
{
Q_ASSERT(measureList.empty() || measureList.back().first->nextMeasure() == m);
if (measureList.empty()) {
tick = m->tick().ticks();
}
measureList.push_back(std::make_pair(m, m->playbackCount()));
}
bool RepeatSegment::containsMeasure(Measure const * const m) const
{
for (std::pair<Measure*, int> measure : measureList)
{
if (measure.first == m)
return true;
}
return false;
}
int RepeatSegment::len() const
{
return (measureList.empty()) ? 0 : (measureList.last().first->endTick().ticks() - tick);
}
//---------------------------------------------------------
// playbackCount
// returns the playbackCount of this measure at the time it was inserted into the repeatSegment
// returns 0 if the measure is not part of this repeatSegment
//---------------------------------------------------------
int RepeatSegment::playbackCount(Measure * const m) const
{
for (std::pair<Measure*, int> measure : measureList)
{
if (measure.first == m)
return measure.second;
}
return 0;
}
//---------------------------------------------------------
// RepeatList
//---------------------------------------------------------
RepeatList::RepeatList(Score* s)
{
_score = s;
idx1 = 0;
idx2 = 0;
}
//---------------------------------------------------------
// ~RepeatList
//---------------------------------------------------------
RepeatList::~RepeatList()
{
qDeleteAll(*this);
}
//---------------------------------------------------------
// ticks
//---------------------------------------------------------
int RepeatList::ticks() const
{
if (length() > 0) {
const RepeatSegment* s = last();
return s->utick + s->len();
}
return 0;
}
//---------------------------------------------------------
// update
//---------------------------------------------------------
void RepeatList::update(bool expand)
{
if (!_scoreChanged && expand == _expanded)
return;
if (expand)
unwind();
else
flatten();
_scoreChanged = false;
}
//---------------------------------------------------------
// updateTempo
//---------------------------------------------------------
void RepeatList::updateTempo()
{
const TempoMap* tl = _score->tempomap();
int utick = 0;
qreal t = 0;
for(RepeatSegment* s : *this) {
s->utick = utick;
s->utime = t;
qreal ct = tl->tick2time(s->tick);
s->timeOffset = t - ct;
utick += s->len();
t += tl->tick2time(s->tick + s->len()) - ct;
}
}
//---------------------------------------------------------
// utick2tick
//---------------------------------------------------------
int RepeatList::utick2tick(int tick) const
{
unsigned n = size();
if (n == 0)
return tick;
if (tick < 0)
return 0;
unsigned ii = (idx1 < n) && (tick >= at(idx1)->utick) ? idx1 : 0;
for (unsigned i = ii; i < n; ++i) {
if ((tick >= at(i)->utick) && ((i + 1 == n) || (tick < at(i+1)->utick))) {
idx1 = i;
return tick - (at(i)->utick - at(i)->tick);
}
}
if (MScore::debugMode) {
qFatal("tick %d not found in RepeatList", tick);
}
return 0;
}
//---------------------------------------------------------
// tick2utick
//---------------------------------------------------------
int RepeatList::tick2utick(int tick) const
{
if (empty())
return 0;
for (const RepeatSegment* s : *this) {
if (tick >= s->tick && tick < (s->tick + s->len() ))
return s->utick + (tick - s->tick);
}
return last()->utick + (tick - last()->tick);
}
//---------------------------------------------------------
// utick2utime
//---------------------------------------------------------
qreal RepeatList::utick2utime(int tick) const
{
unsigned n = size();
unsigned ii = (idx1 < n) && (tick >= at(idx1)->utick) ? idx1 : 0;
for (unsigned i = ii; i < n; ++i) {
if ((tick >= at(i)->utick) && ((i + 1 == n) || (tick < at(i+1)->utick))) {
int t = tick - (at(i)->utick - at(i)->tick);
qreal tt = _score->tempomap()->tick2time(t) + at(i)->timeOffset;
return tt;
}
}
return 0.0;
}
//---------------------------------------------------------
// utime2utick
//---------------------------------------------------------
int RepeatList::utime2utick(qreal t) const
{
unsigned n = size();
unsigned ii = (idx2 < n) && (t >= at(idx2)->utime) ? idx2 : 0;
for (unsigned i = ii; i < n; ++i) {
if ((t >= at(i)->utime) && ((i + 1 == n) || (t < at(i+1)->utime))) {
idx2 = i;
return _score->tempomap()->time2tick(t - at(i)->timeOffset) + (at(i)->utick - at(i)->tick);
}
}
if (MScore::debugMode) {
qFatal("time %f not found in RepeatList", t);
}
return 0;
}
//---------------------------------------------------------
// dump
//---------------------------------------------------------
void RepeatList::dump() const
{
#if 0
qDebug("==Dump Repeat List:==");
for (const RepeatSegment* s : *this) {
qDebug("%p tick: %3d(%d) %3d(%d) len %d(%d) beats %f + %f", s,
s->utick / MScore::division,
s->utick / MScore::division / 4,
s->tick / MScore::division,
s->tick / MScore::division / 4,
s->len() / MScore::division,
s->len() / MScore::division / 4,
s->utime, s->timeOffset);
}
#endif
}
//---------------------------------------------------------
// flatten
/// Make this repeat list flat (don't expand repeats)
//---------------------------------------------------------
void RepeatList::flatten()
{
qDeleteAll(*this);
clear();
Measure* m = _score->firstMeasure();
if (!m)
return;
RepeatSegment* s = new RepeatSegment;
s->tick = 0;
s->utick = 0;
s->utime = 0.0;
s->timeOffset = 0.0;
do {
s->addMeasure(m);
m = m->nextMeasure();
}
while (m);
push_back(s);
_expanded = false;
}
//---------------------------------------------------------
// unwind
// implements:
// - repeats
// - volta
// - d.c. al fine
// - d.s. al fine
// - d.s. al coda
//---------------------------------------------------------
void RepeatList::unwind()
{
qDeleteAll(*this);
clear();
_voltaRanges.clear();
_jumpsTaken.clear();
Measure* fm = _score->firstMeasure();
if (!fm)
return;
//qDebug("unwind===================");
for (Measure* m = fm; m; m = m->nextMeasure())
m->setPlaybackCount(0);
preProcessVoltas();
MeasureBase* sectionStartMeasureBase = NULL; // NULL indicates haven't discovered starting Measure of section
MeasureBase* sectionEndMeasureBase = NULL;
// partition score by section breaks and unwind individual sections separately
// note: section breaks may occur on non-Measure frames, so must search list of all MeasureBases
for (MeasureBase* mb = _score->first(); mb; mb = mb->next()) {
// unwindSection only deals with real Measures, so sectionEndMeasureBase and sectionStartMeasureBase will only point to real Measures
if (mb->isMeasure()) {
sectionEndMeasureBase = mb; // ending measure of section is the most recently encountered actual Measure
// starting measure of section will be the first non-NULL actual Measure encountered
if (sectionStartMeasureBase == NULL)
sectionStartMeasureBase = mb;
}
// if found section break or reached final MeasureBase of score, then unwind
if (mb->sectionBreak() || !mb->nextMeasure()) {
// only unwind if section starts and ends with actual real measure
if (sectionStartMeasureBase && sectionEndMeasureBase) {
unwindSection(reinterpret_cast<Measure*>(sectionStartMeasureBase), reinterpret_cast<Measure*>(sectionEndMeasureBase));
sectionStartMeasureBase = 0; // reset to NULL to indicate that don't know starting Measure of next section after starting new section
sectionEndMeasureBase = 0;
}
else {
qDebug( "Will not unroll a section that doesn't start or end with an actual measure. sectionStartMeasureBase = %p, sectionEndMeasureBase = %p",
sectionStartMeasureBase, sectionEndMeasureBase);
}
}
}
updateTempo();
_expanded = true;
dump();
}
//---------------------------------------------------------
// preProcessVoltas
// determine the real effective endpoint of voltas
// because an open volta doesn't necessarily end on its end anchorpoint
// MUST be called before unwinding(Section) logic!
//---------------------------------------------------------
void RepeatList::preProcessVoltas()
{
Volta* nextVolta = nullptr; //work backwards as a volta can end because the next one starts
for (auto rit = _score->spanner().crbegin(); rit != _score->spanner().crend(); ++rit)
{
Spanner* s = (*rit).second;
if (!s->isVolta())
continue;
Volta* volta = toVolta(s);
if (volta) {
if (_voltaRanges.find(volta) == _voltaRanges.end()) { // not yet determined the real endpoint, should always be true
// start by assuming the end of the spanner == the end of this volta (closed volta)
Measure* voltaEndMeasure = volta->endMeasure();
// open volta may end past its spanner
if (volta->getProperty(Pid::END_HOOK_TYPE).value<HookType>() == HookType::NONE) {
Measure* nextMeasureToInspect = voltaEndMeasure->nextMeasure();
// open volta ends:
while ( (nextMeasureToInspect) // end of score
&& (!voltaEndMeasure->sectionBreak()) // or end of section
&& (!voltaEndMeasure->repeatEnd()) // hitting an endRepeat
&& (!nextMeasureToInspect->repeatStart()) // or starting a new repeat
&& (!nextVolta || (nextMeasureToInspect != nextVolta->startMeasure())) // or if another volta starts
&& (!voltaEndMeasure->repeatJump()) //or hitting a jump, otherwise the part after the jump might be considered under this volta as well…
) { // nextMeasureToInspect is still part of this volta
voltaEndMeasure = nextMeasureToInspect;
nextMeasureToInspect = voltaEndMeasure->nextMeasure();
}
}
// found the real ending of this volta, store it to minimize search efforts
_voltaRanges.insert(std::pair<Volta*, Measure*>(volta, voltaEndMeasure));
nextVolta = volta; // this volta might indicate the end of the previous one
}
else {
qDebug("Found same volta twice in the spannermap");
}
}
} // end spannerloop
}
//---------------------------------------------------------
// searchVolta
// return the iterator in _voltaRanges for the volta spanning the given measure
//---------------------------------------------------------
std::map<Volta*, Measure*>::const_iterator RepeatList::searchVolta(Measure * const measure) const
{
std::map<Volta*, Measure*>::const_iterator voltaRange;
for (voltaRange = _voltaRanges.cbegin(); voltaRange != _voltaRanges.cend(); ++voltaRange) {
if ( (voltaRange->first->startMeasure()->tick() <= measure->tick())
&& (measure->tick() <= voltaRange->second->tick())
) {
break;
}
}
return voltaRange;
}
//---------------------------------------------------------
// unwindSection
// unwinds from sectionStartMeasure through sectionEndMeasure
//---------------------------------------------------------
void RepeatList::unwindSection(Measure* const sectionStartMeasure, Measure* const sectionEndMeasure)
{
// qDebug("unwind %d-measure section starting %p through %p", sectionEndMeasure->no()+1, sectionStartMeasure, sectionEndMeasure);
if (!sectionStartMeasure || !sectionEndMeasure) {
qDebug("invalid section start/end");
return;
}
RepeatSegment* rs = nullptr; // no measures to be played yet
Measure* prevMeasure = nullptr; // the last processed measure that is part of this RepeatSegment
Measure* currentMeasure = sectionStartMeasure; // the measure to be processed/evaluated
Measure* startFrom = sectionStartMeasure; //the last StartRepeat encountered in this loop; we should return here upon hitting a repeat
int startFromRepeatStartCount = findStartFromRepeatCount(startFrom);
std::map<Volta*, Measure*>::const_iterator voltaRange = _voltaRanges.cend();
Measure* playUntilMeasure = nullptr; // used during jumping
Measure* continueAtMeasure = nullptr; // used during jumping
while (currentMeasure && (currentMeasure != sectionEndMeasure->nextMeasure())) {
if ( (voltaRange != _voltaRanges.cend())
&& (currentMeasure == voltaRange->second->nextMeasure())
) { // volta was active -> not anymore
voltaRange = _voltaRanges.cend();
}
// Should we play or skip this measure: --> look for volta
if (voltaRange == _voltaRanges.cend()) {
voltaRange = searchVolta(currentMeasure);
if ( (voltaRange != _voltaRanges.cend())
&& !voltaRange->first->hasEnding(startFrom->playbackCount())
) {
// volta does not apply for expected playbackCount --> skip it
// but first finalize the current RepeatSegment
if (rs) {
push_back(rs);
rs = nullptr;
}
// now skip the volta
currentMeasure = voltaRange->second->nextMeasure();
voltaRange = _voltaRanges.cend();
// restart processing for the new measure
prevMeasure = nullptr;
continue;
}
}
// include this measure into the current RepeatSegment
currentMeasure->setPlaybackCount(currentMeasure->playbackCount() + 1);
if (nullptr == rs) {
rs = new RepeatSegment();
}
rs->addMeasure(currentMeasure);
prevMeasure = currentMeasure;
if (currentMeasure->repeatStart()) {
// always start from the last encountered repeat
startFrom = currentMeasure;
startFromRepeatStartCount = findStartFromRepeatCount(startFrom);
}
if ( (currentMeasure->repeatEnd())
&& (currentMeasure->playbackCount() < currentMeasure->repeatCount()) // not yet exhausted our number of repeats
) {
// finalize this RepeatSegment
push_back(rs);
rs = nullptr;
// we already know where to start from now, so continue right away with the new reference
currentMeasure = startFrom;
prevMeasure = nullptr;
voltaRange = _voltaRanges.cend();
continue;
}
// we will now check for jumps, these should only be followed upon the last pass through a measure
if ( (startFrom->playbackCount() == startFromRepeatStartCount) // means last pass through this set of repeats
|| ( (voltaRange != _voltaRanges.cend())
&& (startFrom->playbackCount() == voltaRange->first->lastEnding()) // or last pass through this volta
)
) {
if (currentMeasure->repeatJump()) { // found a jump, should we follow it?
// fetch the jump
Jump* jump = nullptr;
for (Element* e : currentMeasure->el()) {
if (e->isJump()) {
jump = toJump(e);
break;
}
}
// have we processed it already?
if (_jumpsTaken.find(jump) == _jumpsTaken.end()) { // not yet processed
// processing it now
_jumpsTaken.insert(jump);
// validate the jump
Measure* jumpToMeasure = _score->searchLabelWithinSectionFirst(jump->jumpTo(), sectionStartMeasure, sectionEndMeasure);
playUntilMeasure = _score->searchLabelWithinSectionFirst(jump->playUntil(), sectionStartMeasure, sectionEndMeasure);
continueAtMeasure = _score->searchLabelWithinSectionFirst(jump->continueAt(), sectionStartMeasure, sectionEndMeasure);
if (jumpToMeasure && playUntilMeasure && (continueAtMeasure || jump->continueAt().isEmpty())) {
// we will jump, but first finalize the current RepeatSegment
push_back(rs);
rs = nullptr;
// now jump
// basically, replay the score from jumpToMeasure all the way up the to last occurrence of playUntilMeasure
// this replay lookup uses mostly indexes over iterators as push_back of new segments might invalidate an iterator
// step 1: find the last occurrence of playUntilMeasure
Measure* copyUntilMeasure = playUntilMeasure; // assume we can rewind back to the playUntilMeasure
int copyUntilIdx = this->size() - 1; // assume we will find the copyUntilMeasure in the (currently) last repeatSegment
int playUntilIdx = this->size();
do {
--playUntilIdx;
}
while ( (!(this->at(playUntilIdx)->containsMeasure(playUntilMeasure)))
&& (playUntilIdx > 0)
);
if (isFinalPlaythrough(playUntilMeasure, (this->cbegin() + playUntilIdx))) {
copyUntilIdx = playUntilIdx;
}
else { // not found or not final playthrough
// -> currentMeasure is the most recent parsed measure that should be included into the replay
copyUntilMeasure = currentMeasure;
}
// step 2: find jumpToMeasure
auto copyFromIdx = -1;
Measure * copyFromMeasure = jumpToMeasure;
if (jump->playRepeats()) {
// we want to replay as much from the score as possible
// => find most recent occurrence of first playBack of jumpToMeasure #270332
for (int jumpToIdx = playUntilIdx; jumpToIdx >= 0; --jumpToIdx) {
if (this->at(jumpToIdx)->playbackCount(jumpToMeasure) == 1) {
copyFromIdx = jumpToIdx;
break;
}
}
}
else { // no repeats upon jumping => find final occurrence of jumpToMeasure
int jumpToIdx = this->size();
do {
--jumpToIdx;
}
while ( (!(this->at(jumpToIdx)->containsMeasure(jumpToMeasure)))
&& (jumpToIdx > 0)
);
if (isFinalPlaythrough(jumpToMeasure, (this->cbegin() + jumpToIdx))) {
copyFromIdx = jumpToIdx;
}
}
// step 3 : duplicate the part we would otherwise have to rewind
if (copyFromIdx != -1) {
if (jump->playRepeats()) {
// all should be replayed, simply copy over
for (int idx = copyFromIdx; idx <= copyUntilIdx; ++idx) {
this->push_back(new RepeatSegment(
this->at(idx),
(idx == copyFromIdx) ? copyFromMeasure : nullptr,
(idx == copyUntilIdx) ? copyUntilMeasure : nullptr
)
);
}
}
else { // only most recent passes should be played
// so we have to inspect each measure to be it's most recent playthrough
int idx = copyFromIdx;
while (idx <= copyUntilIdx) {
RepeatSegment* referenceSegment = this->at(idx);
auto referenceIt = referenceSegment->measureList.cbegin();
bool forwardToMoreRecentPlaythrough = false;
if (idx == copyFromIdx) {
// skip start of segment
while ((referenceIt->first != copyFromMeasure) && ((++referenceIt) != referenceSegment->measureList.cend()));
}
// start copy
while ( ((referenceIt != referenceSegment->measureList.cend()) && !forwardToMoreRecentPlaythrough)
&& ((idx != copyUntilIdx) || (referenceIt->first->no() <= copyUntilMeasure->no()))
) {
// find most recent occurrence of this measure
auto mostRecentRepeatSegmentIdx = copyUntilIdx; // look backwards to find to most recent first
while ((mostRecentRepeatSegmentIdx > idx) && !forwardToMoreRecentPlaythrough) {
RepeatSegment * mostRecentSegment = this->at(mostRecentRepeatSegmentIdx);
if ( (mostRecentSegment->playbackCount(referenceIt->first) >= referenceIt->second)
&& (referenceIt->first->no() <= copyUntilMeasure->no())
) {
// found a more recent playthrough => continue our copy from there
forwardToMoreRecentPlaythrough = true;
// save continueCopyPosition
copyFromMeasure = referenceIt->first;
idx = mostRecentRepeatSegmentIdx;
continue;
}
--mostRecentRepeatSegmentIdx;
}
if (!forwardToMoreRecentPlaythrough) {
// this is the most recent playthrough of this measure -> copy it
if (nullptr == rs) {
rs = new RepeatSegment();
rs->tick = referenceIt->first->tick().ticks();
}
rs->measureList.push_back(std::make_pair(referenceIt->first, referenceIt->second));
}
// test & copy next measure
++referenceIt;
}
// store what we've copied from this repeatSegment
if (rs) {
push_back(rs);
rs = nullptr;
}
// move to the next repeatSegment
if (!forwardToMoreRecentPlaythrough) {
++idx;
}
}
}
}
// step 4 : determine the next measure to evaluate
if (copyFromIdx == -1) {
// still everything to process, because we couldn't copy from the jumpToMeasure yet
currentMeasure = jumpToMeasure; // so start there now
}
else {
if (copyUntilMeasure == playUntilMeasure) {
// fully processed this jump, we know where to continue, so jump there
currentMeasure = continueAtMeasure;
// end of processing this jump
playUntilMeasure = nullptr;
continueAtMeasure = nullptr;
}
else {
// we have copied stuff, but not yet all of it
currentMeasure = copyUntilMeasure->nextMeasure();
}
}
if (currentMeasure) {
startFrom = findStartRepeat(currentMeasure); // not yet happy with these, but not worse than before
startFromRepeatStartCount = findStartFromRepeatCount(startFrom);
}
// restart processing
prevMeasure = nullptr;
voltaRange = _voltaRanges.cend();
continue;
}
}
}
if (currentMeasure == playUntilMeasure) {
// end of processing this jump
playUntilMeasure = nullptr;
// finalize the current RepeatSegment
push_back(rs);
rs = nullptr;
// we know where to continue, so jump there
currentMeasure = continueAtMeasure;
continueAtMeasure = nullptr;
// restart processing
prevMeasure = nullptr;
voltaRange = _voltaRanges.cend();
continue;
}
}
// keep looping until reach end of score or end of the section
currentMeasure = currentMeasure->nextMeasure();
}
// append the final repeat segment of that section
if (rs) {
if (prevMeasure) {
if (rs->len()) {
push_back(rs);
rs = nullptr;
}
else
delete rs;
}
else // not even a single measure included in the segment -> it is empty
delete rs;
}
}
//---------------------------------------------------------
// findStartRepeat
// search backwards starting at a given measure to find a repeatStart
// @return the measure having the repeatStart or start of section
//---------------------------------------------------------
Measure* RepeatList::findStartRepeat(Measure * const measure) const
{
Measure* m = measure;
while ((!m->repeatStart())
&& (m != _score->firstMeasure())
&& (!m->prevMeasure()->sectionBreak()))
{
m = m->prevMeasure();
}
return m;
}
//---------------------------------------------------------
// findStartFromRepeatCount
// @param startFrom starting measure for this repeat subsection
// @return number of times playback passes the start repeat barline (not accounting for jumps)
//---------------------------------------------------------
int RepeatList::findStartFromRepeatCount(Measure * const startFrom) const
{
Measure * m = startFrom;
int startFromRepeatCount = (m->repeatEnd())? (m->repeatCount()) : 1;
m = m->nextMeasure();
while (m && !m->repeatStart()) {
if (m->repeatEnd()) {
startFromRepeatCount += m->repeatCount() - 1;
}
m = (m->sectionBreak()) ? nullptr : m->nextMeasure();
}
return startFromRepeatCount;
}
//---------------------------------------------------------
// isFinalPlaythrough
// @param measure the measure to verify
// @param repeatSegment consider measure with its playbackCount in this specific RepeatSegment
// @return true if that measure has its final playthrough in the given repeatSegment
//---------------------------------------------------------
bool RepeatList::isFinalPlaythrough(Measure * const measure, QList<RepeatSegment*>::const_iterator repeatSegmentIt) const
{
bool finalPlaythrough = false;
if ( (repeatSegmentIt != this->cend())
&& ((*repeatSegmentIt)->containsMeasure(measure))
) {
// step 1 : so go and look back for the relevant startRepeatMeasure
Measure * startRepeatMeasure = findStartRepeat(measure);
auto startRepeatIt = repeatSegmentIt;
while ( (startRepeatIt != this->cbegin())
&& (!(*startRepeatIt)->containsMeasure(startRepeatMeasure))
){
--startRepeatIt;
}
int startRepeatPlaybackCount = (*startRepeatIt)->playbackCount(startRepeatMeasure);
// step 2 : does this measure belong to a volta?
auto voltaRange = searchVolta(measure);
// step 3 : is it the final playThrough of this measure?
if ( (startRepeatPlaybackCount == findStartFromRepeatCount(startRepeatMeasure))
|| ( (voltaRange != _voltaRanges.cend())
&& (startRepeatPlaybackCount == voltaRange->first->lastEnding())
)
) {
finalPlaythrough = true;
}
//else: found, but not yet final playthrough -> nothing to do
}
//else: measure not found == not part of this RepeatSegment -> nothing to do
return finalPlaythrough;
}
}