MuseScore/libmscore/stringdata.cpp
ws ec3be9a99a Replacd integer midi tick values by fractions.
- tick names a position on the time axis
- tick is always a Fraction()
- only Measure() and Segment() (and Tuplet?) have a tick value
- tick() for an generic element return only a sensible value if isMeasure() or isSegment() or isSegment(parent())

- "ticks" names a duration stored in a Fraction()
- the tick value for an Segment is relative to its measure

- rename "duration" to "ticks"
- rename afrac() to tick()
- rename rfrac() to rtick()
- rename some variables, changing "fraction" into "tick"
  (example: actualFraction() into actualTicks())

- Lyrics ticks are written as Fraction, on read if xmlreader sees a "/" it reads a fraction
  else midi ticks for backwards compatibility
2019-02-18 11:46:05 +01:00

505 lines
19 KiB
C++

//=============================================================================
// MuseScore
// Music Composition & Notation
//
// Copyright (C) 2002-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 "stringdata.h"
#include "chord.h"
#include "note.h"
#include "part.h"
#include "score.h"
#include "staff.h"
#include "undo.h"
#include "segment.h"
namespace Ms {
//---------------------------------------------------------
// StringData
//---------------------------------------------------------
bool StringData::bFretting = false;
StringData::StringData(int numFrets, int numStrings, int strings[])
{
instrString strg = { 0, false};
_frets = numFrets;
for (int i = 0; i < numStrings; i++) {
strg.pitch = strings[i];
stringTable.append(strg);
}
}
StringData::StringData(int numFrets, QList<instrString>& strings)
{
_frets = numFrets;
stringTable.clear();
foreach(instrString i, strings)
stringTable.append(i);
}
//---------------------------------------------------------
// read
//---------------------------------------------------------
void StringData::read(XmlReader& e)
{
stringTable.clear();
while (e.readNextStartElement()) {
const QStringRef& tag(e.name());
if (tag == "frets")
_frets = e.readInt();
else if (tag == "string") {
instrString strg;
strg.open = e.intAttribute("open", 0);
strg.pitch = e.readInt();
stringTable.append(strg);
}
else
e.unknown();
}
}
//---------------------------------------------------------
// write
//---------------------------------------------------------
void StringData::write(XmlWriter& xml) const
{
xml.stag("StringData");
xml.tag("frets", _frets);
foreach(instrString strg, stringTable) {
if (strg.open)
xml.tag("string open=\"1\"", strg.pitch);
else
xml.tag("string", strg.pitch);
}
xml.etag();
}
//---------------------------------------------------------
// convertPitch
// Finds string and fret for a note.
//
// Fills *string and *fret with suitable values for pitch at given tick of given staff,
// using the highest possible string.
// If note cannot be fretted, uses fret 0 on nearest string and returns false
//
// Note: Strings are stored internally from lowest (0) to highest (strings()-1),
// but the returned *string value references strings in reversed, 'visual', order:
// from highest (0) to lowest (strings()-1)
//---------------------------------------------------------
bool StringData::convertPitch(int pitch, Staff* staff, const Fraction& tick, int* string, int* fret) const
{
return convertPitch(pitch, pitchOffsetAt(staff, tick), string, fret);
}
//---------------------------------------------------------
// getPitch
// Returns the pitch corresponding to the string / fret combination
// at given tick of given staff.
// Returns INVALID_PITCH if not possible
// Note: frets above max fret are accepted.
//---------------------------------------------------------
int StringData::getPitch(int string, int fret, Staff* staff, const Fraction& tick) const
{
return getPitch(string, fret, pitchOffsetAt(staff, tick));
}
//---------------------------------------------------------
// fret
// Returns the fret corresponding to the pitch / string combination
// at given tick of given staff.
// Returns FRET_NONE if not possible
//---------------------------------------------------------
int StringData::fret(int pitch, int string, Staff* staff, const Fraction& tick) const
{
return fret(pitch, string, pitchOffsetAt(staff, tick));
}
//---------------------------------------------------------
// fretChords
// Assigns fretting to all the notes of each chord in the same segment of chord
// re-using existing fretting wherever possible
//
// Minimizes fret conflicts (multiple notes on the same string)
// but marks as fretConflict notes which cannot be fretted
// (outside tablature range) or which cannot be assigned
// a separate string
//---------------------------------------------------------
void StringData::fretChords(Chord * chord) const
{
int nFret, minFret, maxFret, nNewFret, nTempFret;
int nString, nNewString, nTempString;
if(bFretting)
return;
bFretting = true;
// we need to keep track of string allocation
#if (!defined (_MSCVER) && !defined (_MSC_VER))
int bUsed[strings()]; // initially all strings are available
#else
// MSVC does not support VLA. Replace with std::vector. If profiling determines that the
// heap allocation is slow, an optimization might be used.
std::vector<int> bUsed(strings());
#endif
for(nString=0; nString<strings(); nString++)
bUsed[nString] = 0;
// we also need the notes sorted in order of string (from highest to lowest) and then pitch
QMap<int, Note *> sortedNotes;
int count = 0;
// store staff pitch offset at this tick, to speed up actual note pitch calculations
// (ottavas not implemented yet)
int transp = chord->staff() ? chord->part()->instrument()->transpose().chromatic : 0; // TODO: tick?
int pitchOffset = /*chord->staff()->pitchOffset(chord->segment()->tick())*/ - transp;
// if chord parent is not a segment, the chord is special (usually a grace chord):
// fret it by itself, ignoring the segment
if (chord->parent()->type() != ElementType::SEGMENT)
sortChordNotes(sortedNotes, chord, pitchOffset, &count);
else {
// scan each chord of seg from same staff as 'chord', inserting each of its notes in sortedNotes
Segment* seg = chord->segment();
int trk;
int trkFrom = (chord->track() / VOICES) * VOICES;
int trkTo = trkFrom + VOICES;
for(trk = trkFrom; trk < trkTo; ++trk) {
Element* ch = seg->elist().at(trk);
if (ch && ch->type() == ElementType::CHORD)
sortChordNotes(sortedNotes, toChord(ch), pitchOffset, &count);
}
}
// determine used range of frets
minFret = INT32_MAX;
maxFret = INT32_MIN;
foreach(Note* note, sortedNotes) {
if (note->string() != STRING_NONE)
bUsed[note->string()]++;
if (note->fret() != FRET_NONE && note->fret() < minFret)
minFret = note->fret();
if (note->fret() != FRET_NONE && note->fret() > maxFret)
maxFret = note->fret();
}
// scan chord notes from highest, matching with strings from the highest
foreach(Note * note, sortedNotes) {
nString = nNewString = note->string();
nFret = nNewFret = note->fret();
note->setFretConflict(false); // assume no conflicts on this note
// if no fretting (any invalid fretting has been erased by sortChordNotes() )
if (nString == STRING_NONE /*|| nFret == FRET_NONE || getPitch(nString, nFret) != note->pitch()*/) {
// get a new fretting
if (!convertPitch(note->pitch(), pitchOffset, &nNewString, &nNewFret) ) {
// no way to fit this note in this tab:
// mark as fretting conflict
note->setFretConflict(true);
// store fretting change without affecting chord context
if (nFret != nNewFret)
note->undoChangeProperty(Pid::FRET, nNewFret);
if (nString != nNewString)
note->undoChangeProperty(Pid::STRING, nNewString);
continue;
}
// note can be fretted: use string
else {
bUsed[nNewString]++;
}
}
// if the note string (either original or newly assigned) is also used by another note
if (bUsed[nNewString] > 1) {
// attempt to find a suitable string, from topmost
for (nTempString=0; nTempString < strings(); nTempString++) {
if (bUsed[nTempString] < 1
&& (nTempFret=fret(note->pitch(), nTempString, pitchOffset)) != FRET_NONE) {
bUsed[nNewString]--; // free previous string
bUsed[nTempString]++; // and occupy new string
nNewFret = nTempFret;
nNewString = nTempString;
break;
}
}
}
// TODO : try to optimize used fret range, avoiding eccessively open positions
// if fretting did change, store as a fret change
if (nFret != nNewFret)
note->undoChangeProperty(Pid::FRET, nNewFret);
if (nString != nNewString)
note->undoChangeProperty(Pid::STRING, nNewString);
}
// check for any remaining fret conflict
foreach(Note * note, sortedNotes)
if (bUsed[note->string()] > 1)
note->setFretConflict(true);
bFretting = false;
}
//---------------------------------------------------------
// frettedStrings
// Returns the number of fretted strings.
//---------------------------------------------------------
int StringData::frettedStrings() const
{
int num = 0;
for (auto s : stringTable)
if (!s.open)
num++;
return num;
}
//********************
// STATIC METHODS
//********************
//---------------------------------------------------------
// pitchOffsetAt
// Computes the pitch offset relevant for string data calculation at the given point.
//
// For string data calculations, pitch offset may depend on transposition, capos and, possibly, ottavas.
//---------------------------------------------------------
int StringData::pitchOffsetAt(Staff* staff, const Fraction& /*tick*/)
{
int transp = staff ? staff->part()->instrument()->transpose().chromatic : 0; // TODO: tick?
return (/*staff->pitchOffset(tick)*/ - transp);
}
//********************
// PRIVATE METHODS
//********************
//---------------------------------------------------------
// convertPitch
// Finds string and fret for a note.
//
// Fills *string and *fret with suitable values for pitch / pitchOffset,
// using the highest possible string.
// If note cannot be fretted, uses fret 0 on nearest string and returns false
//
// Note: Strings are stored internally from lowest (0) to highest (strings()-1),
// but the returned *string value references strings in reversed, 'visual', order:
// from highest (0) to lowest (strings()-1)
//---------------------------------------------------------
bool StringData::convertPitch(int pitch, int pitchOffset, int* string, int* fret) const
{
int strings = stringTable.size();
if (strings < 1)
return false;
pitch += pitchOffset;
// if above max fret on highest string, fret on first string, but return failure
if(pitch > stringTable.at(strings-1).pitch + _frets) {
*string = 0;
*fret = 0;
return false;
}
// look for a suitable string, starting from the highest
// NOTE: this assumes there are always enough frets to fill
// the interval between any fretted string and the next
for (int i = strings-1; i >=0; i--) {
instrString strg = stringTable.at(i);
if(pitch >= strg.pitch) {
if (pitch == strg.pitch || !strg.open)
*string = strings - i - 1;
*fret = pitch - strg.pitch;
return true;
}
}
// if no string found, pitch is below lowest string:
// fret on last string, but return failure
*string = strings-1;
*fret = 0;
return false;
}
//---------------------------------------------------------
// getPitch
// Returns the pitch corresponding to the string / fret / pitchOffset combination.
// Returns INVALID_PITCH if not possible
// Note: frets above max fret are accepted.
//---------------------------------------------------------
int StringData::getPitch(int string, int fret, int pitchOffset) const
{
int strings = stringTable.size();
if (string < 0 || string >= strings)
return INVALID_PITCH;
instrString strg = stringTable.at(strings - string - 1);
return strg.pitch - pitchOffset + (strg.open ? 0 : fret);
}
//---------------------------------------------------------
// fret
// Returns the fret corresponding to the pitch / string / pitchOffset combination.
// returns FRET_NONE if not possible
//---------------------------------------------------------
int StringData::fret(int pitch, int string, int pitchOffset) const
{
int strings = stringTable.size();
if (strings < 1) // no strings at all!
return FRET_NONE;
if (string < 0 || string >= strings) // no such a string
return FRET_NONE;
pitch += pitchOffset;
int fret = pitch - stringTable[strings - string - 1].pitch;
// fret number is invalid or string cannot be fretted
if (fret < 0 || fret >= _frets || (fret > 0 && stringTable[strings - string - 1].open))
return FRET_NONE;
return fret;
}
//---------------------------------------------------------
// sortChordNotes
// Adds to sortedNotes the notes of Chord in string/pitch order
// Note: notes are sorted first by string (top string being 0),
// then by negated pitch (higher pitches resulting in lower key),
// then by order of submission to disambiguate notes with the same pitch.
// Everything else being equal, this makes notes in higher-numbered voices
// to be sorted after notes in lower-numbered voices (voice 2 after voice 1 and so on)
// Notes without a string assigned yet, are sorted according to the lowest string which can accommodate them.
//---------------------------------------------------------
void StringData::sortChordNotes(QMap<int, Note *>& sortedNotes, const Chord *chord, int pitchOffset, int* count) const
{
int key, string, fret;
foreach(Note * note, chord->notes()) {
string = note->string();
fret = note->fret();
// if note not fretted yet or current fretting no longer valid,
// use most convenient string as key
if (string <= STRING_NONE || fret <= FRET_NONE
|| getPitch(string, fret, pitchOffset) != note->pitch()) {
note->setString(STRING_NONE);
note->setFret(FRET_NONE);
convertPitch(note->pitch(), pitchOffset, &string, &fret);
}
key = string * 100000;
key += -(note->pitch()+pitchOffset) * 100 + *count; // disambiguate notes of equal pitch
sortedNotes.insert(key, note);
(*count)++;
}
}
#if 0
//---------------------------------------------------------
// MusicXMLStepAltOct2Pitch
//---------------------------------------------------------
/**
Convert MusicXML \a step / \a alter / \a octave to midi pitch.
Note: similar to (part of) xmlSetPitch in mscore/importxml.cpp.
TODO: combine ?
*/
static int MusicXMLStepAltOct2Pitch(char step, int alter, int octave)
{
int istep = step - 'A';
// a b c d e f g
static int table[7] = { 9, 11, 0, 2, 4, 5, 7 };
if (istep < 0 || istep > 6) {
qDebug("MusicXMLStepAltOct2Pitch: illegal step %d, <%c>", istep, step);
return -1;
}
int pitch = table[istep] + alter + (octave+1) * 12;
if (pitch < 0)
pitch = -1;
if (pitch > 127)
pitch = -1;
return pitch;
}
//---------------------------------------------------------
// Read MusicXML
//---------------------------------------------------------
void StringData::readMusicXML(XmlReader& e)
{
_frets = 25;
while (e.readNextStartElement()) {
const QStringRef& tag(e.name());
if (tag == "staff-lines") {
int val = e.readInt();
if (val > 0) {
// resize the string table and init with zeroes
stringTable = QVector<int>(val).toList();
}
else
qDebug("StringData::readMusicXML: illegal staff-lines %d", val);
}
else if (tag == "staff-tuning") {
int line = e.intAttribute("line");
QString step;
int alter = 0;
int octave = 0;
while (e.readNextStartElement()) {
const QStringRef& tag(e.name());
if (tag == "tuning-alter")
alter = e.readInt();
else if (tag == "tuning-octave")
octave = e.readInt();
else if (tag == "tuning-step")
step = e.readElementText();
else
e.unknown();
}
if (0 < line && line <= stringTable.size()) {
int pitch = MusicXMLStepAltOct2Pitch(step[0].toLatin1(), alter, octave);
if (pitch >= 0)
stringTable[line - 1] = pitch;
else
qDebug("StringData::readMusicXML invalid string %d tuning step/alter/oct %s/%d/%d",
line, qPrintable(step), alter, octave);
}
}
else if (tag == "capo") {
; // not supported: silently ignored
}
else {
; // others silently ignored
}
}
}
#endif
//---------------------------------------------------------
// Write MusicXML
//---------------------------------------------------------
void StringData::writeMusicXML(XmlWriter& /*xml*/) const
{
}
}