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
|
/* This file is part of Evoral.
* Copyright (C) 2008 David Robillard <http://drobilla.net>
* Copyright (C) 2000-2008 Paul Davis
*
* Evoral 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.
*
* Evoral is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef EVORAL_NOTE_HPP
#define EVORAL_NOTE_HPP
#include <algorithm>
#include <glib.h>
#include <stdint.h>
#include "evoral/visibility.h"
#include "evoral/Event.hpp"
namespace Evoral {
/** An abstract (protocol agnostic) note.
*
* Currently a note is defined as (on event, length, off event).
*/
template<typename Time>
#ifdef COMPILER_MSVC
class LIBEVORAL_LOCAL Note {
#else
class LIBEVORAL_TEMPLATE_API Note {
#endif
public:
Note(uint8_t chan=0, Time time=Time(), Time len=Time(), uint8_t note=0, uint8_t vel=0x40);
Note(const Note<Time>& copy);
~Note();
inline bool operator==(const Note<Time>& other) {
return time() == other.time() &&
note() == other.note() &&
length() == other.length() &&
velocity() == other.velocity() &&
off_velocity() == other.off_velocity() &&
channel() == other.channel();
}
inline event_id_t id() const { return _on_event.id(); }
void set_id (event_id_t);
inline Time time() const { return _on_event.time(); }
inline Time end_time() const { return _off_event.time(); }
inline uint8_t note() const { return _on_event.note(); }
inline uint8_t velocity() const { return _on_event.velocity(); }
inline uint8_t off_velocity() const { return _off_event.velocity(); }
inline Time length() const { return _off_event.time() - _on_event.time(); }
inline uint8_t channel() const {
assert(_on_event.channel() == _off_event.channel());
return _on_event.channel();
}
private:
const Note<Time>& operator=(const Note<Time>& copy); // undefined (unsafe)
inline int clamp(int val, int low, int high) {
return std::min (std::max (val, low), high);
}
public:
inline void set_time(Time t) {
_off_event.set_time(t + length());
_on_event.set_time(t);
}
inline void set_note(uint8_t n) {
const uint8_t nn = clamp(n, 0, 127);
_on_event.buffer()[1] = nn;
_off_event.buffer()[1] = nn;
}
inline void set_velocity(uint8_t n) {
_on_event.buffer()[2] = clamp(n, 0, 127);
}
inline void set_off_velocity(uint8_t n) {
_off_event.buffer()[2] = clamp(n, 0, 127);
}
inline void set_length(Time l) {
_off_event.set_time(_on_event.time() + l);
}
inline void set_channel(uint8_t c) {
const uint8_t cc = clamp(c, 0, 16);
_on_event.set_channel(cc);
_off_event.set_channel(cc);
}
inline Event<Time>& on_event() { return _on_event; }
inline const Event<Time>& on_event() const { return _on_event; }
inline Event<Time>& off_event() { return _off_event; }
inline const Event<Time>& off_event() const { return _off_event; }
private:
// Event buffers are self-contained
Event<Time> _on_event;
Event<Time> _off_event;
};
template<typename Time>
/*LIBEVORAL_API*/ std::ostream& operator<<(std::ostream& o, const Evoral::Note<Time>& n) {
o << "Note #" << n.id() << ": pitch = " << (int) n.note()
<< " @ " << n.time() << " .. " << n.end_time()
<< " velocity " << (int) n.velocity()
<< " chn " << (int) n.channel();
return o;
}
} // namespace Evoral
#ifdef COMPILER_MSVC
#include "../src/Note.impl"
#endif
#endif // EVORAL_NOTE_HPP
|
