| 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 |
} |