Debian Codegraph @

BambooTracker/module/song.cpp

raw
1 /*
2 * Copyright (C) 2018-2021 Rerrah
3 *
4 * Permission is hereby granted, free of charge, to any person
5 * obtaining a copy of this software and associated documentation
6 * files (the "Software"), to deal in the Software without
7 * restriction, including without limitation the rights to use,
8 * copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following
11 * conditions:
12 *
13 * The above copyright notice and this permission notice shall be
14 * included in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 * OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26 #include "song.hpp"
27 #include <algorithm>
28 #include <utility>
29 #include <stdexcept>
30 #include "bamboo_tracker_defs.hpp"
31 #include "utils.hpp"
32
33 Bookmark::Bookmark(const std::string& argname, int argorder, int argstep)
34 : name(argname), order(argorder), step(argstep)
35 {
36 }
37
38 KeySignature::KeySignature(Type type, int scorder, int scstep)
39 : type(type), order(scorder), step(scstep)
40 {
41 }
42
43 Song::Song(int number, SongType songType, const std::string& title, bool isUsedTempo,
44 int tempo, int groove, int speed, size_t defaultPatternSize)
45 : num_(number),
46 type_(songType),
47 title_(title),
48 isUsedTempo_(isUsedTempo),
49 tempo_(tempo),
50 groove_(groove),
51 speed_(speed),
52 defPtnSize_(defaultPatternSize),
53 sigs_{ KeySignature(KeySignature::E, 0, 0) }
54 {
55 switch (songType) {
56 case SongType::Standard:
57 tracks_.reserve(15);
58 for (int i = 0; i < 6; ++i) {
59 tracks_.emplace_back(i, SoundSource::FM, i, defaultPatternSize);
60 }
61 for (int i = 0; i < 3; ++i) {
62 tracks_.emplace_back(i + 6, SoundSource::SSG, i, defaultPatternSize);
63 }
64 for (int i = 0; i < 6; ++i) {
65 tracks_.emplace_back(i + 9, SoundSource::RHYTHM, i, defaultPatternSize);
66 }
67 tracks_.emplace_back(15, SoundSource::ADPCM, 0, defaultPatternSize);
68 break;
69 case SongType::FM3chExpanded:
70 tracks_.reserve(18);
71 for (int i = 0; i < 9; ++i) {
72 int ch = (i < 3) ? i
73 : (i < 6) ? (i + 3) : (i - 3);
74 tracks_.emplace_back(i, SoundSource::FM, ch, defaultPatternSize);
75 }
76 for (int i = 0; i < 3; ++i) {
77 tracks_.emplace_back(i + 9, SoundSource::SSG, i, defaultPatternSize);
78 }
79 for (int i = 0; i < 6; ++i) {
80 tracks_.emplace_back(i + 12, SoundSource::RHYTHM, i, defaultPatternSize);
81 }
82 tracks_.emplace_back(18, SoundSource::ADPCM, 0, defaultPatternSize);
83 break;
84 }
85 }
86
87 void Song::setDefaultPatternSize(size_t size)
88 {
89 defPtnSize_ = size;
90 for (auto& t : tracks_) {
91 t.changeDefaultPatternSize(size);
92 }
93 }
94
95 size_t Song::getPatternSizeFromOrderNumber(int order)
96 {
97 if (static_cast<int>(getOrderSize()) <= order) return 0; // Ilegal value
98 size_t size = 0;
99 for (auto& t : tracks_) {
100 size_t ptnSize = t.getPatternFromOrderNumber(order).getSize();
101 size = !size ? ptnSize : std::min(size, ptnSize);
102 }
103 return size;
104 }
105
106 SongStyle Song::getStyle() const
107 {
108 SongStyle style;
109 style.type = type_;
110 style.trackAttribs = getTrackAttributes();
111 return style;
112 }
113
114
115 std::vector<TrackAttribute> Song::getTrackAttributes() const
116 {
117 std::vector<TrackAttribute> ret;
118 ret.reserve(tracks_.size());
119 std::transform(tracks_.begin(), tracks_.end(), std::back_inserter(ret),
120 [](const Track& track) { return track.getAttribute(); });
121 return ret;
122 }
123
124 Track& Song::getTrack(int num)
125 {
126 return tracks_.at(static_cast<size_t>(num));
127 }
128
129 void Song::changeType(SongType type)
130 {
131 if (std::exchange(type_, type) == type_) return;
132
133 switch (type_) {
134 case SongType::Standard: // Previous type: FM3chExpanded
135 {
136 const bool vis3ch = tracks_[2].isVisible() || tracks_[3].isVisible()
137 || tracks_[4].isVisible() || tracks_[5].isVisible();
138 // Remove FM3-OP2,3,4 (track 3,4,5)
139 tracks_.erase(tracks_.begin() + 3, tracks_.begin() + 6);
140 for (size_t i = 3; i < tracks_.size(); ++i) {
141 const auto attrib = tracks_[i].getAttribute();
142 tracks_[i].setAttribute(static_cast<int>(i), attrib.source, attrib.channelInSource);
143 }
144 tracks_[2].setVisibility(vis3ch);
145 break;
146 }
147 case SongType::FM3chExpanded: // Previous type: Standard
148 const bool vis3ch = tracks_[2].isVisible();
149 // Expand FM3 track
150 for (int i = 3; i < 6; ++i) {
151 Track src = tracks_[2];
152 src.setAttribute(i, SoundSource::FM, i + 3);
153 tracks_.insert(tracks_.begin() + i, std::move(src));
154 tracks_[static_cast<size_t>(i)].setVisibility(vis3ch);
155 }
156 for (size_t i = 6; i < tracks_.size(); ++i) {
157 const auto attrib = tracks_[i].getAttribute();
158 tracks_[i].setAttribute(static_cast<int>(i), attrib.source, attrib.channelInSource);
159 }
160 break;
161 }
162 }
163
164 std::vector<OrderInfo> Song::getOrderData(int order) const
165 {
166 std::vector<OrderInfo> ret;
167 for (const Track& track : tracks_) {
168 ret.push_back(track.getOrderInfo(order));
169 }
170 return ret;
171 }
172
173 size_t Song::getOrderSize() const
174 {
175 return tracks_[0].getOrderSize();
176 }
177
178 bool Song::canAddNewOrder() const
179 {
180 return tracks_[0].canAddNewOrder();
181 }
182
183 void Song::insertOrderBelow(int order)
184 {
185 if (!canAddNewOrder()) return;
186 for (Track& track : tracks_) {
187 track.insertOrderBelow(order);
188 }
189 }
190
191 void Song::deleteOrder(int order)
192 {
193 for (Track& track : tracks_) {
194 track.deleteOrder(order);
195 }
196 }
197
198 void Song::swapOrder(int a, int b)
199 {
200 for (Track& track : tracks_) {
201 track.swapOrder(a, b);
202 }
203 }
204
205 std::set<int> Song::getRegisteredInstruments() const
206 {
207 std::set<int> set;
208 for (const Track& track : tracks_) {
209 auto&& subset = track.getRegisteredInstruments();
210 std::copy(subset.begin(), subset.end(), std::inserter(set, set.end()));
211 }
212 return set;
213 }
214
215 void Song::clearUnusedPatterns()
216 {
217 for (Track& track : tracks_) track.clearUnusedPatterns();
218 }
219
220 void Song::replaceDuplicateInstrumentsInPatterns(const std::unordered_map<int, int>& map)
221 {
222 for (Track& track : tracks_) track.replaceDuplicateInstrumentsInPatterns(map);
223 }
224
225 void Song::transpose(int semitones, const std::vector<int>& excludeInsts)
226 {
227 for (Track& track : tracks_) track.transpose(semitones, excludeInsts);
228 }
229
230 void Song::swapTracks(int track1, int track2)
231 {
232 auto it1 = utils::findIf(tracks_, [&](const Track& t) {
233 return t.getAttribute().number == track1;
234 });
235 if (it1 == tracks_.end()) throw std::invalid_argument("Invalid track number");
236 auto it2 = utils::findIf(tracks_, [&](const Track& t) {
237 return t.getAttribute().number == track2;
238 });
239 if (it2 == tracks_.end()) throw std::invalid_argument("Invalid track number");
240
241 TrackAttribute attrib1 = it1->getAttribute();
242 TrackAttribute attrib2 = it2->getAttribute();
243 it1->setAttribute(attrib2.number, attrib2.source, attrib2.channelInSource);
244 it2->setAttribute(attrib1.number, attrib1.source, attrib1.channelInSource);
245
246 std::iter_swap(it1, it2);
247 }
248
249 int Song::addBookmark(const std::string& name, int order, int step)
250 {
251 bms_.push_back(Bookmark(name, order, step));
252 return static_cast<int>(bms_.size() - 1);
253 }
254
255 void Song::changeBookmark(int i, const std::string& name, int order, int step)
256 {
257 Bookmark& bm = bms_.at(static_cast<size_t>(i));
258 bm.name = name;
259 bm.order = order;
260 bm.step = step;
261 }
262
263 void Song::removeBookmark(int i)
264 {
265 bms_.erase(bms_.begin() + i);
266 }
267
268 void Song::clearBookmark()
269 {
270 bms_.clear();
271 }
272
273 void Song::swapBookmarks(int a, int b)
274 {
275 std::swap(bms_.at(static_cast<size_t>(a)), bms_.at((static_cast<size_t>(b))));
276 }
277
278 void Song::sortBookmarkByPosition()
279 {
280 std::stable_sort(bms_.begin(), bms_.end(), [](Bookmark a, Bookmark b) {
281 return ((a.order == b.order) ? (a.step < b.step) : (a.order < b.order));
282 });
283 }
284
285 void Song::sortBookmarkByName()
286 {
287 std::stable_sort(bms_.begin(), bms_.end(), [](Bookmark a, Bookmark b) {
288 return (a.name < b.name);
289 });
290 }
291
292 Bookmark Song::getBookmark(int i) const
293 {
294 return bms_.at(static_cast<size_t>(i));
295 }
296
297 std::vector<int> Song::findBookmarks(int order, int step) const
298 {
299 std::vector<int> idcs;
300 for (size_t i = 0; i < bms_.size(); ++i) {
301 const Bookmark& bm = bms_[i];
302 if (bm.order == order && bm.step == step)
303 idcs.push_back(static_cast<int>(i));
304 }
305 return idcs;
306 }
307
308 std::vector<Bookmark> Song::getSortedBookmarkList() const
309 {
310 std::vector<Bookmark> tmp(bms_);
311 std::stable_sort(tmp.begin(), tmp.end(), [](Bookmark a, Bookmark b) {
312 return ((a.order == b.order) ? (a.step < b.step) : (a.order < b.order));
313 });
314 return tmp;
315 }
316
317 Bookmark Song::getPreviousBookmark(int order, int step) const
318 {
319 std::vector<Bookmark> list = getSortedBookmarkList();
320 size_t i = 0;
321 for (; i < list.size(); ++i) {
322 Bookmark& bm = list.at(i);
323 if (order < bm.order || (order == bm.order && step <= bm.step)) {
324 break;
325 }
326 }
327 return list.at((list.size() + i - 1) % list.size());
328 }
329
330 Bookmark Song::getNextBookmark(int order, int step) const
331 {
332 std::vector<Bookmark> list = getSortedBookmarkList();
333 size_t i = 0;
334 for (; i < list.size(); ++i) {
335 Bookmark& bm = list.at(i);
336 if (order < bm.order || (order == bm.order && step < bm.step)) {
337 break;
338 }
339 }
340 return list.at(i % list.size());
341 }
342
343 size_t Song::getBookmarkSize() const
344 {
345 return bms_.size();
346 }
347
348 void Song::addKeySignature(KeySignature::Type key, int order, int step)
349 {
350 size_t i = 0;
351 for (; i < sigs_.size(); ++i) {
352 auto& ref = sigs_[i];
353 if (ref.order < order) continue;
354 else if (order < ref.order) break;
355 else {
356 if (ref.step < step) continue;
357 else if (step < ref.step) break;
358 else { // Replace key
359 ref.type = key;
360 return;
361 }
362 }
363 }
364 sigs_.insert(sigs_.begin() + static_cast<decltype(sigs_)::difference_type>(i),
365 KeySignature(key, order, step));
366 }
367
368 void Song::changeKeySignature(int i, KeySignature::Type key, int order, int step)
369 {
370 sigs_.erase(sigs_.begin() + i);
371 addKeySignature(key, order, step);
372 }
373
374 void Song::removeKeySignature(int i)
375 {
376 sigs_.erase(sigs_.begin() + i);
377 }
378
379 void Song::clearKeySignature()
380 {
381 sigs_ = { KeySignature(KeySignature::E, 0, 0) };
382 }
383
384 KeySignature Song::getKeySignature(int i) const
385 {
386 return sigs_.at(static_cast<size_t>(i));
387 }
388
389 size_t Song::getKeySignatureSize() const
390 {
391 return sigs_.size();
392 }
393
394 KeySignature::Type Song::searchKeySignatureAt(int order, int step) const
395 {
396 return std::lower_bound(sigs_.crbegin(), sigs_.crend(), KeySignature(KeySignature::E, order, step),
397 [](const KeySignature& i, const KeySignature& v) {
398 if (i.order == v.order) return (i.step > v.step);
399 else return (i.order > v.order);
400 })->type;
401 }