Audacity 3.2.0
NoteTrack.h
Go to the documentation of this file.
1/**********************************************************************
2
3 Audacity: A Digital Audio Editor
4
5 NoteTrack.h
6
7 Dominic Mazzoni
8
9**********************************************************************/
10
11#ifndef __AUDACITY_NOTETRACK__
12#define __AUDACITY_NOTETRACK__
13
14#include <utility>
15#include "AudioIOSequences.h"
16#include "CRTPBase.h"
17#include "Prefs.h"
18#include "PlayableTrack.h"
19
20#if defined(USE_MIDI)
21
22// define this switch to play MIDI during redisplay to sonify run times
23// Note that if SONIFY is defined, the default MIDI device will be opened
24// and may block normal MIDI playback.
25//#define SONIFY 1
26
27#ifdef SONIFY
28
29#define SONFNS(name) \
30 void Begin ## name(); \
31 void End ## name();
32
33SONFNS(NoteBackground)
34SONFNS(NoteForeground)
35SONFNS(Measures)
36SONFNS(Serialize)
37SONFNS(Unserialize)
38SONFNS(ModifyState)
39SONFNS(AutoSave)
40
41#undef SONFNS
42
43#endif
44
45class wxDC;
46class wxRect;
47
48class Alg_seq; // from "allegro.h"
49
51#ifdef EXPERIMENTAL_MIDI_OUT
53#else
55#endif
56 ;
57
58using QuantizedTimeAndBeat = std::pair< double, double >;
59
60class NoteTrack;
61class StretchHandle;
62class TimeWarper;
63
64struct NOTE_TRACK_API NoteTrackAttachment;
65CRTP_BASE(NoteTrackAttachmentBase, struct,
67struct NoteTrackAttachment : NoteTrackAttachmentBase
68{
71 virtual void WriteXML(XMLWriter &xmlFile) const;
73 virtual bool HandleAttribute(const Attribute &attribute);
74};
75
80>;
81
82class NOTE_TRACK_API NoteTrack final
83 : public UniqueChannelTrack<NoteTrackBase>
86{
87public:
90
91 // Construct and also build all attachments
92 static NoteTrack *New(AudacityProject &project);
93
94 NoteTrack();
96 NoteTrack(const NoteTrack &orig) = delete;
97 NoteTrack(const NoteTrack &orig, ProtectedCreationArg &&) = delete;
98 virtual ~NoteTrack();
99
100 using Holder = std::shared_ptr<NoteTrack>;
101
102private:
103 TrackListHolder Clone(bool backup) const override;
104
105public:
106 void MoveTo(double origin) override { mOrigin = origin; }
107
108 Alg_seq &GetSeq() const;
109
110 void WarpAndTransposeNotes(double t0, double t1,
111 const TimeWarper &warper, double semitones);
112
113 void SetSequence(std::unique_ptr<Alg_seq> &&seq);
114 void PrintSequence();
115
116 Alg_seq *MakeExportableSeq(std::unique_ptr<Alg_seq> &cleanup) const;
117 bool ExportMIDI(const wxString &f) const;
118 bool ExportAllegro(const wxString &f) const;
119
120 // High-level editing
121 TrackListHolder Cut(double t0, double t1) override;
122 TrackListHolder Copy(double t0, double t1, bool forClipboard = true)
123 const override;
124 bool Trim (double t0, double t1) /* not override */;
125 void Clear(double t0, double t1) override;
126 void Paste(double t, const Track &src) override;
127 void
128 Silence(double t0, double t1, ProgressReporter reportProgress = {}) override;
129 void InsertSilence(double t, double len) override;
130 bool Shift(double t) /* not override */;
131
132#ifdef EXPERIMENTAL_MIDI_OUT
133 float GetVelocity() const {
134 return mVelocity.load(std::memory_order_relaxed); }
135 void SetVelocity(float velocity);
136#endif
137
138 QuantizedTimeAndBeat NearestBeatTime( double time ) const;
139 bool StretchRegion
140 ( QuantizedTimeAndBeat t0, QuantizedTimeAndBeat t1, double newDur );
141
142 bool HandleXMLTag(const std::string_view& tag, const AttributesList& attrs) override;
143 XMLTagHandler *HandleXMLChild(const std::string_view& tag) override;
144 void WriteXML(XMLWriter &xmlFile) const override;
145
146 // channels are numbered as integers 0-15, visible channels
147 // (mVisibleChannels) is a bit set. Channels are displayed as
148 // integers 1-16.
149
150 // Allegro's data structure does not restrict channels to 16.
151 // Since there is not way to select more than 16 channels,
152 // map all channel numbers mod 16. This will have no effect
153 // on MIDI files, but it will allow users to at least select
154 // all channels on non-MIDI event sequence data.
155#define NUM_CHANNELS 16
156 // Bitmask with all NUM_CHANNELS bits set
157#define ALL_CHANNELS (1 << NUM_CHANNELS) - 1
158#define CHANNEL_BIT(c) (1 << (c % NUM_CHANNELS))
159 unsigned GetVisibleChannels() const {
160 return mVisibleChannels.load(std::memory_order_relaxed);
161 }
162 void SetVisibleChannels(unsigned value) {
163 mVisibleChannels.store(value, std::memory_order_relaxed);
164 }
165 bool IsVisibleChan(int c) const {
166 return (GetVisibleChannels() & CHANNEL_BIT(c)) != 0;
167 }
168 void SetVisibleChan(int c) {
169 mVisibleChannels.fetch_or(CHANNEL_BIT(c), std::memory_order_relaxed); }
170 void ClearVisibleChan(int c) {
171 mVisibleChannels.fetch_and(~CHANNEL_BIT(c), std::memory_order_relaxed); }
172 void ToggleVisibleChan(int c) {
173 mVisibleChannels.fetch_xor(CHANNEL_BIT(c), std::memory_order_relaxed); }
174 // Solos the given channel. If it's the only channel visible, all channels
175 // are enabled; otherwise, it is set to the only visible channel.
176 void SoloVisibleChan(int c) {
177 auto visibleChannels = 0u;
178 if (GetVisibleChannels() == CHANNEL_BIT(c))
179 visibleChannels = ALL_CHANNELS;
180 else
181 visibleChannels = CHANNEL_BIT(c);
182 mVisibleChannels.store(visibleChannels, std::memory_order_relaxed);
183 }
184
185 const TypeInfo &GetTypeInfo() const override;
186 static const TypeInfo &ClassTypeInfo();
187
189 const override;
190
191 size_t NIntervals() const override;
192
195 ~Interval() override;
196 std::shared_ptr<ChannelInterval> DoGetChannel(size_t iChannel) override;
197 };
198
199private:
200 std::shared_ptr<WideChannelGroupInterval> DoGetInterval(size_t iInterval)
201 override;
202
203#ifdef EXPERIMENTAL_MIDI_OUT
204 void DoSetVelocity(float velocity);
205#endif
206
207 void AddToDuration( double delta );
209 const std::optional<double>& oldTempo, double newTempo) override;
210
211 // These are mutable to allow NoteTrack to switch details of representation
212 // in logically const methods
213 // At most one of the two pointers is not null at any time.
214 // Both are null in a newly constructed NoteTrack.
215 mutable std::unique_ptr<Alg_seq> mSeq;
216 mutable std::unique_ptr<char[]> mSerializationBuffer;
218
219#ifdef EXPERIMENTAL_MIDI_OUT
221 std::atomic<float> mVelocity{ 0.0f }; // velocity offset
222#endif
223
225 std::atomic<unsigned> mVisibleChannels{ ALL_CHANNELS };
226 double mOrigin{ 0.0 };
227};
228
229extern NOTE_TRACK_API StringSetting MIDIPlaybackDevice;
230extern NOTE_TRACK_API StringSetting MIDIRecordingDevice;
231extern NOTE_TRACK_API IntSetting MIDISynthLatency_ms;
232
234
235#endif // USE_MIDI
236
237#ifndef SONIFY
238// no-ops:
239#define SonifyBeginSonification()
240#define SonifyEndSonification()
241#define SonifyBeginNoteBackground()
242#define SonifyEndNoteBackground()
243#define SonifyBeginNoteForeground()
244#define SonifyEndNoteForeground()
245#define SonifyBeginMeasures()
246#define SonifyEndMeasures()
247#define SonifyBeginSerialize()
248#define SonifyEndSerialize()
249#define SonifyBeginUnserialize()
250#define SonifyEndUnserialize()
251#define SonifyBeginAutoSave()
252#define SonifyEndAutoSave()
253#define SonifyBeginModifyState()
254#define SonifyEndModifyState()
255#endif
256
257
258NOTE_TRACK_API wxString GetMIDIDeviceInfo();
259
260#endif
ClientData::Site< NoteTrack, NoteTrackAttachment, ClientData::DeepCopying > NoteTrackAttachments
Definition: NoteTrack.h:80
NOTE_TRACK_API wxString GetMIDIDeviceInfo()
Definition: NoteTrack.cpp:906
#define CHANNEL_BIT(c)
Definition: NoteTrack.h:158
CRTP_BASE(NoteTrackAttachmentBase, struct, ClientData::Cloneable< NoteTrackAttachment, ClientData::UniquePtr >)
NOTE_TRACK_API StringSetting MIDIPlaybackDevice
Definition: NoteTrack.cpp:1010
ENUMERATE_TRACK_TYPE(NoteTrack)
NOTE_TRACK_API IntSetting MIDISynthLatency_ms
Definition: NoteTrack.cpp:1012
NOTE_TRACK_API StringSetting MIDIRecordingDevice
Definition: NoteTrack.cpp:1011
#define ALL_CHANNELS
Definition: NoteTrack.h:157
struct NOTE_TRACK_API NoteTrackAttachment
Definition: NoteTrack.h:64
std::pair< double, double > QuantizedTimeAndBeat
Definition: NoteTrack.h:58
Extends Track with notions of mute and solo setting.
const auto project
std::function< void(double)> ProgressReporter
Definition: Track.h:53
std::shared_ptr< TrackList > TrackListHolder
Definition: Track.h:42
std::pair< std::string_view, XMLAttributeValueView > Attribute
Definition: XMLTagHandler.h:39
std::vector< Attribute > AttributesList
Definition: XMLTagHandler.h:40
The top-level handle to an Audacity project. It serves as a source of events that other objects can b...
Definition: Project.h:90
Track subclass holding data representing sound (as notes, or samples, or ...)
Definition: PlayableTrack.h:21
virtual std::shared_ptr< Interval > DoGetInterval(size_t iInterval)=0
Retrieve an interval.
size_t NIntervals() const
Report the number of intervals.
Definition: Channel.h:608
Utility to register hooks into a host class that attach client data.
Definition: ClientData.h:228
Specialization of Setting for int.
Definition: Prefs.h:356
A Track that is used for Midi notes. (Somewhat old code).
Definition: NoteTrack.h:86
std::unique_ptr< char[]> mSerializationBuffer
Definition: NoteTrack.h:216
bool IsVisibleChan(int c) const
Definition: NoteTrack.h:165
void MoveTo(double origin) override
Change start time to given time point.
Definition: NoteTrack.h:106
void SetVisibleChannels(unsigned value)
Definition: NoteTrack.h:162
std::unique_ptr< Alg_seq > mSeq
Definition: NoteTrack.h:215
std::shared_ptr< NoteTrack > Holder
Definition: NoteTrack.h:100
static EnumSetting< bool > AllegroStyleSetting
Definition: NoteTrack.h:89
unsigned GetVisibleChannels() const
Definition: NoteTrack.h:159
void ToggleVisibleChan(int c)
Definition: NoteTrack.h:172
void SoloVisibleChan(int c)
Definition: NoteTrack.h:176
void ClearVisibleChan(int c)
Definition: NoteTrack.h:170
long mSerializationLength
Definition: NoteTrack.h:217
NoteTrack(const NoteTrack &orig, ProtectedCreationArg &&)=delete
NoteTrack(const NoteTrack &orig)=delete
Copy construction hasn't been necessary yet.
void SetVisibleChan(int c)
Definition: NoteTrack.h:168
This is defined just to enable dynamic_cast on it.
AudioTrack subclass that can also be audibly replayed by the program.
Definition: PlayableTrack.h:40
Specialization of Setting for strings.
Definition: Prefs.h:370
Transforms one point in time to another point. For example, a time stretching effect might use one to...
Definition: TimeWarper.h:62
Abstract base class for an object holding data associated with points on a time axis.
Definition: Track.h:122
virtual void Paste(double t, const Track &src)=0
Weak precondition allows overrides to replicate one channel into many.
virtual Holder PasteInto(AudacityProject &project, TrackList &list) const =0
virtual const TypeInfo & GetTypeInfo() const =0
virtual void InsertSilence(double t, double len)=0
static const TypeInfo & ClassTypeInfo()
Definition: Track.cpp:1206
virtual TrackListHolder Copy(double t0, double t1, bool forClipboard=true) const =0
Create new tracks and don't modify this track.
virtual void DoOnProjectTempoChange(const std::optional< double > &oldTempo, double newTempo)=0
virtual void Clear(double t0, double t1)=0
std::shared_ptr< Track > Holder
Definition: Track.h:225
virtual void WriteXML(XMLWriter &xmlFile) const =0
virtual void Silence(double t0, double t1, ProgressReporter reportProgress={})=0
virtual TrackListHolder Cut(double t0, double t1)=0
Create tracks and modify this track.
virtual TrackListHolder Clone(bool backup) const =0
A flat linked list of tracks supporting Add, Remove, Clear, and Contains, serialization of the list o...
Definition: Track.h:993
Generates overrides of channel-related functions.
Definition: Track.h:508
WideChannelGroupInterval(const ChannelGroup &group, double start, double end)
Definition: Channel.cpp:21
This class is an interface which should be implemented by classes which wish to be able to load and s...
Definition: XMLTagHandler.h:42
virtual XMLTagHandler * HandleXMLChild(const std::string_view &tag)=0
virtual bool HandleXMLTag(const std::string_view &tag, const AttributesList &attrs)=0
Base class for XMLFileWriter and XMLStringWriter that provides the general functionality for creating...
Definition: XMLWriter.h:25
@ DeepCopying
point to new sub-objects; these must define a Clone() member; won't compile for std::weak_ptr
A convenient base class defining abstract virtual Clone() for a given kind of pointer.
Definition: ClientData.h:49
~Interval() override
virtual void WriteXML(XMLWriter &xmlFile) const
Default implementation does nothing.
Definition: NoteTrack.cpp:112
virtual bool HandleAttribute(const Attribute &attribute)
Return whether the attribute was used; default returns false.
Definition: NoteTrack.cpp:115
~NoteTrackAttachment() override
Empty argument passed to some public constructors.
Definition: Track.h:129