File: importmidi_chord.h

package info (click to toggle)
musescore2 2.3.2%2Bdfsg4-16
  • links: PTS, VCS
  • area: main
  • in suites: sid, trixie
  • size: 170,464 kB
  • sloc: cpp: 262,612; xml: 176,707; sh: 3,377; ansic: 1,246; python: 356; makefile: 227; perl: 82; pascal: 78
file content (155 lines) | stat: -rw-r--r-- 5,364 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
#ifndef IMPORTMIDI_CHORD_H
#define IMPORTMIDI_CHORD_H

#include "importmidi_fraction.h"
#include "importmidi_tuplet.h"

#include <map>


namespace Ms {

class Tie;
class TimeSigMap;

class MidiNote {
   public:
      int pitch;
      int velo;
      ReducedFraction offTime;
      Tie* tie = nullptr;
      bool staccato = false;
      bool isInTuplet = false;
                  // for offTime quantization
      std::multimap<ReducedFraction, MidiTuplet::TupletData>::iterator tuplet;
                  // for notation simplification - final quant value
      ReducedFraction offTimeQuant = ReducedFraction(-1, 1);       // invalid by default
                  // to assign lyrics
      ReducedFraction origOnTime;
      };

class MidiChord {
   public:
      int voice = 0;
      QList<MidiNote> notes;
      bool isInTuplet = false;
      int barIndex = -1;
                  // for onTime quantization
      std::multimap<ReducedFraction, MidiTuplet::TupletData>::iterator tuplet;

      bool isStaccato() const
            {
            for (const auto &note: notes)
                  if (note.staccato)
                        return true;
            return false;
            }
      };

class MTrack;

namespace MChord {

bool isGrandStaffProgram(int program);

std::multimap<ReducedFraction, MidiChord>::iterator
findFirstChordInRange(std::multimap<ReducedFraction, MidiChord> &chords,
                      const ReducedFraction &startRangeTick,
                      const ReducedFraction &endRangeTick);

std::multimap<ReducedFraction, MidiChord>::const_iterator
findFirstChordInRange(const std::multimap<ReducedFraction, MidiChord> &chords,
                      const ReducedFraction &startRangeTick,
                      const ReducedFraction &endRangeTick);

template <typename Iter>
Iter findFirstChordInRange(const ReducedFraction &startRangeTick,
                           const ReducedFraction &endRangeTick,
                           const Iter &startChordIt,
                           const Iter &endChordIt)
      {
      auto it = startChordIt;
      for (; it != endChordIt; ++it) {
            if (it->first >= startRangeTick) {
                  if (it->first >= endRangeTick)
                        it = endChordIt;
                  break;
                  }
            }
      return it;
      }

template <typename Iter>
Iter findEndChordInRange(const ReducedFraction &endRangeTick,
                         const Iter &startChordIt,
                         const Iter &endChordIt)
      {
      auto it = startChordIt;
      for (; it != endChordIt; ++it) {
            if (it->first >= endRangeTick)
                  break;
            }
      return it;
      }

ReducedFraction minNoteOffTime(const QList<MidiNote> &notes);
ReducedFraction maxNoteOffTime(const QList<MidiNote> &notes);
ReducedFraction minNoteLen(const std::pair<const ReducedFraction, MidiChord> &chord);
ReducedFraction maxNoteLen(const std::pair<const ReducedFraction, MidiChord> &chord);

const ReducedFraction& minAllowedDuration();
ReducedFraction findMinDuration(const ReducedFraction &onTime,
                                const QList<MidiChord> &midiChords,
                                const ReducedFraction &length);
void sortNotesByPitch(std::multimap<ReducedFraction, MidiChord> &chords);
void sortNotesByLength(std::multimap<ReducedFraction, MidiChord> &chords);

void collectChords(
            std::multimap<int, MTrack> &tracks,
            const ReducedFraction &humanTolCoeff,
            const ReducedFraction &nonHumanTolCoeff);

void collectChords(
            MTrack &track,
            const ReducedFraction &humanTolCoeff,
            const ReducedFraction &nonHumanTolCoeff);

void removeOverlappingNotes(std::multimap<int, MTrack> &tracks);
void mergeChordsWithEqualOnTimeAndVoice(std::multimap<int, MTrack> &tracks);
void splitUnequalChords(std::multimap<int, MTrack> &tracks);
int chordAveragePitch(const QList<MidiNote> &notes, int beg, int end);
int chordAveragePitch(const QList<MidiNote> &notes);

ReducedFraction findMaxChordLength(const std::multimap<ReducedFraction, MidiChord> &chords);

std::vector<std::multimap<ReducedFraction, MidiChord>::const_iterator>
findChordsForTimeRange(
            int voice,
            const ReducedFraction &onTime,
            const ReducedFraction &offTime,
            const std::multimap<ReducedFraction, MidiChord> &chords,
            const ReducedFraction &maxChordLength);

void setBarIndexes(
            std::multimap<ReducedFraction, MidiChord> &chords,
            const ReducedFraction &basicQuant,
            const ReducedFraction &lastTick, const TimeSigMap *sigmap);

#ifdef IMPORTMIDI_DEBUG

bool areOnTimeValuesDifferent(const std::multimap<ReducedFraction, MidiChord> &chords);
bool areBarIndexesSuccessive(const std::multimap<ReducedFraction, MidiChord> &chords);
bool areNotesLongEnough(const std::multimap<ReducedFraction, MidiChord> &chords);
bool isLastTickValid(const ReducedFraction &lastTick,
                     const std::multimap<ReducedFraction, MidiChord> &chords);
bool isLastTickValid(const ReducedFraction &lastTick,
                     const std::multimap<int, MTrack> &tracks);
bool areBarIndexesSet(const std::multimap<ReducedFraction, MidiChord> &chords);

#endif

} // namespace MChord
} // namespace Ms


#endif // IMPORTMIDI_CHORD_H